_ZN3uWS14WebSocketStateILb1EE5StateC2Ev:
   70|  1.49k|        State() {
   71|  1.49k|            wantsHead = true;
   72|  1.49k|            spillLength = 0;
   73|  1.49k|            opStack = -1;
   74|  1.49k|            lastFin = true;
   75|  1.49k|        }
_ZN3uWS17WebSocketProtocolILb1E4ImplE7consumeEPcjPNS_14WebSocketStateILb1EEEPv:
  458|  60.2k|    static inline void consume(char *src, unsigned int length, WebSocketState<isServer> *wState, void *user) {
  459|  60.2k|        if (wState->state.spillLength) {
  ------------------
  |  Branch (459:13): [True: 24.2k, False: 36.0k]
  ------------------
  460|  24.2k|            src -= wState->state.spillLength;
  461|  24.2k|            length += wState->state.spillLength;
  462|  24.2k|            memcpy(src, wState->state.spill, wState->state.spillLength);
  463|  24.2k|        }
  464|  60.2k|        if (wState->state.wantsHead) {
  ------------------
  |  Branch (464:13): [True: 51.2k, False: 8.99k]
  ------------------
  465|  54.9k|            parseNext:
  466|  78.7k|            while (length >= SHORT_MESSAGE_HEADER) {
  ------------------
  |  Branch (466:20): [True: 76.7k, False: 1.98k]
  ------------------
  467|       |
  468|       |                // invalid reserved bits / invalid opcodes / invalid control frames / set compressed frame
  469|  76.7k|                if ((rsv1(src) && !Impl::setCompressed(wState, user)) || rsv23(src) || (getOpCode(src) > 2 && getOpCode(src) < 8) ||
  ------------------
  |  Branch (469:22): [True: 7.56k, False: 69.1k]
  |  Branch (469:35): [True: 0, False: 7.56k]
  |  Branch (469:74): [True: 37.4k, False: 39.2k]
  |  Branch (469:89): [True: 3.64k, False: 35.5k]
  |  Branch (469:111): [True: 809, False: 2.83k]
  ------------------
  470|  76.7k|                    getOpCode(src) > 10 || (getOpCode(src) > 2 && (!isFin(src) || payloadLength(src) > 125))) {
  ------------------
  |  Branch (470:21): [True: 789, False: 37.6k]
  |  Branch (470:45): [True: 2.05k, False: 35.5k]
  |  Branch (470:68): [True: 329, False: 1.72k]
  |  Branch (470:83): [True: 196, False: 1.52k]
  ------------------
  471|  39.6k|                    Impl::forceClose(wState, user);
  472|  39.6k|                    return;
  473|  39.6k|                }
  474|       |
  475|  37.1k|                if (payloadLength(src) < 126) {
  ------------------
  |  Branch (475:21): [True: 26.9k, False: 10.1k]
  ------------------
  476|  26.9k|                    if (consumeMessage<SHORT_MESSAGE_HEADER, uint8_t>(payloadLength(src), src, length, wState, user)) {
  ------------------
  |  Branch (476:25): [True: 5.11k, False: 21.8k]
  ------------------
  477|  5.11k|                        return;
  478|  5.11k|                    }
  479|  26.9k|                } else if (payloadLength(src) == 126) {
  ------------------
  |  Branch (479:28): [True: 4.94k, False: 5.23k]
  ------------------
  480|  4.94k|                    if (length < MEDIUM_MESSAGE_HEADER) {
  ------------------
  |  Branch (480:25): [True: 1.03k, False: 3.90k]
  ------------------
  481|  1.03k|                        break;
  482|  3.90k|                    } 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: 2.94k, False: 962]
  ------------------
  483|  2.94k|                        return;
  484|  2.94k|                    }
  485|  5.23k|                } else if (length < LONG_MESSAGE_HEADER) {
  ------------------
  |  Branch (485:28): [True: 1.09k, False: 4.14k]
  ------------------
  486|  1.09k|                    break;
  487|  4.14k|                } 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.17k, False: 962]
  ------------------
  488|  3.17k|                    return;
  489|  3.17k|                }
  490|  37.1k|            }
  491|  4.11k|            if (length) {
  ------------------
  |  Branch (491:17): [True: 3.17k, False: 940]
  ------------------
  492|  3.17k|                memcpy(wState->state.spill, src, length);
  493|  3.17k|                wState->state.spillLength = length & 0xf;
  494|  3.17k|            }
  495|  8.99k|        } else if (consumeContinuation(src, length, wState, user)) {
  ------------------
  |  Branch (495:20): [True: 3.69k, False: 5.29k]
  ------------------
  496|  3.69k|            goto parseNext;
  497|  3.69k|        }
  498|  60.2k|    }
_ZN3uWS17WebSocketProtocolILb1E4ImplE4rsv1EPc:
  274|  76.7k|    static inline bool rsv1(char *frame) {return *((unsigned char *) frame) & 64;}
_ZN3uWS17WebSocketProtocolILb1E4ImplE5rsv23EPc:
  273|  76.7k|    static inline bool rsv23(char *frame) {return *((unsigned char *) frame) & 48;}
