How to use max method of internal Package

...30	// InternalKeyKindColumnFamilyRangeDelete                  = 1431	InternalKeyKindRangeDelete = 1532	// InternalKeyKindColumnFamilyBlobIndex                    = 1633	// InternalKeyKindBlobIndex                                = 1734	// This maximum value isn't part of the file format. It's unlikely,35	// but future extensions may increase this value.36	//37	// When constructing an internal key to pass to DB.Seek{GE,LE},38	// internalKeyComparer sorts decreasing by kind (after sorting increasing by39	// user key and decreasing by sequence number). Thus, use InternalKeyKindMax,40	// which sorts 'less than or equal to' any other valid internalKeyKind, when41	// searching for any kind of internal key formed by a certain user key and42	// seqNum.43	InternalKeyKindMax InternalKeyKind = 1744	// A marker for an invalid key.45	InternalKeyKindInvalid InternalKeyKind = 25546	// InternalKeySeqNumBatch is a bit that is set on batch sequence numbers47	// which prevents those entries from being excluded from iteration.48	InternalKeySeqNumBatch = uint64(1 << 55)49	// InternalKeySeqNumMax is the largest valid sequence number.50	InternalKeySeqNumMax = uint64(1<<56 - 1)51	// InternalKeyRangeDeleteSentinel is the marker for a range delete sentinel52	// key. This sequence number and kind are used for the upper stable boundary53	// when a range deletion tombstone is the largest key in an sstable. This is54	// necessary because sstable boundaries are inclusive, while the end key of a55	// range deletion tombstone is exclusive.56	InternalKeyRangeDeleteSentinel = (InternalKeySeqNumMax << 8) | InternalKeyKindRangeDelete57)58var internalKeyKindNames = []string{59	InternalKeyKindDelete:       "DEL",60	InternalKeyKindSet:          "SET",61	InternalKeyKindMerge:        "MERGE",62	InternalKeyKindLogData:      "LOGDATA",63	InternalKeyKindSingleDelete: "SINGLEDEL",64	InternalKeyKindRangeDelete:  "RANGEDEL",65	InternalKeyKindMax:          "MAX",66	InternalKeyKindInvalid:      "INVALID",67}68func (k InternalKeyKind) String() string {69	if int(k) < len(internalKeyKindNames) {70		return internalKeyKindNames[k]71	}72	return fmt.Sprintf("UNKNOWN:%d", k)73}74// InternalKey is a key used for the in-memory and on-disk partial DBs that75// make up a pebble DB.76//77// It consists of the user key (as given by the code that uses package pebble)78// followed by 8-bytes of metadata:79//   - 1 byte for the type of internal key: delete or set,80//   - 7 bytes for a uint56 sequence number, in little-endian format.81type InternalKey struct {82	UserKey []byte83	Trailer uint6484}85// InvalidInternalKey is an invalid internal key for which Valid() will return86// false.87var InvalidInternalKey = MakeInternalKey(nil, 0, InternalKeyKindInvalid)88// MakeInternalKey constructs an internal key from a specified user key,89// sequence number and kind.90func MakeInternalKey(userKey []byte, seqNum uint64, kind InternalKeyKind) InternalKey {91	return InternalKey{92		UserKey: userKey,93		Trailer: (seqNum << 8) | uint64(kind),94	}95}96// MakeSearchKey constructs an internal key that is appropriate for searching97// for a the specified user key. The search key contain the maximual sequence98// number and kind ensuring that it sorts before any other internal keys for99// the same user key.100func MakeSearchKey(userKey []byte) InternalKey {101	return InternalKey{102		UserKey: userKey,103		Trailer: (InternalKeySeqNumMax << 8) | uint64(InternalKeyKindMax),104	}105}106// MakeRangeDeleteSentinelKey constructs an internal key that is a range107// deletion sentinel key, used as the upper boundary for an sstable when a108// range deletion is the largest key in an sstable.109func MakeRangeDeleteSentinelKey(userKey []byte) InternalKey {110	return InternalKey{111		UserKey: userKey,112		Trailer: InternalKeyRangeDeleteSentinel,113	}114}115var kindsMap = map[string]InternalKeyKind{116	"DEL":       InternalKeyKindDelete,117	"SINGLEDEL": InternalKeyKindSingleDelete,118	"RANGEDEL":  InternalKeyKindRangeDelete,119	"SET":       InternalKeyKindSet,120	"MERGE":     InternalKeyKindMerge,121	"INVALID":   InternalKeyKindInvalid,122	"MAX":       InternalKeyKindMax,123}124// ParseInternalKey parses the string representation of an internal key. The125// format is <user-key>.<kind>.<seq-num>. If the seq-num starts with a "b" it126// is marked as a batch-seq-num (i.e. the InternalKeySeqNumBatch bit is set).127func ParseInternalKey(s string) InternalKey {128	x := strings.Split(s, ".")129	ukey := x[0]130	kind, ok := kindsMap[x[1]]131	if !ok {132		panic(fmt.Sprintf("unknown kind: %q", x[1]))133	}134	j := 0135	if x[2][0] == 'b' {136		j = 1137	}138	seqNum, _ := strconv.ParseUint(x[2][j:], 10, 64)139	if x[2][0] == 'b' {140		seqNum |= InternalKeySeqNumBatch141	}142	return MakeInternalKey([]byte(ukey), seqNum, kind)143}144// DecodeInternalKey decodes an encoded internal key. See InternalKey.Encode().145func DecodeInternalKey(encodedKey []byte) InternalKey {146	n := len(encodedKey) - 8147	var trailer uint64148	if n >= 0 {149		trailer = binary.LittleEndian.Uint64(encodedKey[n:])150		encodedKey = encodedKey[:n:n]151	} else {152		trailer = uint64(InternalKeyKindInvalid)153		encodedKey = nil154	}155	return InternalKey{156		UserKey: encodedKey,157		Trailer: trailer,158	}159}160// InternalCompare compares two internal keys using the specified comparison161// function. For equal user keys, internal keys compare in descending sequence162// number order. For equal user keys and sequence numbers, internal keys163// compare in descending kind order (though this should never happen in164// practice).165func InternalCompare(userCmp Compare, a, b InternalKey) int {166	if x := userCmp(a.UserKey, b.UserKey); x != 0 {167		return x168	}169	if a.Trailer > b.Trailer {170		return -1171	}172	if a.Trailer < b.Trailer {173		return 1174	}175	return 0176}177// Encode encodes the receiver into the buffer. The buffer must be large enough178// to hold the encoded data. See InternalKey.Size().179func (k InternalKey) Encode(buf []byte) {180	i := copy(buf, k.UserKey)181	binary.LittleEndian.PutUint64(buf[i:], k.Trailer)182}183// EncodeTrailer returns the trailer encoded to an 8-byte array.184func (k InternalKey) EncodeTrailer() [8]byte {185	var buf [8]byte186	binary.LittleEndian.PutUint64(buf[:], k.Trailer)187	return buf188}189// Separator returns a separator key such that k <= x && x < other, where less190// than is consistent with the Compare function. The buf parameter may be used191// to store the returned InternalKey.UserKey, though it is valid to pass a192// nil. See the Separator type for details on separator keys.193func (k InternalKey) Separator(194	cmp Compare, sep Separator, buf []byte, other InternalKey,195) InternalKey {196	buf = sep(buf, k.UserKey, other.UserKey)197	if len(buf) <= len(k.UserKey) && cmp(k.UserKey, buf) < 0 {198		// The separator user key is physically shorter than k.UserKey (if it is199		// longer, we'll continue to use "k"), but logically after. Tack on the max200		// sequence number to the shortened user key. Note that we could tack on201		// any sequence number and kind here to create a valid separator key. We202		// use the max sequence number to match the behavior of LevelDB and203		// RocksDB.204		return MakeInternalKey(buf, InternalKeySeqNumMax, InternalKeyKindMax)205	}206	return k207}208// Successor returns a successor key such that k <= x. A simple implementation209// may return k unchanged. The buf parameter may be used to store the returned210// InternalKey.UserKey, though it is valid to pass a nil.211func (k InternalKey) Successor(cmp Compare, succ Successor, buf []byte) InternalKey {212	buf = succ(buf, k.UserKey)213	if len(buf) <= len(k.UserKey) && cmp(k.UserKey, buf) < 0 {214		// The successor user key is physically shorter that k.UserKey (if it is215		// longer, we'll continue to use "k"), but logically after. Tack on the max216		// sequence number to the shortened user key. Note that we could tack on217		// any sequence number and kind here to create a valid separator key. We218		// use the max sequence number to match the behavior of LevelDB and219		// RocksDB.220		return MakeInternalKey(buf, InternalKeySeqNumMax, InternalKeyKindMax)221	}222	return k223}224// Size returns the encoded size of the key.225func (k InternalKey) Size() int {226	return len(k.UserKey) + 8227}228// SetSeqNum sets the sequence number component of the key.229func (k *InternalKey) SetSeqNum(seqNum uint64) {230	k.Trailer = (seqNum << 8) | (k.Trailer & 0xff)231}232// SeqNum returns the sequence number component of the key....

