_ZN3uWS14WebSocketStateILb1EE5StateC2Ev:
   70|  1.46k|        State() {
   71|  1.46k|            wantsHead = true;
   72|  1.46k|            spillLength = 0;
   73|  1.46k|            opStack = -1;
   74|  1.46k|            lastFin = true;
   75|  1.46k|        }
_ZN3uWS17WebSocketProtocolILb1E4ImplE7consumeEPcjPNS_14WebSocketStateILb1EEEPv:
  458|  63.7k|    static inline void consume(char *src, unsigned int length, WebSocketState<isServer> *wState, void *user) {
  459|  63.7k|        if (wState->state.spillLength) {
  ------------------
  |  Branch (459:13): [True: 23.9k, False: 39.7k]
  ------------------
  460|  23.9k|            src -= wState->state.spillLength;
  461|  23.9k|            length += wState->state.spillLength;
  462|  23.9k|            memcpy(src, wState->state.spill, wState->state.spillLength);
  463|  23.9k|        }
  464|  63.7k|        if (wState->state.wantsHead) {
  ------------------
  |  Branch (464:13): [True: 54.0k, False: 9.72k]
  ------------------
  465|  57.8k|            parseNext:
  466|  65.1k|            while (length >= SHORT_MESSAGE_HEADER) {
  ------------------
  |  Branch (466:20): [True: 63.4k, False: 1.65k]
  ------------------
  467|       |
  468|       |                // invalid reserved bits / invalid opcodes / invalid control frames / set compressed frame
  469|  63.4k|                if ((rsv1(src) && !Impl::setCompressed(wState, user)) || rsv23(src) || (getOpCode(src) > 2 && getOpCode(src) < 8) ||
  ------------------
  |  Branch (469:22): [True: 5.78k, False: 57.7k]
  |  Branch (469:35): [True: 0, False: 5.78k]
  |  Branch (469:74): [True: 40.6k, False: 22.8k]
  |  Branch (469:89): [True: 5.05k, False: 17.7k]
  |  Branch (469:111): [True: 1.68k, False: 3.36k]
  ------------------
  470|  63.4k|                    getOpCode(src) > 10 || (getOpCode(src) > 2 && (!isFin(src) || payloadLength(src) > 125))) {
  ------------------
  |  Branch (470:21): [True: 532, False: 20.6k]
  |  Branch (470:45): [True: 2.83k, False: 17.7k]
  |  Branch (470:68): [True: 252, False: 2.58k]
  |  Branch (470:83): [True: 198, False: 2.38k]
  ------------------
  471|  43.3k|                    Impl::forceClose(wState, user);
  472|  43.3k|                    return;
  473|  43.3k|                }
  474|       |
  475|  20.1k|                if (payloadLength(src) < 126) {
  ------------------
  |  Branch (475:21): [True: 10.8k, False: 9.36k]
  ------------------
  476|  10.8k|                    if (consumeMessage<SHORT_MESSAGE_HEADER, uint8_t>(payloadLength(src), src, length, wState, user)) {
  ------------------
  |  Branch (476:25): [True: 5.62k, False: 5.18k]
  ------------------
  477|  5.62k|                        return;
  478|  5.62k|                    }
  479|  10.8k|                } else if (payloadLength(src) == 126) {
  ------------------
  |  Branch (479:28): [True: 4.77k, False: 4.59k]
  ------------------
  480|  4.77k|                    if (length < MEDIUM_MESSAGE_HEADER) {
  ------------------
  |  Branch (480:25): [True: 368, False: 4.40k]
  ------------------
  481|    368|                        break;
  482|  4.40k|                    } else if(consumeMessage<MEDIUM_MESSAGE_HEADER, uint16_t>(protocol::cond_byte_swap<uint16_t>(protocol::bit_cast<uint16_t>(src + 2)), src, length, wState, user)) {
  ------------------
  |  Branch (482:31): [True: 3.16k, False: 1.24k]
  ------------------
  483|  3.16k|                        return;
  484|  3.16k|                    }
  485|  4.77k|                } else if (length < LONG_MESSAGE_HEADER) {
  ------------------
  |  Branch (485:28): [True: 521, False: 4.07k]
  ------------------
  486|    521|                    break;
  487|  4.07k|                } else if (consumeMessage<LONG_MESSAGE_HEADER, uint64_t>(protocol::cond_byte_swap<uint64_t>(protocol::bit_cast<uint64_t>(src + 2)), src, length, wState, user)) {
  ------------------
  |  Branch (487:28): [True: 3.22k, False: 847]
  ------------------
  488|  3.22k|                    return;
  489|  3.22k|                }
  490|  20.1k|            }
  491|  2.54k|            if (length) {
  ------------------
  |  Branch (491:17): [True: 1.65k, False: 892]
  ------------------
  492|  1.65k|                memcpy(wState->state.spill, src, length);
  493|  1.65k|                wState->state.spillLength = length & 0xf;
  494|  1.65k|            }
  495|  9.72k|        } else if (consumeContinuation(src, length, wState, user)) {
  ------------------
  |  Branch (495:20): [True: 3.87k, False: 5.84k]
  ------------------
  496|  3.87k|            goto parseNext;
  497|  3.87k|        }
  498|  63.7k|    }
_ZN3uWS17WebSocketProtocolILb1E4ImplE4rsv1EPc:
  274|  63.4k|    static inline bool rsv1(char *frame) {return *((unsigned char *) frame) & 64;}
_ZN3uWS17WebSocketProtocolILb1E4ImplE5rsv23EPc:
  273|  63.4k|    static inline bool rsv23(char *frame) {return *((unsigned char *) frame) & 48;}
_ZN3uWS17WebSocketProtocolILb1E4ImplE9getOpCodeEPc:
  271|  96.9k|    static inline unsigned char getOpCode(char *frame) {return *((unsigned char *) frame) & 15;}