_ZN3uWS17WebSocketProtocolILb1E4ImplE9getOpCodeEPc:
  271|   160k|    static inline unsigned char getOpCode(char *frame) {return *((unsigned char *) frame) & 15;}
_ZN3uWS17WebSocketProtocolILb1E4ImplE5isFinEPc:
  270|  65.8k|    static inline bool isFin(char *frame) {return *((unsigned char *) frame) & 128;}
_ZN3uWS17WebSocketProtocolILb1E4ImplE13payloadLengthEPc:
  272|  75.9k|    static inline unsigned char payloadLength(char *frame) {return ((unsigned char *) frame)[1] & 127;}
_ZN3uWS17WebSocketProtocolILb1E4ImplE14consumeMessageILj6EhEEbT0_RPcRjPNS_14WebSocketStateILb1EEEPv:
  340|  26.9k|    static inline bool consumeMessage(T payLength, char *&src, unsigned int &length, WebSocketState<isServer> *wState, void *user) {
  341|  26.9k|        if (getOpCode(src)) {
  ------------------
  |  Branch (341:13): [True: 3.46k, False: 23.4k]
  ------------------
  342|  3.46k|            if (wState->state.opStack == 1 || (!wState->state.lastFin && getOpCode(src) < 2)) {
  ------------------
  |  Branch (342:17): [True: 415, False: 3.04k]
  |  Branch (342:48): [True: 540, False: 2.50k]
  |  Branch (342:74): [True: 204, False: 336]
  ------------------
  343|    619|                Impl::forceClose(wState, user);
  344|    619|                return true;
  345|    619|            }
  346|  2.84k|            wState->state.opCode[++wState->state.opStack] = (OpCode) getOpCode(src);
  347|  23.4k|        } else if (wState->state.opStack == -1) {
  ------------------
  |  Branch (347:20): [True: 847, False: 22.6k]
  ------------------
  348|    847|            Impl::forceClose(wState, user);
  349|    847|            return true;
  350|    847|        }
  351|  25.4k|        wState->state.lastFin = isFin(src);
  352|       |
  353|  25.4k|        if (Impl::refusePayloadLength(payLength, wState, user)) {
  ------------------
  |  Branch (353:13): [True: 0, False: 25.4k]
  ------------------
  354|      0|            Impl::forceClose(wState, user, ERR_TOO_BIG_MESSAGE);
  355|      0|            return true;
  356|      0|        }
  357|       |
  358|  25.4k|        if (payLength + MESSAGE_HEADER <= length) {
  ------------------
  |  Branch (358:13): [True: 23.3k, False: 2.08k]
  ------------------
  359|  23.3k|            bool fin = isFin(src);
  360|  23.3k|            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|  23.3k|                unmaskImpreciseCopyMask<MESSAGE_HEADER>(src + MESSAGE_HEADER, (unsigned int) payLength);
  363|  23.3k|                if (Impl::handleFragment(src, payLength, 0, wState->state.opCode[wState->state.opStack], fin, wState, user)) {
  ------------------
  |  Branch (363:21): [True: 1.56k, False: 21.8k]
  ------------------
  364|  1.56k|                    return true;
  365|  1.56k|                }
  366|  23.3k|            } 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|  21.8k|            if (fin) {
  ------------------
  |  Branch (372:17): [True: 1.37k, False: 20.4k]
  ------------------
  373|  1.37k|                wState->state.opStack--;
  374|  1.37k|            }
  375|       |
  376|  21.8k|            src += payLength + MESSAGE_HEADER;
  377|  21.8k|            length -= (unsigned int) (payLength + MESSAGE_HEADER);
  378|  21.8k|            wState->state.spillLength = 0;
  379|  21.8k|            return false;
  380|  23.3k|        } else {
  381|  2.08k|            wState->state.spillLength = 0;
  382|  2.08k|            wState->state.wantsHead = false;
  383|  2.08k|            wState->remainingBytes = (unsigned int) (payLength - length + MESSAGE_HEADER);
  384|  2.08k|            bool fin = isFin(src);
  385|  2.08k|            if constexpr (isServer) {
  ------------------
  |  Branch (385:27): [Folded - Ignored]
  ------------------
  386|  2.08k|                memcpy(wState->mask, src + MESSAGE_HEADER - 4, 4);
  387|  2.08k|                uint64_t mask;
  388|  2.08k|                memcpy(&mask, src + MESSAGE_HEADER - 4, 4);
  389|  2.08k|                memcpy(((char *)&mask) + 4, src + MESSAGE_HEADER - 4, 4);
  390|  2.08k|                unmaskImprecise8<0>(src + MESSAGE_HEADER, mask, length);
  391|  2.08k|                rotateMask(4 - (length - MESSAGE_HEADER) % 4, wState->mask);
  392|  2.08k|            }
  393|  2.08k|            Impl::handleFragment(src + MESSAGE_HEADER, length - MESSAGE_HEADER, wState->remainingBytes, wState->state.opCode[wState->state.opStack], fin, wState, user);
  394|  2.08k|            return true;
  395|  2.08k|        }
  396|  25.4k|    }
