byte[] resumeKey1 = response.getResumeKey();
        assertNotNull(resumeKey1);
        assertEquals((byte) 0x11, resumeKey1[0]);

        // Second decode - should overwrite
        byte[] buffer2 = new byte[28];
        Arrays.fill(buffer2, 0, 24, (byte) 0x22);

        int bytesConsumed2 = response.decode(buffer2, 0, 28);
        assertEquals(28, bytesConsumed2);

// causes the named policy to be deleted.
func (c *SiteReplicationSys) PeerAddPolicyHandler(ctx context.Context, policyName string, p *policy.Policy, updatedAt time.Time) error {
	var err error
	// skip overwrite of local update if peer sent stale info
	if !updatedAt.IsZero() {
		if p, err := globalIAMSys.store.GetPolicyDoc(policyName); err == nil && p.UpdateDate.After(updatedAt) {
			return nil
		}
	}
	if p == nil {

        assertEquals(0x1111, response.getSecurityMode(), "First decode security mode");
        assertEquals(0x0210, response.getDialect(), "First decode dialect");

        // Second decode - should overwrite values
        byte[] buffer2 = new byte[50];
        SMBUtil.writeInt4(0x22222222, buffer2, 0);
        SMBUtil.writeInt2(0x2222, buffer2, 20);
        SMBUtil.writeInt2(0x0311, buffer2, 22);

    /** Tree copy flag */
    int FLAGS_TREE_COPY = 0x0020;

    // open function
    /** Open function fail if exists */
    int OPEN_FUNCTION_FAIL_IF_EXISTS = 0x0000;
    /** Open function overwrite if exists */
    int OPEN_FUNCTION_OVERWRITE_IF_EXISTS = 0x0020;

    /** Process ID */
    int PID = (int) (Math.random() * 65536d);

    /** Share level security */
    int SECURITY_SHARE = 0x00;

Create new canned policy file `getonly.json`. This policy enables users to download all objects under `my-bucketname`.

```json
cat > getonly.json << EOF
{

If you check the previous app, in the UI you can see that, up to now, it lets the client decide the `id` of the `Hero` to create. 😱

We shouldn't let that happen, they could overwrite an `id` we already have assigned in the DB. Deciding the `id` should be done by the **backend** or the **database**, **not by the client**.

type healSource struct {
	bucket    string
	object    string
	versionID string
	noWait    bool             // a non blocking call, if task queue is full return right away.
	opts      *madmin.HealOpts // optional heal option overrides default setting
}

// healSequence - state for each heal sequence initiated on the
// server.
type healSequence struct {
	// bucket, and object on which heal seq. was initiated
	bucket, object string

n := map[int]int{a: f()}      // n may be {2: 3} or {3: 3}: evaluation order between the key and the value is not specified
</pre>

<p>
At package level, initialization dependencies override the left-to-right rule
for individual initialization expressions, but not for operands within each
expression:
</p>

<pre>
var a, b, c = f() + v(), g(), sqr(u()) + v()

        SmbFile file = new SmbFile(baseUrl + "shared/overwrite.txt", context);
        String initialContent = "Initial content\n";
        String newContent = "New content\n";

        // Write initial content
        try (OutputStream out = file.openOutputStream(false)) {
            out.write(initialContent.getBytes("UTF-8"));
        }

        // Overwrite with new content

	_, ok := err.(ReplicationPermissionCheck)
	return ok
}

// DataMovementOverwriteErr - captures the error when a data movement activity
// like rebalance incorrectly tries to overwrite an object.
type DataMovementOverwriteErr GenericError

func (de DataMovementOverwriteErr) Error() string {
	objInfoStr := fmt.Sprintf("bucket=%s object=%s", de.Bucket, de.Object)
	if de.VersionID != "" {