Line data Source code
1 : /* fd_map_perfect defines a few macros and functions for building
2 : ultra high performance compile-time perfect hash tables.
3 :
4 : If C's preprocessor were more powerful, it might be possible to do
5 : this all automatically and fully generically, but it's not. The good
6 : thing this does provide is that it will fail to compile (with errors
7 : about override-init in GCC and initializer-overrides in Clang) if
8 : your hash function doesn't result in a perfect hash table. It takes
9 : abusing the preprocessor a little and jumping through some hoops in
10 : order to get that property.
11 :
12 : This file also supports tables with no value, in which case it is
13 : essentially a set (quickly answering containment queries). */
14 :
15 : /*
16 : Example usage:
17 :
18 : struct __attribute__((aligned(32))) key_prio {
19 : ulong key;
20 : ulong prio;
21 : };
22 : typedef struct key_prio key_prio_t;
23 :
24 : #define MAP_PERFECT_NAME key_prio_tbl // Name of the table and function prefix
25 : #define MAP_PERFECT_LG_TBL_SZ 3 // Table can fit at most 8 elements
26 : #define MAP_PERFECT_T key_prio_t // The type of each element
27 : #define MAP_PERFECT_HASH_C 650148382U // A random uint, see below for details
28 : #define MAP_PERFECT_KEY key // Name of the key field
29 : #define MAP_PERFECT_KEY_T ulong // Type of the query (typically key type)
30 : #define MAP_PERFECT_ZERO_KEY 0UL // Must be the key that's all zero bytes
31 :
32 : To add elements, just define MAP_PERFECT_i to be key, value (or values).
33 : This will eventually expand to something like
34 : { MAP_PERFECT_KEY = key, values }
35 : so using the .fieldname=value syntax is supported. Otherwise
36 : the fields will be initialized in the order they are declared in the
37 : struct.
38 :
39 : The ordering of these declarations does not matter, but you
40 : must declare at least MAP_PERFECT_0. This implies that there must be at
41 : least one element in the map, but if you know at compile time that the
42 : map is empty, why use a map in the first place? The other limitations
43 : are that the number of elements cannot exceed 1000, and the number of
44 : values in each definition line cannot exceed 100. If you're getting
45 : close to either of these limits, this file is probably not the right
46 : solution to your problem.
47 :
48 : #define MAP_PERFECT_0 44, 12
49 : #define MAP_PERFECT_1 45, .prio = 19
50 : #define MAP_PERFECT_2 17, 0
51 :
52 : #include "fd_map_perfect.c"
53 :
54 : will declare the following static inline functions in the compilation unit:
55 :
56 : // Returns 1 if the key is contained in the table, or 0 if not.
57 :
58 : static inline int key_prio_tbl_contains( ulong key );
59 :
60 : // Returns a pointer to the element in the table that has key `key` if
61 : // one exists, or the value provided as null if one doesn't.
62 :
63 : static inline key_prio_t const * key_prio_tbl_query( ulong key, key_prio_t const * null );
64 :
65 : // Returns the hash of key (using the provided perfect hash) if key is
66 : // in the table. If key is not in the table, returns UINT_MAX.
67 : static inline uint key_prio_tbl_hash_or_default( ulong key );
68 :
69 :
70 : You can do this multiple times within a compilation unit as long as
71 : MAP_PERFECT_NAME differs for the different instantiations. It's also
72 : fine to use it in a header. There are many options (detailed below) to
73 : customize the behavior.
74 :
75 : It's also totally fine to make the element type a struct containing just
76 : the key if you only need a set (containment queries). To do so, just
77 : then append a comma to the elements in the normal way, e.g.
78 : #define MAP_PERFECT_0 44,
79 : adds 44 to the set.
80 :
81 : One advanced usage is with multi-element keys (e.g. arrays). They are
82 : fully supported, but require #define MAP_PERFECT_COMPLEX_KEY 1. See
83 : below for more details. */
84 :
85 : #ifndef MAP_PERFECT_NAME
86 : #error "Define MAP_PERFECT_NAME"
87 : #endif
88 :
89 : /* MAP_PERFECT_LG_TBL_SZ is the base-2 log of the table size. See the
90 : note about MAP_PERFECT_HASH_C below for guidance on how to choose
91 : this value. It must be at least 1. */
92 :
93 : #ifndef MAP_PERFECT_LG_TBL_SZ
94 : #error "Define MAP_PERFECT_LG_TBL_SZ"
95 : #endif
96 :
97 : /* MAP_PERFECT_T is the type of each element in the perfect hash table.
98 : There are no requirements on it other than that it must contain the
99 : key. Large structs are okay, since they never get copied, but they
100 : might be a pain to const initialize. */
101 :
102 : #ifndef MAP_PERFECT_T
103 : #error "Define MAP_PERFECT_T"
104 : #endif
105 :
106 : /* MAP_PERFECT_KEY is the name of the key field in the struct. It
107 : defaults to key. */
108 : #ifndef MAP_PERFECT_KEY
109 : #define MAP_PERFECT_KEY key
110 : #endif
111 :
112 : /* MAP_PERFECT_KEY_T is the type of the query, which should typically be
113 : the key type. When using an array as a key, you may want to make
114 : this a const pointer instead of an array though. For example, if
115 : the key is uchar key[32], #define MAP_PERFECT_KEY_T uchar const * is
116 : pretty reasonable. */
117 :
118 : #ifndef MAP_PERFECT_KEY_T
119 : #error "Define MAP_PERFECT_KEY_T"
120 : #endif
121 :
122 : /* MAP_PERFECT_COMPLEX_KEY controls whether the key type is a scalar
123 : (COMPLEX_KEY==0) or an array (COMPLEX_KEY==1). If a complex key, the
124 : key should be surrounded by parenthesis, e.g.
125 : #define MAP_PERFECT_0 (1,1,1), .value=7, .other_value=8
126 :
127 : In this case, when HASH_PP is invoked, each value in the key will be
128 : a different argument to the macro. The hash of the above example
129 : will be calculated by expanding MAP_PERFECT_HASH_PP( 1, 1, 1 ), not
130 : MAP_PERFECT_HASH_PP( (1,1,1) ). */
131 :
132 : #ifndef MAP_PERFECT_COMPLEX_KEY
133 : # define MAP_PERFECT_COMPLEX_KEY 0
134 : #endif
135 :
136 : /* MAP_PERFECT_ZERO_KEY must be set to the key of all 0s. In the
137 : non-complex case, the code below probably does the right thing. The
138 : reason for this is a little strange: keys in the table that don't
139 : have a value get default initialized, which means set to all 0 bytes.
140 : We have to be able to distinguish that case from the case in which
141 : the zero key was actually inserted into the table, and we need to be
142 : able to do that at preprocessor time. Especially in the complex key
143 : case, this is not easy, so we just require specifying it manually. */
144 :
145 : #ifndef MAP_PERFECT_ZERO_KEY
146 : # if !MAP_PERFECT_COMPLEX_KEY
147 : # define MAP_PERFECT_ZERO_KEY 0
148 : # else
149 : # error "Define MAP_PERFECT_ZERO_KEY to be the key of all zero bytes"
150 : # endif
151 : #endif
152 :
153 : /* MAP_PERFECT_KEYS_EQUAL takes two key arguments, where the second has
154 : type MAP_PERFECT_KEY_T, and returns 1 if they are equal and 0 if they
155 : are not. */
156 :
157 : #ifndef MAP_PERFECT_KEYS_EQUAL
158 : # if !MAP_PERFECT_COMPLEX_KEY
159 15732459 : # define MAP_PERFECT_KEYS_EQUAL(k1,k2) ((k1)==(k2))
160 : # else
161 : # error "Define MAP_PERFECT_KEYS_EQUAL"
162 : # endif
163 : #endif
164 :
165 :
166 : /* By default, this file uses a family of hash functions of the form
167 :
168 : ((uint)k * (uint)MAP_PERFECT_HASH_C)>>(32-MAP_PERFECT_LG_TBL_SZ)
169 :
170 : where k is the key. I'm not too sure about the theory of this
171 : function, but it seems to work decently well in practice, and it's
172 : extremely cheap (2 instructions, 4 cycles of latency, 1 cycle inverse
173 : throughput).
174 : Of course, this is customizable, but you need to provide the hash
175 : function in two forms: One that is executed by the preprocessor, and
176 : one that is executed at runtime.
177 :
178 : IMPORTANT GOTCHA: the preprocessor only kind of understands types.
179 : It seems like it can differentiate between signed and unsigned, but
180 : everything is either a long or a ulong. It's probably easiest to
181 : treat everything as a ulong.
182 :
183 : The other difference is only apparent with complex keys:
184 : MAP_PERFECT_HASH_PP takes as many arguments as the array length,
185 : while MAP_PERFECT_HASH_R takes one argument of type
186 : MAP_PERFECT_KEY_T. They must return identical hashes for equivalent
187 : values. One good way to do that is to make them identical or to have
188 : them both invoke a common macro with the core hash logic.
189 :
190 : The hash must be simple enough that the preprocessor can execute it.
191 : */
192 :
193 : #ifdef MAP_PERFECT_HASH_PP
194 : # ifndef MAP_PERFECT_HASH_R
195 : # error "If you're using a custom hash function, you must define both MAP_PERFECT_HASH_PP and MAP_PERFECT_HASH_R"
196 : # endif
197 : #else
198 : # ifndef MAP_PERFECT_HASH_C
199 : # error "Define MAP_PERFECT_HASH_C"
200 : # endif
201 : # define MAP_PERFECT_HASH_PP( u ) ((( MAP_PERFECT_HASH_C * (u))&UINT_MAX)>>(32-(MAP_PERFECT_LG_TBL_SZ)))
202 15732459 : # define MAP_PERFECT_HASH_R( u ) (( MAP_PERFECT_HASH_C * (uint)(u) )>>(32-(MAP_PERFECT_LG_TBL_SZ)))
203 : #endif
204 :
205 : /* A note on picking MAP_PERFECT_HASH_C: I don't know a better way to
206 : find the constant other than brute force. If we model the hash
207 : function as a random map, then the probability any given constant
208 : results in no collisions is:
209 : N!/((N-m)!*N^m)
210 : where N is 2^MAP_PERFECT_LG_TBL_SZ and m is the number of elements in the
211 : table. The simple estimate of the number of constants you need to
212 : try is then ((N-m)! N^m)/N!. This function grows faster than
213 : exponential as a function of m. The only real downside to a larger
214 : table is increased cache utilization and cache misses.
215 :
216 : Here is some example Python code for finding a hash for prime numbers
217 : under 100:
218 :
219 : import numpy as np
220 : import random
221 : import math
222 :
223 : arr = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
224 : PMP_LG_TBL_SZ = 5
225 : nn = np.array(arr)
226 : best = 0
227 :
228 : estimated_cnt = int(math.factorial( (1<<PMP_LG_TBL_SZ)-len(arr) ) * ((1<<PMP_LG_TBL_SZ)**len(arr)) / math.factorial((1<<PMP_LG_TBL_SZ)))
229 : if estimated_cnt > 2**32:
230 : print(f"Warning: the table is likely too full. Estimated {estimated_cnt} random values needed")
231 : print(f"Trying {2*estimated_cnt} random constants")
232 :
233 : for k in range(2*estimated_cnt):
234 : r = random.randint(0,2**32-1)
235 : cur = len(set( ((nn*r)>>(32-PMP_LG_TBL_SZ))&((1<<PMP_LG_TBL_SZ) - 1) ))
236 : if cur == len(arr):
237 : print(f"Success! Use {r} as the hash constant")
238 : break
239 : if cur>best:
240 : best = cur
241 : print(f"Progress: found projection onto {best} entries.") */
242 :
243 : #if defined(MAP_PERFECT_1000)
244 : # error "fd_map_perfect only supports up to 1000 elements."
245 : #endif
246 :
247 : /* Implementation: */
248 : #include "../bits/fd_bits.h"
249 :
250 : #define MAP_PERFECT_(n) FD_EXPAND_THEN_CONCAT3(MAP_PERFECT_NAME,_,n)
251 :
252 : /* Step 1: Define macros that can kinda distinguish between whether
253 : something has been defined or not. The actual preprocessor function
254 : "defined" only works in #if expressions, so it's no good. Instead we
255 : determine whether the token in question expands to something with a
256 : comma in it (this is why even in the no-value case, the elements need
257 : a comma). This is mostly taken from the Internet. */
258 :
259 : #define FD_MP_EXPAND(x) x
260 :
261 : #define FD_MP_ARG_100(_,\
262 : _100,_99,_98,_97,_96,_95,_94,_93,_92,_91,_90,_89,_88,_87,_86,_85,_84,_83,_82,_81, \
263 : _80,_79,_78,_77,_76,_75,_74,_73,_72,_71,_70,_69,_68,_67,_66,_65,_64,_63,_62,_61, \
264 : _60,_59,_58,_57,_56,_55,_54,_53,_52,_51,_50,_49,_48,_47,_46,_45,_44,_43,_42,_41, \
265 : _40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21, \
266 : _20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,X_,...) X_
267 :
268 : /* Returns whether __VA_ARGS__ has a comma (up to 100 arguments). */
269 : #define FD_MP_HAS_COMMA(...) FD_MP_EXPAND(FD_MP_ARG_100(__VA_ARGS__, \
270 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
271 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
272 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
273 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ,1, \
274 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, -1))
275 :
276 :
277 :
278 : /* Step 2: Define macros that will generate the sequence of integers
279 : 0, 1, ... 999. */
280 :
281 : /* This set of recursive macros expands f with argument p0 concatenated
282 : with successive sequential integers from 0 to 999 (inclusive). The
283 : invocations are joined with j. z1 and z2 are helper arguments that
284 : must start with z1 as empty and z2 as 0. When the leading digit is
285 : not zero, they will be flipped.
286 :
287 : Solving something close to this is not hard: you just concat a digit
288 : onto the prefix (p) and then recurse. The tricky part comes from
289 : leading 0s. To solve that, we use z1 which is empty when it's a
290 : leading zero and a literal zero when not. That almost solves it, but
291 : then the very first call to FD_MP_RECURSE1 has p="" instead of p="0" (not
292 : actually strings), since it's entirely leading zeros. z2 solves
293 : that. */
294 : #define FD_MP_RECURSE4(p0, p, j, z1, z2, f) FD_MP_RECURSE3( p0, FD_EXPAND_THEN_CONCAT2(p,z1), j, z1, z2, f ) j() \
295 : FD_MP_RECURSE3( p0, FD_EXPAND_THEN_CONCAT2(p,1), j, 0, , f ) j() \
296 : FD_MP_RECURSE3( p0, FD_EXPAND_THEN_CONCAT2(p,2), j, 0, , f ) j() \
297 : FD_MP_RECURSE3( p0, FD_EXPAND_THEN_CONCAT2(p,3), j, 0, , f ) j() \
298 : FD_MP_RECURSE3( p0, FD_EXPAND_THEN_CONCAT2(p,4), j, 0, , f ) j() \
299 : FD_MP_RECURSE3( p0, FD_EXPAND_THEN_CONCAT2(p,5), j, 0, , f ) j() \
300 : FD_MP_RECURSE3( p0, FD_EXPAND_THEN_CONCAT2(p,6), j, 0, , f ) j() \
301 : FD_MP_RECURSE3( p0, FD_EXPAND_THEN_CONCAT2(p,7), j, 0, , f ) j() \
302 : FD_MP_RECURSE3( p0, FD_EXPAND_THEN_CONCAT2(p,8), j, 0, , f ) j() \
303 : FD_MP_RECURSE3( p0, FD_EXPAND_THEN_CONCAT2(p,9), j, 0, , f )
304 : #define FD_MP_RECURSE3(p0, p, j, z1, z2, f) FD_MP_RECURSE2( p0, FD_EXPAND_THEN_CONCAT2(p,z1), j, z1, z2, f ) j() \
305 : FD_MP_RECURSE2( p0, FD_EXPAND_THEN_CONCAT2(p,1), j, 0, , f ) j() \
306 : FD_MP_RECURSE2( p0, FD_EXPAND_THEN_CONCAT2(p,2), j, 0, , f ) j() \
307 : FD_MP_RECURSE2( p0, FD_EXPAND_THEN_CONCAT2(p,3), j, 0, , f ) j() \
308 : FD_MP_RECURSE2( p0, FD_EXPAND_THEN_CONCAT2(p,4), j, 0, , f ) j() \
309 : FD_MP_RECURSE2( p0, FD_EXPAND_THEN_CONCAT2(p,5), j, 0, , f ) j() \
310 : FD_MP_RECURSE2( p0, FD_EXPAND_THEN_CONCAT2(p,6), j, 0, , f ) j() \
311 : FD_MP_RECURSE2( p0, FD_EXPAND_THEN_CONCAT2(p,7), j, 0, , f ) j() \
312 : FD_MP_RECURSE2( p0, FD_EXPAND_THEN_CONCAT2(p,8), j, 0, , f ) j() \
313 : FD_MP_RECURSE2( p0, FD_EXPAND_THEN_CONCAT2(p,9), j, 0, , f )
314 : #define FD_MP_RECURSE2(p0, p, j, z1, z2, f) FD_MP_RECURSE1( p0, FD_EXPAND_THEN_CONCAT2(p,z1), j, z1, z2, f ) j() \
315 : FD_MP_RECURSE1( p0, FD_EXPAND_THEN_CONCAT2(p,1), j, 0, , f ) j() \
316 : FD_MP_RECURSE1( p0, FD_EXPAND_THEN_CONCAT2(p,2), j, 0, , f ) j() \
317 : FD_MP_RECURSE1( p0, FD_EXPAND_THEN_CONCAT2(p,3), j, 0, , f ) j() \
318 : FD_MP_RECURSE1( p0, FD_EXPAND_THEN_CONCAT2(p,4), j, 0, , f ) j() \
319 : FD_MP_RECURSE1( p0, FD_EXPAND_THEN_CONCAT2(p,5), j, 0, , f ) j() \
320 : FD_MP_RECURSE1( p0, FD_EXPAND_THEN_CONCAT2(p,6), j, 0, , f ) j() \
321 : FD_MP_RECURSE1( p0, FD_EXPAND_THEN_CONCAT2(p,7), j, 0, , f ) j() \
322 : FD_MP_RECURSE1( p0, FD_EXPAND_THEN_CONCAT2(p,8), j, 0, , f ) j() \
323 : FD_MP_RECURSE1( p0, FD_EXPAND_THEN_CONCAT2(p,9), j, 0, , f )
324 :
325 : #define FD_MP_RECURSE1(p0, p, j, z1, z2, f) f( FD_EXPAND_THEN_CONCAT3(p0, p, z2) )
326 : #define FD_MP_EMPTY()
327 : #define FD_MP_AND() &&
328 :
329 : /* Step 3: Define macros for turning a table element into an array
330 : declaration, and also whether it has a key that hashes to something
331 : other than what the zero key hashes to. */
332 :
333 : #if MAP_PERFECT_COMPLEX_KEY
334 : /* Consume the first and last parenthesis */
335 : # define FD_MP_EAT_PARENS( ... ) __VA_ARGS__
336 : # define FD_MP_FORMAT_KEY( K ) { FD_MP_EAT_PARENS K }
337 : /* Various macro expansion tricks */
338 : # define FD_MP_HASH_PP_1( KEY ) FD_MP_HASH_PP_2( KEY )
339 : # define FD_MP_HASH_PP_2( KEY ) MAP_PERFECT_HASH_PP KEY
340 : #else
341 : # define FD_MP_FORMAT_KEY( K ) K
342 : # define FD_MP_HASH_PP_1( KEY ) MAP_PERFECT_HASH_PP( KEY )
343 : #endif
344 :
345 : #define FD_MP_VAL( K, ... ) __VA_ARGS__
346 : #define FD_MP_KEY( K, ... ) K
347 :
348 : #define FD_MP_ADD_ELE( ... ) \
349 : [ FD_MP_HASH_PP_1( FD_MP_KEY( __VA_ARGS__ ) ) ] = \
350 : { . MAP_PERFECT_KEY = FD_MP_FORMAT_KEY( FD_MP_KEY(__VA_ARGS__) ), FD_MP_VAL(__VA_ARGS__) },
351 :
352 : #define FD_MP_MAKE_ELE_0(...)
353 : #define FD_MP_MAKE_ELE_1(K, ...) FD_MP_ADD_ELE(K, __VA_ARGS__)
354 :
355 : #define FD_MP_CHOOSE_MAKE(...) FD_EXPAND_THEN_CONCAT2( FD_MP_MAKE_ELE_, FD_MP_HAS_COMMA(__VA_ARGS__) )(__VA_ARGS__)
356 :
357 :
358 :
359 : #define FD_MP_HASH_PP_3( ... ) FD_MP_HASH_PP_1( FD_MP_KEY( __VA_ARGS__ ) )
360 :
361 : /* If nothing maps to the same entry as the zero key, then we need to
362 : insert a dummy element. We insert MAP_PERFECT_0 at the index that
363 : the zero key would map to. In this case, nothing maps to the same
364 : entry as the zero key, which means MAP_PERFECT_0 certainly doesn't,
365 : which means the zero key's index is the wrong index for it. Thus it
366 : won't match any queries that hit the zero key's index, as desired. */
367 :
368 : #define FD_MP_NONZERO_ELE_0(...) 1
369 : #define FD_MP_NONZERO_ELE_1(K, ...) (FD_MP_HASH_PP_1(MAP_PERFECT_ZERO_KEY) != FD_MP_HASH_PP_1(K))
370 :
371 : #define FD_MP_CHOOSE_NONZERO(...) FD_EXPAND_THEN_CONCAT2( FD_MP_NONZERO_ELE_, FD_MP_HAS_COMMA(__VA_ARGS__) )(__VA_ARGS__)
372 :
373 : /* only scan candidates 100..999 when something is defined there: probing all 1000 is
374 : ~55 ms of preprocessing per instantiation and the expansion is identical */
375 :
376 : #if defined(MAP_PERFECT_100) || defined(MAP_PERFECT_101) || defined(MAP_PERFECT_102) || defined(MAP_PERFECT_103) || defined(MAP_PERFECT_104) || \
377 : defined(MAP_PERFECT_105) || defined(MAP_PERFECT_106) || defined(MAP_PERFECT_107) || defined(MAP_PERFECT_108) || defined(MAP_PERFECT_109) || \
378 : defined(MAP_PERFECT_110) || defined(MAP_PERFECT_111) || defined(MAP_PERFECT_112) || defined(MAP_PERFECT_113) || defined(MAP_PERFECT_114) || \
379 : defined(MAP_PERFECT_115) || defined(MAP_PERFECT_116) || defined(MAP_PERFECT_117) || defined(MAP_PERFECT_118) || defined(MAP_PERFECT_119) || \
380 : defined(MAP_PERFECT_120) || defined(MAP_PERFECT_121) || defined(MAP_PERFECT_122) || defined(MAP_PERFECT_123) || defined(MAP_PERFECT_124) || \
381 : defined(MAP_PERFECT_125) || defined(MAP_PERFECT_126) || defined(MAP_PERFECT_127) || defined(MAP_PERFECT_128) || defined(MAP_PERFECT_129) || \
382 : defined(MAP_PERFECT_130) || defined(MAP_PERFECT_131) || defined(MAP_PERFECT_132) || defined(MAP_PERFECT_133) || defined(MAP_PERFECT_134) || \
383 : defined(MAP_PERFECT_135) || defined(MAP_PERFECT_136) || defined(MAP_PERFECT_137) || defined(MAP_PERFECT_138) || defined(MAP_PERFECT_139) || \
384 : defined(MAP_PERFECT_140) || defined(MAP_PERFECT_141) || defined(MAP_PERFECT_142) || defined(MAP_PERFECT_143) || defined(MAP_PERFECT_144) || \
385 : defined(MAP_PERFECT_145) || defined(MAP_PERFECT_146) || defined(MAP_PERFECT_147) || defined(MAP_PERFECT_148) || defined(MAP_PERFECT_149) || \
386 : defined(MAP_PERFECT_150) || defined(MAP_PERFECT_151) || defined(MAP_PERFECT_152) || defined(MAP_PERFECT_153) || defined(MAP_PERFECT_154) || \
387 : defined(MAP_PERFECT_155) || defined(MAP_PERFECT_156) || defined(MAP_PERFECT_157) || defined(MAP_PERFECT_158) || defined(MAP_PERFECT_159) || \
388 : defined(MAP_PERFECT_160) || defined(MAP_PERFECT_161) || defined(MAP_PERFECT_162) || defined(MAP_PERFECT_163) || defined(MAP_PERFECT_164) || \
389 : defined(MAP_PERFECT_165) || defined(MAP_PERFECT_166) || defined(MAP_PERFECT_167) || defined(MAP_PERFECT_168) || defined(MAP_PERFECT_169) || \
390 : defined(MAP_PERFECT_170) || defined(MAP_PERFECT_171) || defined(MAP_PERFECT_172) || defined(MAP_PERFECT_173) || defined(MAP_PERFECT_174) || \
391 : defined(MAP_PERFECT_175) || defined(MAP_PERFECT_176) || defined(MAP_PERFECT_177) || defined(MAP_PERFECT_178) || defined(MAP_PERFECT_179) || \
392 : defined(MAP_PERFECT_180) || defined(MAP_PERFECT_181) || defined(MAP_PERFECT_182) || defined(MAP_PERFECT_183) || defined(MAP_PERFECT_184) || \
393 : defined(MAP_PERFECT_185) || defined(MAP_PERFECT_186) || defined(MAP_PERFECT_187) || defined(MAP_PERFECT_188) || defined(MAP_PERFECT_189) || \
394 : defined(MAP_PERFECT_190) || defined(MAP_PERFECT_191) || defined(MAP_PERFECT_192) || defined(MAP_PERFECT_193) || defined(MAP_PERFECT_194) || \
395 : defined(MAP_PERFECT_195) || defined(MAP_PERFECT_196) || defined(MAP_PERFECT_197) || defined(MAP_PERFECT_198) || defined(MAP_PERFECT_199) || \
396 : defined(MAP_PERFECT_200) || defined(MAP_PERFECT_201) || defined(MAP_PERFECT_202) || defined(MAP_PERFECT_203) || defined(MAP_PERFECT_204) || \
397 : defined(MAP_PERFECT_205) || defined(MAP_PERFECT_206) || defined(MAP_PERFECT_207) || defined(MAP_PERFECT_208) || defined(MAP_PERFECT_209) || \
398 : defined(MAP_PERFECT_210) || defined(MAP_PERFECT_211) || defined(MAP_PERFECT_212) || defined(MAP_PERFECT_213) || defined(MAP_PERFECT_214) || \
399 : defined(MAP_PERFECT_215) || defined(MAP_PERFECT_216) || defined(MAP_PERFECT_217) || defined(MAP_PERFECT_218) || defined(MAP_PERFECT_219) || \
400 : defined(MAP_PERFECT_220) || defined(MAP_PERFECT_221) || defined(MAP_PERFECT_222) || defined(MAP_PERFECT_223) || defined(MAP_PERFECT_224) || \
401 : defined(MAP_PERFECT_225) || defined(MAP_PERFECT_226) || defined(MAP_PERFECT_227) || defined(MAP_PERFECT_228) || defined(MAP_PERFECT_229) || \
402 : defined(MAP_PERFECT_230) || defined(MAP_PERFECT_231) || defined(MAP_PERFECT_232) || defined(MAP_PERFECT_233) || defined(MAP_PERFECT_234) || \
403 : defined(MAP_PERFECT_235) || defined(MAP_PERFECT_236) || defined(MAP_PERFECT_237) || defined(MAP_PERFECT_238) || defined(MAP_PERFECT_239) || \
404 : defined(MAP_PERFECT_240) || defined(MAP_PERFECT_241) || defined(MAP_PERFECT_242) || defined(MAP_PERFECT_243) || defined(MAP_PERFECT_244) || \
405 : defined(MAP_PERFECT_245) || defined(MAP_PERFECT_246) || defined(MAP_PERFECT_247) || defined(MAP_PERFECT_248) || defined(MAP_PERFECT_249) || \
406 : defined(MAP_PERFECT_250) || defined(MAP_PERFECT_251) || defined(MAP_PERFECT_252) || defined(MAP_PERFECT_253) || defined(MAP_PERFECT_254) || \
407 : defined(MAP_PERFECT_255) || defined(MAP_PERFECT_256) || defined(MAP_PERFECT_257) || defined(MAP_PERFECT_258) || defined(MAP_PERFECT_259) || \
408 : defined(MAP_PERFECT_260) || defined(MAP_PERFECT_261) || defined(MAP_PERFECT_262) || defined(MAP_PERFECT_263) || defined(MAP_PERFECT_264) || \
409 : defined(MAP_PERFECT_265) || defined(MAP_PERFECT_266) || defined(MAP_PERFECT_267) || defined(MAP_PERFECT_268) || defined(MAP_PERFECT_269) || \
410 : defined(MAP_PERFECT_270) || defined(MAP_PERFECT_271) || defined(MAP_PERFECT_272) || defined(MAP_PERFECT_273) || defined(MAP_PERFECT_274) || \
411 : defined(MAP_PERFECT_275) || defined(MAP_PERFECT_276) || defined(MAP_PERFECT_277) || defined(MAP_PERFECT_278) || defined(MAP_PERFECT_279) || \
412 : defined(MAP_PERFECT_280) || defined(MAP_PERFECT_281) || defined(MAP_PERFECT_282) || defined(MAP_PERFECT_283) || defined(MAP_PERFECT_284) || \
413 : defined(MAP_PERFECT_285) || defined(MAP_PERFECT_286) || defined(MAP_PERFECT_287) || defined(MAP_PERFECT_288) || defined(MAP_PERFECT_289) || \
414 : defined(MAP_PERFECT_290) || defined(MAP_PERFECT_291) || defined(MAP_PERFECT_292) || defined(MAP_PERFECT_293) || defined(MAP_PERFECT_294) || \
415 : defined(MAP_PERFECT_295) || defined(MAP_PERFECT_296) || defined(MAP_PERFECT_297) || defined(MAP_PERFECT_298) || defined(MAP_PERFECT_299) || \
416 : defined(MAP_PERFECT_300) || defined(MAP_PERFECT_301) || defined(MAP_PERFECT_302) || defined(MAP_PERFECT_303) || defined(MAP_PERFECT_304) || \
417 : defined(MAP_PERFECT_305) || defined(MAP_PERFECT_306) || defined(MAP_PERFECT_307) || defined(MAP_PERFECT_308) || defined(MAP_PERFECT_309) || \
418 : defined(MAP_PERFECT_310) || defined(MAP_PERFECT_311) || defined(MAP_PERFECT_312) || defined(MAP_PERFECT_313) || defined(MAP_PERFECT_314) || \
419 : defined(MAP_PERFECT_315) || defined(MAP_PERFECT_316) || defined(MAP_PERFECT_317) || defined(MAP_PERFECT_318) || defined(MAP_PERFECT_319) || \
420 : defined(MAP_PERFECT_320) || defined(MAP_PERFECT_321) || defined(MAP_PERFECT_322) || defined(MAP_PERFECT_323) || defined(MAP_PERFECT_324) || \
421 : defined(MAP_PERFECT_325) || defined(MAP_PERFECT_326) || defined(MAP_PERFECT_327) || defined(MAP_PERFECT_328) || defined(MAP_PERFECT_329) || \
422 : defined(MAP_PERFECT_330) || defined(MAP_PERFECT_331) || defined(MAP_PERFECT_332) || defined(MAP_PERFECT_333) || defined(MAP_PERFECT_334) || \
423 : defined(MAP_PERFECT_335) || defined(MAP_PERFECT_336) || defined(MAP_PERFECT_337) || defined(MAP_PERFECT_338) || defined(MAP_PERFECT_339) || \
424 : defined(MAP_PERFECT_340) || defined(MAP_PERFECT_341) || defined(MAP_PERFECT_342) || defined(MAP_PERFECT_343) || defined(MAP_PERFECT_344) || \
425 : defined(MAP_PERFECT_345) || defined(MAP_PERFECT_346) || defined(MAP_PERFECT_347) || defined(MAP_PERFECT_348) || defined(MAP_PERFECT_349) || \
426 : defined(MAP_PERFECT_350) || defined(MAP_PERFECT_351) || defined(MAP_PERFECT_352) || defined(MAP_PERFECT_353) || defined(MAP_PERFECT_354) || \
427 : defined(MAP_PERFECT_355) || defined(MAP_PERFECT_356) || defined(MAP_PERFECT_357) || defined(MAP_PERFECT_358) || defined(MAP_PERFECT_359) || \
428 : defined(MAP_PERFECT_360) || defined(MAP_PERFECT_361) || defined(MAP_PERFECT_362) || defined(MAP_PERFECT_363) || defined(MAP_PERFECT_364) || \
429 : defined(MAP_PERFECT_365) || defined(MAP_PERFECT_366) || defined(MAP_PERFECT_367) || defined(MAP_PERFECT_368) || defined(MAP_PERFECT_369) || \
430 : defined(MAP_PERFECT_370) || defined(MAP_PERFECT_371) || defined(MAP_PERFECT_372) || defined(MAP_PERFECT_373) || defined(MAP_PERFECT_374) || \
431 : defined(MAP_PERFECT_375) || defined(MAP_PERFECT_376) || defined(MAP_PERFECT_377) || defined(MAP_PERFECT_378) || defined(MAP_PERFECT_379) || \
432 : defined(MAP_PERFECT_380) || defined(MAP_PERFECT_381) || defined(MAP_PERFECT_382) || defined(MAP_PERFECT_383) || defined(MAP_PERFECT_384) || \
433 : defined(MAP_PERFECT_385) || defined(MAP_PERFECT_386) || defined(MAP_PERFECT_387) || defined(MAP_PERFECT_388) || defined(MAP_PERFECT_389) || \
434 : defined(MAP_PERFECT_390) || defined(MAP_PERFECT_391) || defined(MAP_PERFECT_392) || defined(MAP_PERFECT_393) || defined(MAP_PERFECT_394) || \
435 : defined(MAP_PERFECT_395) || defined(MAP_PERFECT_396) || defined(MAP_PERFECT_397) || defined(MAP_PERFECT_398) || defined(MAP_PERFECT_399) || \
436 : defined(MAP_PERFECT_400) || defined(MAP_PERFECT_401) || defined(MAP_PERFECT_402) || defined(MAP_PERFECT_403) || defined(MAP_PERFECT_404) || \
437 : defined(MAP_PERFECT_405) || defined(MAP_PERFECT_406) || defined(MAP_PERFECT_407) || defined(MAP_PERFECT_408) || defined(MAP_PERFECT_409) || \
438 : defined(MAP_PERFECT_410) || defined(MAP_PERFECT_411) || defined(MAP_PERFECT_412) || defined(MAP_PERFECT_413) || defined(MAP_PERFECT_414) || \
439 : defined(MAP_PERFECT_415) || defined(MAP_PERFECT_416) || defined(MAP_PERFECT_417) || defined(MAP_PERFECT_418) || defined(MAP_PERFECT_419) || \
440 : defined(MAP_PERFECT_420) || defined(MAP_PERFECT_421) || defined(MAP_PERFECT_422) || defined(MAP_PERFECT_423) || defined(MAP_PERFECT_424) || \
441 : defined(MAP_PERFECT_425) || defined(MAP_PERFECT_426) || defined(MAP_PERFECT_427) || defined(MAP_PERFECT_428) || defined(MAP_PERFECT_429) || \
442 : defined(MAP_PERFECT_430) || defined(MAP_PERFECT_431) || defined(MAP_PERFECT_432) || defined(MAP_PERFECT_433) || defined(MAP_PERFECT_434) || \
443 : defined(MAP_PERFECT_435) || defined(MAP_PERFECT_436) || defined(MAP_PERFECT_437) || defined(MAP_PERFECT_438) || defined(MAP_PERFECT_439) || \
444 : defined(MAP_PERFECT_440) || defined(MAP_PERFECT_441) || defined(MAP_PERFECT_442) || defined(MAP_PERFECT_443) || defined(MAP_PERFECT_444) || \
445 : defined(MAP_PERFECT_445) || defined(MAP_PERFECT_446) || defined(MAP_PERFECT_447) || defined(MAP_PERFECT_448) || defined(MAP_PERFECT_449) || \
446 : defined(MAP_PERFECT_450) || defined(MAP_PERFECT_451) || defined(MAP_PERFECT_452) || defined(MAP_PERFECT_453) || defined(MAP_PERFECT_454) || \
447 : defined(MAP_PERFECT_455) || defined(MAP_PERFECT_456) || defined(MAP_PERFECT_457) || defined(MAP_PERFECT_458) || defined(MAP_PERFECT_459) || \
448 : defined(MAP_PERFECT_460) || defined(MAP_PERFECT_461) || defined(MAP_PERFECT_462) || defined(MAP_PERFECT_463) || defined(MAP_PERFECT_464) || \
449 : defined(MAP_PERFECT_465) || defined(MAP_PERFECT_466) || defined(MAP_PERFECT_467) || defined(MAP_PERFECT_468) || defined(MAP_PERFECT_469) || \
450 : defined(MAP_PERFECT_470) || defined(MAP_PERFECT_471) || defined(MAP_PERFECT_472) || defined(MAP_PERFECT_473) || defined(MAP_PERFECT_474) || \
451 : defined(MAP_PERFECT_475) || defined(MAP_PERFECT_476) || defined(MAP_PERFECT_477) || defined(MAP_PERFECT_478) || defined(MAP_PERFECT_479) || \
452 : defined(MAP_PERFECT_480) || defined(MAP_PERFECT_481) || defined(MAP_PERFECT_482) || defined(MAP_PERFECT_483) || defined(MAP_PERFECT_484) || \
453 : defined(MAP_PERFECT_485) || defined(MAP_PERFECT_486) || defined(MAP_PERFECT_487) || defined(MAP_PERFECT_488) || defined(MAP_PERFECT_489) || \
454 : defined(MAP_PERFECT_490) || defined(MAP_PERFECT_491) || defined(MAP_PERFECT_492) || defined(MAP_PERFECT_493) || defined(MAP_PERFECT_494) || \
455 : defined(MAP_PERFECT_495) || defined(MAP_PERFECT_496) || defined(MAP_PERFECT_497) || defined(MAP_PERFECT_498) || defined(MAP_PERFECT_499) || \
456 : defined(MAP_PERFECT_500) || defined(MAP_PERFECT_501) || defined(MAP_PERFECT_502) || defined(MAP_PERFECT_503) || defined(MAP_PERFECT_504) || \
457 : defined(MAP_PERFECT_505) || defined(MAP_PERFECT_506) || defined(MAP_PERFECT_507) || defined(MAP_PERFECT_508) || defined(MAP_PERFECT_509) || \
458 : defined(MAP_PERFECT_510) || defined(MAP_PERFECT_511) || defined(MAP_PERFECT_512) || defined(MAP_PERFECT_513) || defined(MAP_PERFECT_514) || \
459 : defined(MAP_PERFECT_515) || defined(MAP_PERFECT_516) || defined(MAP_PERFECT_517) || defined(MAP_PERFECT_518) || defined(MAP_PERFECT_519) || \
460 : defined(MAP_PERFECT_520) || defined(MAP_PERFECT_521) || defined(MAP_PERFECT_522) || defined(MAP_PERFECT_523) || defined(MAP_PERFECT_524) || \
461 : defined(MAP_PERFECT_525) || defined(MAP_PERFECT_526) || defined(MAP_PERFECT_527) || defined(MAP_PERFECT_528) || defined(MAP_PERFECT_529) || \
462 : defined(MAP_PERFECT_530) || defined(MAP_PERFECT_531) || defined(MAP_PERFECT_532) || defined(MAP_PERFECT_533) || defined(MAP_PERFECT_534) || \
463 : defined(MAP_PERFECT_535) || defined(MAP_PERFECT_536) || defined(MAP_PERFECT_537) || defined(MAP_PERFECT_538) || defined(MAP_PERFECT_539) || \
464 : defined(MAP_PERFECT_540) || defined(MAP_PERFECT_541) || defined(MAP_PERFECT_542) || defined(MAP_PERFECT_543) || defined(MAP_PERFECT_544) || \
465 : defined(MAP_PERFECT_545) || defined(MAP_PERFECT_546) || defined(MAP_PERFECT_547) || defined(MAP_PERFECT_548) || defined(MAP_PERFECT_549) || \
466 : defined(MAP_PERFECT_550) || defined(MAP_PERFECT_551) || defined(MAP_PERFECT_552) || defined(MAP_PERFECT_553) || defined(MAP_PERFECT_554) || \
467 : defined(MAP_PERFECT_555) || defined(MAP_PERFECT_556) || defined(MAP_PERFECT_557) || defined(MAP_PERFECT_558) || defined(MAP_PERFECT_559) || \
468 : defined(MAP_PERFECT_560) || defined(MAP_PERFECT_561) || defined(MAP_PERFECT_562) || defined(MAP_PERFECT_563) || defined(MAP_PERFECT_564) || \
469 : defined(MAP_PERFECT_565) || defined(MAP_PERFECT_566) || defined(MAP_PERFECT_567) || defined(MAP_PERFECT_568) || defined(MAP_PERFECT_569) || \
470 : defined(MAP_PERFECT_570) || defined(MAP_PERFECT_571) || defined(MAP_PERFECT_572) || defined(MAP_PERFECT_573) || defined(MAP_PERFECT_574) || \
471 : defined(MAP_PERFECT_575) || defined(MAP_PERFECT_576) || defined(MAP_PERFECT_577) || defined(MAP_PERFECT_578) || defined(MAP_PERFECT_579) || \
472 : defined(MAP_PERFECT_580) || defined(MAP_PERFECT_581) || defined(MAP_PERFECT_582) || defined(MAP_PERFECT_583) || defined(MAP_PERFECT_584) || \
473 : defined(MAP_PERFECT_585) || defined(MAP_PERFECT_586) || defined(MAP_PERFECT_587) || defined(MAP_PERFECT_588) || defined(MAP_PERFECT_589) || \
474 : defined(MAP_PERFECT_590) || defined(MAP_PERFECT_591) || defined(MAP_PERFECT_592) || defined(MAP_PERFECT_593) || defined(MAP_PERFECT_594) || \
475 : defined(MAP_PERFECT_595) || defined(MAP_PERFECT_596) || defined(MAP_PERFECT_597) || defined(MAP_PERFECT_598) || defined(MAP_PERFECT_599) || \
476 : defined(MAP_PERFECT_600) || defined(MAP_PERFECT_601) || defined(MAP_PERFECT_602) || defined(MAP_PERFECT_603) || defined(MAP_PERFECT_604) || \
477 : defined(MAP_PERFECT_605) || defined(MAP_PERFECT_606) || defined(MAP_PERFECT_607) || defined(MAP_PERFECT_608) || defined(MAP_PERFECT_609) || \
478 : defined(MAP_PERFECT_610) || defined(MAP_PERFECT_611) || defined(MAP_PERFECT_612) || defined(MAP_PERFECT_613) || defined(MAP_PERFECT_614) || \
479 : defined(MAP_PERFECT_615) || defined(MAP_PERFECT_616) || defined(MAP_PERFECT_617) || defined(MAP_PERFECT_618) || defined(MAP_PERFECT_619) || \
480 : defined(MAP_PERFECT_620) || defined(MAP_PERFECT_621) || defined(MAP_PERFECT_622) || defined(MAP_PERFECT_623) || defined(MAP_PERFECT_624) || \
481 : defined(MAP_PERFECT_625) || defined(MAP_PERFECT_626) || defined(MAP_PERFECT_627) || defined(MAP_PERFECT_628) || defined(MAP_PERFECT_629) || \
482 : defined(MAP_PERFECT_630) || defined(MAP_PERFECT_631) || defined(MAP_PERFECT_632) || defined(MAP_PERFECT_633) || defined(MAP_PERFECT_634) || \
483 : defined(MAP_PERFECT_635) || defined(MAP_PERFECT_636) || defined(MAP_PERFECT_637) || defined(MAP_PERFECT_638) || defined(MAP_PERFECT_639) || \
484 : defined(MAP_PERFECT_640) || defined(MAP_PERFECT_641) || defined(MAP_PERFECT_642) || defined(MAP_PERFECT_643) || defined(MAP_PERFECT_644) || \
485 : defined(MAP_PERFECT_645) || defined(MAP_PERFECT_646) || defined(MAP_PERFECT_647) || defined(MAP_PERFECT_648) || defined(MAP_PERFECT_649) || \
486 : defined(MAP_PERFECT_650) || defined(MAP_PERFECT_651) || defined(MAP_PERFECT_652) || defined(MAP_PERFECT_653) || defined(MAP_PERFECT_654) || \
487 : defined(MAP_PERFECT_655) || defined(MAP_PERFECT_656) || defined(MAP_PERFECT_657) || defined(MAP_PERFECT_658) || defined(MAP_PERFECT_659) || \
488 : defined(MAP_PERFECT_660) || defined(MAP_PERFECT_661) || defined(MAP_PERFECT_662) || defined(MAP_PERFECT_663) || defined(MAP_PERFECT_664) || \
489 : defined(MAP_PERFECT_665) || defined(MAP_PERFECT_666) || defined(MAP_PERFECT_667) || defined(MAP_PERFECT_668) || defined(MAP_PERFECT_669) || \
490 : defined(MAP_PERFECT_670) || defined(MAP_PERFECT_671) || defined(MAP_PERFECT_672) || defined(MAP_PERFECT_673) || defined(MAP_PERFECT_674) || \
491 : defined(MAP_PERFECT_675) || defined(MAP_PERFECT_676) || defined(MAP_PERFECT_677) || defined(MAP_PERFECT_678) || defined(MAP_PERFECT_679) || \
492 : defined(MAP_PERFECT_680) || defined(MAP_PERFECT_681) || defined(MAP_PERFECT_682) || defined(MAP_PERFECT_683) || defined(MAP_PERFECT_684) || \
493 : defined(MAP_PERFECT_685) || defined(MAP_PERFECT_686) || defined(MAP_PERFECT_687) || defined(MAP_PERFECT_688) || defined(MAP_PERFECT_689) || \
494 : defined(MAP_PERFECT_690) || defined(MAP_PERFECT_691) || defined(MAP_PERFECT_692) || defined(MAP_PERFECT_693) || defined(MAP_PERFECT_694) || \
495 : defined(MAP_PERFECT_695) || defined(MAP_PERFECT_696) || defined(MAP_PERFECT_697) || defined(MAP_PERFECT_698) || defined(MAP_PERFECT_699) || \
496 : defined(MAP_PERFECT_700) || defined(MAP_PERFECT_701) || defined(MAP_PERFECT_702) || defined(MAP_PERFECT_703) || defined(MAP_PERFECT_704) || \
497 : defined(MAP_PERFECT_705) || defined(MAP_PERFECT_706) || defined(MAP_PERFECT_707) || defined(MAP_PERFECT_708) || defined(MAP_PERFECT_709) || \
498 : defined(MAP_PERFECT_710) || defined(MAP_PERFECT_711) || defined(MAP_PERFECT_712) || defined(MAP_PERFECT_713) || defined(MAP_PERFECT_714) || \
499 : defined(MAP_PERFECT_715) || defined(MAP_PERFECT_716) || defined(MAP_PERFECT_717) || defined(MAP_PERFECT_718) || defined(MAP_PERFECT_719) || \
500 : defined(MAP_PERFECT_720) || defined(MAP_PERFECT_721) || defined(MAP_PERFECT_722) || defined(MAP_PERFECT_723) || defined(MAP_PERFECT_724) || \
501 : defined(MAP_PERFECT_725) || defined(MAP_PERFECT_726) || defined(MAP_PERFECT_727) || defined(MAP_PERFECT_728) || defined(MAP_PERFECT_729) || \
502 : defined(MAP_PERFECT_730) || defined(MAP_PERFECT_731) || defined(MAP_PERFECT_732) || defined(MAP_PERFECT_733) || defined(MAP_PERFECT_734) || \
503 : defined(MAP_PERFECT_735) || defined(MAP_PERFECT_736) || defined(MAP_PERFECT_737) || defined(MAP_PERFECT_738) || defined(MAP_PERFECT_739) || \
504 : defined(MAP_PERFECT_740) || defined(MAP_PERFECT_741) || defined(MAP_PERFECT_742) || defined(MAP_PERFECT_743) || defined(MAP_PERFECT_744) || \
505 : defined(MAP_PERFECT_745) || defined(MAP_PERFECT_746) || defined(MAP_PERFECT_747) || defined(MAP_PERFECT_748) || defined(MAP_PERFECT_749) || \
506 : defined(MAP_PERFECT_750) || defined(MAP_PERFECT_751) || defined(MAP_PERFECT_752) || defined(MAP_PERFECT_753) || defined(MAP_PERFECT_754) || \
507 : defined(MAP_PERFECT_755) || defined(MAP_PERFECT_756) || defined(MAP_PERFECT_757) || defined(MAP_PERFECT_758) || defined(MAP_PERFECT_759) || \
508 : defined(MAP_PERFECT_760) || defined(MAP_PERFECT_761) || defined(MAP_PERFECT_762) || defined(MAP_PERFECT_763) || defined(MAP_PERFECT_764) || \
509 : defined(MAP_PERFECT_765) || defined(MAP_PERFECT_766) || defined(MAP_PERFECT_767) || defined(MAP_PERFECT_768) || defined(MAP_PERFECT_769) || \
510 : defined(MAP_PERFECT_770) || defined(MAP_PERFECT_771) || defined(MAP_PERFECT_772) || defined(MAP_PERFECT_773) || defined(MAP_PERFECT_774) || \
511 : defined(MAP_PERFECT_775) || defined(MAP_PERFECT_776) || defined(MAP_PERFECT_777) || defined(MAP_PERFECT_778) || defined(MAP_PERFECT_779) || \
512 : defined(MAP_PERFECT_780) || defined(MAP_PERFECT_781) || defined(MAP_PERFECT_782) || defined(MAP_PERFECT_783) || defined(MAP_PERFECT_784) || \
513 : defined(MAP_PERFECT_785) || defined(MAP_PERFECT_786) || defined(MAP_PERFECT_787) || defined(MAP_PERFECT_788) || defined(MAP_PERFECT_789) || \
514 : defined(MAP_PERFECT_790) || defined(MAP_PERFECT_791) || defined(MAP_PERFECT_792) || defined(MAP_PERFECT_793) || defined(MAP_PERFECT_794) || \
515 : defined(MAP_PERFECT_795) || defined(MAP_PERFECT_796) || defined(MAP_PERFECT_797) || defined(MAP_PERFECT_798) || defined(MAP_PERFECT_799) || \
516 : defined(MAP_PERFECT_800) || defined(MAP_PERFECT_801) || defined(MAP_PERFECT_802) || defined(MAP_PERFECT_803) || defined(MAP_PERFECT_804) || \
517 : defined(MAP_PERFECT_805) || defined(MAP_PERFECT_806) || defined(MAP_PERFECT_807) || defined(MAP_PERFECT_808) || defined(MAP_PERFECT_809) || \
518 : defined(MAP_PERFECT_810) || defined(MAP_PERFECT_811) || defined(MAP_PERFECT_812) || defined(MAP_PERFECT_813) || defined(MAP_PERFECT_814) || \
519 : defined(MAP_PERFECT_815) || defined(MAP_PERFECT_816) || defined(MAP_PERFECT_817) || defined(MAP_PERFECT_818) || defined(MAP_PERFECT_819) || \
520 : defined(MAP_PERFECT_820) || defined(MAP_PERFECT_821) || defined(MAP_PERFECT_822) || defined(MAP_PERFECT_823) || defined(MAP_PERFECT_824) || \
521 : defined(MAP_PERFECT_825) || defined(MAP_PERFECT_826) || defined(MAP_PERFECT_827) || defined(MAP_PERFECT_828) || defined(MAP_PERFECT_829) || \
522 : defined(MAP_PERFECT_830) || defined(MAP_PERFECT_831) || defined(MAP_PERFECT_832) || defined(MAP_PERFECT_833) || defined(MAP_PERFECT_834) || \
523 : defined(MAP_PERFECT_835) || defined(MAP_PERFECT_836) || defined(MAP_PERFECT_837) || defined(MAP_PERFECT_838) || defined(MAP_PERFECT_839) || \
524 : defined(MAP_PERFECT_840) || defined(MAP_PERFECT_841) || defined(MAP_PERFECT_842) || defined(MAP_PERFECT_843) || defined(MAP_PERFECT_844) || \
525 : defined(MAP_PERFECT_845) || defined(MAP_PERFECT_846) || defined(MAP_PERFECT_847) || defined(MAP_PERFECT_848) || defined(MAP_PERFECT_849) || \
526 : defined(MAP_PERFECT_850) || defined(MAP_PERFECT_851) || defined(MAP_PERFECT_852) || defined(MAP_PERFECT_853) || defined(MAP_PERFECT_854) || \
527 : defined(MAP_PERFECT_855) || defined(MAP_PERFECT_856) || defined(MAP_PERFECT_857) || defined(MAP_PERFECT_858) || defined(MAP_PERFECT_859) || \
528 : defined(MAP_PERFECT_860) || defined(MAP_PERFECT_861) || defined(MAP_PERFECT_862) || defined(MAP_PERFECT_863) || defined(MAP_PERFECT_864) || \
529 : defined(MAP_PERFECT_865) || defined(MAP_PERFECT_866) || defined(MAP_PERFECT_867) || defined(MAP_PERFECT_868) || defined(MAP_PERFECT_869) || \
530 : defined(MAP_PERFECT_870) || defined(MAP_PERFECT_871) || defined(MAP_PERFECT_872) || defined(MAP_PERFECT_873) || defined(MAP_PERFECT_874) || \
531 : defined(MAP_PERFECT_875) || defined(MAP_PERFECT_876) || defined(MAP_PERFECT_877) || defined(MAP_PERFECT_878) || defined(MAP_PERFECT_879) || \
532 : defined(MAP_PERFECT_880) || defined(MAP_PERFECT_881) || defined(MAP_PERFECT_882) || defined(MAP_PERFECT_883) || defined(MAP_PERFECT_884) || \
533 : defined(MAP_PERFECT_885) || defined(MAP_PERFECT_886) || defined(MAP_PERFECT_887) || defined(MAP_PERFECT_888) || defined(MAP_PERFECT_889) || \
534 : defined(MAP_PERFECT_890) || defined(MAP_PERFECT_891) || defined(MAP_PERFECT_892) || defined(MAP_PERFECT_893) || defined(MAP_PERFECT_894) || \
535 : defined(MAP_PERFECT_895) || defined(MAP_PERFECT_896) || defined(MAP_PERFECT_897) || defined(MAP_PERFECT_898) || defined(MAP_PERFECT_899) || \
536 : defined(MAP_PERFECT_900) || defined(MAP_PERFECT_901) || defined(MAP_PERFECT_902) || defined(MAP_PERFECT_903) || defined(MAP_PERFECT_904) || \
537 : defined(MAP_PERFECT_905) || defined(MAP_PERFECT_906) || defined(MAP_PERFECT_907) || defined(MAP_PERFECT_908) || defined(MAP_PERFECT_909) || \
538 : defined(MAP_PERFECT_910) || defined(MAP_PERFECT_911) || defined(MAP_PERFECT_912) || defined(MAP_PERFECT_913) || defined(MAP_PERFECT_914) || \
539 : defined(MAP_PERFECT_915) || defined(MAP_PERFECT_916) || defined(MAP_PERFECT_917) || defined(MAP_PERFECT_918) || defined(MAP_PERFECT_919) || \
540 : defined(MAP_PERFECT_920) || defined(MAP_PERFECT_921) || defined(MAP_PERFECT_922) || defined(MAP_PERFECT_923) || defined(MAP_PERFECT_924) || \
541 : defined(MAP_PERFECT_925) || defined(MAP_PERFECT_926) || defined(MAP_PERFECT_927) || defined(MAP_PERFECT_928) || defined(MAP_PERFECT_929) || \
542 : defined(MAP_PERFECT_930) || defined(MAP_PERFECT_931) || defined(MAP_PERFECT_932) || defined(MAP_PERFECT_933) || defined(MAP_PERFECT_934) || \
543 : defined(MAP_PERFECT_935) || defined(MAP_PERFECT_936) || defined(MAP_PERFECT_937) || defined(MAP_PERFECT_938) || defined(MAP_PERFECT_939) || \
544 : defined(MAP_PERFECT_940) || defined(MAP_PERFECT_941) || defined(MAP_PERFECT_942) || defined(MAP_PERFECT_943) || defined(MAP_PERFECT_944) || \
545 : defined(MAP_PERFECT_945) || defined(MAP_PERFECT_946) || defined(MAP_PERFECT_947) || defined(MAP_PERFECT_948) || defined(MAP_PERFECT_949) || \
546 : defined(MAP_PERFECT_950) || defined(MAP_PERFECT_951) || defined(MAP_PERFECT_952) || defined(MAP_PERFECT_953) || defined(MAP_PERFECT_954) || \
547 : defined(MAP_PERFECT_955) || defined(MAP_PERFECT_956) || defined(MAP_PERFECT_957) || defined(MAP_PERFECT_958) || defined(MAP_PERFECT_959) || \
548 : defined(MAP_PERFECT_960) || defined(MAP_PERFECT_961) || defined(MAP_PERFECT_962) || defined(MAP_PERFECT_963) || defined(MAP_PERFECT_964) || \
549 : defined(MAP_PERFECT_965) || defined(MAP_PERFECT_966) || defined(MAP_PERFECT_967) || defined(MAP_PERFECT_968) || defined(MAP_PERFECT_969) || \
550 : defined(MAP_PERFECT_970) || defined(MAP_PERFECT_971) || defined(MAP_PERFECT_972) || defined(MAP_PERFECT_973) || defined(MAP_PERFECT_974) || \
551 : defined(MAP_PERFECT_975) || defined(MAP_PERFECT_976) || defined(MAP_PERFECT_977) || defined(MAP_PERFECT_978) || defined(MAP_PERFECT_979) || \
552 : defined(MAP_PERFECT_980) || defined(MAP_PERFECT_981) || defined(MAP_PERFECT_982) || defined(MAP_PERFECT_983) || defined(MAP_PERFECT_984) || \
553 : defined(MAP_PERFECT_985) || defined(MAP_PERFECT_986) || defined(MAP_PERFECT_987) || defined(MAP_PERFECT_988) || defined(MAP_PERFECT_989) || \
554 : defined(MAP_PERFECT_990) || defined(MAP_PERFECT_991) || defined(MAP_PERFECT_992) || defined(MAP_PERFECT_993) || defined(MAP_PERFECT_994) || \
555 : defined(MAP_PERFECT_995) || defined(MAP_PERFECT_996) || defined(MAP_PERFECT_997) || defined(MAP_PERFECT_998) || defined(MAP_PERFECT_999)
556 : # define FD_MP_RECURSE_ALL FD_MP_RECURSE4
557 : #else
558 : # define FD_MP_RECURSE_ALL FD_MP_RECURSE3
559 : #endif
560 :
561 : #if FD_MP_RECURSE_ALL( MAP_PERFECT_, , FD_MP_AND, FD_MP_EMPTY(), 0, FD_MP_CHOOSE_NONZERO)
562 : #define FD_MP_ZERO_KEY_VAL_1( ... ) \
563 : { . MAP_PERFECT_KEY = FD_MP_FORMAT_KEY( FD_MP_KEY(__VA_ARGS__) ), \
564 : FD_MP_VAL(__VA_ARGS__) }
565 : #define FD_MP_ZERO_KEY_ELE [ FD_MP_HASH_PP_1(MAP_PERFECT_ZERO_KEY) ] = \
566 : FD_MP_ZERO_KEY_VAL_1(MAP_PERFECT_0),
567 : #else
568 : #define FD_MP_ZERO_KEY_ELE
569 : #endif
570 :
571 : static const MAP_PERFECT_T MAP_PERFECT_(tbl)[ 1<<MAP_PERFECT_LG_TBL_SZ ] = {
572 : FD_MP_RECURSE_ALL( MAP_PERFECT_, , FD_MP_EMPTY, FD_MP_EMPTY(), 0, FD_MP_CHOOSE_MAKE )
573 : FD_MP_ZERO_KEY_ELE
574 : };
575 :
576 :
577 : static inline int
578 179753 : MAP_PERFECT_(contains)( MAP_PERFECT_KEY_T key ) {
579 179753 : uint hash = MAP_PERFECT_HASH_R( key );
580 179753 : return MAP_PERFECT_KEYS_EQUAL( MAP_PERFECT_(tbl)[ hash ].MAP_PERFECT_KEY, key );
581 179753 : }
582 :
583 : static inline MAP_PERFECT_T const *
584 16480923 : MAP_PERFECT_(query)( MAP_PERFECT_KEY_T key, MAP_PERFECT_T const * null ) {
585 16480923 : uint hash = MAP_PERFECT_HASH_R( key );
586 16480923 : int contained = MAP_PERFECT_KEYS_EQUAL( MAP_PERFECT_(tbl)[ hash ].MAP_PERFECT_KEY, key );
587 16480923 : return fd_ptr_if( contained, MAP_PERFECT_(tbl)+hash, null );
588 16480923 : }
589 :
590 : static inline uint
591 1527 : MAP_PERFECT_(hash_or_default)( MAP_PERFECT_KEY_T key ) {
592 1527 : uint hash = MAP_PERFECT_HASH_R( key );
593 1527 : int contained = MAP_PERFECT_KEYS_EQUAL( MAP_PERFECT_(tbl)[ hash ].MAP_PERFECT_KEY, key );
594 1527 : return fd_uint_if( contained, hash, UINT_MAX );
595 1527 : }
596 :
597 : #undef FD_MP_ZERO_KEY_ELE
598 : #undef FD_MP_ZERO_KEY_VAL_1
599 : #undef FD_MP_CHOOSE_NONZERO
600 : #undef FD_MP_NONZERO_ELE_1
601 : #undef FD_MP_NONZERO_ELE_0
602 : #undef FD_MP_CHOOSE_MAKE
603 : #undef FD_MP_MAKE_ELE_0
604 : #undef FD_MP_MAKE_ELE_1
605 : #undef FD_MP_ADD_ELE
606 : #undef FD_MP_VAL
607 : #undef FD_MP_KEY
608 : #undef FD_MP_HASH_PP_3
609 : #undef FD_MP_HASH_PP_2
610 : #undef FD_MP_HASH_PP_1
611 : #undef FD_MP_FORMAT_KEY
612 : #undef FD_MP_EAT_PARENS
613 : #undef FD_MP_AND
614 : #undef FD_MP_EMPTY
615 : #undef FD_MP_RECURSE_ALL
616 : #undef FD_MP_RECURSE_1
617 : #undef FD_MP_RECURSE_2
618 : #undef FD_MP_RECURSE_3
619 : #undef FD_MP_RECURSE_4
620 : #undef FD_MP_HAS_COMMA
621 : #undef FD_MP_ARG_100
622 : #undef FD_MP_EXPAND
623 : #undef MAP_PERFECT_
624 : #undef MAP_PERFECT_HASH_R
625 : #undef MAP_PERFECT_HASH_PP
626 : #undef MAP_PERFECT_HASH_C
627 : #undef MAP_PERFECT_KEYS_EQUAL
628 : #undef MAP_PERFECT_ZERO_KEY
629 : #undef MAP_PERFECT_COMPLEX_KEY
630 : #undef MAP_PERFECT_KEY_T
631 : #undef MAP_PERFECT_KEY
632 : #undef MAP_PERFECT_T
633 : #undef MAP_PERFECT_LG_TBL_SZ
634 : #undef MAP_PERFECT_NAME
635 :
636 : /* Finally, undefine all the 1000 possible entries... It's not possible to
637 : make a macro emit an undef command. Nothing else follows this section. */
638 : #undef MAP_PERFECT_999
639 : #undef MAP_PERFECT_998
640 : #undef MAP_PERFECT_997
641 : #undef MAP_PERFECT_996
642 : #undef MAP_PERFECT_995
643 : #undef MAP_PERFECT_994
644 : #undef MAP_PERFECT_993
645 : #undef MAP_PERFECT_992
646 : #undef MAP_PERFECT_991
647 : #undef MAP_PERFECT_990
648 : #undef MAP_PERFECT_989
649 : #undef MAP_PERFECT_988
650 : #undef MAP_PERFECT_987
651 : #undef MAP_PERFECT_986
652 : #undef MAP_PERFECT_985
653 : #undef MAP_PERFECT_984
654 : #undef MAP_PERFECT_983
655 : #undef MAP_PERFECT_982
656 : #undef MAP_PERFECT_981
657 : #undef MAP_PERFECT_980
658 : #undef MAP_PERFECT_979
659 : #undef MAP_PERFECT_978
660 : #undef MAP_PERFECT_977
661 : #undef MAP_PERFECT_976
662 : #undef MAP_PERFECT_975
663 : #undef MAP_PERFECT_974
664 : #undef MAP_PERFECT_973
665 : #undef MAP_PERFECT_972
666 : #undef MAP_PERFECT_971
667 : #undef MAP_PERFECT_970
668 : #undef MAP_PERFECT_969
669 : #undef MAP_PERFECT_968
670 : #undef MAP_PERFECT_967
671 : #undef MAP_PERFECT_966
672 : #undef MAP_PERFECT_965
673 : #undef MAP_PERFECT_964
674 : #undef MAP_PERFECT_963
675 : #undef MAP_PERFECT_962
676 : #undef MAP_PERFECT_961
677 : #undef MAP_PERFECT_960
678 : #undef MAP_PERFECT_959
679 : #undef MAP_PERFECT_958
680 : #undef MAP_PERFECT_957
681 : #undef MAP_PERFECT_956
682 : #undef MAP_PERFECT_955
683 : #undef MAP_PERFECT_954
684 : #undef MAP_PERFECT_953
685 : #undef MAP_PERFECT_952
686 : #undef MAP_PERFECT_951
687 : #undef MAP_PERFECT_950
688 : #undef MAP_PERFECT_949
689 : #undef MAP_PERFECT_948
690 : #undef MAP_PERFECT_947
691 : #undef MAP_PERFECT_946
692 : #undef MAP_PERFECT_945
693 : #undef MAP_PERFECT_944
694 : #undef MAP_PERFECT_943
695 : #undef MAP_PERFECT_942
696 : #undef MAP_PERFECT_941
697 : #undef MAP_PERFECT_940
698 : #undef MAP_PERFECT_939
699 : #undef MAP_PERFECT_938
700 : #undef MAP_PERFECT_937
701 : #undef MAP_PERFECT_936
702 : #undef MAP_PERFECT_935
703 : #undef MAP_PERFECT_934
704 : #undef MAP_PERFECT_933
705 : #undef MAP_PERFECT_932
706 : #undef MAP_PERFECT_931
707 : #undef MAP_PERFECT_930
708 : #undef MAP_PERFECT_929
709 : #undef MAP_PERFECT_928
710 : #undef MAP_PERFECT_927
711 : #undef MAP_PERFECT_926
712 : #undef MAP_PERFECT_925
713 : #undef MAP_PERFECT_924
714 : #undef MAP_PERFECT_923
715 : #undef MAP_PERFECT_922
716 : #undef MAP_PERFECT_921
717 : #undef MAP_PERFECT_920
718 : #undef MAP_PERFECT_919
719 : #undef MAP_PERFECT_918
720 : #undef MAP_PERFECT_917
721 : #undef MAP_PERFECT_916
722 : #undef MAP_PERFECT_915
723 : #undef MAP_PERFECT_914
724 : #undef MAP_PERFECT_913
725 : #undef MAP_PERFECT_912
726 : #undef MAP_PERFECT_911
727 : #undef MAP_PERFECT_910
728 : #undef MAP_PERFECT_909
729 : #undef MAP_PERFECT_908
730 : #undef MAP_PERFECT_907
731 : #undef MAP_PERFECT_906
732 : #undef MAP_PERFECT_905
733 : #undef MAP_PERFECT_904
734 : #undef MAP_PERFECT_903
735 : #undef MAP_PERFECT_902
736 : #undef MAP_PERFECT_901
737 : #undef MAP_PERFECT_900
738 : #undef MAP_PERFECT_899
739 : #undef MAP_PERFECT_898
740 : #undef MAP_PERFECT_897
741 : #undef MAP_PERFECT_896
742 : #undef MAP_PERFECT_895
743 : #undef MAP_PERFECT_894
744 : #undef MAP_PERFECT_893
745 : #undef MAP_PERFECT_892
746 : #undef MAP_PERFECT_891
747 : #undef MAP_PERFECT_890
748 : #undef MAP_PERFECT_889
749 : #undef MAP_PERFECT_888
750 : #undef MAP_PERFECT_887
751 : #undef MAP_PERFECT_886
752 : #undef MAP_PERFECT_885
753 : #undef MAP_PERFECT_884
754 : #undef MAP_PERFECT_883
755 : #undef MAP_PERFECT_882
756 : #undef MAP_PERFECT_881
757 : #undef MAP_PERFECT_880
758 : #undef MAP_PERFECT_879
759 : #undef MAP_PERFECT_878
760 : #undef MAP_PERFECT_877
761 : #undef MAP_PERFECT_876
762 : #undef MAP_PERFECT_875
763 : #undef MAP_PERFECT_874
764 : #undef MAP_PERFECT_873
765 : #undef MAP_PERFECT_872
766 : #undef MAP_PERFECT_871
767 : #undef MAP_PERFECT_870
768 : #undef MAP_PERFECT_869
769 : #undef MAP_PERFECT_868
770 : #undef MAP_PERFECT_867
771 : #undef MAP_PERFECT_866
772 : #undef MAP_PERFECT_865
773 : #undef MAP_PERFECT_864
774 : #undef MAP_PERFECT_863
775 : #undef MAP_PERFECT_862
776 : #undef MAP_PERFECT_861
777 : #undef MAP_PERFECT_860
778 : #undef MAP_PERFECT_859
779 : #undef MAP_PERFECT_858
780 : #undef MAP_PERFECT_857
781 : #undef MAP_PERFECT_856
782 : #undef MAP_PERFECT_855
783 : #undef MAP_PERFECT_854
784 : #undef MAP_PERFECT_853
785 : #undef MAP_PERFECT_852
786 : #undef MAP_PERFECT_851
787 : #undef MAP_PERFECT_850
788 : #undef MAP_PERFECT_849
789 : #undef MAP_PERFECT_848
790 : #undef MAP_PERFECT_847
791 : #undef MAP_PERFECT_846
792 : #undef MAP_PERFECT_845
793 : #undef MAP_PERFECT_844
794 : #undef MAP_PERFECT_843
795 : #undef MAP_PERFECT_842
796 : #undef MAP_PERFECT_841
797 : #undef MAP_PERFECT_840
798 : #undef MAP_PERFECT_839
799 : #undef MAP_PERFECT_838
800 : #undef MAP_PERFECT_837
801 : #undef MAP_PERFECT_836
802 : #undef MAP_PERFECT_835
803 : #undef MAP_PERFECT_834
804 : #undef MAP_PERFECT_833
805 : #undef MAP_PERFECT_832
806 : #undef MAP_PERFECT_831
807 : #undef MAP_PERFECT_830
808 : #undef MAP_PERFECT_829
809 : #undef MAP_PERFECT_828
810 : #undef MAP_PERFECT_827
811 : #undef MAP_PERFECT_826
812 : #undef MAP_PERFECT_825
813 : #undef MAP_PERFECT_824
814 : #undef MAP_PERFECT_823
815 : #undef MAP_PERFECT_822
816 : #undef MAP_PERFECT_821
817 : #undef MAP_PERFECT_820
818 : #undef MAP_PERFECT_819
819 : #undef MAP_PERFECT_818
820 : #undef MAP_PERFECT_817
821 : #undef MAP_PERFECT_816
822 : #undef MAP_PERFECT_815
823 : #undef MAP_PERFECT_814
824 : #undef MAP_PERFECT_813
825 : #undef MAP_PERFECT_812
826 : #undef MAP_PERFECT_811
827 : #undef MAP_PERFECT_810
828 : #undef MAP_PERFECT_809
829 : #undef MAP_PERFECT_808
830 : #undef MAP_PERFECT_807
831 : #undef MAP_PERFECT_806
832 : #undef MAP_PERFECT_805
833 : #undef MAP_PERFECT_804
834 : #undef MAP_PERFECT_803
835 : #undef MAP_PERFECT_802
836 : #undef MAP_PERFECT_801
837 : #undef MAP_PERFECT_800
838 : #undef MAP_PERFECT_799
839 : #undef MAP_PERFECT_798
840 : #undef MAP_PERFECT_797
841 : #undef MAP_PERFECT_796
842 : #undef MAP_PERFECT_795
843 : #undef MAP_PERFECT_794
844 : #undef MAP_PERFECT_793
845 : #undef MAP_PERFECT_792
846 : #undef MAP_PERFECT_791
847 : #undef MAP_PERFECT_790
848 : #undef MAP_PERFECT_789
849 : #undef MAP_PERFECT_788
850 : #undef MAP_PERFECT_787
851 : #undef MAP_PERFECT_786
852 : #undef MAP_PERFECT_785
853 : #undef MAP_PERFECT_784
854 : #undef MAP_PERFECT_783
855 : #undef MAP_PERFECT_782
856 : #undef MAP_PERFECT_781
857 : #undef MAP_PERFECT_780
858 : #undef MAP_PERFECT_779
859 : #undef MAP_PERFECT_778
860 : #undef MAP_PERFECT_777
861 : #undef MAP_PERFECT_776
862 : #undef MAP_PERFECT_775
863 : #undef MAP_PERFECT_774
864 : #undef MAP_PERFECT_773
865 : #undef MAP_PERFECT_772
866 : #undef MAP_PERFECT_771
867 : #undef MAP_PERFECT_770
868 : #undef MAP_PERFECT_769
869 : #undef MAP_PERFECT_768
870 : #undef MAP_PERFECT_767
871 : #undef MAP_PERFECT_766
872 : #undef MAP_PERFECT_765
873 : #undef MAP_PERFECT_764
874 : #undef MAP_PERFECT_763
875 : #undef MAP_PERFECT_762
876 : #undef MAP_PERFECT_761
877 : #undef MAP_PERFECT_760
878 : #undef MAP_PERFECT_759
879 : #undef MAP_PERFECT_758
880 : #undef MAP_PERFECT_757
881 : #undef MAP_PERFECT_756
882 : #undef MAP_PERFECT_755
883 : #undef MAP_PERFECT_754
884 : #undef MAP_PERFECT_753
885 : #undef MAP_PERFECT_752
886 : #undef MAP_PERFECT_751
887 : #undef MAP_PERFECT_750
888 : #undef MAP_PERFECT_749
889 : #undef MAP_PERFECT_748
890 : #undef MAP_PERFECT_747
891 : #undef MAP_PERFECT_746
892 : #undef MAP_PERFECT_745
893 : #undef MAP_PERFECT_744
894 : #undef MAP_PERFECT_743
895 : #undef MAP_PERFECT_742
896 : #undef MAP_PERFECT_741
897 : #undef MAP_PERFECT_740
898 : #undef MAP_PERFECT_739
899 : #undef MAP_PERFECT_738
900 : #undef MAP_PERFECT_737
901 : #undef MAP_PERFECT_736
902 : #undef MAP_PERFECT_735
903 : #undef MAP_PERFECT_734
904 : #undef MAP_PERFECT_733
905 : #undef MAP_PERFECT_732
906 : #undef MAP_PERFECT_731
907 : #undef MAP_PERFECT_730
908 : #undef MAP_PERFECT_729
909 : #undef MAP_PERFECT_728
910 : #undef MAP_PERFECT_727
911 : #undef MAP_PERFECT_726
912 : #undef MAP_PERFECT_725
913 : #undef MAP_PERFECT_724
914 : #undef MAP_PERFECT_723
915 : #undef MAP_PERFECT_722
916 : #undef MAP_PERFECT_721
917 : #undef MAP_PERFECT_720
918 : #undef MAP_PERFECT_719
919 : #undef MAP_PERFECT_718
920 : #undef MAP_PERFECT_717
921 : #undef MAP_PERFECT_716
922 : #undef MAP_PERFECT_715
923 : #undef MAP_PERFECT_714
924 : #undef MAP_PERFECT_713
925 : #undef MAP_PERFECT_712
926 : #undef MAP_PERFECT_711
927 : #undef MAP_PERFECT_710
928 : #undef MAP_PERFECT_709
929 : #undef MAP_PERFECT_708
930 : #undef MAP_PERFECT_707
931 : #undef MAP_PERFECT_706
932 : #undef MAP_PERFECT_705
933 : #undef MAP_PERFECT_704
934 : #undef MAP_PERFECT_703
935 : #undef MAP_PERFECT_702
936 : #undef MAP_PERFECT_701
937 : #undef MAP_PERFECT_700
938 : #undef MAP_PERFECT_699
939 : #undef MAP_PERFECT_698
940 : #undef MAP_PERFECT_697
941 : #undef MAP_PERFECT_696
942 : #undef MAP_PERFECT_695
943 : #undef MAP_PERFECT_694
944 : #undef MAP_PERFECT_693
945 : #undef MAP_PERFECT_692
946 : #undef MAP_PERFECT_691
947 : #undef MAP_PERFECT_690
948 : #undef MAP_PERFECT_689
949 : #undef MAP_PERFECT_688
950 : #undef MAP_PERFECT_687
951 : #undef MAP_PERFECT_686
952 : #undef MAP_PERFECT_685
953 : #undef MAP_PERFECT_684
954 : #undef MAP_PERFECT_683
955 : #undef MAP_PERFECT_682
956 : #undef MAP_PERFECT_681
957 : #undef MAP_PERFECT_680
958 : #undef MAP_PERFECT_679
959 : #undef MAP_PERFECT_678
960 : #undef MAP_PERFECT_677
961 : #undef MAP_PERFECT_676
962 : #undef MAP_PERFECT_675
963 : #undef MAP_PERFECT_674
964 : #undef MAP_PERFECT_673
965 : #undef MAP_PERFECT_672
966 : #undef MAP_PERFECT_671
967 : #undef MAP_PERFECT_670
968 : #undef MAP_PERFECT_669
969 : #undef MAP_PERFECT_668
970 : #undef MAP_PERFECT_667
971 : #undef MAP_PERFECT_666
972 : #undef MAP_PERFECT_665
973 : #undef MAP_PERFECT_664
974 : #undef MAP_PERFECT_663
975 : #undef MAP_PERFECT_662
976 : #undef MAP_PERFECT_661
977 : #undef MAP_PERFECT_660
978 : #undef MAP_PERFECT_659
979 : #undef MAP_PERFECT_658
980 : #undef MAP_PERFECT_657
981 : #undef MAP_PERFECT_656
982 : #undef MAP_PERFECT_655
983 : #undef MAP_PERFECT_654
984 : #undef MAP_PERFECT_653
985 : #undef MAP_PERFECT_652
986 : #undef MAP_PERFECT_651
987 : #undef MAP_PERFECT_650
988 : #undef MAP_PERFECT_649
989 : #undef MAP_PERFECT_648
990 : #undef MAP_PERFECT_647
991 : #undef MAP_PERFECT_646
992 : #undef MAP_PERFECT_645
993 : #undef MAP_PERFECT_644
994 : #undef MAP_PERFECT_643
995 : #undef MAP_PERFECT_642
996 : #undef MAP_PERFECT_641
997 : #undef MAP_PERFECT_640
998 : #undef MAP_PERFECT_639
999 : #undef MAP_PERFECT_638
1000 : #undef MAP_PERFECT_637
1001 : #undef MAP_PERFECT_636
1002 : #undef MAP_PERFECT_635
1003 : #undef MAP_PERFECT_634
1004 : #undef MAP_PERFECT_633
1005 : #undef MAP_PERFECT_632
1006 : #undef MAP_PERFECT_631
1007 : #undef MAP_PERFECT_630
1008 : #undef MAP_PERFECT_629
1009 : #undef MAP_PERFECT_628
1010 : #undef MAP_PERFECT_627
1011 : #undef MAP_PERFECT_626
1012 : #undef MAP_PERFECT_625
1013 : #undef MAP_PERFECT_624
1014 : #undef MAP_PERFECT_623
1015 : #undef MAP_PERFECT_622
1016 : #undef MAP_PERFECT_621
1017 : #undef MAP_PERFECT_620
1018 : #undef MAP_PERFECT_619
1019 : #undef MAP_PERFECT_618
1020 : #undef MAP_PERFECT_617
1021 : #undef MAP_PERFECT_616
1022 : #undef MAP_PERFECT_615
1023 : #undef MAP_PERFECT_614
1024 : #undef MAP_PERFECT_613
1025 : #undef MAP_PERFECT_612
1026 : #undef MAP_PERFECT_611
1027 : #undef MAP_PERFECT_610
1028 : #undef MAP_PERFECT_609
1029 : #undef MAP_PERFECT_608
1030 : #undef MAP_PERFECT_607
1031 : #undef MAP_PERFECT_606
1032 : #undef MAP_PERFECT_605
1033 : #undef MAP_PERFECT_604
1034 : #undef MAP_PERFECT_603
1035 : #undef MAP_PERFECT_602
1036 : #undef MAP_PERFECT_601
1037 : #undef MAP_PERFECT_600
1038 : #undef MAP_PERFECT_599
1039 : #undef MAP_PERFECT_598
1040 : #undef MAP_PERFECT_597
1041 : #undef MAP_PERFECT_596
1042 : #undef MAP_PERFECT_595
1043 : #undef MAP_PERFECT_594
1044 : #undef MAP_PERFECT_593
1045 : #undef MAP_PERFECT_592
1046 : #undef MAP_PERFECT_591
1047 : #undef MAP_PERFECT_590
1048 : #undef MAP_PERFECT_589
1049 : #undef MAP_PERFECT_588
1050 : #undef MAP_PERFECT_587
1051 : #undef MAP_PERFECT_586
1052 : #undef MAP_PERFECT_585
1053 : #undef MAP_PERFECT_584
1054 : #undef MAP_PERFECT_583
1055 : #undef MAP_PERFECT_582
1056 : #undef MAP_PERFECT_581
1057 : #undef MAP_PERFECT_580
1058 : #undef MAP_PERFECT_579
1059 : #undef MAP_PERFECT_578
1060 : #undef MAP_PERFECT_577
1061 : #undef MAP_PERFECT_576
1062 : #undef MAP_PERFECT_575
1063 : #undef MAP_PERFECT_574
1064 : #undef MAP_PERFECT_573
1065 : #undef MAP_PERFECT_572
1066 : #undef MAP_PERFECT_571
1067 : #undef MAP_PERFECT_570
1068 : #undef MAP_PERFECT_569
1069 : #undef MAP_PERFECT_568
1070 : #undef MAP_PERFECT_567
1071 : #undef MAP_PERFECT_566
1072 : #undef MAP_PERFECT_565
1073 : #undef MAP_PERFECT_564
1074 : #undef MAP_PERFECT_563
1075 : #undef MAP_PERFECT_562
1076 : #undef MAP_PERFECT_561
1077 : #undef MAP_PERFECT_560
1078 : #undef MAP_PERFECT_559
1079 : #undef MAP_PERFECT_558
1080 : #undef MAP_PERFECT_557
1081 : #undef MAP_PERFECT_556
1082 : #undef MAP_PERFECT_555
1083 : #undef MAP_PERFECT_554
1084 : #undef MAP_PERFECT_553
1085 : #undef MAP_PERFECT_552
1086 : #undef MAP_PERFECT_551
1087 : #undef MAP_PERFECT_550
1088 : #undef MAP_PERFECT_549
1089 : #undef MAP_PERFECT_548
1090 : #undef MAP_PERFECT_547
1091 : #undef MAP_PERFECT_546
1092 : #undef MAP_PERFECT_545
1093 : #undef MAP_PERFECT_544
1094 : #undef MAP_PERFECT_543
1095 : #undef MAP_PERFECT_542
1096 : #undef MAP_PERFECT_541
1097 : #undef MAP_PERFECT_540
1098 : #undef MAP_PERFECT_539
1099 : #undef MAP_PERFECT_538
1100 : #undef MAP_PERFECT_537
1101 : #undef MAP_PERFECT_536
1102 : #undef MAP_PERFECT_535
1103 : #undef MAP_PERFECT_534
1104 : #undef MAP_PERFECT_533
1105 : #undef MAP_PERFECT_532
1106 : #undef MAP_PERFECT_531
1107 : #undef MAP_PERFECT_530
1108 : #undef MAP_PERFECT_529
1109 : #undef MAP_PERFECT_528
1110 : #undef MAP_PERFECT_527
1111 : #undef MAP_PERFECT_526
1112 : #undef MAP_PERFECT_525
1113 : #undef MAP_PERFECT_524
1114 : #undef MAP_PERFECT_523
1115 : #undef MAP_PERFECT_522
1116 : #undef MAP_PERFECT_521
1117 : #undef MAP_PERFECT_520
1118 : #undef MAP_PERFECT_519
1119 : #undef MAP_PERFECT_518
1120 : #undef MAP_PERFECT_517
1121 : #undef MAP_PERFECT_516
1122 : #undef MAP_PERFECT_515
1123 : #undef MAP_PERFECT_514
1124 : #undef MAP_PERFECT_513
1125 : #undef MAP_PERFECT_512
1126 : #undef MAP_PERFECT_511
1127 : #undef MAP_PERFECT_510
1128 : #undef MAP_PERFECT_509
1129 : #undef MAP_PERFECT_508
1130 : #undef MAP_PERFECT_507
1131 : #undef MAP_PERFECT_506
1132 : #undef MAP_PERFECT_505
1133 : #undef MAP_PERFECT_504
1134 : #undef MAP_PERFECT_503
1135 : #undef MAP_PERFECT_502
1136 : #undef MAP_PERFECT_501
1137 : #undef MAP_PERFECT_500
1138 : #undef MAP_PERFECT_499
1139 : #undef MAP_PERFECT_498
1140 : #undef MAP_PERFECT_497
1141 : #undef MAP_PERFECT_496
1142 : #undef MAP_PERFECT_495
1143 : #undef MAP_PERFECT_494
1144 : #undef MAP_PERFECT_493
1145 : #undef MAP_PERFECT_492
1146 : #undef MAP_PERFECT_491
1147 : #undef MAP_PERFECT_490
1148 : #undef MAP_PERFECT_489
1149 : #undef MAP_PERFECT_488
1150 : #undef MAP_PERFECT_487
1151 : #undef MAP_PERFECT_486
1152 : #undef MAP_PERFECT_485
1153 : #undef MAP_PERFECT_484
1154 : #undef MAP_PERFECT_483
1155 : #undef MAP_PERFECT_482
1156 : #undef MAP_PERFECT_481
1157 : #undef MAP_PERFECT_480
1158 : #undef MAP_PERFECT_479
1159 : #undef MAP_PERFECT_478
1160 : #undef MAP_PERFECT_477
1161 : #undef MAP_PERFECT_476
1162 : #undef MAP_PERFECT_475
1163 : #undef MAP_PERFECT_474
1164 : #undef MAP_PERFECT_473
1165 : #undef MAP_PERFECT_472
1166 : #undef MAP_PERFECT_471
1167 : #undef MAP_PERFECT_470
1168 : #undef MAP_PERFECT_469
1169 : #undef MAP_PERFECT_468
1170 : #undef MAP_PERFECT_467
1171 : #undef MAP_PERFECT_466
1172 : #undef MAP_PERFECT_465
1173 : #undef MAP_PERFECT_464
1174 : #undef MAP_PERFECT_463
1175 : #undef MAP_PERFECT_462
1176 : #undef MAP_PERFECT_461
1177 : #undef MAP_PERFECT_460
1178 : #undef MAP_PERFECT_459
1179 : #undef MAP_PERFECT_458
1180 : #undef MAP_PERFECT_457
1181 : #undef MAP_PERFECT_456
1182 : #undef MAP_PERFECT_455
1183 : #undef MAP_PERFECT_454
1184 : #undef MAP_PERFECT_453
1185 : #undef MAP_PERFECT_452
1186 : #undef MAP_PERFECT_451
1187 : #undef MAP_PERFECT_450
1188 : #undef MAP_PERFECT_449
1189 : #undef MAP_PERFECT_448
1190 : #undef MAP_PERFECT_447
1191 : #undef MAP_PERFECT_446
1192 : #undef MAP_PERFECT_445
1193 : #undef MAP_PERFECT_444
1194 : #undef MAP_PERFECT_443
1195 : #undef MAP_PERFECT_442
1196 : #undef MAP_PERFECT_441
1197 : #undef MAP_PERFECT_440
1198 : #undef MAP_PERFECT_439
1199 : #undef MAP_PERFECT_438
1200 : #undef MAP_PERFECT_437
1201 : #undef MAP_PERFECT_436
1202 : #undef MAP_PERFECT_435
1203 : #undef MAP_PERFECT_434
1204 : #undef MAP_PERFECT_433
1205 : #undef MAP_PERFECT_432
1206 : #undef MAP_PERFECT_431
1207 : #undef MAP_PERFECT_430
1208 : #undef MAP_PERFECT_429
1209 : #undef MAP_PERFECT_428
1210 : #undef MAP_PERFECT_427
1211 : #undef MAP_PERFECT_426
1212 : #undef MAP_PERFECT_425
1213 : #undef MAP_PERFECT_424
1214 : #undef MAP_PERFECT_423
1215 : #undef MAP_PERFECT_422
1216 : #undef MAP_PERFECT_421
1217 : #undef MAP_PERFECT_420
1218 : #undef MAP_PERFECT_419
1219 : #undef MAP_PERFECT_418
1220 : #undef MAP_PERFECT_417
1221 : #undef MAP_PERFECT_416
1222 : #undef MAP_PERFECT_415
1223 : #undef MAP_PERFECT_414
1224 : #undef MAP_PERFECT_413
1225 : #undef MAP_PERFECT_412
1226 : #undef MAP_PERFECT_411
1227 : #undef MAP_PERFECT_410
1228 : #undef MAP_PERFECT_409
1229 : #undef MAP_PERFECT_408
1230 : #undef MAP_PERFECT_407
1231 : #undef MAP_PERFECT_406
1232 : #undef MAP_PERFECT_405
1233 : #undef MAP_PERFECT_404
1234 : #undef MAP_PERFECT_403
1235 : #undef MAP_PERFECT_402
1236 : #undef MAP_PERFECT_401
1237 : #undef MAP_PERFECT_400
1238 : #undef MAP_PERFECT_399
1239 : #undef MAP_PERFECT_398
1240 : #undef MAP_PERFECT_397
1241 : #undef MAP_PERFECT_396
1242 : #undef MAP_PERFECT_395
1243 : #undef MAP_PERFECT_394
1244 : #undef MAP_PERFECT_393
1245 : #undef MAP_PERFECT_392
1246 : #undef MAP_PERFECT_391
1247 : #undef MAP_PERFECT_390
1248 : #undef MAP_PERFECT_389
1249 : #undef MAP_PERFECT_388
1250 : #undef MAP_PERFECT_387
1251 : #undef MAP_PERFECT_386
1252 : #undef MAP_PERFECT_385
1253 : #undef MAP_PERFECT_384
1254 : #undef MAP_PERFECT_383
1255 : #undef MAP_PERFECT_382
1256 : #undef MAP_PERFECT_381
1257 : #undef MAP_PERFECT_380
1258 : #undef MAP_PERFECT_379
1259 : #undef MAP_PERFECT_378
1260 : #undef MAP_PERFECT_377
1261 : #undef MAP_PERFECT_376
1262 : #undef MAP_PERFECT_375
1263 : #undef MAP_PERFECT_374
1264 : #undef MAP_PERFECT_373
1265 : #undef MAP_PERFECT_372
1266 : #undef MAP_PERFECT_371
1267 : #undef MAP_PERFECT_370
1268 : #undef MAP_PERFECT_369
1269 : #undef MAP_PERFECT_368
1270 : #undef MAP_PERFECT_367
1271 : #undef MAP_PERFECT_366
1272 : #undef MAP_PERFECT_365
1273 : #undef MAP_PERFECT_364
1274 : #undef MAP_PERFECT_363
1275 : #undef MAP_PERFECT_362
1276 : #undef MAP_PERFECT_361
1277 : #undef MAP_PERFECT_360
1278 : #undef MAP_PERFECT_359
1279 : #undef MAP_PERFECT_358
1280 : #undef MAP_PERFECT_357
1281 : #undef MAP_PERFECT_356
1282 : #undef MAP_PERFECT_355
1283 : #undef MAP_PERFECT_354
1284 : #undef MAP_PERFECT_353
1285 : #undef MAP_PERFECT_352
1286 : #undef MAP_PERFECT_351
1287 : #undef MAP_PERFECT_350
1288 : #undef MAP_PERFECT_349
1289 : #undef MAP_PERFECT_348
1290 : #undef MAP_PERFECT_347
1291 : #undef MAP_PERFECT_346
1292 : #undef MAP_PERFECT_345
1293 : #undef MAP_PERFECT_344
1294 : #undef MAP_PERFECT_343
1295 : #undef MAP_PERFECT_342
1296 : #undef MAP_PERFECT_341
1297 : #undef MAP_PERFECT_340
1298 : #undef MAP_PERFECT_339
1299 : #undef MAP_PERFECT_338
1300 : #undef MAP_PERFECT_337
1301 : #undef MAP_PERFECT_336
1302 : #undef MAP_PERFECT_335
1303 : #undef MAP_PERFECT_334
1304 : #undef MAP_PERFECT_333
1305 : #undef MAP_PERFECT_332
1306 : #undef MAP_PERFECT_331
1307 : #undef MAP_PERFECT_330
1308 : #undef MAP_PERFECT_329
1309 : #undef MAP_PERFECT_328
1310 : #undef MAP_PERFECT_327
1311 : #undef MAP_PERFECT_326
1312 : #undef MAP_PERFECT_325
1313 : #undef MAP_PERFECT_324
1314 : #undef MAP_PERFECT_323
1315 : #undef MAP_PERFECT_322
1316 : #undef MAP_PERFECT_321
1317 : #undef MAP_PERFECT_320
1318 : #undef MAP_PERFECT_319
1319 : #undef MAP_PERFECT_318
1320 : #undef MAP_PERFECT_317
1321 : #undef MAP_PERFECT_316
1322 : #undef MAP_PERFECT_315
1323 : #undef MAP_PERFECT_314
1324 : #undef MAP_PERFECT_313
1325 : #undef MAP_PERFECT_312
1326 : #undef MAP_PERFECT_311
1327 : #undef MAP_PERFECT_310
1328 : #undef MAP_PERFECT_309
1329 : #undef MAP_PERFECT_308
1330 : #undef MAP_PERFECT_307
1331 : #undef MAP_PERFECT_306
1332 : #undef MAP_PERFECT_305
1333 : #undef MAP_PERFECT_304
1334 : #undef MAP_PERFECT_303
1335 : #undef MAP_PERFECT_302
1336 : #undef MAP_PERFECT_301
1337 : #undef MAP_PERFECT_300
1338 : #undef MAP_PERFECT_299
1339 : #undef MAP_PERFECT_298
1340 : #undef MAP_PERFECT_297
1341 : #undef MAP_PERFECT_296
1342 : #undef MAP_PERFECT_295
1343 : #undef MAP_PERFECT_294
1344 : #undef MAP_PERFECT_293
1345 : #undef MAP_PERFECT_292
1346 : #undef MAP_PERFECT_291
1347 : #undef MAP_PERFECT_290
1348 : #undef MAP_PERFECT_289
1349 : #undef MAP_PERFECT_288
1350 : #undef MAP_PERFECT_287
1351 : #undef MAP_PERFECT_286
1352 : #undef MAP_PERFECT_285
1353 : #undef MAP_PERFECT_284
1354 : #undef MAP_PERFECT_283
1355 : #undef MAP_PERFECT_282
1356 : #undef MAP_PERFECT_281
1357 : #undef MAP_PERFECT_280
1358 : #undef MAP_PERFECT_279
1359 : #undef MAP_PERFECT_278
1360 : #undef MAP_PERFECT_277
1361 : #undef MAP_PERFECT_276
1362 : #undef MAP_PERFECT_275
1363 : #undef MAP_PERFECT_274
1364 : #undef MAP_PERFECT_273
1365 : #undef MAP_PERFECT_272
1366 : #undef MAP_PERFECT_271
1367 : #undef MAP_PERFECT_270
1368 : #undef MAP_PERFECT_269
1369 : #undef MAP_PERFECT_268
1370 : #undef MAP_PERFECT_267
1371 : #undef MAP_PERFECT_266
1372 : #undef MAP_PERFECT_265
1373 : #undef MAP_PERFECT_264
1374 : #undef MAP_PERFECT_263
1375 : #undef MAP_PERFECT_262
1376 : #undef MAP_PERFECT_261
1377 : #undef MAP_PERFECT_260
1378 : #undef MAP_PERFECT_259
1379 : #undef MAP_PERFECT_258
1380 : #undef MAP_PERFECT_257
1381 : #undef MAP_PERFECT_256
1382 : #undef MAP_PERFECT_255
1383 : #undef MAP_PERFECT_254
1384 : #undef MAP_PERFECT_253
1385 : #undef MAP_PERFECT_252
1386 : #undef MAP_PERFECT_251
1387 : #undef MAP_PERFECT_250
1388 : #undef MAP_PERFECT_249
1389 : #undef MAP_PERFECT_248
1390 : #undef MAP_PERFECT_247
1391 : #undef MAP_PERFECT_246
1392 : #undef MAP_PERFECT_245
1393 : #undef MAP_PERFECT_244
1394 : #undef MAP_PERFECT_243
1395 : #undef MAP_PERFECT_242
1396 : #undef MAP_PERFECT_241
1397 : #undef MAP_PERFECT_240
1398 : #undef MAP_PERFECT_239
1399 : #undef MAP_PERFECT_238
1400 : #undef MAP_PERFECT_237
1401 : #undef MAP_PERFECT_236
1402 : #undef MAP_PERFECT_235
1403 : #undef MAP_PERFECT_234
1404 : #undef MAP_PERFECT_233
1405 : #undef MAP_PERFECT_232
1406 : #undef MAP_PERFECT_231
1407 : #undef MAP_PERFECT_230
1408 : #undef MAP_PERFECT_229
1409 : #undef MAP_PERFECT_228
1410 : #undef MAP_PERFECT_227
1411 : #undef MAP_PERFECT_226
1412 : #undef MAP_PERFECT_225
1413 : #undef MAP_PERFECT_224
1414 : #undef MAP_PERFECT_223
1415 : #undef MAP_PERFECT_222
1416 : #undef MAP_PERFECT_221
1417 : #undef MAP_PERFECT_220
1418 : #undef MAP_PERFECT_219
1419 : #undef MAP_PERFECT_218
1420 : #undef MAP_PERFECT_217
1421 : #undef MAP_PERFECT_216
1422 : #undef MAP_PERFECT_215
1423 : #undef MAP_PERFECT_214
1424 : #undef MAP_PERFECT_213
1425 : #undef MAP_PERFECT_212
1426 : #undef MAP_PERFECT_211
1427 : #undef MAP_PERFECT_210
1428 : #undef MAP_PERFECT_209
1429 : #undef MAP_PERFECT_208
1430 : #undef MAP_PERFECT_207
1431 : #undef MAP_PERFECT_206
1432 : #undef MAP_PERFECT_205
1433 : #undef MAP_PERFECT_204
1434 : #undef MAP_PERFECT_203
1435 : #undef MAP_PERFECT_202
1436 : #undef MAP_PERFECT_201
1437 : #undef MAP_PERFECT_200
1438 : #undef MAP_PERFECT_199
1439 : #undef MAP_PERFECT_198
1440 : #undef MAP_PERFECT_197
1441 : #undef MAP_PERFECT_196
1442 : #undef MAP_PERFECT_195
1443 : #undef MAP_PERFECT_194
1444 : #undef MAP_PERFECT_193
1445 : #undef MAP_PERFECT_192
1446 : #undef MAP_PERFECT_191
1447 : #undef MAP_PERFECT_190
1448 : #undef MAP_PERFECT_189
1449 : #undef MAP_PERFECT_188
1450 : #undef MAP_PERFECT_187
1451 : #undef MAP_PERFECT_186
1452 : #undef MAP_PERFECT_185
1453 : #undef MAP_PERFECT_184
1454 : #undef MAP_PERFECT_183
1455 : #undef MAP_PERFECT_182
1456 : #undef MAP_PERFECT_181
1457 : #undef MAP_PERFECT_180
1458 : #undef MAP_PERFECT_179
1459 : #undef MAP_PERFECT_178
1460 : #undef MAP_PERFECT_177
1461 : #undef MAP_PERFECT_176
1462 : #undef MAP_PERFECT_175
1463 : #undef MAP_PERFECT_174
1464 : #undef MAP_PERFECT_173
1465 : #undef MAP_PERFECT_172
1466 : #undef MAP_PERFECT_171
1467 : #undef MAP_PERFECT_170
1468 : #undef MAP_PERFECT_169
1469 : #undef MAP_PERFECT_168
1470 : #undef MAP_PERFECT_167
1471 : #undef MAP_PERFECT_166
1472 : #undef MAP_PERFECT_165
1473 : #undef MAP_PERFECT_164
1474 : #undef MAP_PERFECT_163
1475 : #undef MAP_PERFECT_162
1476 : #undef MAP_PERFECT_161
1477 : #undef MAP_PERFECT_160
1478 : #undef MAP_PERFECT_159
1479 : #undef MAP_PERFECT_158
1480 : #undef MAP_PERFECT_157
1481 : #undef MAP_PERFECT_156
1482 : #undef MAP_PERFECT_155
1483 : #undef MAP_PERFECT_154
1484 : #undef MAP_PERFECT_153
1485 : #undef MAP_PERFECT_152
1486 : #undef MAP_PERFECT_151
1487 : #undef MAP_PERFECT_150
1488 : #undef MAP_PERFECT_149
1489 : #undef MAP_PERFECT_148
1490 : #undef MAP_PERFECT_147
1491 : #undef MAP_PERFECT_146
1492 : #undef MAP_PERFECT_145
1493 : #undef MAP_PERFECT_144
1494 : #undef MAP_PERFECT_143
1495 : #undef MAP_PERFECT_142
1496 : #undef MAP_PERFECT_141
1497 : #undef MAP_PERFECT_140
1498 : #undef MAP_PERFECT_139
1499 : #undef MAP_PERFECT_138
1500 : #undef MAP_PERFECT_137
1501 : #undef MAP_PERFECT_136
1502 : #undef MAP_PERFECT_135
1503 : #undef MAP_PERFECT_134
1504 : #undef MAP_PERFECT_133
1505 : #undef MAP_PERFECT_132
1506 : #undef MAP_PERFECT_131
1507 : #undef MAP_PERFECT_130
1508 : #undef MAP_PERFECT_129
1509 : #undef MAP_PERFECT_128
1510 : #undef MAP_PERFECT_127
1511 : #undef MAP_PERFECT_126
1512 : #undef MAP_PERFECT_125
1513 : #undef MAP_PERFECT_124
1514 : #undef MAP_PERFECT_123
1515 : #undef MAP_PERFECT_122
1516 : #undef MAP_PERFECT_121
1517 : #undef MAP_PERFECT_120
1518 : #undef MAP_PERFECT_119
1519 : #undef MAP_PERFECT_118
1520 : #undef MAP_PERFECT_117
1521 : #undef MAP_PERFECT_116
1522 : #undef MAP_PERFECT_115
1523 : #undef MAP_PERFECT_114
1524 : #undef MAP_PERFECT_113
1525 : #undef MAP_PERFECT_112
1526 : #undef MAP_PERFECT_111
1527 : #undef MAP_PERFECT_110
1528 : #undef MAP_PERFECT_109
1529 : #undef MAP_PERFECT_108
1530 : #undef MAP_PERFECT_107
1531 : #undef MAP_PERFECT_106
1532 : #undef MAP_PERFECT_105
1533 : #undef MAP_PERFECT_104
1534 : #undef MAP_PERFECT_103
1535 : #undef MAP_PERFECT_102
1536 : #undef MAP_PERFECT_101
1537 : #undef MAP_PERFECT_100
1538 : #undef MAP_PERFECT_99
1539 : #undef MAP_PERFECT_98
1540 : #undef MAP_PERFECT_97
1541 : #undef MAP_PERFECT_96
1542 : #undef MAP_PERFECT_95
1543 : #undef MAP_PERFECT_94
1544 : #undef MAP_PERFECT_93
1545 : #undef MAP_PERFECT_92
1546 : #undef MAP_PERFECT_91
1547 : #undef MAP_PERFECT_90
1548 : #undef MAP_PERFECT_89
1549 : #undef MAP_PERFECT_88
1550 : #undef MAP_PERFECT_87
1551 : #undef MAP_PERFECT_86
1552 : #undef MAP_PERFECT_85
1553 : #undef MAP_PERFECT_84
1554 : #undef MAP_PERFECT_83
1555 : #undef MAP_PERFECT_82
1556 : #undef MAP_PERFECT_81
1557 : #undef MAP_PERFECT_80
1558 : #undef MAP_PERFECT_79
1559 : #undef MAP_PERFECT_78
1560 : #undef MAP_PERFECT_77
1561 : #undef MAP_PERFECT_76
1562 : #undef MAP_PERFECT_75
1563 : #undef MAP_PERFECT_74
1564 : #undef MAP_PERFECT_73
1565 : #undef MAP_PERFECT_72
1566 : #undef MAP_PERFECT_71
1567 : #undef MAP_PERFECT_70
1568 : #undef MAP_PERFECT_69
1569 : #undef MAP_PERFECT_68
1570 : #undef MAP_PERFECT_67
1571 : #undef MAP_PERFECT_66
1572 : #undef MAP_PERFECT_65
1573 : #undef MAP_PERFECT_64
1574 : #undef MAP_PERFECT_63
1575 : #undef MAP_PERFECT_62
1576 : #undef MAP_PERFECT_61
1577 : #undef MAP_PERFECT_60
1578 : #undef MAP_PERFECT_59
1579 : #undef MAP_PERFECT_58
1580 : #undef MAP_PERFECT_57
1581 : #undef MAP_PERFECT_56
1582 : #undef MAP_PERFECT_55
1583 : #undef MAP_PERFECT_54
1584 : #undef MAP_PERFECT_53
1585 : #undef MAP_PERFECT_52
1586 : #undef MAP_PERFECT_51
1587 : #undef MAP_PERFECT_50
1588 : #undef MAP_PERFECT_49
1589 : #undef MAP_PERFECT_48
1590 : #undef MAP_PERFECT_47
1591 : #undef MAP_PERFECT_46
1592 : #undef MAP_PERFECT_45
1593 : #undef MAP_PERFECT_44
1594 : #undef MAP_PERFECT_43
1595 : #undef MAP_PERFECT_42
1596 : #undef MAP_PERFECT_41
1597 : #undef MAP_PERFECT_40
1598 : #undef MAP_PERFECT_39
1599 : #undef MAP_PERFECT_38
1600 : #undef MAP_PERFECT_37
1601 : #undef MAP_PERFECT_36
1602 : #undef MAP_PERFECT_35
1603 : #undef MAP_PERFECT_34
1604 : #undef MAP_PERFECT_33
1605 : #undef MAP_PERFECT_32
1606 : #undef MAP_PERFECT_31
1607 : #undef MAP_PERFECT_30
1608 : #undef MAP_PERFECT_29
1609 : #undef MAP_PERFECT_28
1610 : #undef MAP_PERFECT_27
1611 : #undef MAP_PERFECT_26
1612 : #undef MAP_PERFECT_25
1613 : #undef MAP_PERFECT_24
1614 : #undef MAP_PERFECT_23
1615 : #undef MAP_PERFECT_22
1616 : #undef MAP_PERFECT_21
1617 : #undef MAP_PERFECT_20
1618 : #undef MAP_PERFECT_19
1619 : #undef MAP_PERFECT_18
1620 : #undef MAP_PERFECT_17
1621 : #undef MAP_PERFECT_16
1622 : #undef MAP_PERFECT_15
1623 : #undef MAP_PERFECT_14
1624 : #undef MAP_PERFECT_13
1625 : #undef MAP_PERFECT_12
1626 : #undef MAP_PERFECT_11
1627 : #undef MAP_PERFECT_10
1628 : #undef MAP_PERFECT_9
1629 : #undef MAP_PERFECT_8
1630 : #undef MAP_PERFECT_7
1631 : #undef MAP_PERFECT_6
1632 : #undef MAP_PERFECT_5
1633 : #undef MAP_PERFECT_4
1634 : #undef MAP_PERFECT_3
1635 : #undef MAP_PERFECT_2
1636 : #undef MAP_PERFECT_1
1637 : #undef MAP_PERFECT_0
|
