ng_async.c revision 184205
1/* 2 * ng_async.c 3 */ 4 5/*- 6 * Copyright (c) 1996-1999 Whistle Communications, Inc. 7 * All rights reserved. 8 * 9 * Subject to the following obligations and disclaimer of warranty, use and 10 * redistribution of this software, in source or object code forms, with or 11 * without modifications are expressly permitted by Whistle Communications; 12 * provided, however, that: 13 * 1. Any and all reproductions of the source or object code must include the 14 * copyright notice above and the following disclaimer of warranties; and 15 * 2. No rights are granted, in any manner or form, to use Whistle 16 * Communications, Inc. trademarks, including the mark "WHISTLE 17 * COMMUNICATIONS" on advertising, endorsements, or otherwise except as 18 * such appears in the above copyright notice or in the software. 19 * 20 * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND 21 * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO 22 * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE, 23 * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF 24 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. 25 * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY 26 * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS 27 * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE. 28 * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES 29 * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING 30 * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, 31 * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR 32 * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY 33 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 34 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 35 * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY 36 * OF SUCH DAMAGE. 37 * 38 * Author: Archie Cobbs <archie@freebsd.org> 39 * 40 * $FreeBSD: head/sys/netgraph/ng_async.c 184205 2008-10-23 15:53:51Z des $ 41 * $Whistle: ng_async.c,v 1.17 1999/11/01 09:24:51 julian Exp $ 42 */ 43 44/* 45 * This node type implements a PPP style sync <-> async converter. 46 * See RFC 1661 for details of how asynchronous encoding works. 47 */ 48 49#include <sys/param.h> 50#include <sys/systm.h> 51#include <sys/kernel.h> 52#include <sys/mbuf.h> 53#include <sys/malloc.h> 54#include <sys/errno.h> 55 56#include <netgraph/ng_message.h> 57#include <netgraph/netgraph.h> 58#include <netgraph/ng_async.h> 59#include <netgraph/ng_parse.h> 60 61#include <net/ppp_defs.h> 62 63#ifdef NG_SEPARATE_MALLOC 64MALLOC_DEFINE(M_NETGRAPH_ASYNC, "netgraph_async", "netgraph async node "); 65#else 66#define M_NETGRAPH_ASYNC M_NETGRAPH 67#endif 68 69 70/* Async decode state */ 71#define MODE_HUNT 0 72#define MODE_NORMAL 1 73#define MODE_ESC 2 74 75/* Private data structure */ 76struct ng_async_private { 77 node_p node; /* Our node */ 78 hook_p async; /* Asynchronous side */ 79 hook_p sync; /* Synchronous side */ 80 u_char amode; /* Async hunt/esape mode */ 81 u_int16_t fcs; /* Decoded async FCS (so far) */ 82 u_char *abuf; /* Buffer to encode sync into */ 83 u_char *sbuf; /* Buffer to decode async into */ 84 u_int slen; /* Length of data in sbuf */ 85 long lasttime; /* Time of last async packet sent */ 86 struct ng_async_cfg cfg; /* Configuration */ 87 struct ng_async_stat stats; /* Statistics */ 88}; 89typedef struct ng_async_private *sc_p; 90 91/* Useful macros */ 92#define ASYNC_BUF_SIZE(smru) (2 * (smru) + 10) 93#define SYNC_BUF_SIZE(amru) ((amru) + 10) 94#define ERROUT(x) do { error = (x); goto done; } while (0) 95 96/* Netgraph methods */ 97static ng_constructor_t nga_constructor; 98static ng_rcvdata_t nga_rcvdata; 99static ng_rcvmsg_t nga_rcvmsg; 100static ng_shutdown_t nga_shutdown; 101static ng_newhook_t nga_newhook; 102static ng_disconnect_t nga_disconnect; 103 104/* Helper stuff */ 105static int nga_rcv_sync(const sc_p sc, item_p item); 106static int nga_rcv_async(const sc_p sc, item_p item); 107 108/* Parse type for struct ng_async_cfg */ 109static const struct ng_parse_struct_field nga_config_type_fields[] 110 = NG_ASYNC_CONFIG_TYPE_INFO; 111static const struct ng_parse_type nga_config_type = { 112 &ng_parse_struct_type, 113 &nga_config_type_fields 114}; 115 116/* Parse type for struct ng_async_stat */ 117static const struct ng_parse_struct_field nga_stats_type_fields[] 118 = NG_ASYNC_STATS_TYPE_INFO; 119static const struct ng_parse_type nga_stats_type = { 120 &ng_parse_struct_type, 121 &nga_stats_type_fields 122}; 123 124/* List of commands and how to convert arguments to/from ASCII */ 125static const struct ng_cmdlist nga_cmdlist[] = { 126 { 127 NGM_ASYNC_COOKIE, 128 NGM_ASYNC_CMD_SET_CONFIG, 129 "setconfig", 130 &nga_config_type, 131 NULL 132 }, 133 { 134 NGM_ASYNC_COOKIE, 135 NGM_ASYNC_CMD_GET_CONFIG, 136 "getconfig", 137 NULL, 138 &nga_config_type 139 }, 140 { 141 NGM_ASYNC_COOKIE, 142 NGM_ASYNC_CMD_GET_STATS, 143 "getstats", 144 NULL, 145 &nga_stats_type 146 }, 147 { 148 NGM_ASYNC_COOKIE, 149 NGM_ASYNC_CMD_CLR_STATS, 150 "clrstats", 151 &nga_stats_type, 152 NULL 153 }, 154 { 0 } 155}; 156 157/* Define the netgraph node type */ 158static struct ng_type typestruct = { 159 .version = NG_ABI_VERSION, 160 .name = NG_ASYNC_NODE_TYPE, 161 .constructor = nga_constructor, 162 .rcvmsg = nga_rcvmsg, 163 .shutdown = nga_shutdown, 164 .newhook = nga_newhook, 165 .rcvdata = nga_rcvdata, 166 .disconnect = nga_disconnect, 167 .cmdlist = nga_cmdlist 168}; 169NETGRAPH_INIT(async, &typestruct); 170 171/* CRC table */ 172static const u_int16_t fcstab[]; 173 174/****************************************************************** 175 NETGRAPH NODE METHODS 176******************************************************************/ 177 178/* 179 * Initialize a new node 180 */ 181static int 182nga_constructor(node_p node) 183{ 184 sc_p sc; 185 186 sc = malloc(sizeof(*sc), M_NETGRAPH_ASYNC, M_NOWAIT | M_ZERO); 187 if (sc == NULL) 188 return (ENOMEM); 189 sc->amode = MODE_HUNT; 190 sc->cfg.accm = ~0; 191 sc->cfg.amru = NG_ASYNC_DEFAULT_MRU; 192 sc->cfg.smru = NG_ASYNC_DEFAULT_MRU; 193 sc->abuf = malloc( ASYNC_BUF_SIZE(sc->cfg.smru), M_NETGRAPH_ASYNC, M_NOWAIT); 194 if (sc->abuf == NULL) 195 goto fail; 196 sc->sbuf = malloc( SYNC_BUF_SIZE(sc->cfg.amru), M_NETGRAPH_ASYNC, M_NOWAIT); 197 if (sc->sbuf == NULL) { 198 free(sc->abuf, M_NETGRAPH_ASYNC); 199fail: 200 free(sc, M_NETGRAPH_ASYNC); 201 return (ENOMEM); 202 } 203 NG_NODE_SET_PRIVATE(node, sc); 204 sc->node = node; 205 return (0); 206} 207 208/* 209 * Reserve a hook for a pending connection 210 */ 211static int 212nga_newhook(node_p node, hook_p hook, const char *name) 213{ 214 const sc_p sc = NG_NODE_PRIVATE(node); 215 hook_p *hookp; 216 217 if (!strcmp(name, NG_ASYNC_HOOK_ASYNC)) { 218 /* 219 * We use a static buffer here so only one packet 220 * at a time can be allowed to travel in this direction. 221 * Force Writer semantics. 222 */ 223 NG_HOOK_FORCE_WRITER(hook); 224 hookp = &sc->async; 225 } else if (!strcmp(name, NG_ASYNC_HOOK_SYNC)) { 226 /* 227 * We use a static state here so only one packet 228 * at a time can be allowed to travel in this direction. 229 * Force Writer semantics. 230 * Since we set this for both directions 231 * we might as well set it for the whole node 232 * bit I haven;t done that (yet). 233 */ 234 NG_HOOK_FORCE_WRITER(hook); 235 hookp = &sc->sync; 236 } else { 237 return (EINVAL); 238 } 239 if (*hookp) /* actually can't happen I think [JRE] */ 240 return (EISCONN); 241 *hookp = hook; 242 return (0); 243} 244 245/* 246 * Receive incoming data 247 */ 248static int 249nga_rcvdata(hook_p hook, item_p item) 250{ 251 const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); 252 253 if (hook == sc->sync) 254 return (nga_rcv_sync(sc, item)); 255 if (hook == sc->async) 256 return (nga_rcv_async(sc, item)); 257 panic(__func__); 258} 259 260/* 261 * Receive incoming control message 262 */ 263static int 264nga_rcvmsg(node_p node, item_p item, hook_p lasthook) 265{ 266 const sc_p sc = NG_NODE_PRIVATE(node); 267 struct ng_mesg *resp = NULL; 268 int error = 0; 269 struct ng_mesg *msg; 270 271 NGI_GET_MSG(item, msg); 272 switch (msg->header.typecookie) { 273 case NGM_ASYNC_COOKIE: 274 switch (msg->header.cmd) { 275 case NGM_ASYNC_CMD_GET_STATS: 276 NG_MKRESPONSE(resp, msg, sizeof(sc->stats), M_NOWAIT); 277 if (resp == NULL) 278 ERROUT(ENOMEM); 279 *((struct ng_async_stat *) resp->data) = sc->stats; 280 break; 281 case NGM_ASYNC_CMD_CLR_STATS: 282 bzero(&sc->stats, sizeof(sc->stats)); 283 break; 284 case NGM_ASYNC_CMD_SET_CONFIG: 285 { 286 struct ng_async_cfg *const cfg = 287 (struct ng_async_cfg *) msg->data; 288 u_char *buf; 289 290 if (msg->header.arglen != sizeof(*cfg)) 291 ERROUT(EINVAL); 292 if (cfg->amru < NG_ASYNC_MIN_MRU 293 || cfg->amru > NG_ASYNC_MAX_MRU 294 || cfg->smru < NG_ASYNC_MIN_MRU 295 || cfg->smru > NG_ASYNC_MAX_MRU) 296 ERROUT(EINVAL); 297 cfg->enabled = !!cfg->enabled; /* normalize */ 298 if (cfg->smru > sc->cfg.smru) { /* reallocate buffer */ 299 buf = malloc(ASYNC_BUF_SIZE(cfg->smru), 300 M_NETGRAPH_ASYNC, M_NOWAIT); 301 if (!buf) 302 ERROUT(ENOMEM); 303 free(sc->abuf, M_NETGRAPH_ASYNC); 304 sc->abuf = buf; 305 } 306 if (cfg->amru > sc->cfg.amru) { /* reallocate buffer */ 307 buf = malloc(SYNC_BUF_SIZE(cfg->amru), 308 M_NETGRAPH_ASYNC, M_NOWAIT); 309 if (!buf) 310 ERROUT(ENOMEM); 311 free(sc->sbuf, M_NETGRAPH_ASYNC); 312 sc->sbuf = buf; 313 sc->amode = MODE_HUNT; 314 sc->slen = 0; 315 } 316 if (!cfg->enabled) { 317 sc->amode = MODE_HUNT; 318 sc->slen = 0; 319 } 320 sc->cfg = *cfg; 321 break; 322 } 323 case NGM_ASYNC_CMD_GET_CONFIG: 324 NG_MKRESPONSE(resp, msg, sizeof(sc->cfg), M_NOWAIT); 325 if (!resp) 326 ERROUT(ENOMEM); 327 *((struct ng_async_cfg *) resp->data) = sc->cfg; 328 break; 329 default: 330 ERROUT(EINVAL); 331 } 332 break; 333 default: 334 ERROUT(EINVAL); 335 } 336done: 337 NG_RESPOND_MSG(error, node, item, resp); 338 NG_FREE_MSG(msg); 339 return (error); 340} 341 342/* 343 * Shutdown this node 344 */ 345static int 346nga_shutdown(node_p node) 347{ 348 const sc_p sc = NG_NODE_PRIVATE(node); 349 350 free(sc->abuf, M_NETGRAPH_ASYNC); 351 free(sc->sbuf, M_NETGRAPH_ASYNC); 352 bzero(sc, sizeof(*sc)); 353 free(sc, M_NETGRAPH_ASYNC); 354 NG_NODE_SET_PRIVATE(node, NULL); 355 NG_NODE_UNREF(node); 356 return (0); 357} 358 359/* 360 * Lose a hook. When both hooks go away, we disappear. 361 */ 362static int 363nga_disconnect(hook_p hook) 364{ 365 const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); 366 hook_p *hookp; 367 368 if (hook == sc->async) 369 hookp = &sc->async; 370 else if (hook == sc->sync) 371 hookp = &sc->sync; 372 else 373 panic(__func__); 374 if (!*hookp) 375 panic("%s 2", __func__); 376 *hookp = NULL; 377 bzero(&sc->stats, sizeof(sc->stats)); 378 sc->lasttime = 0; 379 if ((NG_NODE_NUMHOOKS(NG_HOOK_NODE(hook)) == 0) 380 && (NG_NODE_IS_VALID(NG_HOOK_NODE(hook)))) 381 ng_rmnode_self(NG_HOOK_NODE(hook)); 382 return (0); 383} 384 385/****************************************************************** 386 INTERNAL HELPER STUFF 387******************************************************************/ 388 389/* 390 * Encode a byte into the async buffer 391 */ 392static __inline void 393nga_async_add(const sc_p sc, u_int16_t *fcs, u_int32_t accm, int *len, u_char x) 394{ 395 *fcs = PPP_FCS(*fcs, x); 396 if ((x < 32 && ((1 << x) & accm)) 397 || (x == PPP_ESCAPE) 398 || (x == PPP_FLAG)) { 399 sc->abuf[(*len)++] = PPP_ESCAPE; 400 x ^= PPP_TRANS; 401 } 402 sc->abuf[(*len)++] = x; 403} 404 405/* 406 * Receive incoming synchronous data. 407 */ 408static int 409nga_rcv_sync(const sc_p sc, item_p item) 410{ 411 struct ifnet *rcvif; 412 int alen, error = 0; 413 struct timeval time; 414 u_int16_t fcs, fcs0; 415 u_int32_t accm; 416 struct mbuf *m; 417 418 419#define ADD_BYTE(x) nga_async_add(sc, &fcs, accm, &alen, (x)) 420 421 /* Check for bypass mode */ 422 if (!sc->cfg.enabled) { 423 NG_FWD_ITEM_HOOK(error, item, sc->async ); 424 return (error); 425 } 426 NGI_GET_M(item, m); 427 428 rcvif = m->m_pkthdr.rcvif; 429 430 /* Get ACCM; special case LCP frames, which use full ACCM */ 431 accm = sc->cfg.accm; 432 if (m->m_pkthdr.len >= 4) { 433 static const u_char lcphdr[4] = { 434 PPP_ALLSTATIONS, 435 PPP_UI, 436 (u_char)(PPP_LCP >> 8), 437 (u_char)(PPP_LCP & 0xff) 438 }; 439 u_char buf[4]; 440 441 m_copydata(m, 0, 4, (caddr_t)buf); 442 if (bcmp(buf, &lcphdr, 4) == 0) 443 accm = ~0; 444 } 445 446 /* Check for overflow */ 447 if (m->m_pkthdr.len > sc->cfg.smru) { 448 sc->stats.syncOverflows++; 449 NG_FREE_M(m); 450 NG_FREE_ITEM(item); 451 return (EMSGSIZE); 452 } 453 454 /* Update stats */ 455 sc->stats.syncFrames++; 456 sc->stats.syncOctets += m->m_pkthdr.len; 457 458 /* Initialize async encoded version of input mbuf */ 459 alen = 0; 460 fcs = PPP_INITFCS; 461 462 /* Add beginning sync flag if it's been long enough to need one */ 463 getmicrotime(&time); 464 if (time.tv_sec >= sc->lasttime + 1) { 465 sc->abuf[alen++] = PPP_FLAG; 466 sc->lasttime = time.tv_sec; 467 } 468 469 /* Add packet payload */ 470 while (m != NULL) { 471 while (m->m_len > 0) { 472 ADD_BYTE(*mtod(m, u_char *)); 473 m->m_data++; 474 m->m_len--; 475 } 476 m = m_free(m); 477 } 478 479 /* Add checksum and final sync flag */ 480 fcs0 = fcs; 481 ADD_BYTE(~fcs0 & 0xff); 482 ADD_BYTE(~fcs0 >> 8); 483 sc->abuf[alen++] = PPP_FLAG; 484 485 /* Put frame in an mbuf and ship it off */ 486 if (!(m = m_devget(sc->abuf, alen, 0, rcvif, NULL))) { 487 NG_FREE_ITEM(item); 488 error = ENOBUFS; 489 } else { 490 NG_FWD_NEW_DATA(error, item, sc->async, m); 491 } 492 return (error); 493} 494 495/* 496 * Receive incoming asynchronous data 497 * XXX Technically, we should strip out incoming characters 498 * that are in our ACCM. Not sure if this is good or not. 499 */ 500static int 501nga_rcv_async(const sc_p sc, item_p item) 502{ 503 struct ifnet *rcvif; 504 int error; 505 struct mbuf *m; 506 507 if (!sc->cfg.enabled) { 508 NG_FWD_ITEM_HOOK(error, item, sc->sync); 509 return (error); 510 } 511 NGI_GET_M(item, m); 512 rcvif = m->m_pkthdr.rcvif; 513 while (m) { 514 struct mbuf *n; 515 516 for (; m->m_len > 0; m->m_data++, m->m_len--) { 517 u_char ch = *mtod(m, u_char *); 518 519 sc->stats.asyncOctets++; 520 if (ch == PPP_FLAG) { /* Flag overrides everything */ 521 int skip = 0; 522 523 /* Check for runts */ 524 if (sc->slen < 2) { 525 if (sc->slen > 0) 526 sc->stats.asyncRunts++; 527 goto reset; 528 } 529 530 /* Verify CRC */ 531 if (sc->fcs != PPP_GOODFCS) { 532 sc->stats.asyncBadCheckSums++; 533 goto reset; 534 } 535 sc->slen -= 2; 536 537 /* Strip address and control fields */ 538 if (sc->slen >= 2 539 && sc->sbuf[0] == PPP_ALLSTATIONS 540 && sc->sbuf[1] == PPP_UI) 541 skip = 2; 542 543 /* Check for frame too big */ 544 if (sc->slen - skip > sc->cfg.amru) { 545 sc->stats.asyncOverflows++; 546 goto reset; 547 } 548 549 /* OK, ship it out */ 550 if ((n = m_devget(sc->sbuf + skip, 551 sc->slen - skip, 0, rcvif, NULL))) { 552 if (item) { /* sets NULL -> item */ 553 NG_FWD_NEW_DATA(error, item, 554 sc->sync, n); 555 } else { 556 NG_SEND_DATA_ONLY(error, 557 sc->sync ,n); 558 } 559 } 560 sc->stats.asyncFrames++; 561reset: 562 sc->amode = MODE_NORMAL; 563 sc->fcs = PPP_INITFCS; 564 sc->slen = 0; 565 continue; 566 } 567 switch (sc->amode) { 568 case MODE_NORMAL: 569 if (ch == PPP_ESCAPE) { 570 sc->amode = MODE_ESC; 571 continue; 572 } 573 break; 574 case MODE_ESC: 575 ch ^= PPP_TRANS; 576 sc->amode = MODE_NORMAL; 577 break; 578 case MODE_HUNT: 579 default: 580 continue; 581 } 582 583 /* Add byte to frame */ 584 if (sc->slen >= SYNC_BUF_SIZE(sc->cfg.amru)) { 585 sc->stats.asyncOverflows++; 586 sc->amode = MODE_HUNT; 587 sc->slen = 0; 588 } else { 589 sc->sbuf[sc->slen++] = ch; 590 sc->fcs = PPP_FCS(sc->fcs, ch); 591 } 592 } 593 m = m_free(m); 594 } 595 if (item) 596 NG_FREE_ITEM(item); 597 return (0); 598} 599 600/* 601 * CRC table 602 * 603 * Taken from RFC 1171 Appendix B 604 */ 605static const u_int16_t fcstab[256] = { 606 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf, 607 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7, 608 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e, 609 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876, 610 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd, 611 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5, 612 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c, 613 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974, 614 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb, 615 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3, 616 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a, 617 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72, 618 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9, 619 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1, 620 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738, 621 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70, 622 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7, 623 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff, 624 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036, 625 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e, 626 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5, 627 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd, 628 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134, 629 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c, 630 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3, 631 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb, 632 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232, 633 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a, 634 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1, 635 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9, 636 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330, 637 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78 638}; 639