internal const val OPCODE_FLAG_CONTROL = 8

  /**
   * Byte 1 flag for whether the payload data is masked.
   *
   * If this flag is set, the next four
   * bytes represent the mask key. These bytes appear after any additional bytes specified by [B1_MASK_LENGTH].
   */
  internal const val B1_FLAG_MASK = 128

  /**
   * Byte 1 mask for the payload length.
   *
   * If this value is [PAYLOAD_SHORT], the next two

            response.setDigest(null);

            response.haveResponse(buffer, 1, 3);

            byte[] payload = response.getRawPayload();
            assertNotNull(payload);
            assertEquals(3, payload.length);
            assertArrayEquals(new byte[] { 2, 3, 4 }, payload);
            assertTrue(response.isReceived());
            assertFalse(response.isAsyncHandled());
        }

        @Test

)

// http Header "x-amz-content-sha256" == "UNSIGNED-PAYLOAD" indicates that the
// client did not calculate sha256 of the payload.
const unsignedPayload = "UNSIGNED-PAYLOAD"

// http Header "x-amz-content-sha256" == "STREAMING-UNSIGNED-PAYLOAD-TRAILER" indicates that the
// client did not calculate sha256 of the payload and there is a trailer.
const unsignedPayloadTrailer = "STREAMING-UNSIGNED-PAYLOAD-TRAILER"

				fmt.Println("muxServer: Mux", m.ID, "send EOF", hErr)
			}
			msg.Flags |= FlagEOF
			if hErr != nil {
				msg.Flags |= FlagPayloadIsErr
				msg.Payload = []byte(*hErr)
			}
			msg.setZeroPayloadFlag()
			m.send(msg)
			return
		}
		msg.Payload = payload
		msg.setZeroPayloadFlag()
		m.send(msg)
	}
}

// handleRequests will handle the requests from the client and call the handler function.

}

// Post submit 'payload' to specified URL
func (c Config) Post(reqURL string, payload any) (string, error) {
	if !c.Registered() {
		return "", errors.New("Deployment is not registered with SUBNET. Please register the deployment via 'mc license register ALIAS'")
	}
	body, err := json.Marshal(payload)
	if err != nil {
		return "", err
	}

		return
	}

	// Route directly to output.
	m.respWait = out
}

// RequestStream will send a single payload request and stream back results.
// 'requests' can be nil, in which case only req is sent as input.
// It will however take less resources.
func (m *muxClient) RequestStream(h HandlerID, payload []byte, requests chan []byte, responses chan Response) (*Stream, error) {
	if m.init {

		}
	}
	payload := make([]byte, 1, plSize)
	payload[0] = xlMetaInlineDataVer
	payload = msgp.AppendMapHeader(payload, uint32(len(keys)))
	for i := range keys {
		payload = msgp.AppendStringFromBytes(payload, keys[i])
		payload = msgp.AppendBytes(payload, vals[i])
	}
	*x = payload
}

// entries returns the number of entries in the data.

        'CSV': {
            "FileHeaderInfo": "USE",
        },
        'CompressionType': 'GZIP',
    },
    OutputSerialization={'CSV': {}},
)

for event in r['Payload']:
    if 'Records' in event:
        records = event['Records']['Payload'].decode('utf-8')
        print(records)
    elif 'Stats' in event:
        statsDetails = event['Stats']['Details']
        print("Stats details bytesScanned: ")

            assertTrue(w.isReady(), "WriterThread should be ready to accept work");

            // Act: submit a write
            w.write(payload, 3, out);
        }

        // Assert: verify the underlying stream was called
        verify(out, timeout(1000)).write(payload, 0, 3);

        // Stop the thread by sending n = -1
        synchronized (w) {
            w.write(new byte[0], -1, out);
        }

  interface FrameCallback {
    @Throws(IOException::class)
    fun onReadMessage(text: String)

    @Throws(IOException::class)
    fun onReadMessage(bytes: ByteString)

    fun onReadPing(payload: ByteString)

    fun onReadPong(payload: ByteString)

    fun onReadClose(
      code: Int,
      reason: String,
    )
  }

  /**
   * Process the next protocol frame.
   *