_ZN3uWS17WebSocketProtocolILb1E4ImplE23unmaskImpreciseCopyMaskILi6EEEvPcj:
  308|  23.3k|    static inline void unmaskImpreciseCopyMask(char *src, unsigned int length) {
  309|  23.3k|        if constexpr (HEADER_SIZE != 6) {
  ------------------
  |  Branch (309:23): [Folded - Ignored]
  ------------------
  310|  23.3k|            char mask[8] = {src[-4], src[-3], src[-2], src[-1], src[-4], src[-3], src[-2], src[-1]};
  311|  23.3k|            uint64_t maskInt;
  312|  23.3k|            memcpy(&maskInt, mask, 8);
  313|  23.3k|            unmaskImprecise8<HEADER_SIZE>(src, maskInt, length);
  314|  23.3k|        } else {
  315|  23.3k|            char mask[4] = {src[-4], src[-3], src[-2], src[-1]};
  316|  23.3k|            uint32_t maskInt;
  317|  23.3k|            memcpy(&maskInt, mask, 4);
  318|  23.3k|            unmaskImprecise4<HEADER_SIZE>(src, maskInt, length);
  319|  23.3k|        }
  320|  23.3k|    }
_ZN3uWS17WebSocketProtocolILb1E4ImplE16unmaskImprecise4ILi6EEEvPcjj:
  297|  23.3k|    static inline void unmaskImprecise4(char *src, uint32_t mask, unsigned int length) {
  298|  60.9k|        for (unsigned int n = (length >> 2) + 1; n; n--) {
  ------------------
  |  Branch (298:50): [True: 37.6k, False: 23.3k]
  ------------------
  299|  37.6k|            uint32_t loaded;
  300|  37.6k|            memcpy(&loaded, src, 4);
  301|  37.6k|            loaded ^= mask;
  302|  37.6k|            memcpy(src - DESTINATION, &loaded, 4);
  303|  37.6k|            src += 4;
  304|  37.6k|        }
  305|  23.3k|    }
WebSocket.cpp:_ZN3uWS8protocolL11isValidUtf8EPhm:
  117|  14.2k|{
  118|  24.0k|    for (unsigned char *e = s + length; s != e; ) {
  ------------------
  |  Branch (118:41): [True: 20.0k, False: 4.03k]
  ------------------
  119|  20.0k|        if (s + 4 <= e) {
  ------------------
  |  Branch (119:13): [True: 13.9k, False: 6.04k]
  ------------------
  120|  13.9k|            uint32_t tmp;
  121|  13.9k|            memcpy(&tmp, s, 4);
  122|  13.9k|            if ((tmp & 0x80808080) == 0) {
  ------------------
  |  Branch (122:17): [True: 7.79k, False: 6.17k]
  ------------------
  123|  7.79k|                s += 4;
  124|  7.79k|                continue;
  125|  7.79k|            }
  126|  13.9k|        }
  127|       |
  128|  16.0k|        while (!(*s & 0x80)) {
  ------------------
  |  Branch (128:16): [True: 6.09k, False: 9.92k]
  ------------------
  129|  6.09k|            if (++s == e) {
  ------------------
  |  Branch (129:17): [True: 2.29k, False: 3.79k]
  ------------------
  130|  2.29k|                return true;
  131|  2.29k|            }
  132|  6.09k|        }
  133|       |
  134|  9.92k|        if ((s[0] & 0x60) == 0x40) {
  ------------------
  |  Branch (134:13): [True: 2.45k, False: 7.47k]
  ------------------
  135|  2.45k|            if (s + 1 >= e || (s[1] & 0xc0) != 0x80 || (s[0] & 0xfe) == 0xc0) {
  ------------------
  |  Branch (135:17): [True: 465, False: 1.99k]
  |  Branch (135:31): [True: 1.10k, False: 883]
  |  Branch (135:56): [True: 197, False: 686]
  ------------------
  136|  1.76k|                return false;
  137|  1.76k|            }
  138|    686|            s += 2;
  139|  7.47k|        } else if ((s[0] & 0xf0) == 0xe0) {
  ------------------
  |  Branch (139:20): [True: 2.16k, False: 5.31k]
  ------------------
  140|  2.16k|            if (s + 2 >= e || (s[1] & 0xc0) != 0x80 || (s[2] & 0xc0) != 0x80 ||
  ------------------
  |  Branch (140:17): [True: 536, False: 1.62k]
  |  Branch (140:31): [True: 412, False: 1.21k]
  |  Branch (140:56): [True: 204, False: 1.01k]
  ------------------
  141|  2.16k|                    (s[0] == 0xe0 && (s[1] & 0xe0) == 0x80) || (s[0] == 0xed && (s[1] & 0xe0) == 0xa0)) {
  ------------------
  |  Branch (141:22): [True: 391, False: 620]
  |  Branch (141:38): [True: 194, False: 197]
  |  Branch (141:65): [True: 404, False: 413]
  |  Branch (141:81): [True: 194, False: 210]
  ------------------
  142|  1.54k|                return false;
  143|  1.54k|            }
  144|    623|            s += 3;
  145|  5.31k|        } else if ((s[0] & 0xf8) == 0xf0) {
  ------------------
  |  Branch (145:20): [True: 2.55k, False: 2.75k]
  ------------------
  146|  2.55k|            if (s + 3 >= e || (s[1] & 0xc0) != 0x80 || (s[2] & 0xc0) != 0x80 || (s[3] & 0xc0) != 0x80 ||
  ------------------
  |  Branch (146:17): [True: 455, False: 2.10k]
  |  Branch (146:31): [True: 395, False: 1.70k]
  |  Branch (146:56): [True: 202, False: 1.50k]
  |  Branch (146:81): [True: 204, False: 1.30k]
  ------------------
  147|  2.55k|                    (s[0] == 0xf0 && (s[1] & 0xf0) == 0x80) || (s[0] == 0xf4 && s[1] > 0x8f) || s[0] > 0xf4) {
  ------------------
  |  Branch (147:22): [True: 393, False: 907]
  |  Branch (147:38): [True: 194, False: 199]
  |  Branch (147:65): [True: 491, False: 615]
  |  Branch (147:81): [True: 198, False: 293]
  |  Branch (147:97): [True: 197, False: 711]
  ------------------
  148|  1.84k|                return false;
  149|  1.84k|            }
  150|    711|            s += 4;
  151|  2.75k|        } else {
  152|  2.75k|            return false;
  153|  2.75k|        }
  154|  9.92k|    }
  155|  4.03k|    return true;
  156|  14.2k|}