_ZN3uWS17WebSocketProtocolILb1E4ImplE5isFinEPc:
  270|  34.6k|    static inline bool isFin(char *frame) {return *((unsigned char *) frame) & 128;}
_ZN3uWS17WebSocketProtocolILb1E4ImplE13payloadLengthEPc:
  272|  42.9k|    static inline unsigned char payloadLength(char *frame) {return ((unsigned char *) frame)[1] & 127;}
_ZN3uWS17WebSocketProtocolILb1E4ImplE14consumeMessageILj6EhEEbT0_RPcRjPNS_14WebSocketStateILb1EEEPv:
  340|  10.8k|    static inline bool consumeMessage(T payLength, char *&src, unsigned int &length, WebSocketState<isServer> *wState, void *user) {
  341|  10.8k|        if (getOpCode(src)) {
  ------------------
  |  Branch (341:13): [True: 4.20k, False: 6.59k]
  ------------------
  342|  4.20k|            if (wState->state.opStack == 1 || (!wState->state.lastFin && getOpCode(src) < 2)) {
  ------------------
  |  Branch (342:17): [True: 384, False: 3.82k]
  |  Branch (342:48): [True: 529, False: 3.29k]
  |  Branch (342:74): [True: 201, False: 328]
  ------------------
  343|    585|                Impl::forceClose(wState, user);
  344|    585|                return true;
  345|    585|            }
  346|  3.62k|            wState->state.opCode[++wState->state.opStack] = (OpCode) getOpCode(src);
  347|  6.59k|        } else if (wState->state.opStack == -1) {
  ------------------
  |  Branch (347:20): [True: 1.16k, False: 5.43k]
  ------------------
  348|  1.16k|            Impl::forceClose(wState, user);
  349|  1.16k|            return true;
  350|  1.16k|        }
  351|  9.05k|        wState->state.lastFin = isFin(src);
  352|       |
  353|  9.05k|        if (Impl::refusePayloadLength(payLength, wState, user)) {
  ------------------
  |  Branch (353:13): [True: 0, False: 9.05k]
  ------------------
  354|      0|            Impl::forceClose(wState, user, ERR_TOO_BIG_MESSAGE);
  355|      0|            return true;
  356|      0|        }
  357|       |
  358|  9.05k|        if (payLength + MESSAGE_HEADER <= length) {
  ------------------
  |  Branch (358:13): [True: 6.80k, False: 2.25k]
  ------------------
  359|  6.80k|            bool fin = isFin(src);
  360|  6.80k|            if (isServer) {
  ------------------
  |  Branch (360:17): [Folded - Ignored]
  ------------------
  361|       |                /* This guy can never be assumed to be perfectly aligned since we can get multiple messages in one read */
  362|  6.80k|                unmaskImpreciseCopyMask<MESSAGE_HEADER>(src + MESSAGE_HEADER, (unsigned int) payLength);
  363|  6.80k|                if (Impl::handleFragment(src, payLength, 0, wState->state.opCode[wState->state.opStack], fin, wState, user)) {
  ------------------
  |  Branch (363:21): [True: 1.62k, False: 5.18k]
  ------------------
  364|  1.62k|                    return true;
  365|  1.62k|                }
  366|  6.80k|            } else {
  367|      0|                if (Impl::handleFragment(src + MESSAGE_HEADER, payLength, 0, wState->state.opCode[wState->state.opStack], isFin(src), wState, user)) {
  ------------------
  |  Branch (367:21): [True: 0, False: 0]
  ------------------
  368|      0|                    return true;
  369|      0|                }
  370|      0|            }
  371|       |
  372|  5.18k|            if (fin) {
  ------------------
  |  Branch (372:17): [True: 1.67k, False: 3.51k]
  ------------------
  373|  1.67k|                wState->state.opStack--;
  374|  1.67k|            }
  375|       |
  376|  5.18k|            src += payLength + MESSAGE_HEADER;
  377|  5.18k|            length -= (unsigned int) (payLength + MESSAGE_HEADER);
  378|  5.18k|            wState->state.spillLength = 0;
  379|  5.18k|            return false;
  380|  6.80k|        } else {
  381|  2.25k|            wState->state.spillLength = 0;
  382|  2.25k|            wState->state.wantsHead = false;
  383|  2.25k|            wState->remainingBytes = (unsigned int) (payLength - length + MESSAGE_HEADER);
  384|  2.25k|            bool fin = isFin(src);
  385|  2.25k|            if constexpr (isServer) {
  ------------------
  |  Branch (385:27): [Folded - Ignored]
  ------------------
  386|  2.25k|                memcpy(wState->mask, src + MESSAGE_HEADER - 4, 4);
  387|  2.25k|                uint64_t mask;
  388|  2.25k|                memcpy(&mask, src + MESSAGE_HEADER - 4, 4);
  389|  2.25k|                memcpy(((char *)&mask) + 4, src + MESSAGE_HEADER - 4, 4);
  390|  2.25k|                unmaskImprecise8<0>(src + MESSAGE_HEADER, mask, length);
  391|  2.25k|                rotateMask(4 - (length - MESSAGE_HEADER) % 4, wState->mask);
  392|  2.25k|            }
  393|  2.25k|            Impl::handleFragment(src + MESSAGE_HEADER, length - MESSAGE_HEADER, wState->remainingBytes, wState->state.opCode[wState->state.opStack], fin, wState, user);
  394|  2.25k|            return true;
  395|  2.25k|        }
  396|  9.05k|    }
