Commit | Line | Data |
---|---|---|
cffb78b0 | 1 | /* |
cffb78b0 | 2 | * LZ4 - Fast LZ compression algorithm |
4e1a33b1 SS |
3 | * Copyright (C) 2011 - 2016, Yann Collet. |
4 | * BSD 2 - Clause License (http://www.opensource.org/licenses/bsd - license.php) | |
cffb78b0 KL |
5 | * Redistribution and use in source and binary forms, with or without |
6 | * modification, are permitted provided that the following conditions are | |
7 | * met: | |
4e1a33b1 SS |
8 | * * Redistributions of source code must retain the above copyright |
9 | * notice, this list of conditions and the following disclaimer. | |
10 | * * Redistributions in binary form must reproduce the above | |
cffb78b0 KL |
11 | * copyright notice, this list of conditions and the following disclaimer |
12 | * in the documentation and/or other materials provided with the | |
13 | * distribution. | |
cffb78b0 KL |
14 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
15 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
16 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
17 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
18 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
19 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
20 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
21 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
22 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
23 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
24 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
4e1a33b1 SS |
25 | * You can contact the author at : |
26 | * - LZ4 homepage : http://www.lz4.org | |
27 | * - LZ4 source repository : https://github.com/lz4/lz4 | |
cffb78b0 | 28 | * |
4e1a33b1 SS |
29 | * Changed for kernel usage by: |
30 | * Sven Schmidt <4sschmid@informatik.uni-hamburg.de> | |
cffb78b0 KL |
31 | */ |
32 | ||
4e1a33b1 SS |
33 | /*-************************************ |
34 | * Dependencies | |
35 | **************************************/ | |
36 | #include <linux/lz4.h> | |
37 | #include "lz4defs.h" | |
38 | #include <linux/init.h> | |
cffb78b0 KL |
39 | #include <linux/module.h> |
40 | #include <linux/kernel.h> | |
cffb78b0 KL |
41 | #include <asm/unaligned.h> |
42 | ||
4e1a33b1 SS |
43 | /*-***************************** |
44 | * Decompression functions | |
45 | *******************************/ | |
46 | /* LZ4_decompress_generic() : | |
47 | * This generic decompression function cover all use cases. | |
48 | * It shall be instantiated several times, using different sets of directives | |
49 | * Note that it is important this generic function is really inlined, | |
50 | * in order to remove useless branches during compilation optimization. | |
51 | */ | |
52 | static FORCE_INLINE int LZ4_decompress_generic( | |
53 | const char * const source, | |
54 | char * const dest, | |
55 | int inputSize, | |
56 | /* | |
57 | * If endOnInput == endOnInputSize, | |
58 | * this value is the max size of Output Buffer. | |
59 | */ | |
60 | int outputSize, | |
61 | /* endOnOutputSize, endOnInputSize */ | |
62 | int endOnInput, | |
63 | /* full, partial */ | |
64 | int partialDecoding, | |
65 | /* only used if partialDecoding == partial */ | |
66 | int targetOutputSize, | |
67 | /* noDict, withPrefix64k, usingExtDict */ | |
68 | int dict, | |
69 | /* == dest when no prefix */ | |
70 | const BYTE * const lowPrefix, | |
71 | /* only if dict == usingExtDict */ | |
72 | const BYTE * const dictStart, | |
73 | /* note : = 0 if noDict */ | |
74 | const size_t dictSize | |
75 | ) | |
cffb78b0 | 76 | { |
4e1a33b1 | 77 | /* Local Variables */ |
cffb78b0 | 78 | const BYTE *ip = (const BYTE *) source; |
4e1a33b1 SS |
79 | const BYTE * const iend = ip + inputSize; |
80 | ||
cffb78b0 | 81 | BYTE *op = (BYTE *) dest; |
4e1a33b1 | 82 | BYTE * const oend = op + outputSize; |
cffb78b0 | 83 | BYTE *cpy; |
4e1a33b1 SS |
84 | BYTE *oexit = op + targetOutputSize; |
85 | const BYTE * const lowLimit = lowPrefix - dictSize; | |
86 | ||
87 | const BYTE * const dictEnd = (const BYTE *)dictStart + dictSize; | |
88 | const unsigned int dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 }; | |
89 | const int dec64table[] = { 0, 0, 0, -1, 0, 1, 2, 3 }; | |
cffb78b0 | 90 | |
4e1a33b1 SS |
91 | const int safeDecode = (endOnInput == endOnInputSize); |
92 | const int checkOffset = ((safeDecode) && (dictSize < (int)(64 * KB))); | |
93 | ||
94 | /* Special cases */ | |
95 | /* targetOutputSize too high => decode everything */ | |
96 | if ((partialDecoding) && (oexit > oend - MFLIMIT)) | |
97 | oexit = oend - MFLIMIT; | |
98 | ||
99 | /* Empty output buffer */ | |
100 | if ((endOnInput) && (unlikely(outputSize == 0))) | |
101 | return ((inputSize == 1) && (*ip == 0)) ? 0 : -1; | |
102 | ||
103 | if ((!endOnInput) && (unlikely(outputSize == 0))) | |
104 | return (*ip == 0 ? 1 : -1); | |
105 | ||
106 | /* Main Loop : decode sequences */ | |
cffb78b0 | 107 | while (1) { |
4e1a33b1 SS |
108 | size_t length; |
109 | const BYTE *match; | |
110 | size_t offset; | |
111 | ||
112 | /* get literal length */ | |
113 | unsigned int const token = *ip++; | |
114 | ||
115 | length = token>>ML_BITS; | |
cffb78b0 | 116 | |
cffb78b0 | 117 | if (length == RUN_MASK) { |
4e1a33b1 | 118 | unsigned int s; |
cffb78b0 | 119 | |
4e1a33b1 SS |
120 | do { |
121 | s = *ip++; | |
122 | length += s; | |
123 | } while (likely(endOnInput | |
124 | ? ip < iend - RUN_MASK | |
125 | : 1) & (s == 255)); | |
126 | ||
127 | if ((safeDecode) | |
128 | && unlikely( | |
129 | (size_t)(op + length) < (size_t)(op))) { | |
130 | /* overflow detection */ | |
206204a1 | 131 | goto _output_error; |
4e1a33b1 SS |
132 | } |
133 | if ((safeDecode) | |
134 | && unlikely( | |
135 | (size_t)(ip + length) < (size_t)(ip))) { | |
136 | /* overflow detection */ | |
137 | goto _output_error; | |
138 | } | |
cffb78b0 KL |
139 | } |
140 | ||
141 | /* copy literals */ | |
142 | cpy = op + length; | |
4e1a33b1 SS |
143 | if (((endOnInput) && ((cpy > (partialDecoding ? oexit : oend - MFLIMIT)) |
144 | || (ip + length > iend - (2 + 1 + LASTLITERALS)))) | |
145 | || ((!endOnInput) && (cpy > oend - WILDCOPYLENGTH))) { | |
146 | if (partialDecoding) { | |
147 | if (cpy > oend) { | |
148 | /* | |
149 | * Error : | |
150 | * write attempt beyond end of output buffer | |
151 | */ | |
152 | goto _output_error; | |
153 | } | |
154 | if ((endOnInput) | |
155 | && (ip + length > iend)) { | |
156 | /* | |
157 | * Error : | |
158 | * read attempt beyond | |
159 | * end of input buffer | |
160 | */ | |
161 | goto _output_error; | |
162 | } | |
163 | } else { | |
164 | if ((!endOnInput) | |
165 | && (cpy != oend)) { | |
166 | /* | |
167 | * Error : | |
168 | * block decoding must | |
169 | * stop exactly there | |
170 | */ | |
171 | goto _output_error; | |
172 | } | |
173 | if ((endOnInput) | |
174 | && ((ip + length != iend) | |
175 | || (cpy > oend))) { | |
176 | /* | |
177 | * Error : | |
178 | * input must be consumed | |
179 | */ | |
180 | goto _output_error; | |
181 | } | |
182 | } | |
cffb78b0 KL |
183 | |
184 | memcpy(op, ip, length); | |
185 | ip += length; | |
4e1a33b1 SS |
186 | op += length; |
187 | /* Necessarily EOF, due to parsing restrictions */ | |
188 | break; | |
cffb78b0 | 189 | } |
4e1a33b1 SS |
190 | |
191 | LZ4_wildCopy(op, ip, cpy); | |
192 | ip += length; | |
cffb78b0 KL |
193 | op = cpy; |
194 | ||
195 | /* get offset */ | |
4e1a33b1 | 196 | offset = LZ4_readLE16(ip); |
cffb78b0 | 197 | ip += 2; |
4e1a33b1 | 198 | match = op - offset; |
cffb78b0 | 199 | |
4e1a33b1 SS |
200 | if ((checkOffset) && (unlikely(match < lowLimit))) { |
201 | /* Error : offset outside buffers */ | |
cffb78b0 | 202 | goto _output_error; |
4e1a33b1 SS |
203 | } |
204 | ||
205 | /* costs ~1%; silence an msan warning when offset == 0 */ | |
206 | LZ4_write32(op, (U32)offset); | |
cffb78b0 KL |
207 | |
208 | /* get matchlength */ | |
209 | length = token & ML_MASK; | |
210 | if (length == ML_MASK) { | |
4e1a33b1 SS |
211 | unsigned int s; |
212 | ||
213 | do { | |
214 | s = *ip++; | |
215 | ||
216 | if ((endOnInput) && (ip > iend - LASTLITERALS)) | |
217 | goto _output_error; | |
218 | ||
219 | length += s; | |
220 | } while (s == 255); | |
221 | ||
222 | if ((safeDecode) | |
223 | && unlikely( | |
224 | (size_t)(op + length) < (size_t)op)) { | |
225 | /* overflow detection */ | |
4148c1f6 | 226 | goto _output_error; |
4e1a33b1 | 227 | } |
cffb78b0 KL |
228 | } |
229 | ||
4e1a33b1 SS |
230 | length += MINMATCH; |
231 | ||
232 | /* check external dictionary */ | |
233 | if ((dict == usingExtDict) && (match < lowPrefix)) { | |
234 | if (unlikely(op + length > oend - LASTLITERALS)) { | |
235 | /* doesn't respect parsing restriction */ | |
236 | goto _output_error; | |
237 | } | |
238 | ||
239 | if (length <= (size_t)(lowPrefix - match)) { | |
240 | /* | |
241 | * match can be copied as a single segment | |
242 | * from external dictionary | |
243 | */ | |
244 | memmove(op, dictEnd - (lowPrefix - match), | |
245 | length); | |
246 | op += length; | |
247 | } else { | |
248 | /* | |
249 | * match encompass external | |
250 | * dictionary and current block | |
251 | */ | |
252 | size_t const copySize = (size_t)(lowPrefix - match); | |
253 | size_t const restSize = length - copySize; | |
254 | ||
255 | memcpy(op, dictEnd - copySize, copySize); | |
256 | op += copySize; | |
257 | ||
258 | if (restSize > (size_t)(op - lowPrefix)) { | |
259 | /* overlap copy */ | |
260 | BYTE * const endOfMatch = op + restSize; | |
261 | const BYTE *copyFrom = lowPrefix; | |
262 | ||
263 | while (op < endOfMatch) | |
264 | *op++ = *copyFrom++; | |
265 | } else { | |
266 | memcpy(op, lowPrefix, restSize); | |
267 | op += restSize; | |
268 | } | |
269 | } | |
270 | ||
271 | continue; | |
272 | } | |
273 | ||
274 | /* copy match within block */ | |
275 | cpy = op + length; | |
276 | ||
277 | if (unlikely(offset < 8)) { | |
278 | const int dec64 = dec64table[offset]; | |
279 | ||
280 | op[0] = match[0]; | |
281 | op[1] = match[1]; | |
282 | op[2] = match[2]; | |
283 | op[3] = match[3]; | |
284 | match += dec32table[offset]; | |
285 | memcpy(op + 4, match, 4); | |
286 | match -= dec64; | |
cffb78b0 | 287 | } else { |
4e1a33b1 SS |
288 | LZ4_copy8(op, match); |
289 | match += 8; | |
cffb78b0 | 290 | } |
cffb78b0 | 291 | |
4e1a33b1 SS |
292 | op += 8; |
293 | ||
294 | if (unlikely(cpy > oend - 12)) { | |
295 | BYTE * const oCopyLimit = oend - (WILDCOPYLENGTH - 1); | |
296 | ||
297 | if (cpy > oend - LASTLITERALS) { | |
298 | /* | |
299 | * Error : last LASTLITERALS bytes | |
300 | * must be literals (uncompressed) | |
301 | */ | |
d5e7cafd | 302 | goto _output_error; |
4e1a33b1 SS |
303 | } |
304 | ||
305 | if (op < oCopyLimit) { | |
306 | LZ4_wildCopy(op, match, oCopyLimit); | |
307 | match += oCopyLimit - op; | |
308 | op = oCopyLimit; | |
309 | } | |
310 | ||
cffb78b0 | 311 | while (op < cpy) |
4e1a33b1 SS |
312 | *op++ = *match++; |
313 | } else { | |
314 | LZ4_copy8(op, match); | |
315 | ||
316 | if (length > 16) | |
317 | LZ4_wildCopy(op + 8, match + 8, cpy); | |
cffb78b0 | 318 | } |
4e1a33b1 | 319 | |
cffb78b0 KL |
320 | op = cpy; /* correction */ |
321 | } | |
4e1a33b1 | 322 | |
cffb78b0 | 323 | /* end of decoding */ |
4e1a33b1 SS |
324 | if (endOnInput) { |
325 | /* Nb of output bytes decoded */ | |
326 | return (int) (((char *)op) - dest); | |
327 | } else { | |
328 | /* Nb of input bytes read */ | |
329 | return (int) (((const char *)ip) - source); | |
330 | } | |
cffb78b0 | 331 | |
4e1a33b1 | 332 | /* Overflow error detected */ |
cffb78b0 | 333 | _output_error: |
4148c1f6 | 334 | return -1; |
cffb78b0 KL |
335 | } |
336 | ||
4e1a33b1 SS |
337 | int LZ4_decompress_safe(const char *source, char *dest, |
338 | int compressedSize, int maxDecompressedSize) | |
cffb78b0 | 339 | { |
4e1a33b1 SS |
340 | return LZ4_decompress_generic(source, dest, compressedSize, |
341 | maxDecompressedSize, endOnInputSize, full, 0, | |
342 | noDict, (BYTE *)dest, NULL, 0); | |
343 | } | |
cffb78b0 | 344 | |
4e1a33b1 SS |
345 | int LZ4_decompress_safe_partial(const char *source, char *dest, |
346 | int compressedSize, int targetOutputSize, int maxDecompressedSize) | |
347 | { | |
348 | return LZ4_decompress_generic(source, dest, compressedSize, | |
349 | maxDecompressedSize, endOnInputSize, partial, | |
350 | targetOutputSize, noDict, (BYTE *)dest, NULL, 0); | |
351 | } | |
cffb78b0 | 352 | |
4e1a33b1 SS |
353 | int LZ4_decompress_fast(const char *source, char *dest, int originalSize) |
354 | { | |
355 | return LZ4_decompress_generic(source, dest, 0, originalSize, | |
356 | endOnOutputSize, full, 0, withPrefix64k, | |
357 | (BYTE *)(dest - 64 * KB), NULL, 64 * KB); | |
358 | } | |
cffb78b0 | 359 | |
4e1a33b1 SS |
360 | int LZ4_setStreamDecode(LZ4_streamDecode_t *LZ4_streamDecode, |
361 | const char *dictionary, int dictSize) | |
362 | { | |
363 | LZ4_streamDecode_t_internal *lz4sd = (LZ4_streamDecode_t_internal *) LZ4_streamDecode; | |
cffb78b0 | 364 | |
4e1a33b1 SS |
365 | lz4sd->prefixSize = (size_t) dictSize; |
366 | lz4sd->prefixEnd = (const BYTE *) dictionary + dictSize; | |
367 | lz4sd->externalDict = NULL; | |
368 | lz4sd->extDictSize = 0; | |
369 | return 1; | |
370 | } | |
cffb78b0 | 371 | |
4e1a33b1 SS |
372 | /* |
373 | * *_continue() : | |
374 | * These decoding functions allow decompression of multiple blocks | |
375 | * in "streaming" mode. | |
376 | * Previously decoded blocks must still be available at the memory | |
377 | * position where they were decoded. | |
378 | * If it's not possible, save the relevant part of | |
379 | * decoded data into a safe buffer, | |
380 | * and indicate where it stands using LZ4_setStreamDecode() | |
381 | */ | |
382 | int LZ4_decompress_safe_continue(LZ4_streamDecode_t *LZ4_streamDecode, | |
383 | const char *source, char *dest, int compressedSize, int maxOutputSize) | |
384 | { | |
385 | LZ4_streamDecode_t_internal *lz4sd = &LZ4_streamDecode->internal_donotuse; | |
386 | int result; | |
387 | ||
388 | if (lz4sd->prefixEnd == (BYTE *)dest) { | |
389 | result = LZ4_decompress_generic(source, dest, | |
390 | compressedSize, | |
391 | maxOutputSize, | |
392 | endOnInputSize, full, 0, | |
393 | usingExtDict, lz4sd->prefixEnd - lz4sd->prefixSize, | |
394 | lz4sd->externalDict, | |
395 | lz4sd->extDictSize); | |
396 | ||
397 | if (result <= 0) | |
398 | return result; | |
399 | ||
400 | lz4sd->prefixSize += result; | |
401 | lz4sd->prefixEnd += result; | |
402 | } else { | |
403 | lz4sd->extDictSize = lz4sd->prefixSize; | |
404 | lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize; | |
405 | result = LZ4_decompress_generic(source, dest, | |
406 | compressedSize, maxOutputSize, | |
407 | endOnInputSize, full, 0, | |
408 | usingExtDict, (BYTE *)dest, | |
409 | lz4sd->externalDict, lz4sd->extDictSize); | |
410 | if (result <= 0) | |
411 | return result; | |
412 | lz4sd->prefixSize = result; | |
413 | lz4sd->prefixEnd = (BYTE *)dest + result; | |
414 | } | |
cffb78b0 | 415 | |
4e1a33b1 SS |
416 | return result; |
417 | } | |
cffb78b0 | 418 | |
4e1a33b1 SS |
419 | int LZ4_decompress_fast_continue(LZ4_streamDecode_t *LZ4_streamDecode, |
420 | const char *source, char *dest, int originalSize) | |
421 | { | |
422 | LZ4_streamDecode_t_internal *lz4sd = &LZ4_streamDecode->internal_donotuse; | |
423 | int result; | |
424 | ||
425 | if (lz4sd->prefixEnd == (BYTE *)dest) { | |
426 | result = LZ4_decompress_generic(source, dest, 0, originalSize, | |
427 | endOnOutputSize, full, 0, | |
428 | usingExtDict, | |
429 | lz4sd->prefixEnd - lz4sd->prefixSize, | |
430 | lz4sd->externalDict, lz4sd->extDictSize); | |
431 | ||
432 | if (result <= 0) | |
433 | return result; | |
434 | ||
435 | lz4sd->prefixSize += originalSize; | |
436 | lz4sd->prefixEnd += originalSize; | |
437 | } else { | |
438 | lz4sd->extDictSize = lz4sd->prefixSize; | |
439 | lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize; | |
440 | result = LZ4_decompress_generic(source, dest, 0, originalSize, | |
441 | endOnOutputSize, full, 0, | |
442 | usingExtDict, (BYTE *)dest, | |
443 | lz4sd->externalDict, lz4sd->extDictSize); | |
444 | if (result <= 0) | |
445 | return result; | |
446 | lz4sd->prefixSize = originalSize; | |
447 | lz4sd->prefixEnd = (BYTE *)dest + originalSize; | |
cffb78b0 | 448 | } |
cffb78b0 | 449 | |
4e1a33b1 | 450 | return result; |
cffb78b0 KL |
451 | } |
452 | ||
4e1a33b1 SS |
453 | /* |
454 | * Advanced decoding functions : | |
455 | * *_usingDict() : | |
456 | * These decoding functions work the same as "_continue" ones, | |
457 | * the dictionary must be explicitly provided within parameters | |
458 | */ | |
459 | static FORCE_INLINE int LZ4_decompress_usingDict_generic(const char *source, | |
460 | char *dest, int compressedSize, int maxOutputSize, int safe, | |
461 | const char *dictStart, int dictSize) | |
cffb78b0 | 462 | { |
4e1a33b1 SS |
463 | if (dictSize == 0) |
464 | return LZ4_decompress_generic(source, dest, | |
465 | compressedSize, maxOutputSize, safe, full, 0, | |
466 | noDict, (BYTE *)dest, NULL, 0); | |
467 | if (dictStart + dictSize == dest) { | |
468 | if (dictSize >= (int)(64 * KB - 1)) | |
469 | return LZ4_decompress_generic(source, dest, | |
470 | compressedSize, maxOutputSize, safe, full, 0, | |
471 | withPrefix64k, (BYTE *)dest - 64 * KB, NULL, 0); | |
472 | return LZ4_decompress_generic(source, dest, compressedSize, | |
473 | maxOutputSize, safe, full, 0, noDict, | |
474 | (BYTE *)dest - dictSize, NULL, 0); | |
475 | } | |
476 | return LZ4_decompress_generic(source, dest, compressedSize, | |
477 | maxOutputSize, safe, full, 0, usingExtDict, | |
478 | (BYTE *)dest, (const BYTE *)dictStart, dictSize); | |
479 | } | |
cffb78b0 | 480 | |
4e1a33b1 SS |
481 | int LZ4_decompress_safe_usingDict(const char *source, char *dest, |
482 | int compressedSize, int maxOutputSize, | |
483 | const char *dictStart, int dictSize) | |
484 | { | |
485 | return LZ4_decompress_usingDict_generic(source, dest, | |
486 | compressedSize, maxOutputSize, 1, dictStart, dictSize); | |
cffb78b0 | 487 | } |
cffb78b0 | 488 | |
4e1a33b1 SS |
489 | int LZ4_decompress_fast_usingDict(const char *source, char *dest, |
490 | int originalSize, const char *dictStart, int dictSize) | |
cffb78b0 | 491 | { |
4e1a33b1 SS |
492 | return LZ4_decompress_usingDict_generic(source, dest, 0, |
493 | originalSize, 0, dictStart, dictSize); | |
cffb78b0 | 494 | } |
4e1a33b1 | 495 | |
cffb78b0 | 496 | #ifndef STATIC |
4e1a33b1 SS |
497 | EXPORT_SYMBOL(LZ4_decompress_safe); |
498 | EXPORT_SYMBOL(LZ4_decompress_safe_partial); | |
499 | EXPORT_SYMBOL(LZ4_decompress_fast); | |
500 | EXPORT_SYMBOL(LZ4_setStreamDecode); | |
501 | EXPORT_SYMBOL(LZ4_decompress_safe_continue); | |
502 | EXPORT_SYMBOL(LZ4_decompress_fast_continue); | |
503 | EXPORT_SYMBOL(LZ4_decompress_safe_usingDict); | |
504 | EXPORT_SYMBOL(LZ4_decompress_fast_usingDict); | |
cffb78b0 | 505 | |
ee8a99bd | 506 | MODULE_LICENSE("Dual BSD/GPL"); |
4e1a33b1 | 507 | MODULE_DESCRIPTION("LZ4 decompressor"); |
cffb78b0 | 508 | #endif |