WebSocket.cpp:_ZN3uWS8protocolL17parseClosePayloadEPcm:
  164|  1.45k|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|  1.45k|    CloseFrame cf = {1005, nullptr, 0};
  167|  1.45k|    if (length >= 2) {
  ------------------
  |  Branch (167:9): [True: 791, False: 660]
  ------------------
  168|    791|        memcpy(&cf.code, src, 2);
  169|    791|        cf = {cond_byte_swap<uint16_t>(cf.code), src + 2, length - 2};
  170|    791|        if (cf.code < 1000 || cf.code > 4999 || (cf.code > 1011 && cf.code < 4000) ||
  ------------------
  |  Branch (170:13): [True: 493, False: 298]
  |  Branch (170:31): [True: 212, False: 86]
  |  Branch (170:50): [True: 66, False: 20]
  |  Branch (170:68): [True: 53, False: 13]
  ------------------
  171|    791|            (cf.code >= 1004 && cf.code <= 1006) || !isValidUtf8((unsigned char *) cf.message, cf.length)) {
  ------------------
  |  Branch (171:14): [True: 27, False: 6]
  |  Branch (171:33): [True: 5, False: 22]
  |  Branch (171:53): [True: 21, False: 7]
  ------------------
  172|       |            /* Even though we got a WebSocket close frame, it in itself is abnormal */
  173|    784|            return {1006, nullptr, 0};
  174|    784|        }
  175|    791|    }
  176|    667|    return cf;
  177|  1.45k|}
_ZN3uWS17WebSocketProtocolILb1E4ImplE16unmaskImprecise8ILi0EEEvPcmj:
  285|  4.26k|    static inline void unmaskImprecise8(char *src, uint64_t mask, unsigned int length) {
  286|  39.4k|        for (unsigned int n = (length >> 3) + 1; n; n--) {
  ------------------
  |  Branch (286:50): [True: 35.1k, False: 4.26k]
  ------------------
  287|  35.1k|            uint64_t loaded;
  288|  35.1k|            memcpy(&loaded, src, 8);
  289|  35.1k|            loaded ^= mask;
  290|  35.1k|            memcpy(src - DESTINATION, &loaded, 8);
  291|  35.1k|            src += 8;
  292|  35.1k|        }
  293|  4.26k|    }
_ZN3uWS17WebSocketProtocolILb1E4ImplE10rotateMaskEjPc:
  322|  5.67k|    static inline void rotateMask(unsigned int offset, char *mask) {
  323|  5.67k|        char originalMask[4] = {mask[0], mask[1], mask[2], mask[3]};
  324|  5.67k|        mask[(0 + offset) % 4] = originalMask[0];
  325|  5.67k|        mask[(1 + offset) % 4] = originalMask[1];
  326|  5.67k|        mask[(2 + offset) % 4] = originalMask[2];
  327|  5.67k|        mask[(3 + offset) % 4] = originalMask[3];
  328|  5.67k|    }