_ZN3uWS17WebSocketProtocolILb1E4ImplE23unmaskImpreciseCopyMaskILi6EEEvPcj:
  308|  6.80k|    static inline void unmaskImpreciseCopyMask(char *src, unsigned int length) {
  309|  6.80k|        if constexpr (HEADER_SIZE != 6) {
  ------------------
  |  Branch (309:23): [Folded - Ignored]
  ------------------
  310|  6.80k|            char mask[8] = {src[-4], src[-3], src[-2], src[-1], src[-4], src[-3], src[-2], src[-1]};
  311|  6.80k|            uint64_t maskInt;
  312|  6.80k|            memcpy(&maskInt, mask, 8);
  313|  6.80k|            unmaskImprecise8<HEADER_SIZE>(src, maskInt, length);
  314|  6.80k|        } else {
  315|  6.80k|            char mask[4] = {src[-4], src[-3], src[-2], src[-1]};
  316|  6.80k|            uint32_t maskInt;
  317|  6.80k|            memcpy(&maskInt, mask, 4);
  318|  6.80k|            unmaskImprecise4<HEADER_SIZE>(src, maskInt, length);
  319|  6.80k|        }
  320|  6.80k|    }
_ZN3uWS17WebSocketProtocolILb1E4ImplE16unmaskImprecise4ILi6EEEvPcjj:
  297|  6.80k|    static inline void unmaskImprecise4(char *src, uint32_t mask, unsigned int length) {
  298|  28.7k|        for (unsigned int n = (length >> 2) + 1; n; n--) {
  ------------------
  |  Branch (298:50): [True: 21.9k, False: 6.80k]
  ------------------
  299|  21.9k|            uint32_t loaded;
  300|  21.9k|            memcpy(&loaded, src, 4);
  301|  21.9k|            loaded ^= mask;
  302|  21.9k|            memcpy(src - DESTINATION, &loaded, 4);
  303|  21.9k|            src += 4;
  304|  21.9k|        }
  305|  6.80k|    }
WebSocket.cpp:_ZN3uWS8protocolL11isValidUtf8EPhm:
  117|  15.3k|{
  118|  19.9k|    for (unsigned char *e = s + length; s != e; ) {
  ------------------
  |  Branch (118:41): [True: 16.0k, False: 3.87k]
  ------------------
  119|  16.0k|        if (s + 4 <= e) {
  ------------------
  |  Branch (119:13): [True: 9.66k, False: 6.43k]
  ------------------
  120|  9.66k|            uint32_t tmp;
  121|  9.66k|            memcpy(&tmp, s, 4);
  122|  9.66k|            if ((tmp & 0x80808080) == 0) {
  ------------------
  |  Branch (122:17): [True: 2.19k, False: 7.46k]
  ------------------
  123|  2.19k|                s += 4;
  124|  2.19k|                continue;
  125|  2.19k|            }
  126|  9.66k|        }
  127|       |
  128|  19.0k|        while (!(*s & 0x80)) {
  ------------------
  |  Branch (128:16): [True: 7.14k, False: 11.8k]
  ------------------
  129|  7.14k|            if (++s == e) {
  ------------------
  |  Branch (129:17): [True: 2.03k, False: 5.11k]
  ------------------
  130|  2.03k|                return true;
  131|  2.03k|            }
  132|  7.14k|        }
  133|       |
  134|  11.8k|        if ((s[0] & 0x60) == 0x40) {
  ------------------
  |  Branch (134:13): [True: 3.32k, False: 8.53k]
  ------------------
  135|  3.32k|            if (s + 1 >= e || (s[1] & 0xc0) != 0x80 || (s[0] & 0xfe) == 0xc0) {
  ------------------
  |  Branch (135:17): [True: 998, False: 2.33k]
  |  Branch (135:31): [True: 946, False: 1.38k]
  |  Branch (135:56): [True: 329, False: 1.05k]
  ------------------
  136|  2.27k|                return false;
  137|  2.27k|            }
  138|  1.05k|            s += 2;
  139|  8.53k|        } else if ((s[0] & 0xf0) == 0xe0) {
  ------------------
  |  Branch (139:20): [True: 2.38k, False: 6.15k]
  ------------------
  140|  2.38k|            if (s + 2 >= e || (s[1] & 0xc0) != 0x80 || (s[2] & 0xc0) != 0x80 ||
  ------------------
  |  Branch (140:17): [True: 443, False: 1.93k]
  |  Branch (140:31): [True: 558, False: 1.38k]
  |  Branch (140:56): [True: 227, False: 1.15k]
  ------------------
  141|  2.38k|                    (s[0] == 0xe0 && (s[1] & 0xe0) == 0x80) || (s[0] == 0xed && (s[1] & 0xe0) == 0xa0)) {
  ------------------
  |  Branch (141:22): [True: 429, False: 724]
  |  Branch (141:38): [True: 211, False: 218]
  |  Branch (141:65): [True: 390, False: 552]
  |  Branch (141:81): [True: 194, False: 196]
  ------------------
  142|  1.63k|                return false;
  143|  1.63k|            }
  144|    748|            s += 3;
  145|  6.15k|        } else if ((s[0] & 0xf8) == 0xf0) {
  ------------------
  |  Branch (145:20): [True: 2.19k, False: 3.95k]
  ------------------
  146|  2.19k|            if (s + 3 >= e || (s[1] & 0xc0) != 0x80 || (s[2] & 0xc0) != 0x80 || (s[3] & 0xc0) != 0x80 ||
  ------------------
  |  Branch (146:17): [True: 221, False: 1.97k]
  |  Branch (146:31): [True: 272, False: 1.70k]
  |  Branch (146:56): [True: 201, False: 1.50k]
  |  Branch (146:81): [True: 198, False: 1.30k]
  ------------------
  147|  2.19k|                    (s[0] == 0xf0 && (s[1] & 0xf0) == 0x80) || (s[0] == 0xf4 && s[1] > 0x8f) || s[0] > 0xf4) {
  ------------------
  |  Branch (147:22): [True: 399, False: 907]
  |  Branch (147:38): [True: 197, False: 202]
  |  Branch (147:65): [True: 451, False: 658]
  |  Branch (147:81): [True: 197, False: 254]
  |  Branch (147:97): [True: 251, False: 661]
  ------------------
  148|  1.53k|                return false;
  149|  1.53k|            }
  150|    661|            s += 4;
  151|  3.95k|        } else {
  152|  3.95k|            return false;
  153|  3.95k|        }
  154|  11.8k|    }
  155|  3.87k|    return true;
  156|  15.3k|}