1package models2import (3	"fmt"4	"google.golang.org/protobuf/proto" //nolint:gci5	"github.com/SKF/go-pas-client/internal/events"6	models "github.com/SKF/go-pas-client/internal/models"7	"github.com/SKF/go-utility/v2/uuid"8	pas "github.com/SKF/proto/v2/pas"9)10type (11	BandAlarm struct {12		Label            string13		MinFrequency     BandAlarmFrequency14		MaxFrequency     BandAlarmFrequency15		OverallThreshold *BandAlarmOverallThreshold16	}17	BandAlarmFrequency struct {18		ValueType BandAlarmFrequencyValueType19		Value     float6420	}21	BandAlarmThreshold struct {22		ValueType BandAlarmThresholdType23		Value     float6424	}25	BandAlarmOverallThreshold struct {26		Unit        string27		UpperAlert  *BandAlarmThreshold28		UpperDanger *BandAlarmThreshold29	}30)31func (b *BandAlarm) FromInternal(internal *models.ModelsBandAlarm) {32	if b == nil || internal == nil {33		return34	}35	b.Label = internal.Label36	b.MinFrequency.FromInternalThreshold(internal.MinFrequency)37	b.MaxFrequency.FromInternalThreshold(internal.MaxFrequency)38	if internal.OverallThreshold != nil {39		b.OverallThreshold = new(BandAlarmOverallThreshold)40		b.OverallThreshold.FromInternal(internal.OverallThreshold)41	}42}43func (b BandAlarm) ToInternal() *models.ModelsBandAlarm {44	bandAlarm := &models.ModelsBandAlarm{45		Label:            b.Label,46		OverallThreshold: nil,47		MinFrequency:     b.MinFrequency.ToInternal(),48		MaxFrequency:     b.MaxFrequency.ToInternal(),49	}50	if b.OverallThreshold != nil {51		bandAlarm.OverallThreshold = b.OverallThreshold.ToInternal()52	}53	return bandAlarm54}55func (b *BandAlarm) FromProto(buf []byte) error {56	if b == nil {57		return nil58	}59	var internal pas.BandAlarm60	if err := proto.Unmarshal(buf, &internal); err != nil {61		return fmt.Errorf("decoding band alarm failed: %w", err)62	}63	b.Label = internal.Label64	b.MinFrequency.FromProto(internal.MinFrequency)65	b.MaxFrequency.FromProto(internal.MaxFrequency)66	if internal.OverallThreshold != nil {67		b.OverallThreshold = new(BandAlarmOverallThreshold)68		b.OverallThreshold.FromProto(internal.OverallThreshold)69	}70	return nil71}72func (f *BandAlarmFrequency) FromInternalThreshold(internal *models.ModelsBandAlarmFrequency) {73	if f == nil || internal == nil {74		return75	}76	if internal.ValueType != nil {77		f.ValueType = BandAlarmFrequencyValueType(*internal.ValueType)78	}79	if internal.Value != nil {80		f.Value = *internal.Value81	}82}83func (f *BandAlarmFrequency) FromInternalAlarmStatus(internal *models.ModelsGetAlarmStatusResponseFrequency) {84	if f == nil || internal == nil {85		return86	}87	if internal.ValueType != nil {88		f.ValueType = BandAlarmFrequencyValueType(*internal.ValueType)89	}90	if internal.Value != nil {91		f.Value = *internal.Value92	}93}94func (f BandAlarmFrequency) ToInternal() *models.ModelsBandAlarmFrequency {95	valueType := int32(f.ValueType)96	return &models.ModelsBandAlarmFrequency{97		ValueType: &valueType,98		Value:     &f.Value,99	}100}101func (f *BandAlarmFrequency) FromProto(internal *pas.Frequency) {102	if f == nil || internal == nil {103		return104	}105	f.ValueType = BandAlarmFrequencyValueType(internal.ValueType)106	if internal.Value != nil {107		f.Value = internal.Value.Value108	}109}110func (b *BandAlarmOverallThreshold) FromInternal(internal *models.ModelsBandAlarmOverallThreshold) {111	if b == nil || internal == nil {112		return113	}114	b.Unit = internal.Unit115	if internal.UpperAlert != nil {116		b.UpperAlert = new(BandAlarmThreshold)117		b.UpperAlert.FromInternal(internal.UpperAlert)118	}119	if internal.UpperDanger != nil {120		b.UpperDanger = new(BandAlarmThreshold)121		b.UpperDanger.FromInternal(internal.UpperDanger)122	}123}124func (b BandAlarmOverallThreshold) ToInternal() *models.ModelsBandAlarmOverallThreshold {125	threshold := &models.ModelsBandAlarmOverallThreshold{126		Unit:        b.Unit,127		UpperAlert:  nil,128		UpperDanger: nil,129	}130	if b.UpperAlert != nil {131		threshold.UpperAlert = b.UpperAlert.ToInternal()132	}133	if b.UpperDanger != nil {134		threshold.UpperDanger = b.UpperDanger.ToInternal()135	}136	return threshold137}138func (b *BandAlarmOverallThreshold) FromProto(internal *pas.BandAlarmOverallThreshold) {139	if b == nil || internal == nil {140		return141	}142	b.Unit = internal.Unit143	if internal.UpperAlert != nil {144		b.UpperAlert = new(BandAlarmThreshold)145		b.UpperAlert.FromProto(internal.UpperAlert)146	}147	if internal.UpperDanger != nil {148		b.UpperDanger = new(BandAlarmThreshold)149		b.UpperDanger.FromProto(internal.UpperDanger)150	}151}152func (t *BandAlarmThreshold) FromInternal(internal *models.ModelsBandAlarmThreshold) {153	if t == nil || internal == nil {154		return155	}156	if internal.ValueType != nil {157		t.ValueType = BandAlarmThresholdType(*internal.ValueType)158	}159	if internal.Value != nil {160		t.Value = *internal.Value161	}162}163func (t BandAlarmThreshold) ToInternal() *models.ModelsBandAlarmThreshold {164	valueType := int32(t.ValueType)165	return &models.ModelsBandAlarmThreshold{166		ValueType: &valueType,167		Value:     &t.Value,168	}169}170func (t *BandAlarmThreshold) FromProto(internal *pas.ThresholdValue) {171	if t == nil || internal == nil {172		return173	}174	t.ValueType = BandAlarmThresholdType(internal.ValueType)175	if internal.Value != nil {176		t.Value = internal.Value.Value177	}178}179type (180	BandAlarmStatus struct {181		GenericAlarmStatus182		Label             string183		MinFrequency      BandAlarmFrequency184		MaxFrequency      BandAlarmFrequency185		CalculatedOverall *BandAlarmStatusCalculatedOverall186	}187	BandAlarmStatusCalculatedOverall struct {188		Unit  string189		Value float64190	}191)192func (b *BandAlarmStatus) FromInternal(internal *models.ModelsGetAlarmStatusResponseBandAlarm) {193	if b == nil || internal == nil {194		return195	}196	b.Label = internal.Label197	if internal.Status != nil {198		b.Status = AlarmStatusType(*internal.Status)199	}200	b.TriggeringMeasurement = uuid.UUID(internal.TriggeringMeasurement.String())201	if internal.MinFrequency != nil {202		b.MinFrequency.FromInternalAlarmStatus(internal.MinFrequency)203	}204	if internal.MaxFrequency != nil {205		b.MaxFrequency.FromInternalAlarmStatus(internal.MaxFrequency)206	}207	if internal.CalculatedOverall != nil {208		b.CalculatedOverall = &BandAlarmStatusCalculatedOverall{209			Unit:  internal.CalculatedOverall.Unit,210			Value: 0,211		}212		if internal.CalculatedOverall.Value != nil {213			b.CalculatedOverall.Value = *internal.CalculatedOverall.Value214		}215	}216}217func (b *BandAlarmStatus) FromEvent(internal events.BandAlarmStatus) {218	if b == nil {219		return220	}221	b.Label = internal.Label222	b.Status = AlarmStatusType(internal.Status)223	b.TriggeringMeasurement = internal.TriggeringMeasurement224	b.MinFrequency = BandAlarmFrequency{225		ValueType: BandAlarmFrequencyValueType(internal.MinFrequency.ValueType),226		Value:     internal.MinFrequency.Value,227	}228	b.MaxFrequency = BandAlarmFrequency{229		ValueType: BandAlarmFrequencyValueType(internal.MaxFrequency.ValueType),230		Value:     internal.MaxFrequency.Value,231	}232	if internal.CalculatedOverall != nil {233		b.CalculatedOverall = &BandAlarmStatusCalculatedOverall{234			Unit:  internal.CalculatedOverall.Unit,235			Value: internal.CalculatedOverall.Value,236		}237	}238}...

1// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>2// All rights reserved.3//4// Use of this source code is governed by a BSD-style license that can be5// found in the LICENSE file.6package leveldb7import (8	"encoding/binary"9	"fmt"10	"github.com/syndtr/goleveldb/leveldb/errors"11	"github.com/syndtr/goleveldb/leveldb/storage"12)13// ErrInternalKeyCorrupted records internal key corruption.14type ErrInternalKeyCorrupted struct {15	Ikey   []byte16	Reason string17}18func (e *ErrInternalKeyCorrupted) Error() string {19	return fmt.Sprintf("leveldb: internal key %q corrupted: %s", e.Ikey, e.Reason)20}21func newErrInternalKeyCorrupted(ikey []byte, reason string) error {22	return errors.NewErrCorrupted(storage.FileDesc{}, &ErrInternalKeyCorrupted{append([]byte{}, ikey...), reason})23}24type keyType uint25func (kt keyType) String() string {26	switch kt {27	case keyTypeDel:28		return "d"29	case keyTypeVal:30		return "v"31	}32	return fmt.Sprintf("<invalid:%#x>", uint(kt))33}34// Value types encoded as the last component of internal keys.35// Don't modify; this value are saved to disk.36const (37	keyTypeDel = keyType(0)38	keyTypeVal = keyType(1)39)40// keyTypeSeek defines the keyType that should be passed when constructing an41// internal key for seeking to a particular sequence number (since we42// sort sequence numbers in decreasing order and the value type is43// embedded as the low 8 bits in the sequence number in internal keys,44// we need to use the highest-numbered ValueType, not the lowest).45const keyTypeSeek = keyTypeVal46const (47	// Maximum value possible for sequence number; the 8-bits are48	// used by value type, so its can packed together in single49	// 64-bit integer.50	keyMaxSeq = (uint64(1) << 56) - 151	// Maximum value possible for packed sequence number and type.52	keyMaxNum = (keyMaxSeq << 8) | uint64(keyTypeSeek)53)54// Maximum number encoded in bytes.55var keyMaxNumBytes = make([]byte, 8)56func init() {57	binary.LittleEndian.PutUint64(keyMaxNumBytes, keyMaxNum)58}59type internalKey []byte60func makeInternalKey(dst, ukey []byte, seq uint64, kt keyType) internalKey {61	if seq > keyMaxSeq {62		panic("leveldb: invalid sequence number")63	} else if kt > keyTypeVal {64		panic("leveldb: invalid type")65	}66	dst = ensureBuffer(dst, len(ukey)+8)67	copy(dst, ukey)68	binary.LittleEndian.PutUint64(dst[len(ukey):], (seq<<8)|uint64(kt))69	return internalKey(dst)70}71func parseInternalKey(ik []byte) (ukey []byte, seq uint64, kt keyType, err error) {72	if len(ik) < 8 {73		return nil, 0, 0, newErrInternalKeyCorrupted(ik, "invalid length")74	}75	num := binary.LittleEndian.Uint64(ik[len(ik)-8:])76	seq, kt = uint64(num>>8), keyType(num&0xff)77	if kt > keyTypeVal {78		return nil, 0, 0, newErrInternalKeyCorrupted(ik, "invalid type")79	}80	ukey = ik[:len(ik)-8]81	return82}83func validInternalKey(ik []byte) bool {84	_, _, _, err := parseInternalKey(ik)85	return err == nil86}87func (ik internalKey) assert() {88	if ik == nil {89		panic("leveldb: nil internalKey")90	}91	if len(ik) < 8 {92		panic(fmt.Sprintf("leveldb: internal key %q, len=%d: invalid length", []byte(ik), len(ik)))93	}94}95func (ik internalKey) ukey() []byte {96	ik.assert()97	return ik[:len(ik)-8]98}99func (ik internalKey) num() uint64 {100	ik.assert()101	return binary.LittleEndian.Uint64(ik[len(ik)-8:])102}103func (ik internalKey) parseNum() (seq uint64, kt keyType) {104	num := ik.num()105	seq, kt = uint64(num>>8), keyType(num&0xff)106	if kt > keyTypeVal {107		panic(fmt.Sprintf("leveldb: internal key %q, len=%d: invalid type %#x", []byte(ik), len(ik), kt))108	}109	return110}111func (ik internalKey) String() string {112	if ik == nil {113		return "<nil>"114	}115	if ukey, seq, kt, err := parseInternalKey(ik); err == nil {116		return fmt.Sprintf("%s,%s%d", shorten(string(ukey)), kt, seq)117	}118	return fmt.Sprintf("<invalid:%#x>", []byte(ik))119}...

1import "internal/math"2func main() {3    fmt.Println(math.Max(2,3))4}5import "internal/math"6func main() {7    fmt.Println(math.Max(2,3))8}9	/usr/local/go/src/internal/math (from $GOROOT)10	/home/sayantan/go/src/internal/math (from $GOPATH)

1import (2func main() {3    fmt.Println(math.Max(1, 2))4}5import (6func main() {7    fmt.Println(math.Max(1, 2))8}9import (10func main() {11    fmt.Println(math.Max(1, 2))12}13import (14func main() {15    fmt.Println(math.Max(1, 2))16}17import (18func main() {19    fmt.Println(math.Max(1, 2))20}21import (22func main() {23    fmt.Println(math.Max(1, 2))24}25import (26func main() {27    fmt.Println(math.Max(1, 2))28}29import (30func main() {31    fmt.Println(math.Max(1, 2))32}33import (34func main() {35    fmt.Println(math.Max(1, 2))36}

1import (2func main() {3    fmt.Println("The max number is:", math.Max(12.3, 45.6))4}5func Max(a, b float64) float64 {6    if a > b {7    }8}9import (10func main() {11    fmt.Println("The max number is:", mymath.Max(12.3, 45.6))12}13import (14func main() {15    fmt.Println("The max number is:", mymath.Max(12.3, 45.6))16}17import (18func main() {19    fmt.Println("The max number is:",

1import (2func main() {3	fmt.Println("Hello, playground")4	fmt.Println(x.Max(y))5}6import (7func main() {8	fmt.Println("Hello, playground")9	fmt.Println(x.Max(y))10}11import (12func main() {13	fmt.Println("Hello, playground")14	fmt.Println(x.Max(y))15}16import (17func main() {18	fmt.Println("Hello, playground")19	fmt.Println(x.Max(y))20}21func (x Int) Max(y Int) Int {22	if x > y {23	}24}25func (x

1import (2func main() {3	fmt.Println(math.Max(2, 3))4}5We can also import the entire package using the following syntax:6import "math"7import (8func main() {9	fmt.Println(math.Max(2, 3))10}11Package Description archive/zip Provides support for reading and writing ZIP archives. bufio Provides buffered I/O. bytes Provides functions for the manipulation of byte slices. compress/bzip2 Provides support for the bzip2 algorithm, as specified in RFC 1950. compress/flate Provides support for the DEFLATE algorithm, as specified in RFC 1951. compress/gzip Provides support for the gzip file format, as specified in RFC 1952. compress/lzw Provides support for the Lempel-Ziv-Welch compressed data format, as specified in ANSI X3.159-1989. compress/zlib Provides support for the zlib file format, as specified in RFC 1950. container/heap Provides heap operations. container/list Provides a doubly linked list. container/ring Provides ring buffer operations. context Provides a type for propagating cancellation signals. crypto/aes Provides an implementation of AES encryption as specified in U.S. Federal Information Processing Standards Publication 197. crypto/cipher Provides common block cipher modes that can be wrapped around low-level block cipher implementations. crypto/des Provides an implementation of DES encryption as specified in U.S. Federal Information Processing Standards Publication 46. crypto/dsa Provides an implementation of the Digital Signature Algorithm as defined in FIPS PUB 186-2. crypto/ecdsa Provides an implementation of the Elliptic Curve Digital Signature Algorithm as defined in ANSI X9.62. crypto/elliptic Provides implementations of elliptic curves. crypto/hmac Provides an implementation of the keyed-Hash Message Authentication Code (HMAC) as defined in U.S. Federal Information Processing Standards Publication 198. crypto/md5 Provides an implementation of the MD5 hash algorithm as defined in RFC 1321. crypto/rand Provides a cryptographically secure random number generator. crypto/rc4 Provides an implementation of the RC4

1import (2func main() {3	fmt.Println(math.Max(10, 20))4}5func Max(a, b int) int {6	if a > b {7	}8}9func Min(a, b int) int {10	if a < b {11	}12}13import (14func main() {15	fmt.Println(math.Max(10, 20))16}17func Max(a, b int) int {18	if a > b {19	}20}21func Min(a, b int) int {22	if a < b {23	}24}