diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml
index e2201d1..d8162e2 100644
--- a/.github/workflows/test.yaml
+++ b/.github/workflows/test.yaml
@@ -12,13 +12,13 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Install Go
-      uses: actions/setup-go@v2
+      uses: actions/setup-go@v3
       with:
-        go-version: 1.15.x
+        go-version: 1.17
     - name: Checkout code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
     - name: Run linters
-      uses: golangci/golangci-lint-action@v2
+      uses: golangci/golangci-lint-action@v3
       with:
         version: v1.29
 
diff --git a/atomic_resolver.go b/atomic_resolver.go
index ff337c2..35d385a 100644
--- a/atomic_resolver.go
+++ b/atomic_resolver.go
@@ -18,7 +18,7 @@ func AtomicResolver(ms int64) (uint16, error) {
 		}
 
 		if last == ms {
-			seq = MaxSequence & (localSeq + 1)
+			seq = uint32(MaxSequence) & (localSeq + 1)
 			if seq == 0 {
 				return MaxSequence, nil
 			}
diff --git a/snowflake.go b/snowflake.go
index 9b5eb19..0153806 100644
--- a/snowflake.go
+++ b/snowflake.go
@@ -7,12 +7,12 @@ import (
 
 // These constants are the bit lengths of snowflake ID parts.
 const (
-	TimestampLength = 41
-	MachineIDLength = 10
-	SequenceLength  = 12
-	MaxSequence     = 1<<SequenceLength - 1
-	MaxTimestamp    = 1<<TimestampLength - 1
-	MaxMachineID    = 1<<MachineIDLength - 1
+	TimestampLength uint8  = 41
+	MachineIDLength uint8  = 10
+	SequenceLength  uint8  = 12
+	MaxSequence     uint16 = 1<<SequenceLength - 1
+	MaxTimestamp    uint64 = 1<<TimestampLength - 1
+	MaxMachineID    uint16 = 1<<MachineIDLength - 1
 
 	machineIDMoveLength = SequenceLength
 	timestampMoveLength = MachineIDLength + SequenceLength
@@ -20,22 +20,22 @@ const (
 
 // SequenceResolver the snowflake sequence resolver.
 //
-// When you want use the snowflake algorithm to generate unique ID, You must ensure: The sequence-number generated in the same millisecond of the same node is unique.
-// Based on this, we create this interface provide following reslover:
+// When you want to use the snowflake algorithm to generate unique ID, You must ensure: The sequence-number generated in the same millisecond of the same node is unique.
+// Based on this, we create this interface provide following resolver:
 //   AtomicResolver : base sync/atomic (by default).
 type SequenceResolver func(ms int64) (uint16, error)
 
 // default start time is 2008-11-10 23:00:00 UTC, why ? In the playground the time begins at 2009-11-10 23:00:00 UTC.
-// It's can run on golang playground.
+// It can run on golang playground.
 // default machineID is 0
 // default resolver is AtomicResolver
 var (
 	resolver  SequenceResolver
-	machineID = 0
-	startTime = time.Date(2008, 11, 10, 23, 0, 0, 0, time.UTC)
+	machineID uint64 = 0
+	startTime        = time.Date(2008, 11, 10, 23, 0, 0, 0, time.UTC)
 )
 
-// ID use ID to generate snowflake id and it will ignore error. if you want error info, you need use NextID method.
+// ID use ID to generate snowflake id, and it will ignore error. if you want error info, you need use NextID method.
 // This function is thread safe.
 func ID() uint64 {
 	id, _ := NextID()
@@ -61,12 +61,12 @@ func NextID() (uint64, error) {
 		}
 	}
 
-	df := int(elapsedTime(c, startTime))
-	if df < 0 || df > MaxTimestamp {
-		return 0, errors.New("The maximum life cycle of the snowflake algorithm is 2^41-1(millis), please check starttime")
+	df := elapsedTime(c, startTime)
+	if df < 0 || uint64(df) > MaxTimestamp {
+		return 0, errors.New("the maximum life cycle of the snowflake algorithm is 2^41-1(millis), please check start-time")
 	}
 
-	id := uint64((df << timestampMoveLength) | (machineID << machineIDMoveLength) | int(seq))
+	id := (uint64(df) << uint64(timestampMoveLength)) | (machineID << uint64(machineIDMoveLength)) | uint64(seq)
 	return id, nil
 }
 
@@ -74,7 +74,7 @@ func NextID() (uint64, error) {
 //
 // It will panic when:
 //   s IsZero
-//   s > current millisecond
+//   s > current millisecond,
 //   current millisecond - s > 2^41(69 years).
 // This function is thread-unsafe, recommended you call him in the main function.
 func SetStartTime(s time.Time) {
@@ -88,25 +88,25 @@ func SetStartTime(s time.Time) {
 		panic("The s cannot be greater than the current millisecond")
 	}
 
-	// Because s must after now, so the `df` not < 0.
+	// since we check the current millisecond is greater than s, so we don't need to check the overflow.
 	df := elapsedTime(currentMillis(), s)
-	if df > MaxTimestamp {
+	if uint64(df) > MaxTimestamp {
 		panic("The maximum life cycle of the snowflake algorithm is 69 years")
 	}
 
 	startTime = s
 }
 
-// SetMachineID specify the machine ID. It will panic when machineid > max limit for 2^10-1.
+// SetMachineID specify the machine ID. It will panic when machined > max limit for 2^10-1.
 // This function is thread-unsafe, recommended you call him in the main function.
 func SetMachineID(m uint16) {
 	if m > MaxMachineID {
-		panic("The machineid cannot be greater than 1023")
+		panic("The machineID cannot be greater than 1023")
 	}
-	machineID = int(m)
+	machineID = uint64(m)
 }
 
-// SetSequenceResolver set an custom sequence resolver.
+// SetSequenceResolver set a custom sequence resolver.
 // This function is thread-unsafe, recommended you call him in the main function.
 func SetSequenceResolver(seq SequenceResolver) {
 	if seq != nil {
@@ -126,20 +126,20 @@ type SID struct {
 func (id *SID) GenerateTime() time.Time {
 	ms := startTime.UTC().UnixNano()/1e6 + int64(id.Timestamp)
 
-	return time.Unix(0, (ms * int64(time.Millisecond))).UTC()
+	return time.Unix(0, ms*int64(time.Millisecond)).UTC()
 }
 
 // ParseID parse snowflake it to SID struct.
 func ParseID(id uint64) SID {
-	time := id >> (SequenceLength + MachineIDLength)
-	sequence := id & MaxSequence
-	machineID := (id & (MaxMachineID << SequenceLength)) >> SequenceLength
+	t := id >> uint64(SequenceLength+MachineIDLength)
+	sequence := id & uint64(MaxSequence)
+	mID := (id & (uint64(MaxMachineID) << SequenceLength)) >> SequenceLength
 
 	return SID{
 		ID:        id,
 		Sequence:  sequence,
-		MachineID: machineID,
-		Timestamp: time,
+		MachineID: mID,
+		Timestamp: t,
 	}
 }
 
@@ -163,8 +163,8 @@ func callSequenceResolver() SequenceResolver {
 	return resolver
 }
 
-func elapsedTime(nowms int64, s time.Time) int64 {
-	return nowms - s.UTC().UnixNano()/1e6
+func elapsedTime(noms int64, s time.Time) int64 {
+	return noms - s.UTC().UnixNano()/1e6
 }
 
 // currentMillis get current millisecond.
diff --git a/snowflake_test.go b/snowflake_test.go
index 691632b..8be7592 100644
--- a/snowflake_test.go
+++ b/snowflake_test.go
@@ -156,8 +156,8 @@ func TestSetMachineID(t *testing.T) {
 		defer func() {
 			if err := recover(); err == nil {
 				tt.Error("Should throw a error")
-			} else if err.(string) != "The machineid cannot be greater than 1023" {
-				tt.Error("The error message should be eq 「The machineid cannot be greater than 1023」")
+			} else if err.(string) != "The machineID cannot be greater than 1023" {
+				tt.Error("The error message should be eq 「The machineID cannot be greater than 1023」")
 			}
 		}()