WebSocket.cpp:_ZN3uWS8protocolL17parseClosePayloadEPcm:
  164|  2.87k|static inline CloseFrame parseClosePayload(char *src, size_t length) {
  165|       |    /* If we get no code or message, default to reporting 1005 no status code present */
  166|  2.87k|    CloseFrame cf = {1005, nullptr, 0};
  167|  2.87k|    if (length >= 2) {
  ------------------
  |  Branch (167:9): [True: 1.59k, False: 1.27k]
  ------------------
  168|  1.59k|        memcpy(&cf.code, src, 2);
  169|  1.59k|        cf = {cond_byte_swap<uint16_t>(cf.code), src + 2, length - 2};
  170|  1.59k|        if (cf.code < 1000 || cf.code > 4999 || (cf.code > 1011 && cf.code < 4000) ||
  ------------------
  |  Branch (170:13): [True: 946, False: 652]
  |  Branch (170:31): [True: 386, False: 266]
  |  Branch (170:50): [True: 234, False: 32]
  |  Branch (170:68): [True: 33, False: 201]
  ------------------
  171|  1.59k|            (cf.code >= 1004 && cf.code <= 1006) || !isValidUtf8((unsigned char *) cf.message, cf.length)) {
  ------------------
  |  Branch (171:14): [True: 229, False: 4]
  |  Branch (171:33): [True: 22, False: 207]
  |  Branch (171:53): [True: 209, False: 2]
  ------------------
  172|       |            /* Even though we got a WebSocket close frame, it in itself is abnormal */
  173|  1.59k|            return {1006, nullptr, 0};
  174|  1.59k|        }
  175|  1.59k|    }
  176|  1.28k|    return cf;
  177|  2.87k|}
_ZN3uWS17WebSocketProtocolILb1E4ImplE16unmaskImprecise8ILi0EEEvPcmj:
  285|  4.43k|    static inline void unmaskImprecise8(char *src, uint64_t mask, unsigned int length) {
  286|  37.7k|        for (unsigned int n = (length >> 3) + 1; n; n--) {
  ------------------
  |  Branch (286:50): [True: 33.3k, False: 4.43k]
  ------------------
  287|  33.3k|            uint64_t loaded;
  288|  33.3k|            memcpy(&loaded, src, 8);
  289|  33.3k|            loaded ^= mask;
  290|  33.3k|            memcpy(src - DESTINATION, &loaded, 8);
  291|  33.3k|            src += 8;
  292|  33.3k|        }
  293|  4.43k|    }
_ZN3uWS17WebSocketProtocolILb1E4ImplE10rotateMaskEjPc:
  322|  5.49k|    static inline void rotateMask(unsigned int offset, char *mask) {
  323|  5.49k|        char originalMask[4] = {mask[0], mask[1], mask[2], mask[3]};
  324|  5.49k|        mask[(0 + offset) % 4] = originalMask[0];
  325|  5.49k|        mask[(1 + offset) % 4] = originalMask[1];
  326|  5.49k|        mask[(2 + offset) % 4] = originalMask[2];
  327|  5.49k|        mask[(3 + offset) % 4] = originalMask[3];
  328|  5.49k|    }
_ZN3uWS17WebSocketProtocolILb1E4ImplE14consumeMessageILj8EtEEbT0_RPcRjPNS_14WebSocketStateILb1EEEPv:
  340|  4.40k|    static inline bool consumeMessage(T payLength, char *&src, unsigned int &length, WebSocketState<isServer> *wState, void *user) {
  341|  4.40k|        if (getOpCode(src)) {
  ------------------
  |  Branch (341:13): [True: 1.92k, False: 2.47k]
  ------------------
  342|  1.92k|            if (wState->state.opStack == 1 || (!wState->state.lastFin && getOpCode(src) < 2)) {
  ------------------
  |  Branch (342:17): [True: 221, False: 1.70k]
  |  Branch (342:48): [True: 430, False: 1.27k]
  |  Branch (342:74): [True: 195, False: 235]
  ------------------
  343|    416|                Impl::forceClose(wState, user);
  344|    416|                return true;
  345|    416|            }
  346|  1.50k|            wState->state.opCode[++wState->state.opStack] = (OpCode) getOpCode(src);
  347|  2.47k|        } else if (wState->state.opStack == -1) {
  ------------------
  |  Branch (347:20): [True: 319, False: 2.15k]
  ------------------
  348|    319|            Impl::forceClose(wState, user);
  349|    319|            return true;
  350|    319|        }
  351|  3.66k|        wState->state.lastFin = isFin(src);
  352|       |
  353|  3.66k|        if (Impl::refusePayloadLength(payLength, wState, user)) {
  ------------------
  |  Branch (353:13): [True: 243, False: 3.42k]
  ------------------
  354|    243|            Impl::forceClose(wState, user, ERR_TOO_BIG_MESSAGE);
  355|    243|            return true;
  356|    243|        }
  357|       |
  358|  3.42k|        if (payLength + MESSAGE_HEADER <= length) {
  ------------------
  |  Branch (358:13): [True: 2.35k, False: 1.06k]
  ------------------
  359|  2.35k|            bool fin = isFin(src);
  360|  2.35k|            if (isServer) {
  ------------------
  |  Branch (360:17): [Folded - Ignored]
  ------------------
  361|       |                /* This guy can never be assumed to be perfectly aligned since we can get multiple messages in one read */
  362|  2.35k|                unmaskImpreciseCopyMask<MESSAGE_HEADER>(src + MESSAGE_HEADER, (unsigned int) payLength);
  363|  2.35k|                if (Impl::handleFragment(src, payLength, 0, wState->state.opCode[wState->state.opStack], fin, wState, user)) {
  ------------------
  |  Branch (363:21): [True: 1.11k, False: 1.24k]
  ------------------
  364|  1.11k|                    return true;
  365|  1.11k|                }
  366|  2.35k|            } else {
  367|      0|                if (Impl::handleFragment(src + MESSAGE_HEADER, payLength, 0, wState->state.opCode[wState->state.opStack], isFin(src), wState, user)) {
  ------------------
  |  Branch (367:21): [True: 0, False: 0]
  ------------------
  368|      0|                    return true;
  369|      0|                }
  370|      0|            }
  371|       |
  372|  1.24k|            if (fin) {
  ------------------
  |  Branch (372:17): [True: 992, False: 248]
  ------------------
  373|    992|                wState->state.opStack--;
  374|    992|            }
  375|       |
  376|  1.24k|            src += payLength + MESSAGE_HEADER;
  377|  1.24k|            length -= (unsigned int) (payLength + MESSAGE_HEADER);
  378|  1.24k|            wState->state.spillLength = 0;
  379|  1.24k|            return false;
  380|  2.35k|        } else {
  381|  1.06k|            wState->state.spillLength = 0;
  382|  1.06k|            wState->state.wantsHead = false;
  383|  1.06k|            wState->remainingBytes = (unsigned int) (payLength - length + MESSAGE_HEADER);
  384|  1.06k|            bool fin = isFin(src);
  385|  1.06k|            if constexpr (isServer) {
  ------------------
  |  Branch (385:27): [Folded - Ignored]
  ------------------
  386|  1.06k|                memcpy(wState->mask, src + MESSAGE_HEADER - 4, 4);
  387|  1.06k|                uint64_t mask;
  388|  1.06k|                memcpy(&mask, src + MESSAGE_HEADER - 4, 4);
  389|  1.06k|                memcpy(((char *)&mask) + 4, src + MESSAGE_HEADER - 4, 4);
  390|  1.06k|                unmaskImprecise8<0>(src + MESSAGE_HEADER, mask, length);
  391|  1.06k|                rotateMask(4 - (length - MESSAGE_HEADER) % 4, wState->mask);
  392|  1.06k|            }
  393|  1.06k|            Impl::handleFragment(src + MESSAGE_HEADER, length - MESSAGE_HEADER, wState->remainingBytes, wState->state.opCode[wState->state.opStack], fin, wState, user);
  394|  1.06k|            return true;
  395|  1.06k|        }
  396|  3.42k|    }