_ZN3uWS17WebSocketProtocolILb1E4ImplE14consumeMessageILj8EtEEbT0_RPcRjPNS_14WebSocketStateILb1EEEPv:
  340|  3.90k|    static inline bool consumeMessage(T payLength, char *&src, unsigned int &length, WebSocketState<isServer> *wState, void *user) {
  341|  3.90k|        if (getOpCode(src)) {
  ------------------
  |  Branch (341:13): [True: 1.59k, False: 2.31k]
  ------------------
  342|  1.59k|            if (wState->state.opStack == 1 || (!wState->state.lastFin && getOpCode(src) < 2)) {
  ------------------
  |  Branch (342:17): [True: 194, False: 1.40k]
  |  Branch (342:48): [True: 425, False: 978]
  |  Branch (342:74): [True: 196, False: 229]
  ------------------
  343|    390|                Impl::forceClose(wState, user);
  344|    390|                return true;
  345|    390|            }
  346|  1.20k|            wState->state.opCode[++wState->state.opStack] = (OpCode) getOpCode(src);
  347|  2.31k|        } else if (wState->state.opStack == -1) {
  ------------------
  |  Branch (347:20): [True: 194, False: 2.11k]
  ------------------
  348|    194|            Impl::forceClose(wState, user);
  349|    194|            return true;
  350|    194|        }
  351|  3.32k|        wState->state.lastFin = isFin(src);
  352|       |
  353|  3.32k|        if (Impl::refusePayloadLength(payLength, wState, user)) {
  ------------------
  |  Branch (353:13): [True: 244, False: 3.08k]
  ------------------
  354|    244|            Impl::forceClose(wState, user, ERR_TOO_BIG_MESSAGE);
  355|    244|            return true;
  356|    244|        }
  357|       |
  358|  3.08k|        if (payLength + MESSAGE_HEADER <= length) {
  ------------------
  |  Branch (358:13): [True: 2.06k, False: 1.01k]
  ------------------
  359|  2.06k|            bool fin = isFin(src);
  360|  2.06k|            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.06k|                unmaskImpreciseCopyMask<MESSAGE_HEADER>(src + MESSAGE_HEADER, (unsigned int) payLength);
  363|  2.06k|                if (Impl::handleFragment(src, payLength, 0, wState->state.opCode[wState->state.opStack], fin, wState, user)) {
  ------------------
  |  Branch (363:21): [True: 1.10k, False: 962]
  ------------------
  364|  1.10k|                    return true;
  365|  1.10k|                }
  366|  2.06k|            } 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|    962|            if (fin) {
  ------------------
  |  Branch (372:17): [True: 723, False: 239]
  ------------------
  373|    723|                wState->state.opStack--;
  374|    723|            }
  375|       |
  376|    962|            src += payLength + MESSAGE_HEADER;
  377|    962|            length -= (unsigned int) (payLength + MESSAGE_HEADER);
  378|    962|            wState->state.spillLength = 0;
  379|    962|            return false;
  380|  2.06k|        } else {
  381|  1.01k|            wState->state.spillLength = 0;
  382|  1.01k|            wState->state.wantsHead = false;
  383|  1.01k|            wState->remainingBytes = (unsigned int) (payLength - length + MESSAGE_HEADER);
  384|  1.01k|            bool fin = isFin(src);
  385|  1.01k|            if constexpr (isServer) {
  ------------------
  |  Branch (385:27): [Folded - Ignored]
  ------------------
  386|  1.01k|                memcpy(wState->mask, src + MESSAGE_HEADER - 4, 4);
  387|  1.01k|                uint64_t mask;
  388|  1.01k|                memcpy(&mask, src + MESSAGE_HEADER - 4, 4);
  389|  1.01k|                memcpy(((char *)&mask) + 4, src + MESSAGE_HEADER - 4, 4);
  390|  1.01k|                unmaskImprecise8<0>(src + MESSAGE_HEADER, mask, length);
  391|  1.01k|                rotateMask(4 - (length - MESSAGE_HEADER) % 4, wState->mask);
  392|  1.01k|            }
  393|  1.01k|            Impl::handleFragment(src + MESSAGE_HEADER, length - MESSAGE_HEADER, wState->remainingBytes, wState->state.opCode[wState->state.opStack], fin, wState, user);
  394|  1.01k|            return true;
  395|  1.01k|        }
  396|  3.08k|    }
_ZN3uWS17WebSocketProtocolILb1E4ImplE23unmaskImpreciseCopyMaskILi8EEEvPcj:
  308|  2.06k|    static inline void unmaskImpreciseCopyMask(char *src, unsigned int length) {
  309|  2.06k|        if constexpr (HEADER_SIZE != 6) {
  ------------------
  |  Branch (309:23): [Folded - Ignored]
  ------------------
  310|  2.06k|            char mask[8] = {src[-4], src[-3], src[-2], src[-1], src[-4], src[-3], src[-2], src[-1]};
  311|  2.06k|            uint64_t maskInt;
  312|  2.06k|            memcpy(&maskInt, mask, 8);
  313|  2.06k|            unmaskImprecise8<HEADER_SIZE>(src, maskInt, length);
  314|  2.06k|        } else {
  315|  2.06k|            char mask[4] = {src[-4], src[-3], src[-2], src[-1]};
  316|  2.06k|            uint32_t maskInt;
  317|  2.06k|            memcpy(&maskInt, mask, 4);
  318|  2.06k|            unmaskImprecise4<HEADER_SIZE>(src, maskInt, length);
  319|  2.06k|        }
  320|  2.06k|    }
_ZN3uWS17WebSocketProtocolILb1E4ImplE16unmaskImprecise8ILi8EEEvPcmj:
  285|  2.06k|    static inline void unmaskImprecise8(char *src, uint64_t mask, unsigned int length) {
  286|  47.5k|        for (unsigned int n = (length >> 3) + 1; n; n--) {
  ------------------
  |  Branch (286:50): [True: 45.4k, False: 2.06k]
  ------------------
  287|  45.4k|            uint64_t loaded;
  288|  45.4k|            memcpy(&loaded, src, 8);
  289|  45.4k|            loaded ^= mask;
  290|  45.4k|            memcpy(src - DESTINATION, &loaded, 8);
  291|  45.4k|            src += 8;
  292|  45.4k|        }
  293|  2.06k|    }
