// WaterMark is operation of watermark text content.
969206
func (image *Image) WaterMark(param *WaterMarkParam) *Image {
	return image.setActionParam(WaterMarkOperation, param)
}
185260
func (in *ImageLabel) DeepCopy() *ImageLabel {
	if in == nil {
		return nil
	}
	out := new(ImageLabel)
	in.DeepCopyInto(out)
	return out
}
800187
func (p *Producer) QueryWatermarkOffsets(topic string, partition int32, timeoutMs int) (low, high int64, err error) {
	return queryWatermarkOffsets(p, topic, partition, timeoutMs)
}
880131
func (g *gcmAsm) Seal(dst, nonce, plaintext, data []byte) []byte {
	if len(nonce) != g.nonceSize {
		panic("cipher: incorrect nonce length given to GCM")
	}

	var counter, tagMask [gcmBlockSize]byte

	if len(nonce) == gcmStandardNonceSize {
		// Init counter to nonce||1
		copy(counter[:], nonce)
		counter[gcmBlockSize-1] = 1
	} else {
		// Otherwise counter = GHASH(nonce)
		gcmAesData(&g.productTable, nonce, &counter)
		gcmAesFinish(&g.productTable, &tagMask, &counter, uint64(len(nonce)), uint64(0))
	}

	aesEncBlock(&tagMask, &counter, g.ks)

	var tagOut [16]byte
	gcmAesData(&g.productTable, data, &tagOut)

	ret, out := sliceForAppend(dst, len(plaintext)+gcmTagSize)
	if len(plaintext) > 0 {
		gcmAesEnc(&g.productTable, out, plaintext, &counter, &tagOut, g.ks)
	}
	gcmAesFinish(&g.productTable, &tagMask, &tagOut, uint64(len(plaintext)), uint64(len(data)))
	copy(out[len(plaintext):], tagOut[:gcmTagSize])

	return ret
}
325439
func (in *CertificateSigningRequestStatus) DeepCopy() *CertificateSigningRequestStatus {
	if in == nil {
		return nil
	}
	out := new(CertificateSigningRequestStatus)
	in.DeepCopyInto(out)
	return out
}
506120
func (in *CertInfo) DeepCopy() *CertInfo {
	if in == nil {
		return nil
	}
	out := new(CertInfo)
	in.DeepCopyInto(out)
	return out
}
638075
func (cache *DiskBlockCacheLocal) Mark(
	ctx context.Context, blockID kbfsblock.ID, tag string) error {
	cache.lock.Lock()
	defer cache.lock.Unlock()
	err := cache.checkCacheLocked("Block(UpdateMetadata)")
	if err != nil {
		return err
	}

	md, err := cache.getMetadataLocked(blockID, false)
	if err != nil {
		return data.NoSuchBlockError{ID: blockID}
	}
	md.Tag = tag
	return cache.updateMetadataLocked(ctx, blockID.Bytes(), md, false)
}
1279030
func (m *LevelMetadata) Text(enableColor bool) string {
	if enableColor {
		return m.ColorfulText
	}
	return m.RawText
}
1373525
func (peer *Peer) mark(envelope *Envelope) {
	peer.known.Add(envelope.Hash())
}
1281717
func (in *StripPrefix) DeepCopy() *StripPrefix {
	if in == nil {
		return nil
	}
	out := new(StripPrefix)
	in.DeepCopyInto(out)
	return out
}
20600
func (resp *Response) Text() (string, error) {
	b, err := resp.Content()
	s := string(b)
	return s, err
}
1309813
func (u UUID) MarshalText() ([]byte, error) {
	text := make([]byte, 24)
	base64.StdEncoding.Encode(text, u[:])
	return text, nil
}
951445
func (v *TextBuffer) CreateMark(mark_name string, where *TextIter, left_gravity bool) *TextMark {
	ptr := C.CString(mark_name)
	defer cfree(ptr)
	return &TextMark{C.gtk_text_buffer_create_mark(v.GTextBuffer, gstring(ptr), &where.GTextIter, gbool(left_gravity))}
}
679474
func (l *Slog) Tag(tags ...string) *Slog {
	l = l.copy()
	l.Log.Tags.Clean()
	l.Log.Tags.Add(tags...)
	return l
}
1157836
func QRCode(content string) (string, error) {
	q, err := qrcode.New(content, qrcode.Medium)
	if err != nil {
		return "", err
	}
	buf := bytes.Buffer{}
	i := q.Image(0)
	b := i.Bounds()
	for x := b.Min.X; x < b.Max.X; x++ {
		for y := b.Min.Y; y < b.Max.Y; y++ {
			col := i.At(x, y)
			if sameColor(col, q.ForegroundColor) {
				_, _ = buf.WriteString(black)
			} else if sameColor(col, q.BackgroundColor) {
				_, _ = buf.WriteString(white)
			} else {
				return "", errors.Errorf("Unexpected color at (%d,%d): %+v", x, y, col)
			}
		}
		_, _ = buf.WriteString("\n")
	}
	return buf.String(), nil
}
1343113
func (in *NamespaceStatus) DeepCopy() *NamespaceStatus {
	if in == nil {
		return nil
	}
	out := new(NamespaceStatus)
	in.DeepCopyInto(out)
	return out
}
252537
func (in *ImageSignature) DeepCopy() *ImageSignature {
	if in == nil {
		return nil
	}
	out := new(ImageSignature)
	in.DeepCopyInto(out)
	return out
}