_ZN3uWS17WebSocketProtocolILb1E4ImplE23unmaskImpreciseCopyMaskILi8EEEvPcj:
  308|  2.35k|    static inline void unmaskImpreciseCopyMask(char *src, unsigned int length) {
  309|  2.35k|        if constexpr (HEADER_SIZE != 6) {
  ------------------
  |  Branch (309:23): [Folded - Ignored]
  ------------------
  310|  2.35k|            char mask[8] = {src[-4], src[-3], src[-2], src[-1], src[-4], src[-3], src[-2], src[-1]};
  311|  2.35k|            uint64_t maskInt;
  312|  2.35k|            memcpy(&maskInt, mask, 8);
  313|  2.35k|            unmaskImprecise8<HEADER_SIZE>(src, maskInt, length);
  314|  2.35k|        } else {
  315|  2.35k|            char mask[4] = {src[-4], src[-3], src[-2], src[-1]};
  316|  2.35k|            uint32_t maskInt;
  317|  2.35k|            memcpy(&maskInt, mask, 4);
  318|  2.35k|            unmaskImprecise4<HEADER_SIZE>(src, maskInt, length);
  319|  2.35k|        }
  320|  2.35k|    }
_ZN3uWS17WebSocketProtocolILb1E4ImplE16unmaskImprecise8ILi8EEEvPcmj:
  285|  2.35k|    static inline void unmaskImprecise8(char *src, uint64_t mask, unsigned int length) {
  286|  45.5k|        for (unsigned int n = (length >> 3) + 1; n; n--) {
  ------------------
  |  Branch (286:50): [True: 43.2k, False: 2.35k]
  ------------------
  287|  43.2k|            uint64_t loaded;
  288|  43.2k|            memcpy(&loaded, src, 8);
  289|  43.2k|            loaded ^= mask;
  290|  43.2k|            memcpy(src - DESTINATION, &loaded, 8);
  291|  43.2k|            src += 8;
  292|  43.2k|        }
  293|  2.35k|    }
_ZN3uWS8protocol14cond_byte_swapItEET_S2_:
   95|  6.00k|T cond_byte_swap(T value) {
   96|  6.00k|    uint32_t endian_test = 1;
   97|  6.00k|    if (*((char *)&endian_test)) {
  ------------------
  |  Branch (97:9): [True: 6.00k, False: 0]
  ------------------
   98|  6.00k|        union {
   99|  6.00k|            T i;
  100|  6.00k|            uint8_t b[sizeof(T)];
  101|  6.00k|        } src = { value }, dst;
  102|       |
  103|  18.0k|        for (unsigned int i = 0; i < sizeof(value); i++) {
  ------------------
  |  Branch (103:34): [True: 12.0k, False: 6.00k]
  ------------------
  104|  12.0k|            dst.b[i] = src.b[sizeof(value) - 1 - i];
  105|  12.0k|        }
  106|       |
  107|  6.00k|        return dst.i;
  108|  6.00k|    }
  109|      0|    return value;
  110|  6.00k|}
_ZN3uWS8protocol8bit_castItEET_Pc:
   87|  4.40k|T bit_cast(char *c) {
   88|  4.40k|    T val;
   89|  4.40k|    memcpy(&val, c, sizeof(T));
   90|  4.40k|    return val;
   91|  4.40k|}