_ZN3uWS8protocol14cond_byte_swapItEET_S2_:
   95|  4.69k|T cond_byte_swap(T value) {
   96|  4.69k|    uint32_t endian_test = 1;
   97|  4.69k|    if (*((char *)&endian_test)) {
  ------------------
  |  Branch (97:9): [True: 4.69k, False: 0]
  ------------------
   98|  4.69k|        union {
   99|  4.69k|            T i;
  100|  4.69k|            uint8_t b[sizeof(T)];
  101|  4.69k|        } src = { value }, dst;
  102|       |
  103|  14.0k|        for (unsigned int i = 0; i < sizeof(value); i++) {
  ------------------
  |  Branch (103:34): [True: 9.39k, False: 4.69k]
  ------------------
  104|  9.39k|            dst.b[i] = src.b[sizeof(value) - 1 - i];
  105|  9.39k|        }
  106|       |
  107|  4.69k|        return dst.i;
  108|  4.69k|    }
  109|      0|    return value;
  110|  4.69k|}
_ZN3uWS8protocol8bit_castItEET_Pc:
   87|  3.90k|T bit_cast(char *c) {
   88|  3.90k|    T val;
   89|  3.90k|    memcpy(&val, c, sizeof(T));
   90|  3.90k|    return val;
   91|  3.90k|}
_ZN3uWS17WebSocketProtocolILb1E4ImplE14consumeMessageILj14EmEEbT0_RPcRjPNS_14WebSocketStateILb1EEEPv:
  340|  4.14k|    static inline bool consumeMessage(T payLength, char *&src, unsigned int &length, WebSocketState<isServer> *wState, void *user) {
  341|  4.14k|        if (getOpCode(src)) {
  ------------------
  |  Branch (341:13): [True: 1.55k, False: 2.58k]
  ------------------
  342|  1.55k|            if (wState->state.opStack == 1 || (!wState->state.lastFin && getOpCode(src) < 2)) {
  ------------------
  |  Branch (342:17): [True: 194, False: 1.36k]
  |  Branch (342:48): [True: 496, False: 864]
  |  Branch (342:74): [True: 199, False: 297]
  ------------------
  343|    393|                Impl::forceClose(wState, user);
  344|    393|                return true;
  345|    393|            }
  346|  1.16k|            wState->state.opCode[++wState->state.opStack] = (OpCode) getOpCode(src);
  347|  2.58k|        } else if (wState->state.opStack == -1) {
  ------------------
  |  Branch (347:20): [True: 343, False: 2.24k]
  ------------------
  348|    343|            Impl::forceClose(wState, user);
  349|    343|            return true;
  350|    343|        }
  351|  3.40k|        wState->state.lastFin = isFin(src);
  352|       |
  353|  3.40k|        if (Impl::refusePayloadLength(payLength, wState, user)) {
  ------------------
  |  Branch (353:13): [True: 389, False: 3.01k]
  ------------------
  354|    389|            Impl::forceClose(wState, user, ERR_TOO_BIG_MESSAGE);
  355|    389|            return true;
  356|    389|        }
  357|       |
  358|  3.01k|        if (payLength + MESSAGE_HEADER <= length) {
  ------------------
  |  Branch (358:13): [True: 1.85k, False: 1.16k]
  ------------------
  359|  1.85k|            bool fin = isFin(src);
  360|  1.85k|            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|  1.85k|                unmaskImpreciseCopyMask<MESSAGE_HEADER>(src + MESSAGE_HEADER, (unsigned int) payLength);
  363|  1.85k|                if (Impl::handleFragment(src, payLength, 0, wState->state.opCode[wState->state.opStack], fin, wState, user)) {
  ------------------
  |  Branch (363:21): [True: 889, False: 962]
  ------------------
  364|    889|                    return true;
  365|    889|                }
  366|  1.85k|            } 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|    962|            if (fin) {
  ------------------
  |  Branch (372:17): [True: 595, False: 367]
  ------------------
  373|    595|                wState->state.opStack--;
  374|    595|            }
  375|       |
  376|    962|            src += payLength + MESSAGE_HEADER;
  377|    962|            length -= (unsigned int) (payLength + MESSAGE_HEADER);
  378|    962|            wState->state.spillLength = 0;
  379|    962|            return false;
  380|  1.85k|        } else {
  381|  1.16k|            wState->state.spillLength = 0;
  382|  1.16k|            wState->state.wantsHead = false;
  383|  1.16k|            wState->remainingBytes = (unsigned int) (payLength - length + MESSAGE_HEADER);
  384|  1.16k|            bool fin = isFin(src);
  385|  1.16k|            if constexpr (isServer) {
  ------------------
  |  Branch (385:27): [Folded - Ignored]
  ------------------
  386|  1.16k|                memcpy(wState->mask, src + MESSAGE_HEADER - 4, 4);
  387|  1.16k|                uint64_t mask;
  388|  1.16k|                memcpy(&mask, src + MESSAGE_HEADER - 4, 4);
  389|  1.16k|                memcpy(((char *)&mask) + 4, src + MESSAGE_HEADER - 4, 4);
  390|  1.16k|                unmaskImprecise8<0>(src + MESSAGE_HEADER, mask, length);
  391|  1.16k|                rotateMask(4 - (length - MESSAGE_HEADER) % 4, wState->mask);
  392|  1.16k|            }
  393|  1.16k|            Impl::handleFragment(src + MESSAGE_HEADER, length - MESSAGE_HEADER, wState->remainingBytes, wState->state.opCode[wState->state.opStack], fin, wState, user);
  394|  1.16k|            return true;
  395|  1.16k|        }
  396|  3.01k|    }
