002007e1,          ," "
01e092d6,          ,"■msg♦Got complete HDLC packet■module♦■file♦applications/rpc/main.cc"
08d350be,          ,"■msg♦Nanopb failed to decode request payload from channel %u■module♦■file♦third_party/pigweed/pw_rpc/nanopb/method.cc"
0aed610d,          ,"■msg♦          free() is called %u times. (realloc() counted as one time)■module♦■file♦third_party/pigweed/pw_allocator/freelist_heap.cc"
0dea0ed0,          ,"■msg♦Nanopb protobuf decode failed: %s■module♦■file♦third_party/pigweed/pw_rpc/nanopb/common.cc"
0f831860,          ,"Failed to decode request payload from channel %u"
0f8381fa,          ,"■msg♦          The cumulative allocated heap memory is %u bytes.■module♦■file♦third_party/pigweed/pw_allocator/freelist_heap.cc"
0fbd23ba,          ,"Failed to send response packet for channel %u"
119afa25,          ,"■msg♦Registering pw_rpc services■module♦■file♦applications/rpc/main.cc"
130e2c4b,          ,"Received incomplete packet on interface %s"
1ea870fb,          ,"Blink Low!"
22997f2f,          ,"Failed to send response packet for channel %u, status %u"
2bc3cb0f,          ,"          The current allocated heap memory is %u bytes."
2e100de9,          ,"■msg♦Received client stream packet for %u:%08x/%08x, but its client stream is closed■module♦PW_RPC■file♦third_party/pigweed/pw_rpc/server.cc"
32bdc9b8,          ,"■msg♦Channel %u failed to send packet with status %u■module♦■file♦third_party/pigweed/pw_rpc/channel.cc"
36c4d845,          ,"■msg♦          The cumulative freed heap memory is %u bytes.■module♦■file♦third_party/pigweed/pw_allocator/freelist_heap.cc"
39b2c339,          ,"Failed to decode packet on interface %s"
3dfbffed,          ,"Got packet with no destination; address: %llu"
3e886e8b,          ,"■msg♦Received packet on channel %u for unknown RPC %08x/%08x■module♦PW_RPC■file♦third_party/pigweed/pw_rpc/server.cc"
3f774ea7,          ,"Unable to handle packet of type %u"
44a10848,          ,"■msg♦RPC client received stream message for an unknown call■module♦PW_RPC■file♦third_party/pigweed/pw_rpc/client.cc"
47c93d0f,          ,"Failed to encode RPC response packet to channel %u buffer"
4c33bbce,          ,"■msg♦pw_rpc server unable to handle packet of type %u■module♦■file♦third_party/pigweed/pw_rpc/server.cc"
4fa792c0,          ,"■msg♦RPC client received a packet for an unregistered channel■module♦PW_RPC■file♦third_party/pigweed/pw_rpc/client.cc"
4fc62508,          ,"■msg♦Nanopb protobuf encode failed: %s■module♦■file♦third_party/pigweed/pw_rpc/nanopb/common.cc"
56a41879,          ,"■msg♦Blink Low!■module♦■file♦applications/rpc/main.cc"
56bffbde,          ,"■msg♦RPC server received packet for unknown channel %u■module♦PW_RPC■file♦third_party/pigweed/pw_rpc/server.cc"
5a592684,          ,"          malloc() is called %u times. (realloc()/calloc() counted as one time)"
5b712e67,          ,"■msg♦pw_rpc server unable to handle packet of type %u■module♦PW_RPC■file♦third_party/pigweed/pw_rpc/server.cc"
5b94e6f3,          ,"■msg♦Received SERVER_STREAM for RPC without a server stream■module♦PW_RPC■file♦third_party/pigweed/pw_rpc/client.cc"
5d1647a3,          ,"■msg♦          The total heap size is %u bytes.■module♦■file♦third_party/pigweed/pw_allocator/freelist_heap.cc"
6271ad9a,          ,"Got complete packet!"
687eb970,          ,"■msg♦Failed to encode RPC packet type %u to channel %u buffer, status %u■module♦■file♦third_party/pigweed/pw_rpc/channel.cc"
6efb923c,          ,"■msg♦Received client stream packet for %u:%08x/%08x, which is not pending■module♦■file♦third_party/pigweed/pw_rpc/server.cc"
74627b3f,          ,"Received CANCEL packet for method that is not pending"
787ce38d,          ,"Nanopb failed to decode request payload from channel %u"
7a5c0c83,          ,"■msg♦Nanopb protobuf decode failed: %s■module♦PW_RPC■file♦third_party/pigweed/pw_rpc/nanopb/common.cc"
7b20ae2f,          ,"■msg♦RPC client received stream message for an unknown call■module♦■file♦third_party/pigweed/pw_rpc/client.cc"
7dca9e87,          ,"■msg♦Got packet with no destination; address: %llu■module♦■file♦applications/rpc/main.cc"
84648644,          ,"■msg♦Frame check sequence verification failed■module♦■file♦third_party/pigweed/pw_hdlc/decoder.cc"
8c88b1a3,          ,"■msg♦Received malformed pw_rpc packet■module♦PW_RPC■file♦third_party/pigweed/pw_rpc/endpoint.cc"
8d82c223,          ,"■msg♦Failed to encode RPC packet type %u to channel %u buffer, status %u■module♦PW_RPC■file♦third_party/pigweed/pw_rpc/channel.cc"
8e1fd36b,          ,"■msg♦Channel %u failed to send packet with status %u■module♦PW_RPC■file♦third_party/pigweed/pw_rpc/channel.cc"
91a1c5d5,          ,"■msg♦Received client stream packet for %u:%08x/%08x, which is not pending■module♦PW_RPC■file♦third_party/pigweed/pw_rpc/server.cc"
92148cda,          ,"■msg♦Received SERVER_STREAM for RPC without a server stream■module♦■file♦third_party/pigweed/pw_rpc/client.cc"
92a63809,          ,"Received %lu-byte frame; frame must be at least 6 bytes"
974389bc,          ,"Got packet with no destination; address: %d"
9dcacd5c,          ,"          The cumulative allocated heap memory is %u bytes."
a2f7c8a2,          ,"Nanopb failed to encode response packet for channel %u, status %u"
a811e114,          ,"■msg♦Failed to decode pw_rpc packet■module♦■file♦third_party/pigweed/pw_rpc/endpoint.cc"
aecb244f,          ,"Frame size [%lu] exceeds the maximum buffer size [%lu]"
af49fb70,          ,"Blink High!"
af9623fa,          ,"■msg♦          malloc() is called %u times. (realloc()/calloc() counted as one time)■module♦■file♦third_party/pigweed/pw_allocator/freelist_heap.cc"
b0ebaaab,          ,"Registering pw_rpc services"
b12fd0ac,          ,"Starting pw_rpc server"
b3e37df6,          ,"Frame check sequence verification failed"
bc3822bb,          ,"■msg♦Nanopb protobuf encode failed: %s■module♦PW_RPC■file♦third_party/pigweed/pw_rpc/nanopb/common.cc"
bd173e2d,          ,"■msg♦Failed to decode pw_rpc packet■module♦PW_RPC■file♦third_party/pigweed/pw_rpc/endpoint.cc"
bdfb3c80,          ,"■msg♦Blink High!■module♦■file♦applications/rpc/main.cc"
be290f47,          ,"          free() is called %u times. (realloc() counted as one time)"
c0c64a7a,          ,"Got complete HDLC packet"
c23385f1,          ,"■msg♦Nanopb failed to decode request payload from channel %u■module♦PW_RPC■file♦third_party/pigweed/pw_rpc/nanopb/method.cc"
c51612b3,          ,"Failed to encode response packet to channel buffer"
c5792a96,          ,"    The current heap information: "
d2d5d9aa,          ,"Failed to encode response packet for channel %u"
d506ae0a,          ,"■msg♦Received malformed pw_rpc packet■module♦■file♦third_party/pigweed/pw_rpc/endpoint.cc"
da03df49,          ,"          The cumulative freed heap memory is %u bytes."
dbb7d7d1,          ,"■msg♦Received %lu-byte frame; frame must be at least 6 bytes■module♦■file♦third_party/pigweed/pw_hdlc/decoder.cc"
e457fb7d,          ,"          The total heap size is %u bytes."
eb4dddde,          ,"■msg♦pw_rpc client unable to handle packet of type %u■module♦■file♦third_party/pigweed/pw_rpc/client.cc"
eb591227,          ,"■msg♦RPC client received a packet for an unregistered channel■module♦■file♦third_party/pigweed/pw_rpc/client.cc"
eeac4446,          ,"■msg♦No ChannelOutput was provided, so a channel cannot be created■module♦PW_RPC■file♦third_party/pigweed/pw_rpc/server.cc"
ef2fe42d,          ,"■msg♦          The current allocated heap memory is %u bytes.■module♦■file♦third_party/pigweed/pw_allocator/freelist_heap.cc"
ef6825c1,          ,"■msg♦ ■module♦■file♦third_party/pigweed/pw_allocator/freelist_heap.cc"
f3804eba,          ,"■msg♦    The current heap information: ■module♦■file♦third_party/pigweed/pw_allocator/freelist_heap.cc"
f716dbeb,          ,"[ ]"
f79e993b,          ,"■msg♦Received client stream packet for %u:%08x/%08x, which doesn't have a client stream■module♦PW_RPC■file♦third_party/pigweed/pw_rpc/server.cc"
fa204477,          ,"■msg♦pw_rpc client unable to handle packet of type %u■module♦PW_RPC■file♦third_party/pigweed/pw_rpc/client.cc"
fc0376f5,          ,"[*]"