_ZN3uWS17WebSocketProtocolILb1E4ImplE14consumeMessageILj14EmEEbT0_RPcRjPNS_14WebSocketStateILb1EEEPv:
  340|  4.07k|    static inline bool consumeMessage(T payLength, char *&src, unsigned int &length, WebSocketState<isServer> *wState, void *user) {
  341|  4.07k|        if (getOpCode(src)) {
  ------------------
  |  Branch (341:13): [True: 1.89k, False: 2.17k]
  ------------------
  342|  1.89k|            if (wState->state.opStack == 1 || (!wState->state.lastFin && getOpCode(src) < 2)) {
  ------------------
  |  Branch (342:17): [True: 199, False: 1.70k]
  |  Branch (342:48): [True: 475, False: 1.22k]
  |  Branch (342:74): [True: 201, False: 274]
  ------------------
  343|    400|                Impl::forceClose(wState, user);
  344|    400|                return true;
  345|    400|            }
  346|  1.49k|            wState->state.opCode[++wState->state.opStack] = (OpCode) getOpCode(src);
  347|  2.17k|        } else if (wState->state.opStack == -1) {
  ------------------
  |  Branch (347:20): [True: 196, False: 1.97k]
  ------------------
  348|    196|            Impl::forceClose(wState, user);
  349|    196|            return true;
  350|    196|        }
  351|  3.47k|        wState->state.lastFin = isFin(src);
  352|       |
  353|  3.47k|        if (Impl::refusePayloadLength(payLength, wState, user)) {
  ------------------
  |  Branch (353:13): [True: 332, False: 3.14k]
  ------------------
  354|    332|            Impl::forceClose(wState, user, ERR_TOO_BIG_MESSAGE);
  355|    332|            return true;
  356|    332|        }
  357|       |
  358|  3.14k|        if (payLength + MESSAGE_HEADER <= length) {
  ------------------
  |  Branch (358:13): [True: 2.02k, False: 1.11k]
  ------------------
  359|  2.02k|            bool fin = isFin(src);
  360|  2.02k|            if (isServer) {
  ------------------
  |  Branch (360:17): [Folded - Ignored]
  ------------------
  361|       |                /* This guy can never be assumed to be perfectly aligned since we can get multiple messages in one read */
  362|  2.02k|                unmaskImpreciseCopyMask<MESSAGE_HEADER>(src + MESSAGE_HEADER, (unsigned int) payLength);
  363|  2.02k|                if (Impl::handleFragment(src, payLength, 0, wState->state.opCode[wState->state.opStack], fin, wState, user)) {
  ------------------
  |  Branch (363:21): [True: 1.18k, False: 847]
  ------------------
  364|  1.18k|                    return true;
  365|  1.18k|                }
  366|  2.02k|            } else {
  367|      0|                if (Impl::handleFragment(src + MESSAGE_HEADER, payLength, 0, wState->state.opCode[wState->state.opStack], isFin(src), wState, user)) {
  ------------------
  |  Branch (367:21): [True: 0, False: 0]
  ------------------
  368|      0|                    return true;
  369|      0|                }
  370|      0|            }
  371|       |
  372|    847|            if (fin) {
  ------------------
  |  Branch (372:17): [True: 578, False: 269]
  ------------------
  373|    578|                wState->state.opStack--;
  374|    578|            }
  375|       |
  376|    847|            src += payLength + MESSAGE_HEADER;
  377|    847|            length -= (unsigned int) (payLength + MESSAGE_HEADER);
  378|    847|            wState->state.spillLength = 0;
  379|    847|            return false;
  380|  2.02k|        } else {
  381|  1.11k|            wState->state.spillLength = 0;
  382|  1.11k|            wState->state.wantsHead = false;
  383|  1.11k|            wState->remainingBytes = (unsigned int) (payLength - length + MESSAGE_HEADER);
  384|  1.11k|            bool fin = isFin(src);
  385|  1.11k|            if constexpr (isServer) {
  ------------------
  |  Branch (385:27): [Folded - Ignored]
  ------------------
  386|  1.11k|                memcpy(wState->mask, src + MESSAGE_HEADER - 4, 4);
  387|  1.11k|                uint64_t mask;
  388|  1.11k|                memcpy(&mask, src + MESSAGE_HEADER - 4, 4);
  389|  1.11k|                memcpy(((char *)&mask) + 4, src + MESSAGE_HEADER - 4, 4);
  390|  1.11k|                unmaskImprecise8<0>(src + MESSAGE_HEADER, mask, length);
  391|  1.11k|                rotateMask(4 - (length - MESSAGE_HEADER) % 4, wState->mask);
  392|  1.11k|            }
  393|  1.11k|            Impl::handleFragment(src + MESSAGE_HEADER, length - MESSAGE_HEADER, wState->remainingBytes, wState->state.opCode[wState->state.opStack], fin, wState, user);
  394|  1.11k|            return true;
  395|  1.11k|        }
  396|  3.14k|    }
_ZN3uWS17WebSocketProtocolILb1E4ImplE23unmaskImpreciseCopyMaskILi14EEEvPcj:
  308|  2.02k|    static inline void unmaskImpreciseCopyMask(char *src, unsigned int length) {
  309|  2.02k|        if constexpr (HEADER_SIZE != 6) {
  ------------------
  |  Branch (309:23): [Folded - Ignored]
  ------------------
  310|  2.02k|            char mask[8] = {src[-4], src[-3], src[-2], src[-1], src[-4], src[-3], src[-2], src[-1]};
  311|  2.02k|            uint64_t maskInt;
  312|  2.02k|            memcpy(&maskInt, mask, 8);
  313|  2.02k|            unmaskImprecise8<HEADER_SIZE>(src, maskInt, length);
  314|  2.02k|        } else {
  315|  2.02k|            char mask[4] = {src[-4], src[-3], src[-2], src[-1]};
  316|  2.02k|            uint32_t maskInt;
  317|  2.02k|            memcpy(&maskInt, mask, 4);
  318|  2.02k|            unmaskImprecise4<HEADER_SIZE>(src, maskInt, length);
  319|  2.02k|        }
  320|  2.02k|    }