_ZN3uWS17WebSocketProtocolILb1E4ImplE23unmaskImpreciseCopyMaskILi14EEEvPcj:
  308|  1.85k|    static inline void unmaskImpreciseCopyMask(char *src, unsigned int length) {
  309|  1.85k|        if constexpr (HEADER_SIZE != 6) {
  ------------------
  |  Branch (309:23): [Folded - Ignored]
  ------------------
  310|  1.85k|            char mask[8] = {src[-4], src[-3], src[-2], src[-1], src[-4], src[-3], src[-2], src[-1]};
  311|  1.85k|            uint64_t maskInt;
  312|  1.85k|            memcpy(&maskInt, mask, 8);
  313|  1.85k|            unmaskImprecise8<HEADER_SIZE>(src, maskInt, length);
  314|  1.85k|        } else {
  315|  1.85k|            char mask[4] = {src[-4], src[-3], src[-2], src[-1]};
  316|  1.85k|            uint32_t maskInt;
  317|  1.85k|            memcpy(&maskInt, mask, 4);
  318|  1.85k|            unmaskImprecise4<HEADER_SIZE>(src, maskInt, length);
  319|  1.85k|        }
  320|  1.85k|    }
_ZN3uWS17WebSocketProtocolILb1E4ImplE16unmaskImprecise8ILi14EEEvPcmj:
  285|  1.85k|    static inline void unmaskImprecise8(char *src, uint64_t mask, unsigned int length) {
  286|  36.7k|        for (unsigned int n = (length >> 3) + 1; n; n--) {
  ------------------
  |  Branch (286:50): [True: 34.9k, False: 1.85k]
  ------------------
  287|  34.9k|            uint64_t loaded;
  288|  34.9k|            memcpy(&loaded, src, 8);
  289|  34.9k|            loaded ^= mask;
  290|  34.9k|            memcpy(src - DESTINATION, &loaded, 8);
  291|  34.9k|            src += 8;
  292|  34.9k|        }
  293|  1.85k|    }
_ZN3uWS8protocol14cond_byte_swapImEET_S2_:
   95|  4.14k|T cond_byte_swap(T value) {
   96|  4.14k|    uint32_t endian_test = 1;
   97|  4.14k|    if (*((char *)&endian_test)) {
  ------------------
  |  Branch (97:9): [True: 4.14k, False: 0]
  ------------------
   98|  4.14k|        union {
   99|  4.14k|            T i;
  100|  4.14k|            uint8_t b[sizeof(T)];
  101|  4.14k|        } src = { value }, dst;
  102|       |
  103|  37.2k|        for (unsigned int i = 0; i < sizeof(value); i++) {
  ------------------
  |  Branch (103:34): [True: 33.1k, False: 4.14k]
  ------------------
  104|  33.1k|            dst.b[i] = src.b[sizeof(value) - 1 - i];
  105|  33.1k|        }
  106|       |
  107|  4.14k|        return dst.i;
  108|  4.14k|    }
  109|      0|    return value;
  110|  4.14k|}
_ZN3uWS8protocol8bit_castImEET_Pc:
   87|  4.14k|T bit_cast(char *c) {
   88|  4.14k|    T val;
   89|  4.14k|    memcpy(&val, c, sizeof(T));
   90|  4.14k|    return val;
   91|  4.14k|}
