sleq(t, ws.BytesWritten(), wpex)
	rf(t, ws, []byte{})

	// seeks and reads.
	sk(t, ws, 1, io.SeekStart)
	rf(t, ws, []byte{2, 7})
	sk(t, ws, -2, io.SeekCurrent)
	rf(t, ws, []byte{2, 7})
	sk(t, ws, -4, io.SeekEnd)
	rf(t, ws, []byte{2, 7})
	off := sk(t, ws, 0, io.SeekEnd)
	sk(t, ws, off, io.SeekStart)

	// seek back and overwrite
	sk(t, ws, 1, io.SeekStart)
	wf(t, ws, []byte{9, 11})
	wpex = []byte{1, 9, 11, 8, 9}

            PgpSignatory si = null
            PGPPublicKey pk = null
            PGPSecretKey sk = null
            try {
                si = factory.createSignatory(name, keyId, keyRingFile, password)
                sk = factory.readSecretKey(keyId, keyRingFile)
                pk = sk.publicKey
            } catch (Exception ex) {
                // invalid keyring
            } finally {

		if at.IsArray() {
			return makeOf(a, OpArrayMake0, nil)
		}
		if at.IsStruct() {
			return makeOf(a, OpStructMake0, nil)
		}
		return a
	}

	sk := selKey{from: container, size: 0, offsetOrIndex: rc.storeOffset, typ: at}
	dupe := x.commonSelectors[sk]
	if dupe != nil {
		if a == nil {
			return dupe
		}
		a.copyOf(dupe)
		return a
	}

	var argStore [10]*Value
	args := argStore[:0]

				}

				// No pushtype allowed here. Tried and rejected.
				sk.Value = Expr(sk.Value)
				sk.Value = AssignConv(sk.Value, sk.Field.Type, "field value")
				ls[i] = sk
			}
		}

		n.SetOp(ir.OSTRUCTLIT)
	}

	return n
}

// tcStructLitKey typechecks an OKEY node that appeared within a
// struct literal.
func tcStructLitKey(typ *types.Type, kv *ir.KeyExpr) *ir.StructKeyExpr {

  private static final long busyOffset;

  static {
    try {
      UNSAFE = getUnsafe();
      Class<?> sk = Striped64.class;
      baseOffset = UNSAFE.objectFieldOffset(sk.getDeclaredField("base"));
      busyOffset = UNSAFE.objectFieldOffset(sk.getDeclaredField("busy"));
    } catch (Exception e) {
      throw new Error(e);
    }
  }

  /**

type ShardKey struct {
	Cluster  cluster.ID
	Provider provider.ID
}

func (sk ShardKey) String() string {
	return string(sk.Provider) + "/" + string(sk.Cluster) // format: %s/%s
}

// MarshalText implements the TextMarshaler interface (for json key usage)
func (sk ShardKey) MarshalText() (text []byte, err error) {
	return []byte(sk.String()), nil
}

  private static final long busyOffset;

  static {
    try {
      UNSAFE = getUnsafe();
      Class<?> sk = Striped64.class;
      baseOffset = UNSAFE.objectFieldOffset(sk.getDeclaredField("base"));
      busyOffset = UNSAFE.objectFieldOffset(sk.getDeclaredField("busy"));
    } catch (Exception e) {
      throw new Error(e);
    }
  }

  /**

  private static final long busyOffset;

  static {
    try {
      UNSAFE = getUnsafe();
      Class<?> sk = Striped64.class;
      baseOffset = UNSAFE.objectFieldOffset(sk.getDeclaredField("base"));
      busyOffset = UNSAFE.objectFieldOffset(sk.getDeclaredField("busy"));
    } catch (Exception e) {
      throw new Error(e);
    }
  }

  /**

  private static final long busyOffset;

  static {
    try {
      UNSAFE = getUnsafe();
      Class<?> sk = Striped64.class;
      baseOffset = UNSAFE.objectFieldOffset(sk.getDeclaredField("base"));
      busyOffset = UNSAFE.objectFieldOffset(sk.getDeclaredField("busy"));
    } catch (Exception e) {
      throw new Error(e);
    }
  }

  /**

since those use the underlying algorithm. This list is sent to the client if
it supports the server-sig-algs extension. Order is irrelevant.

Valid values
```
ssh-ed25519
sk******@****.***
sk******@****.***
ecdsa-sha2-nistp256
ecdsa-sha2-nistp384
ecdsa-sha2-nistp521
rsa-sha2-256
rsa-sha2-512
ssh-rsa
ssh-dss
```