_ZN3uWS17WebSocketProtocolILb1E4ImplE16unmaskImprecise8ILi14EEEvPcmj:
  285|  2.02k|    static inline void unmaskImprecise8(char *src, uint64_t mask, unsigned int length) {
  286|  29.8k|        for (unsigned int n = (length >> 3) + 1; n; n--) {
  ------------------
  |  Branch (286:50): [True: 27.8k, False: 2.02k]
  ------------------
  287|  27.8k|            uint64_t loaded;
  288|  27.8k|            memcpy(&loaded, src, 8);
  289|  27.8k|            loaded ^= mask;
  290|  27.8k|            memcpy(src - DESTINATION, &loaded, 8);
  291|  27.8k|            src += 8;
  292|  27.8k|        }
  293|  2.02k|    }
_ZN3uWS8protocol14cond_byte_swapImEET_S2_:
   95|  4.07k|T cond_byte_swap(T value) {
   96|  4.07k|    uint32_t endian_test = 1;
   97|  4.07k|    if (*((char *)&endian_test)) {
  ------------------
  |  Branch (97:9): [True: 4.07k, False: 0]
  ------------------
   98|  4.07k|        union {
   99|  4.07k|            T i;
  100|  4.07k|            uint8_t b[sizeof(T)];
  101|  4.07k|        } src = { value }, dst;
  102|       |
  103|  36.6k|        for (unsigned int i = 0; i < sizeof(value); i++) {
  ------------------
  |  Branch (103:34): [True: 32.5k, False: 4.07k]
  ------------------
  104|  32.5k|            dst.b[i] = src.b[sizeof(value) - 1 - i];
  105|  32.5k|        }
  106|       |
  107|  4.07k|        return dst.i;
  108|  4.07k|    }
  109|      0|    return value;
  110|  4.07k|}
_ZN3uWS8protocol8bit_castImEET_Pc:
   87|  4.07k|T bit_cast(char *c) {
   88|  4.07k|    T val;
   89|  4.07k|    memcpy(&val, c, sizeof(T));
   90|  4.07k|    return val;
   91|  4.07k|}
_ZN3uWS17WebSocketProtocolILb1E4ImplE19consumeContinuationERPcRjPNS_14WebSocketStateILb1EEEPv:
  405|  9.72k|    static inline bool consumeContinuation(char *&src, unsigned int &length, WebSocketState<isServer> *wState, void *user) {
  406|  9.72k|        if (wState->remainingBytes <= length) {
  ------------------
  |  Branch (406:13): [True: 7.71k, False: 2.01k]
  ------------------
  407|  7.71k|            if (isServer) {
  ------------------
  |  Branch (407:17): [Folded - Ignored]
  ------------------
  408|  7.71k|                unsigned int n = wState->remainingBytes >> 2;
  409|  7.71k|                unmaskInplace(src, src + n * 4, wState->mask);
  410|  17.3k|                for (unsigned int i = 0, s = wState->remainingBytes % 4; i < s; i++) {
  ------------------
  |  Branch (410:74): [True: 9.60k, False: 7.71k]
  ------------------
  411|  9.60k|                    src[n * 4 + i] ^= wState->mask[i];
  412|  9.60k|                }
  413|  7.71k|            }
  414|       |
  415|  7.71k|            if (Impl::handleFragment(src, wState->remainingBytes, 0, wState->state.opCode[wState->state.opStack], wState->state.lastFin, wState, user)) {
  ------------------
  |  Branch (415:17): [True: 3.83k, False: 3.87k]
  ------------------
  416|  3.83k|                return false;
  417|  3.83k|            }
  418|       |
  419|  3.87k|            if (wState->state.lastFin) {
  ------------------
  |  Branch (419:17): [True: 2.04k, False: 1.82k]
  ------------------
  420|  2.04k|                wState->state.opStack--;
  421|  2.04k|            }
  422|       |
  423|  3.87k|            src += wState->remainingBytes;
  424|  3.87k|            length -= wState->remainingBytes;
  425|  3.87k|            wState->state.wantsHead = true;
  426|  3.87k|            return true;
  427|  7.71k|        } else {
  428|  2.01k|            if (isServer) {
  ------------------
  |  Branch (428:17): [Folded - Ignored]
  ------------------
  429|       |                /* No need to unmask if mask is 0 */
  430|  2.01k|                uint32_t nullmask = 0;
  431|  2.01k|                if (memcmp(wState->mask, &nullmask, sizeof(uint32_t))) {
  ------------------
  |  Branch (431:21): [True: 1.24k, False: 771]
  ------------------
  432|  1.24k|                    if /*constexpr*/ (LIBUS_RECV_BUFFER_LENGTH == length) {
  ------------------
  |  |   22|  1.24k|#define LIBUS_RECV_BUFFER_LENGTH 524288
  ------------------
  |  Branch (432:39): [True: 0, False: 1.24k]
  ------------------
  433|      0|                        unmaskAll(src, wState->mask);
  434|  1.24k|                    } else {
  435|       |                        // Slow path
  436|  1.24k|                        unmaskInplace(src, src + ((length >> 2) + 1) * 4, wState->mask);
  437|  1.24k|                    }
  438|  1.24k|                }
  439|  2.01k|            }
  440|       |
  441|  2.01k|            wState->remainingBytes -= length;
  442|  2.01k|            if (Impl::handleFragment(src, length, wState->remainingBytes, wState->state.opCode[wState->state.opStack], wState->state.lastFin, wState, user)) {
  ------------------
  |  Branch (442:17): [True: 674, False: 1.33k]
  ------------------
  443|    674|                return false;
  444|    674|            }
  445|       |
  446|  1.33k|            if (isServer && length % 4) {
  ------------------
  |  Branch (446:17): [Folded - Ignored]
  |  Branch (446:29): [True: 1.06k, False: 277]
  ------------------
  447|  1.06k|                rotateMask(4 - (length % 4), wState->mask);
  448|  1.06k|            }
  449|  1.33k|            return false;
  450|  2.01k|        }
  451|  9.72k|    }