_ZN3uWS17WebSocketProtocolILb1E4ImplE19consumeContinuationERPcRjPNS_14WebSocketStateILb1EEEPv:
  405|  8.99k|    static inline bool consumeContinuation(char *&src, unsigned int &length, WebSocketState<isServer> *wState, void *user) {
  406|  8.99k|        if (wState->remainingBytes <= length) {
  ------------------
  |  Branch (406:13): [True: 6.87k, False: 2.11k]
  ------------------
  407|  6.87k|            if (isServer) {
  ------------------
  |  Branch (407:17): [Folded - Ignored]
  ------------------
  408|  6.87k|                unsigned int n = wState->remainingBytes >> 2;
  409|  6.87k|                unmaskInplace(src, src + n * 4, wState->mask);
  410|  15.7k|                for (unsigned int i = 0, s = wState->remainingBytes % 4; i < s; i++) {
  ------------------
  |  Branch (410:74): [True: 8.87k, False: 6.87k]
  ------------------
  411|  8.87k|                    src[n * 4 + i] ^= wState->mask[i];
  412|  8.87k|                }
  413|  6.87k|            }
  414|       |
  415|  6.87k|            if (Impl::handleFragment(src, wState->remainingBytes, 0, wState->state.opCode[wState->state.opStack], wState->state.lastFin, wState, user)) {
  ------------------
  |  Branch (415:17): [True: 3.17k, False: 3.69k]
  ------------------
  416|  3.17k|                return false;
  417|  3.17k|            }
  418|       |
  419|  3.69k|            if (wState->state.lastFin) {
  ------------------
  |  Branch (419:17): [True: 1.16k, False: 2.53k]
  ------------------
  420|  1.16k|                wState->state.opStack--;
  421|  1.16k|            }
  422|       |
  423|  3.69k|            src += wState->remainingBytes;
  424|  3.69k|            length -= wState->remainingBytes;
  425|  3.69k|            wState->state.wantsHead = true;
  426|  3.69k|            return true;
  427|  6.87k|        } else {
  428|  2.11k|            if (isServer) {
  ------------------
  |  Branch (428:17): [Folded - Ignored]
  ------------------
  429|       |                /* No need to unmask if mask is 0 */
  430|  2.11k|                uint32_t nullmask = 0;
  431|  2.11k|                if (memcmp(wState->mask, &nullmask, sizeof(uint32_t))) {
  ------------------
  |  Branch (431:21): [True: 895, False: 1.22k]
  ------------------
  432|    895|                    if /*constexpr*/ (LIBUS_RECV_BUFFER_LENGTH == length) {
  ------------------
  |  |   22|    895|#define LIBUS_RECV_BUFFER_LENGTH 524288
  ------------------
  |  Branch (432:39): [True: 0, False: 895]
  ------------------
  433|      0|                        unmaskAll(src, wState->mask);
  434|    895|                    } else {
  435|       |                        // Slow path
  436|    895|                        unmaskInplace(src, src + ((length >> 2) + 1) * 4, wState->mask);
  437|    895|                    }
  438|    895|                }
  439|  2.11k|            }
  440|       |
  441|  2.11k|            wState->remainingBytes -= length;
  442|  2.11k|            if (Impl::handleFragment(src, length, wState->remainingBytes, wState->state.opCode[wState->state.opStack], wState->state.lastFin, wState, user)) {
  ------------------
  |  Branch (442:17): [True: 416, False: 1.70k]
  ------------------
  443|    416|                return false;
  444|    416|            }
  445|       |
  446|  1.70k|            if (isServer && length % 4) {
  ------------------
  |  Branch (446:17): [Folded - Ignored]
  |  Branch (446:29): [True: 1.41k, False: 285]
  ------------------
  447|  1.41k|                rotateMask(4 - (length % 4), wState->mask);
  448|  1.41k|            }
  449|  1.70k|            return false;
  450|  2.11k|        }
  451|  8.99k|    }
_ZN3uWS17WebSocketProtocolILb1E4ImplE13unmaskInplaceEPcS3_S3_:
  330|  7.77k|    static inline void unmaskInplace(char *data, char *stop, char *mask) {
  331|  50.4k|        while (data < stop) {
  ------------------
  |  Branch (331:16): [True: 42.6k, False: 7.77k]
  ------------------
  332|  42.6k|            *(data++) ^= mask[0];
  333|  42.6k|            *(data++) ^= mask[1];
  334|  42.6k|            *(data++) ^= mask[2];
  335|  42.6k|            *(data++) ^= mask[3];
  336|  42.6k|        }
  337|  7.77k|    }

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

WebSocket.cpp:_ZL11makeChunkedPKhmNSt3__18functionIFvS0_mEEE:
   28|  1.49k|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|  61.7k|    for (int i = 0; i < size; ) {
  ------------------
  |  Branch (30:21): [True: 60.2k, False: 1.49k]
  ------------------
   31|  60.2k|        unsigned int chunkSize = data[i++];
   32|  60.2k|        if (!chunkSize) {
  ------------------
  |  Branch (32:13): [True: 490, False: 59.7k]
  ------------------
   33|    490|            chunkSize = size - i;
   34|  59.7k|        } else {
   35|  59.7k|            chunkSize = std::min<int>(chunkSize, size - i);
   36|  59.7k|        }
   37|       |
   38|  60.2k|        cb(data + i, chunkSize);
   39|  60.2k|        i += chunkSize;
   40|  60.2k|    }
   41|  1.49k|}
WebSocket.cpp:_ZL10makePaddedPKhm:
   11|  1.49k|static inline const uint8_t *makePadded(const uint8_t *data, size_t size) {
   12|  1.49k|    static int paddedLength = 512 * 1024;
   13|  1.49k|    static char *padded = new char[128 + paddedLength + 128];
   14|       |
   15|       |    /* Increase landing area if required */
   16|  1.49k|    if (paddedLength < size) {
  ------------------
  |  Branch (16:9): [True: 12, False: 1.48k]
  ------------------
   17|     12|        delete [] padded;
   18|     12|        paddedLength = size;
   19|     12|        padded = new char [128 + paddedLength + 128];
   20|     12|    }
   21|       |
   22|  1.49k|    memcpy(padded + 128, data, size);
   23|       |
   24|  1.49k|    return (uint8_t *) padded + 128;
   25|  1.49k|}