_ZN3uWS17WebSocketProtocolILb1E4ImplE13unmaskInplaceEPcS3_S3_:
  330|  8.95k|    static inline void unmaskInplace(char *data, char *stop, char *mask) {
  331|  61.2k|        while (data < stop) {
  ------------------
  |  Branch (331:16): [True: 52.2k, False: 8.95k]
  ------------------
  332|  52.2k|            *(data++) ^= mask[0];
  333|  52.2k|            *(data++) ^= mask[1];
  334|  52.2k|            *(data++) ^= mask[2];
  335|  52.2k|            *(data++) ^= mask[3];
  336|  52.2k|        }
  337|  8.95k|    }

LLVMFuzzerTestOneInput:
   47|  1.46k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   48|       |
   49|       |    /* Create the parser state */
   50|  1.46k|    uWS::WebSocketState<true> state;
   51|       |
   52|  1.46k|    makeChunked(makePadded(data, size), size, [&state](const uint8_t *data, size_t size) {
   53|       |        /* Parse it */
   54|  1.46k|        uWS::WebSocketProtocol<true, Impl>::consume((char *) data, size, &state, nullptr);
   55|  1.46k|    });
   56|       |
   57|  1.46k|    return 0;
   58|  1.46k|}
WebSocket.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_0clEPKhm:
   52|  63.7k|    makeChunked(makePadded(data, size), size, [&state](const uint8_t *data, size_t size) {
   53|       |        /* Parse it */
   54|  63.7k|        uWS::WebSocketProtocol<true, Impl>::consume((char *) data, size, &state, nullptr);
   55|  63.7k|    });
_ZN4Impl13setCompressedEPN3uWS14WebSocketStateILb1EEEPv:
   22|  5.78k|    static bool setCompressed(uWS::WebSocketState<true> *wState, void *s) {
   23|       |        /* We support it */
   24|  5.78k|        return true;
   25|  5.78k|    }
_ZN4Impl10forceCloseEPN3uWS14WebSocketStateILb1EEEPvNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEE:
   27|  46.9k|    static void forceClose(uWS::WebSocketState<true> *wState, void *s, std::string_view reason = {}) {
   28|       |
   29|  46.9k|    }
_ZN4Impl19refusePayloadLengthEmPN3uWS14WebSocketStateILb1EEEPv:
   11|  16.2k|    static bool refusePayloadLength(uint64_t length, uWS::WebSocketState<true> *wState, void *s) {
   12|       |
   13|       |        /* We need a limit */
   14|  16.2k|        if (length > 16000) {
  ------------------
  |  Branch (14:13): [True: 575, False: 15.6k]
  ------------------
   15|    575|            return true;
   16|    575|        }
   17|       |
   18|       |        /* Return ok */
   19|  15.6k|        return false;
   20|  16.2k|    }
_ZN4Impl14handleFragmentEPcmjibPN3uWS14WebSocketStateILb1EEEPv:
   31|  25.3k|    static bool handleFragment(char *data, size_t length, unsigned int remainingBytes, int opCode, bool fin, uWS::WebSocketState<true> *webSocketState, void *s) {
   32|       |
   33|  25.3k|        if (opCode == uWS::TEXT) {
  ------------------
  |  Branch (33:13): [True: 15.1k, False: 10.2k]
  ------------------
   34|  15.1k|            if (!uWS::protocol::isValidUtf8((unsigned char *)data, length)) {
  ------------------
  |  Branch (34:17): [True: 9.19k, False: 5.91k]
  ------------------
   35|       |                /* Return break */
   36|  9.19k|                return true;
   37|  9.19k|            }
   38|  15.1k|        } else if (opCode == uWS::CLOSE) {
  ------------------
  |  Branch (38:20): [True: 2.87k, False: 7.36k]
  ------------------
   39|  2.87k|            uWS::protocol::parseClosePayload((char *)data, length);
   40|  2.87k|        }
   41|       |
   42|       |        /* Return ok */
   43|  16.1k|        return false;
   44|  25.3k|    }

WebSocket.cpp:_ZL11makeChunkedPKhmNSt3__18functionIFvS0_mEEE:
   28|  1.46k|static inline void makeChunked(const uint8_t *data, size_t size, std::function<void(const uint8_t *data, size_t size)> cb) {
   29|       |    /* First byte determines chunk size; 0 is all that remains, 1-255 is small chunk */
   30|  65.1k|    for (int i = 0; i < size; ) {
  ------------------
  |  Branch (30:21): [True: 63.7k, False: 1.46k]
  ------------------
   31|  63.7k|        unsigned int chunkSize = data[i++];
   32|  63.7k|        if (!chunkSize) {
  ------------------
  |  Branch (32:13): [True: 469, False: 63.2k]
  ------------------
   33|    469|            chunkSize = size - i;
   34|  63.2k|        } else {
   35|  63.2k|            chunkSize = std::min<int>(chunkSize, size - i);
   36|  63.2k|        }
   37|       |
   38|  63.7k|        cb(data + i, chunkSize);
   39|  63.7k|        i += chunkSize;
   40|  63.7k|    }
   41|  1.46k|}
WebSocket.cpp:_ZL10makePaddedPKhm:
   11|  1.46k|static inline const uint8_t *makePadded(const uint8_t *data, size_t size) {
   12|  1.46k|    static int paddedLength = 512 * 1024;
   13|  1.46k|    static char *padded = new char[128 + paddedLength + 128];
   14|       |
   15|       |    /* Increase landing area if required */
   16|  1.46k|    if (paddedLength < size) {
  ------------------
  |  Branch (16:9): [True: 12, False: 1.45k]
  ------------------
   17|     12|        delete [] padded;
   18|     12|        paddedLength = size;
   19|     12|        padded = new char [128 + paddedLength + 128];
   20|     12|    }
   21|       |
   22|  1.46k|    memcpy(padded + 128, data, size);
   23|       |
   24|  1.46k|    return (uint8_t *) padded + 128;
   25|  1.46k|}