diff --git a/internal/jbig2/decoder/arithmetic/arithmetic.go b/internal/jbig2/decoder/arithmetic/arithmetic.go
index 4860699ed..a691734d5 100644
--- a/internal/jbig2/decoder/arithmetic/arithmetic.go
+++ b/internal/jbig2/decoder/arithmetic/arithmetic.go
@@ -35,7 +35,7 @@ var (
 		{0x5601, 46, 46, 0},
 	}
 
-	qeTable = []int{
+	qeTable = []uint32{
 		0x56010000, 0x34010000, 0x18010000, 0x0AC10000,
 		0x05210000, 0x02210000, 0x56010000, 0x54010000,
 		0x48010000, 0x38010000, 0x30010000, 0x24010000,
@@ -50,20 +50,20 @@ var (
 		0x00050000, 0x00010000, 0x56010000,
 	}
 
-	nmpsTable = []int{
+	nmpsTable = []uint32{
 		1, 2, 3, 4, 5, 38, 7, 8, 9, 10, 11, 12, 13, 29, 15,
 		16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
 		30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
 		44, 45, 45, 46,
 	}
 
-	nlpsTable = []int{
+	nlpsTable = []uint32{
 		1, 6, 9, 12, 29, 33, 6, 14, 14, 14, 17, 18, 20, 21, 14, 14, 15, 16, 17, 18, 19,
 		19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
 		39, 40, 41, 42, 43, 46,
 	}
 
-	switchTable = []int{
+	switchTable = []uint32{
 		1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
 		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -73,16 +73,16 @@ var (
 // Decoder is the arithmetic Decoder structure, used to decode the jbig2 Segments.
 type Decoder struct {
 	// ContextSize is the current decoder context size
-	ContextSize          []int
-	ReferedToContextSize []int
+	ContextSize          []uint32
+	ReferedToContextSize []uint32
 
 	r              reader.StreamReader
-	b              int
+	b              uint8
 	c              uint64
 	a              uint32
 	previous       int64
-	ct             int
-	prvCtr         int
+	ct             int32
+	prvCtr         int32
 	streamPosition int64
 }
 
@@ -90,8 +90,8 @@ type Decoder struct {
 func New(r reader.StreamReader) (*Decoder, error) {
 	d := &Decoder{
 		r:                    r,
-		ContextSize:          []int{16, 13, 10, 10},
-		ReferedToContextSize: []int{13, 10},
+		ContextSize:          []uint32{16, 13, 10, 10},
+		ReferedToContextSize: []uint32{13, 10},
 	}
 
 	// initialize the decoder from the reader
@@ -107,7 +107,7 @@ func (d *Decoder) DecodeBit(stats *DecoderStats) (int, error) {
 	var (
 		bit     int
 		qeValue = qe[stats.cx()][0]
-		icx     = int(stats.cx())
+		icx     = int32(stats.cx())
 	)
 
 	defer func() {
@@ -138,10 +138,11 @@ func (d *Decoder) DecodeBit(stats *DecoderStats) (int, error) {
 }
 
 // DecodeInt decodes the Integer from the arithmetic Decoder for the provided DecoderStats.
-func (d *Decoder) DecodeInt(stats *DecoderStats) (int, error) {
+func (d *Decoder) DecodeInt(stats *DecoderStats) (int32, error) {
 	var (
-		value, bit, s, bitsToRead, offset int
-		err                               error
+		value, offset      int32
+		bit, s, bitsToRead int
+		err                error
 	)
 	if stats == nil {
 		stats = NewStats(512, 1)
@@ -222,16 +223,16 @@ func (d *Decoder) DecodeInt(stats *DecoderStats) (int, error) {
 		if err != nil {
 			return 0, err
 		}
-		value = (value << 1) | bit
+		value = (value << 1) | int32(bit)
 	}
 	value += offset
 
 	if s == 0 {
-		return int(value), nil
+		return value, nil
 	} else if s == 1 && value > 0 {
-		return int(-value), nil
+		return -value, nil
 	}
-	return math.MaxInt64, nil
+	return math.MaxInt32, nil
 }
 
 // DecodeIAID decodes the IAID procedure, Annex A.3.
@@ -242,7 +243,7 @@ func (d *Decoder) DecodeIAID(codeLen uint64, stats *DecoderStats) (int64, error)
 
 	// A.3 2)
 	for i = 0; i < codeLen; i++ {
-		stats.SetIndex(int(d.previous))
+		stats.SetIndex(int32(d.previous))
 		bit, err := d.DecodeBit(stats)
 		if err != nil {
 			return 0, err
@@ -264,7 +265,7 @@ func (d *Decoder) init() error {
 		return err
 	}
 
-	d.b = int(b)
+	d.b = b
 	d.c = (uint64(b) << 16)
 
 	if err = d.readByte(); err != nil {
@@ -291,7 +292,7 @@ func (d *Decoder) readByte() error {
 		return err
 	}
 
-	d.b = int(b)
+	d.b = b
 
 	if d.b == 0xFF {
 		b1, err := d.r.ReadByte()
@@ -314,7 +315,7 @@ func (d *Decoder) readByte() error {
 		if err != nil {
 			return err
 		}
-		d.b = int(b)
+		d.b = b
 
 		d.c += uint64(d.b) << 8
 		d.ct = 8
@@ -345,7 +346,7 @@ func (d *Decoder) renormalize() error {
 }
 
 func (d *Decoder) decodeIntBit(stats *DecoderStats) (int, error) {
-	stats.SetIndex(int(d.previous))
+	stats.SetIndex(int32(d.previous))
 	bit, err := d.DecodeBit(stats)
 	if err != nil {
 		common.Log.Debug("ArithmeticDecoder 'decodeIntBit'-> DecodeBit failed. %v", err)
@@ -360,7 +361,7 @@ func (d *Decoder) decodeIntBit(stats *DecoderStats) (int, error) {
 	return bit, nil
 }
 
-func (d *Decoder) mpsExchange(stats *DecoderStats, icx int) int {
+func (d *Decoder) mpsExchange(stats *DecoderStats, icx int32) int {
 	mps := stats.mps[stats.index]
 
 	if d.a < qe[icx][0] {
@@ -376,7 +377,7 @@ func (d *Decoder) mpsExchange(stats *DecoderStats, icx int) int {
 
 }
 
-func (d *Decoder) lpsExchange(stats *DecoderStats, icx int, qeValue uint32) int {
+func (d *Decoder) lpsExchange(stats *DecoderStats, icx int32, qeValue uint32) int {
 	mps := stats.getMps()
 	if d.a < qeValue {
 		stats.setEntry(int(qe[icx][1]))
diff --git a/internal/jbig2/decoder/arithmetic/stats.go b/internal/jbig2/decoder/arithmetic/stats.go
index 5bbb917fc..923d34f14 100644
--- a/internal/jbig2/decoder/arithmetic/stats.go
+++ b/internal/jbig2/decoder/arithmetic/stats.go
@@ -12,14 +12,14 @@ import (
 
 // DecoderStats is the structure that contains arithmetic decode context.
 type DecoderStats struct {
-	index              int
-	contextSize        int
+	index              int32
+	contextSize        int32
 	codingContextTable []byte
 	mps                []byte
 }
 
 // NewStats creates new DecoderStats of size 'contextSize'.
-func NewStats(contextSize int, index int) *DecoderStats {
+func NewStats(contextSize int32, index int32) *DecoderStats {
 	return &DecoderStats{
 		index:              index,
 		contextSize:        contextSize,
@@ -59,8 +59,8 @@ func (d *DecoderStats) Reset() {
 }
 
 // SetIndex sets current decoder stats 'index'.
-func (d *DecoderStats) SetIndex(index int) {
-	d.index = int(uint(index))
+func (d *DecoderStats) SetIndex(index int32) {
+	d.index = index
 }
 
 // String implements Stringer interface.
diff --git a/internal/jbig2/decoder/huffman/encoded_table.go b/internal/jbig2/decoder/huffman/encoded_table.go
index a002e0598..f0aab3880 100644
--- a/internal/jbig2/decoder/huffman/encoded_table.go
+++ b/internal/jbig2/decoder/huffman/encoded_table.go
@@ -63,7 +63,7 @@ func (e *EncodedTable) String() string {
 func (e *EncodedTable) parseTable() error {
 	var (
 		codeTable                   []*Code
-		prefLen, rangeLen, rangeLow int
+		prefLen, rangeLen, rangeLow int32
 		temp                        uint64
 		err                         error
 	)
@@ -77,13 +77,13 @@ func (e *EncodedTable) parseTable() error {
 		if err != nil {
 			return err
 		}
-		prefLen = int(temp)
+		prefLen = int32(temp)
 
 		temp, err = r.ReadBits(byte(e.HtRS()))
 		if err != nil {
 			return err
 		}
-		rangeLen = int(temp)
+		rangeLen = int32(temp)
 
 		codeTable = append(codeTable, NewCode(prefLen, rangeLen, rangeLow, false))
 		curRangeLow += (1 << uint(rangeLen))
@@ -94,7 +94,7 @@ func (e *EncodedTable) parseTable() error {
 	if err != nil {
 		return err
 	}
-	prefLen = int(temp)
+	prefLen = int32(temp)
 
 	// Annex B.2 7)
 	rangeLen = 32
@@ -106,7 +106,7 @@ func (e *EncodedTable) parseTable() error {
 	if err != nil {
 		return err
 	}
-	prefLen = int(temp)
+	prefLen = int32(temp)
 
 	// Annex B.2 9)
 	rangeLen = 32
@@ -119,7 +119,7 @@ func (e *EncodedTable) parseTable() error {
 		if err != nil {
 			return err
 		}
-		prefLen = int(temp)
+		prefLen = int32(temp)
 		codeTable = append(codeTable, NewCode(prefLen, -1, -1, false))
 	}
 
diff --git a/internal/jbig2/decoder/huffman/node.go b/internal/jbig2/decoder/huffman/node.go
index b9d353947..59355c47d 100644
--- a/internal/jbig2/decoder/huffman/node.go
+++ b/internal/jbig2/decoder/huffman/node.go
@@ -27,7 +27,7 @@ type OutOfBandNode struct{}
 var _ Node = &OutOfBandNode{}
 
 // Decode implements Node interface.
-// NOTE: Decodes the out of band node by returning max int64 value.
+// Decodes the out of band node by returning max int64 value.
 func (o *OutOfBandNode) Decode(r reader.StreamReader) (int64, error) {
 	return int64(math.MaxInt64), nil
 }
@@ -43,8 +43,8 @@ func newOufOfBandNode(c *Code) *OutOfBandNode {
 
 // ValueNode represents a value node in a huffman tree. It is a leaf of a tree.
 type ValueNode struct {
-	rangeLen     int
-	rangeLow     int
+	rangeLen     int32
+	rangeLow     int32
 	isLowerRange bool
 }
 
@@ -82,7 +82,7 @@ func newValueNode(c *Code) *ValueNode {
 // It is defined as a pair of  two child nodes 'zero' and 'one' and a 'depth' level.
 // Implements Node interface.
 type InternalNode struct {
-	depth int
+	depth int32
 	zero  Node
 	one   Node
 }
@@ -175,12 +175,12 @@ func (i *InternalNode) append(c *Code) error {
 }
 
 func (i *InternalNode) pad(sb *strings.Builder) {
-	for j := 0; j < i.depth; j++ {
+	for j := int32(0); j < i.depth; j++ {
 		sb.WriteString("   ")
 	}
 }
 
 // newInternalNode creates new internal node.
-func newInternalNode(depth int) *InternalNode {
+func newInternalNode(depth int32) *InternalNode {
 	return &InternalNode{depth: depth}
 }
diff --git a/internal/jbig2/decoder/huffman/standard_table.go b/internal/jbig2/decoder/huffman/standard_table.go
index 6eb948673..3c459a989 100644
--- a/internal/jbig2/decoder/huffman/standard_table.go
+++ b/internal/jbig2/decoder/huffman/standard_table.go
@@ -65,7 +65,7 @@ func GetStandardTable(number int) (Tabler, error) {
 	return table, nil
 }
 
-func newStandardTable(table [][]int) (*StandardTable, error) {
+func newStandardTable(table [][]int32) (*StandardTable, error) {
 	var codeTable []*Code
 
 	for i := 0; i < len(table); i++ {
@@ -88,7 +88,7 @@ func newStandardTable(table [][]int) (*StandardTable, error) {
 	return s, nil
 }
 
-var tables = [][][]int{
+var tables = [][][]int32{
 	// B1
 	{
 		{1, 4, 0},
diff --git a/internal/jbig2/decoder/huffman/standard_table_test.go b/internal/jbig2/decoder/huffman/standard_table_test.go
index b4c18bfaf..37e7600a7 100644
--- a/internal/jbig2/decoder/huffman/standard_table_test.go
+++ b/internal/jbig2/decoder/huffman/standard_table_test.go
@@ -22,9 +22,7 @@ func TestGetStandardTable(t *testing.T) {
 		table, err := GetStandardTable(1)
 		require.NoError(t, err)
 
-		if assert.NotNil(t, table.RootNode()) {
-			t.Logf(table.String())
-		}
+		assert.NotNil(t, table.RootNode())
 	})
 
 	t.Run("OutOfRange", func(t *testing.T) {
diff --git a/internal/jbig2/decoder/huffman/table.go b/internal/jbig2/decoder/huffman/table.go
index 59582b060..82cec0351 100644
--- a/internal/jbig2/decoder/huffman/table.go
+++ b/internal/jbig2/decoder/huffman/table.go
@@ -22,21 +22,21 @@ type Tabler interface {
 
 // BasicTabler is the interface common for the huffman tables.
 type BasicTabler interface {
-	HtHigh() int
-	HtLow() int
+	HtHigh() int32
+	HtLow() int32
 	StreamReader() reader.StreamReader
-	HtPS() int
-	HtRS() int
-	HtOOB() int
+	HtPS() int32
+	HtRS() int32
+	HtOOB() int32
 }
 
 // Code is the model for the huffman table code.
 type Code struct {
-	prefixLength int
-	rangeLength  int
-	rangeLow     int
+	prefixLength int32
+	rangeLength  int32
+	rangeLow     int32
 	isLowerRange bool
-	code         int
+	code         int32
 }
 
 // String implements Stringer interface.
@@ -51,7 +51,7 @@ func (c *Code) String() string {
 }
 
 // NewCode creates new huffman code.
-func NewCode(prefixLength, rangeLength, rangeLow int, isLowerRange bool) *Code {
+func NewCode(prefixLength, rangeLength, rangeLow int32, isLowerRange bool) *Code {
 	return &Code{
 		prefixLength: prefixLength,
 		rangeLength:  rangeLength,
@@ -61,11 +61,11 @@ func NewCode(prefixLength, rangeLength, rangeLow int, isLowerRange bool) *Code {
 	}
 }
 
-func bitPattern(v, l int) string {
-	var temp int
+func bitPattern(v, l int32) string {
+	var temp int32
 	result := make([]rune, l)
 
-	for i := 1; i <= l; i++ {
+	for i := int32(1); i <= l; i++ {
 		temp = (v >> uint(l-i) & 1)
 		if temp != 0 {
 			result[i-1] = '1'
@@ -78,24 +78,24 @@ func bitPattern(v, l int) string {
 
 func preprocessCodes(codeTable []*Code) {
 	// Annex B.3 1) build the histogram.
-	var maxPrefixLength int
+	var maxPrefixLength int32
 
 	for _, c := range codeTable {
 		maxPrefixLength = maxInt(maxPrefixLength, c.prefixLength)
 	}
 
-	lenCount := make([]int, maxPrefixLength+1)
+	lenCount := make([]int32, maxPrefixLength+1)
 
 	for _, c := range codeTable {
 		lenCount[c.prefixLength]++
 	}
 
-	var curCode int
-	firstCode := make([]int, len(lenCount)+1)
+	var curCode int32
+	firstCode := make([]int32, len(lenCount)+1)
 	lenCount[0] = 0
 
 	// Annex B.3 3)
-	for curLen := 1; curLen <= len(lenCount); curLen++ {
+	for curLen := int32(1); curLen <= int32(len(lenCount)); curLen++ {
 		firstCode[curLen] = (firstCode[curLen-1] + (lenCount[curLen-1])) << 1
 		curCode = firstCode[curLen]
 
@@ -108,7 +108,7 @@ func preprocessCodes(codeTable []*Code) {
 	}
 }
 
-func maxInt(x, y int) int {
+func maxInt(x, y int32) int32 {
 	if x > y {
 		return x
 	}
diff --git a/internal/jbig2/decoder/mmr/mmr.go b/internal/jbig2/decoder/mmr/mmr.go
index 1d2240ba9..621640966 100644
--- a/internal/jbig2/decoder/mmr/mmr.go
+++ b/internal/jbig2/decoder/mmr/mmr.go
@@ -57,7 +57,7 @@ func (m *Decoder) UncompressMMR() (b *bitmap.Bitmap, err error) {
 	referenceOffsets[0] = b.Width
 
 	refRunLength := 1
-	count := 0
+	var count int
 
 	for line := 0; line < b.Height; line++ {
 		count, err = m.uncompress2d(m.data, referenceOffsets, refRunLength, currentOffsets, b.Width)
diff --git a/internal/jbig2/decoder/mmr/rundata.go b/internal/jbig2/decoder/mmr/rundata.go
index 982e6b0f8..4e02e9376 100644
--- a/internal/jbig2/decoder/mmr/rundata.go
+++ b/internal/jbig2/decoder/mmr/rundata.go
@@ -157,7 +157,7 @@ func (r *runData) fillBuffer(byteOffset int) error {
 		r.bufferTop, err = r.r.Read(r.buffer)
 		if err != nil {
 			if err == io.EOF {
-				common.Log.Debug("Read EOF")
+				common.Log.Trace("Read EOF")
 				r.bufferTop = -1
 			} else {
 				return err
diff --git a/internal/jbig2/document_test.go b/internal/jbig2/document_test.go
index f4f4ac0ea..403e418d3 100644
--- a/internal/jbig2/document_test.go
+++ b/internal/jbig2/document_test.go
@@ -105,8 +105,8 @@ func TestDocument(t *testing.T) {
 
 			assert.True(t, sd.IsHuffmanEncoded())
 			assert.False(t, sd.UseRefinementAggregation())
-			assert.Equal(t, 1, sd.NumberOfExportedSymbols())
-			assert.Equal(t, 1, sd.NumberOfNewSymbols())
+			assert.Equal(t, uint32(1), sd.NumberOfExportedSymbols())
+			assert.Equal(t, uint32(1), sd.NumberOfNewSymbols())
 
 			bm, err := sd.GetDictionary()
 			require.NoError(t, err)
@@ -368,7 +368,8 @@ func TestDocument(t *testing.T) {
 		t.Run("Page#2", func(t *testing.T) {
 			bm, err := p2.GetBitmap()
 			require.NoError(t, err)
-			t.Logf("Page#2: %s", bm.String())
+
+			assert.NotEmpty(t, bm.Data)
 		})
 
 		p3, err := d.GetPage(3)
@@ -465,7 +466,6 @@ func TestDocument(t *testing.T) {
 		require.NoError(t, err)
 
 		data := []byte{
-
 			// File Header
 			0x97, 0x4A, 0x42, 0x32, 0x0D, 0x0A, 0x1A, 0x0A, 0x01, 0x00, 0x00, 0x00, 0x01,
 
diff --git a/internal/jbig2/page.go b/internal/jbig2/page.go
index c43a172f3..a0834d46c 100644
--- a/internal/jbig2/page.go
+++ b/internal/jbig2/page.go
@@ -8,6 +8,7 @@ package jbig2
 import (
 	"errors"
 	"fmt"
+	"math"
 
 	"github.com/unidoc/unipdf/v3/common"
 
@@ -162,7 +163,7 @@ func (p *Page) createNormalPage(i *segments.PageInformationSegment) error {
 			} else {
 				regionInfo := r.GetRegionInfo()
 				op := p.getCombinationOperator(i, regionInfo.CombinaionOperator)
-				err = bitmap.Blit(regionBitmap, p.Bitmap, regionInfo.XLocation, regionInfo.YLocation, op)
+				err = bitmap.Blit(regionBitmap, p.Bitmap, int(regionInfo.XLocation), int(regionInfo.YLocation), op)
 				if err != nil {
 					return err
 				}
@@ -194,7 +195,7 @@ func (p *Page) createStripedPage(i *segments.PageInformationSegment) error {
 				return err
 			}
 
-			err = bitmap.Blit(regionBitmap, p.Bitmap, regionInfo.XLocation, startLine, op)
+			err = bitmap.Blit(regionBitmap, p.Bitmap, int(regionInfo.XLocation), startLine, op)
 			if err != nil {
 				return err
 			}
@@ -303,7 +304,7 @@ func (p *Page) getHeight() (int, error) {
 			return 0, errors.New("page information segment is of invalid type")
 		}
 
-		if pi.PageBMHeight == 0xffffffff {
+		if pi.PageBMHeight == math.MaxInt32 {
 			_, err = p.GetBitmap()
 			if err != nil {
 				return 0, err
diff --git a/internal/jbig2/segments/eos.go b/internal/jbig2/segments/eos.go
index 249090f71..74f05ffc9 100644
--- a/internal/jbig2/segments/eos.go
+++ b/internal/jbig2/segments/eos.go
@@ -6,6 +6,8 @@
 package segments
 
 import (
+	"math"
+
 	"github.com/unidoc/unipdf/v3/internal/jbig2/reader"
 )
 
@@ -31,6 +33,6 @@ func (e *EndOfStripe) parseHeader(h *Header, r reader.StreamReader) error {
 	if err != nil {
 		return err
 	}
-	e.lineNumber = int(temp)
+	e.lineNumber = int(temp & math.MaxInt32)
 	return nil
 }
diff --git a/internal/jbig2/segments/generic-refinement-region.go b/internal/jbig2/segments/generic-refinement-region.go
index 77e99eed3..e46348604 100644
--- a/internal/jbig2/segments/generic-refinement-region.go
+++ b/internal/jbig2/segments/generic-refinement-region.go
@@ -44,8 +44,8 @@ type GenericRefinementRegion struct {
 
 	// Variables for decoding.
 	ReferenceBitmap *bitmap.Bitmap
-	ReferenceDX     int
-	ReferenceDY     int
+	ReferenceDX     int32
+	ReferenceDY     int32
 
 	arithDecode *arithmetic.Decoder
 	cx          *arithmetic.DecoderStats
@@ -99,7 +99,7 @@ func (g *GenericRefinementRegion) GetRegionBitmap() (*bitmap.Bitmap, error) {
 		g.cx = arithmetic.NewStats(8192, 1)
 	}
 
-	g.RegionBitmap = bitmap.New(g.RegionInfo.BitmapWidth, g.RegionInfo.BitmapHeight)
+	g.RegionBitmap = bitmap.New(int(g.RegionInfo.BitmapWidth), int(g.RegionInfo.BitmapHeight))
 
 	if g.TemplateID == 0 {
 		if err = g.updateOverride(); err != nil {
@@ -111,7 +111,7 @@ func (g *GenericRefinementRegion) GetRegionBitmap() (*bitmap.Bitmap, error) {
 	var deltaRefStride int
 
 	if g.IsTPGROn {
-		deltaRefStride = -g.ReferenceDY * g.ReferenceBitmap.RowStride
+		deltaRefStride = int(-g.ReferenceDY) * g.ReferenceBitmap.RowStride
 	}
 
 	yOffset := deltaRefStride + 1
@@ -182,14 +182,14 @@ func (g *GenericRefinementRegion) decodeOptimized(
 		rx        int
 		tempIndex int
 	)
-	currentLine := lineNumber - g.ReferenceDY
-	if t := (-g.ReferenceDX); t > 0 {
+	currentLine := lineNumber - int(g.ReferenceDY)
+	if t := int(-g.ReferenceDX); t > 0 {
 		rx = t
 	}
 	refByteIndex := g.ReferenceBitmap.GetByteIndex(rx, currentLine)
 
 	if g.ReferenceDX > 0 {
-		tempIndex = g.ReferenceDX
+		tempIndex = int(g.ReferenceDX)
 	}
 
 	byteIndex := g.RegionBitmap.GetByteIndex(tempIndex, lineNumber)
@@ -207,7 +207,7 @@ func (g *GenericRefinementRegion) decodeTypicalPredictedLine(
 	lineNumber, width, rowStride, refRowStride, paddedWidth, deltaRefStride int,
 ) error {
 	// Offset of the reference bitmap with respect to the bitmap being decoded
-	currentLine := lineNumber - g.ReferenceDY
+	currentLine := lineNumber - int(g.ReferenceDY)
 	refByteIndex := g.ReferenceBitmap.GetByteIndex(0, currentLine)
 	byteIndex := g.RegionBitmap.GetByteIndex(0, lineNumber)
 	var err error
@@ -342,9 +342,9 @@ func (g *GenericRefinementRegion) decodeTypicalPredictedLineTemplate0(
 			if !isPixelTypicalPredicted {
 				if g.override {
 					overridenContext = g.overrideAtTemplate0(context, x+minorX, lineNumber, result, minorX)
-					g.cx.SetIndex(overridenContext)
+					g.cx.SetIndex(int32(overridenContext))
 				} else {
-					g.cx.SetIndex(context)
+					g.cx.SetIndex(int32(context))
 				}
 
 				bit, err = g.arithDecode.DecodeBit(g.cx)
@@ -492,7 +492,7 @@ func (g *GenericRefinementRegion) decodeTypicalPredictedLineTemplate1(
 			} else if bitmapValue == 0x00 {
 				bit = 0
 			} else {
-				g.cx.SetIndex(context)
+				g.cx.SetIndex(int32(context))
 				bit, err = g.arithDecode.DecodeBit(g.cx)
 				if err != nil {
 					return
@@ -700,9 +700,9 @@ func (g *GenericRefinementRegion) decodeTemplate(
 			if err != nil {
 				return err
 			}
-			g.cx.SetIndex(g.overrideAtTemplate0(int(tval), x, lineNumber, int(temp), minorX))
+			g.cx.SetIndex(int32(g.overrideAtTemplate0(int(tval), x, lineNumber, int(temp), minorX)))
 		} else {
-			g.cx.SetIndex(int(tval))
+			g.cx.SetIndex(int32(tval))
 		}
 
 		bit, err = g.arithDecode.DecodeBit(g.cx)
@@ -720,12 +720,12 @@ func (g *GenericRefinementRegion) decodeTemplate(
 		c4 = (((c4 << 1) | 0x01&int16(w4>>7)) & 0x07)
 		c5 = int16(bit)
 
-		if (x-g.ReferenceDX)%8 == 5 {
+		if (x-int(g.ReferenceDX))%8 == 5 {
 			w1 = 0
 			w2 = 0
 			w3 = 0
 
-			if ((x-g.ReferenceDX)/8)+1 < g.ReferenceBitmap.RowStride {
+			if ((x-int(g.ReferenceDX))/8)+1 < g.ReferenceBitmap.RowStride {
 				if currentLine >= 1 && (currentLine-1) < g.ReferenceBitmap.Height {
 					temp, err = g.ReferenceBitmap.GetByte(refByteIndex - refRowStride)
 					if err != nil {
@@ -895,8 +895,8 @@ func (g *GenericRefinementRegion) readAtPixels() error {
 // setParameters sets the parameters for the Generic Refinemenet Region.
 func (g *GenericRefinementRegion) setParameters(
 	cx *arithmetic.DecoderStats, arithmDecoder *arithmetic.Decoder,
-	grTemplate int8, regionWidth, regionHeight int,
-	grReference *bitmap.Bitmap, grReferenceDX, grReferenceDY int,
+	grTemplate int8, regionWidth, regionHeight uint32,
+	grReference *bitmap.Bitmap, grReferenceDX, grReferenceDY int32,
 	isTPGRon bool, grAtX []int8, grAtY []int8,
 ) {
 	common.Log.Trace("[GENERIC-REF-REGION] setParameters")
diff --git a/internal/jbig2/segments/generic-region.go b/internal/jbig2/segments/generic-region.go
index dfd7c1e28..db575ac82 100644
--- a/internal/jbig2/segments/generic-region.go
+++ b/internal/jbig2/segments/generic-region.go
@@ -80,11 +80,7 @@ func (g *GenericRegion) GetRegionBitmap() (bm *bitmap.Bitmap, err error) {
 	if g.IsMMREncoded {
 		// MMR Decoder Call
 		if g.mmrDecoder == nil {
-			g.mmrDecoder, err = mmr.New(
-				g.r,
-				g.RegionSegment.BitmapWidth, g.RegionSegment.BitmapHeight,
-				g.DataOffset, g.DataLength,
-			)
+			g.mmrDecoder, err = mmr.New(g.r, int(g.RegionSegment.BitmapWidth), int(g.RegionSegment.BitmapHeight), g.DataOffset, g.DataLength)
 			if err != nil {
 				return nil, err
 			}
@@ -113,7 +109,7 @@ func (g *GenericRegion) GetRegionBitmap() (bm *bitmap.Bitmap, err error) {
 	}
 
 	// 6.2.5.7 - 2)
-	g.Bitmap = bitmap.New(g.RegionSegment.BitmapWidth, g.RegionSegment.BitmapHeight)
+	g.Bitmap = bitmap.New(int(g.RegionSegment.BitmapWidth), int(g.RegionSegment.BitmapHeight))
 	paddedWidth := int(uint32(g.Bitmap.Width+7) & (^uint32(7)))
 
 	// 6.2.5.7 - 3)
@@ -356,9 +352,9 @@ func (g *GenericRegion) decodeTemplate0a(line, width, paddedWidth int, byteIndex
 
 			if g.override {
 				overriddenContext = g.overrideAtTemplate0a(context, x+minorX, line, int(result), minorX, int(toShift))
-				g.cx.SetIndex(overriddenContext)
+				g.cx.SetIndex(int32(overriddenContext))
 			} else {
-				g.cx.SetIndex(context)
+				g.cx.SetIndex(int32(context))
 			}
 
 			var bit int
@@ -449,9 +445,9 @@ func (g *GenericRegion) decodeTemplate0b(line, width, paddedWidth int, byteIndex
 
 			if g.override {
 				overriddenContext = g.overrideAtTemplate0b(context, x+minorX, line, int(result), minorX, int(toShift))
-				g.cx.SetIndex(overriddenContext)
+				g.cx.SetIndex(int32(overriddenContext))
 			} else {
-				g.cx.SetIndex(context)
+				g.cx.SetIndex(int32(context))
 			}
 
 			var bit int
@@ -542,9 +538,9 @@ func (g *GenericRegion) decodeTemplate1(line, width, paddedWidth int, byteIndex,
 		for minorX := 0; minorX < minorWidth; minorX++ {
 			if g.override {
 				overriddenContext = g.overrideAtTemplate1(context, x+minorX, line, int(result), minorX)
-				g.cx.SetIndex(overriddenContext)
+				g.cx.SetIndex(int32(overriddenContext))
 			} else {
-				g.cx.SetIndex(context)
+				g.cx.SetIndex(int32(context))
 			}
 
 			bit, err = g.arithDecoder.DecodeBit(g.cx)
@@ -636,9 +632,9 @@ func (g *GenericRegion) decodeTemplate2(lineNumber, width, paddedWidth int, byte
 
 			if g.override {
 				overriddenContext = g.overrideAtTemplate2(context, x+minorX, lineNumber, int(result), minorX)
-				g.cx.SetIndex(overriddenContext)
+				g.cx.SetIndex(int32(overriddenContext))
 			} else {
-				g.cx.SetIndex(context)
+				g.cx.SetIndex(int32(context))
 			}
 
 			bit, err = g.arithDecoder.DecodeBit(g.cx)
@@ -707,9 +703,9 @@ func (g *GenericRegion) decodeTemplate3(line, width, paddedWidth int, byteIndex,
 		for minorX := 0; minorX < minorWidth; minorX++ {
 			if g.override {
 				overriddenContext = g.overrideAtTemplate3(context, x+minorX, line, int(result), minorX)
-				g.cx.SetIndex(overriddenContext)
+				g.cx.SetIndex(int32(overriddenContext))
 			} else {
-				g.cx.SetIndex(context)
+				g.cx.SetIndex(int32(context))
 			}
 
 			bit, err = g.arithDecoder.DecodeBit(g.cx)
@@ -1029,11 +1025,7 @@ func (g *GenericRegion) setOverrideFlag(index int) {
 	g.override = true
 }
 
-func (g *GenericRegion) setParameters(
-	isMMREncoded bool,
-	dataOffset, dataLength int64,
-	gbh, gbw int,
-) {
+func (g *GenericRegion) setParameters(isMMREncoded bool, dataOffset, dataLength int64, gbh, gbw uint32) {
 	g.IsMMREncoded = isMMREncoded
 	g.DataOffset = dataOffset
 	g.DataLength = dataLength
@@ -1048,7 +1040,7 @@ func (g *GenericRegion) setParametersWithAt(
 	SDTemplate byte,
 	isTPGDon, useSkip bool,
 	sDAtX, sDAtY []int8,
-	symWidth, hcHeight int,
+	symWidth, hcHeight uint32,
 	cx *arithmetic.DecoderStats, a *arithmetic.Decoder,
 ) {
 	g.IsMMREncoded = isMMREncoded
@@ -1074,7 +1066,7 @@ func (g *GenericRegion) setParametersWithAt(
 func (g *GenericRegion) setParametersMMR(
 	isMMREncoded bool,
 	dataOffset, dataLength int64,
-	gbh, gbw int,
+	gbh, gbw uint32,
 	gbTemplate byte,
 	isTPGDon, useSkip bool,
 	gbAtX, gbAtY []int8,
diff --git a/internal/jbig2/segments/generic-region_test.go b/internal/jbig2/segments/generic-region_test.go
index 80f734bce..12d565758 100644
--- a/internal/jbig2/segments/generic-region_test.go
+++ b/internal/jbig2/segments/generic-region_test.go
@@ -50,8 +50,8 @@ func TestDecodeGenericRegion(t *testing.T) {
 			s, ok := sg.(*GenericRegion)
 			require.True(t, ok)
 
-			assert.Equal(t, 44, s.RegionSegment.BitmapHeight)
-			assert.Equal(t, 54, s.RegionSegment.BitmapWidth)
+			assert.Equal(t, uint32(44), s.RegionSegment.BitmapHeight)
+			assert.Equal(t, uint32(54), s.RegionSegment.BitmapWidth)
 			assert.Equal(t, bitmap.CmbOpOr, s.RegionSegment.CombinaionOperator)
 			assert.Equal(t, true, s.IsTPGDon)
 			assert.Equal(t, byte(0), s.GBTemplate)
@@ -59,7 +59,7 @@ func TestDecodeGenericRegion(t *testing.T) {
 			bm, err := s.GetRegionBitmap()
 			require.NoError(t, err)
 
-			t.Log(bm.String())
+			isTestingFrame(t, bm)
 		})
 
 		t.Run("S-5th", func(t *testing.T) {
@@ -88,15 +88,35 @@ func TestDecodeGenericRegion(t *testing.T) {
 			s, ok := gs.(*GenericRegion)
 			require.True(t, ok)
 
-			assert.Equal(t, 44, s.RegionSegment.BitmapHeight)
-			assert.Equal(t, 54, s.RegionSegment.BitmapWidth)
+			assert.Equal(t, uint32(44), s.RegionSegment.BitmapHeight)
+			assert.Equal(t, uint32(54), s.RegionSegment.BitmapWidth)
 			assert.Equal(t, bitmap.CmbOpOr, s.RegionSegment.CombinaionOperator)
 			assert.Equal(t, true, s.IsMMREncoded)
 
 			b, err := s.GetRegionBitmap()
 			require.NoError(t, err)
 
-			t.Log(b.String())
+			isTestingFrame(t, b)
 		})
 	})
 }
+
+func isTestingFrame(t *testing.T, b *bitmap.Bitmap) {
+	assert.Equal(t, 44, b.Height)
+	assert.Equal(t, 54, b.Width)
+
+	for y := 0; y < b.Height; y++ {
+		for x := 0; x < b.Width; x++ {
+			pix := b.GetPixel(x, y)
+
+			// first two and last two rows are set to '1'
+			if y == 0 || y == 1 || y == b.Height-1 || y == b.Height-2 {
+				assert.Equal(t, true, pix)
+			} else if x == 0 || x == 1 || x == b.Width-1 || x == b.Width-2 {
+				assert.Equal(t, true, pix)
+			} else {
+				assert.Equal(t, false, pix)
+			}
+		}
+	}
+}
diff --git a/internal/jbig2/segments/halftone-segment.go b/internal/jbig2/segments/halftone-segment.go
index 6e79915d6..191d4ce0b 100644
--- a/internal/jbig2/segments/halftone-segment.go
+++ b/internal/jbig2/segments/halftone-segment.go
@@ -28,7 +28,7 @@ type HalftoneRegion struct {
 	RegionSegment *RegionSegment
 
 	// Halftone segment information field, 7.4.5.1.1.
-	HDefaultPixel       int
+	HDefaultPixel       int8
 	CombinationOperator bitmap.CombinationOperator
 	HSkipEnabled        bool
 	HTemplate           byte
@@ -36,19 +36,19 @@ type HalftoneRegion struct {
 
 	// Halftone grid position and size, 7.4.5.1.2
 	// Width of the gray-scale image, 7.4.5.1.2.1
-	HGridWidth int
+	HGridWidth uint32
 	// Height of the gray-scale image, 7.4.5.1.2.2
-	HGridHeight int
+	HGridHeight uint32
 	// Horizontal offset of the grid, 7.4.5.1.2.3
-	HGridX int
+	HGridX int32
 	// Vertical offset of the grid, 7.4.5.1.2.4
-	HGridY int
+	HGridY int32
 
 	// Halftone grid vector, 7.4.5.1.3
 	// Horizontal coordinate of the halftone grid vector, 7.4.5.1.3.1
-	HRegionX int
+	HRegionX uint16
 	// Vertical coordinate of the halftone grod vector, 7.4.5.1.3.2
-	HRegionY int
+	HRegionY uint16
 
 	// Decoded data
 	HalftoneRegionBitmap *bitmap.Bitmap
@@ -73,7 +73,7 @@ func (h *HalftoneRegion) GetRegionBitmap() (*bitmap.Bitmap, error) {
 	var err error
 
 	// 6.6.5 1)
-	h.HalftoneRegionBitmap = bitmap.New(h.RegionSegment.BitmapWidth, h.RegionSegment.BitmapHeight)
+	h.HalftoneRegionBitmap = bitmap.New(int(h.RegionSegment.BitmapWidth), int(h.RegionSegment.BitmapHeight))
 
 	if h.Patterns == nil || len(h.Patterns) == 0 {
 		h.Patterns, err = h.GetPatterns()
@@ -187,11 +187,10 @@ func (h *HalftoneRegion) computeGrayScalePlanes(grayScalePlanes []*bitmap.Bitmap
 		grayScaleValues[i] = make([]int, h.HGridWidth)
 	}
 
-	for y := 0; y < h.HGridHeight; y++ {
-		for x := 0; x < h.HGridWidth; x += 8 {
+	for y := 0; y < int(h.HGridHeight); y++ {
+		for x := 0; x < int(h.HGridWidth); x += 8 {
 			var minorWidth int
-
-			if d := h.HGridWidth - x; d > 8 {
+			if d := int(h.HGridWidth) - x; d > 8 {
 				minorWidth = 8
 			} else {
 				minorWidth = d
@@ -228,11 +227,11 @@ func (h *HalftoneRegion) computeSegmentDataStructure() error {
 }
 
 func (h *HalftoneRegion) computeX(m, n int) int {
-	return h.shiftAndFill(h.HGridX + m*h.HRegionY + n*h.HRegionX)
+	return h.shiftAndFill(int(h.HGridX) + m*int(h.HRegionY) + n*int(h.HRegionX))
 }
 
 func (h *HalftoneRegion) computeY(m, n int) int {
-	return h.shiftAndFill(h.HGridY + m*h.HRegionX - n*h.HRegionY)
+	return h.shiftAndFill(int(h.HGridY) + m*int(h.HRegionX) - n*int(h.HRegionY))
 }
 
 func (h *HalftoneRegion) grayScaleDecoding(bitsPerValue int) ([][]int, error) {
@@ -299,7 +298,7 @@ func (h *HalftoneRegion) parseHeader() error {
 	if err != nil {
 		return err
 	}
-	h.HDefaultPixel = b
+	h.HDefaultPixel = int8(b)
 
 	// Bit 4-6
 	temp, err := h.r.ReadBits(3)
@@ -338,37 +337,37 @@ func (h *HalftoneRegion) parseHeader() error {
 	if err != nil {
 		return err
 	}
-	h.HGridWidth = int(temp) & 0xFFFFFFFF
+	h.HGridWidth = uint32(temp & math.MaxUint32)
 
 	temp, err = h.r.ReadBits(32)
 	if err != nil {
 		return err
 	}
-	h.HGridHeight = int(temp) & 0xFFFFFFFF
+	h.HGridHeight = uint32(temp & math.MaxUint32)
 
 	temp, err = h.r.ReadBits(32)
 	if err != nil {
 		return err
 	}
-	h.HGridX = int(temp)
+	h.HGridX = int32(temp & math.MaxInt32)
 
 	temp, err = h.r.ReadBits(32)
 	if err != nil {
 		return err
 	}
-	h.HGridY = int(temp)
+	h.HGridY = int32(temp & math.MaxInt32)
 
 	temp, err = h.r.ReadBits(16)
 	if err != nil {
 		return err
 	}
-	h.HRegionX = int(temp) & 0xFFFF
+	h.HRegionX = uint16(temp & math.MaxUint16)
 
 	temp, err = h.r.ReadBits(16)
 	if err != nil {
 		return err
 	}
-	h.HRegionY = int(temp) & 0xFFFF
+	h.HRegionY = uint16(temp & math.MaxUint16)
 
 	if err = h.computeSegmentDataStructure(); err != nil {
 		return err
@@ -380,15 +379,15 @@ func (h *HalftoneRegion) parseHeader() error {
 func (h *HalftoneRegion) renderPattern(grayScaleValues [][]int) (err error) {
 	var x, y int
 
-	for m := 0; m < h.HGridHeight; m++ {
-		for n := 0; n < h.HGridWidth; n++ {
+	for m := 0; m < int(h.HGridHeight); m++ {
+		for n := 0; n < int(h.HGridWidth); n++ {
 			x = h.computeX(m, n)
 			y = h.computeY(m, n)
 			patternBitmap := h.Patterns[grayScaleValues[m][n]]
 
 			if err = bitmap.Blit(
 				patternBitmap, h.HalftoneRegionBitmap,
-				x+h.HGridX, y+h.HGridY, h.CombinationOperator,
+				x+int(h.HGridX), y+int(h.HGridY), h.CombinationOperator,
 			); err != nil {
 				return err
 			}
diff --git a/internal/jbig2/segments/header.go b/internal/jbig2/segments/header.go
index d03cdd909..a06a71681 100644
--- a/internal/jbig2/segments/header.go
+++ b/internal/jbig2/segments/header.go
@@ -9,6 +9,7 @@ import (
 	"encoding/binary"
 	"fmt"
 	"io"
+	"math"
 	"strings"
 
 	"github.com/unidoc/unipdf/v3/common"
@@ -33,16 +34,11 @@ type Header struct {
 }
 
 // NewHeader creates new segment header for the provided document from the stream reader.
-func NewHeader(
-	d Documenter, r reader.StreamReader,
-	offset int64, organizationType OrganizationType,
-) (*Header, error) {
+func NewHeader(d Documenter, r reader.StreamReader, offset int64, organizationType OrganizationType) (*Header, error) {
 	h := &Header{Reader: r}
-
 	if err := h.parse(d, r, offset, organizationType); err != nil {
 		return nil, err
 	}
-
 	return h, nil
 }
 
@@ -238,7 +234,7 @@ func (h *Header) readNumberOfReferredToSegments(r reader.StreamReader) (uint64,
 		if err != nil {
 			return 0, err
 		}
-		countOfRTS &= 0xffffffff
+		countOfRTS &= math.MaxInt32
 		arrayLength := (countOfRTS + 8) >> 3
 		arrayLength <<= 3
 		retainBit = make([]byte, arrayLength)
@@ -282,17 +278,14 @@ func (h *Header) readReferedToSegmentNumbers(r reader.StreamReader, countOfRTS i
 			if err != nil {
 				return nil, err
 			}
-			rtsNumbers[i] = int(bits & 0xffffffff)
+			rtsNumbers[i] = int(bits & math.MaxInt32)
 		}
 	}
 	return rtsNumbers, nil
 }
 
 // readSegmentPageAssociation gets the segment's associated page number.
-func (h *Header) readSegmentPageAssociation(
-	d Documenter, r reader.StreamReader,
-	countOfRTS uint64, rtsNumbers ...int,
-) error {
+func (h *Header) readSegmentPageAssociation(d Documenter, r reader.StreamReader, countOfRTS uint64, rtsNumbers ...int) error {
 	// 7.2.6
 	if !h.PageAssociationFieldSize {
 		// Short format
@@ -309,7 +302,7 @@ func (h *Header) readSegmentPageAssociation(
 			return err
 		}
 
-		h.PageAssociation = int(bits & 0xFFFFFFFF)
+		h.PageAssociation = int(bits & math.MaxInt32)
 	}
 
 	if countOfRTS > 0 {
@@ -336,7 +329,7 @@ func (h *Header) readSegmentDataLength(r reader.StreamReader) (err error) {
 	}
 
 	// Set the 4bytes mask
-	h.SegmentDataLength &= 0xffffffff
+	h.SegmentDataLength &= math.MaxInt32
 	return nil
 }
 
diff --git a/internal/jbig2/segments/page-information.go b/internal/jbig2/segments/page-information.go
index 4a7932056..406564e9f 100644
--- a/internal/jbig2/segments/page-information.go
+++ b/internal/jbig2/segments/page-information.go
@@ -7,6 +7,7 @@ package segments
 
 import (
 	"fmt"
+	"math"
 	"strings"
 
 	"github.com/unidoc/unipdf/v3/common"
@@ -21,13 +22,10 @@ type PageInformationSegment struct {
 
 	// Page bitmap height, four byte, 7.4.8.1
 	PageBMHeight int
-
 	// Page bitmap width, four byte, 7.4.8.1
 	PageBMWidth int
-
 	// Page X resolution, four byte 7.4.8.3
 	ResolutionX int
-
 	// Page Y resolution, four byte 7.4.8.4
 	ResolutionY int
 
@@ -86,9 +84,9 @@ func (p *PageInformationSegment) String() string {
 }
 
 func (p *PageInformationSegment) checkInput() error {
-	if p.PageBMHeight == 0xFFFFFFFFFF {
+	if p.PageBMHeight == math.MaxInt32 {
 		if !p.IsStripe {
-			common.Log.Debug("isStriped should contaion the value true")
+			common.Log.Debug("PageInformationSegment.IsStripe should be true.")
 		}
 	}
 	return nil
@@ -177,14 +175,14 @@ func (p *PageInformationSegment) readResolution() error {
 	if err != nil {
 		return err
 	}
-	p.ResolutionX = int(tempResolution)
+	p.ResolutionX = int(tempResolution & math.MaxInt32)
 
 	tempResolution, err = p.r.ReadBits(32)
 	if err != nil {
 		return err
 	}
 
-	p.ResolutionY = int(tempResolution)
+	p.ResolutionY = int(tempResolution & math.MaxInt32)
 	return nil
 }
 
@@ -230,7 +228,7 @@ func (p *PageInformationSegment) readDefaultPixelValue() error {
 	if err != nil {
 		return err
 	}
-	p.defaultPixelValue = uint8(b)
+	p.defaultPixelValue = uint8(b & 0xf)
 	return nil
 }
 
@@ -277,7 +275,7 @@ func (p *PageInformationSegment) readMaxStripeSize() error {
 		return err
 	}
 
-	p.MaxStripeSize = uint16(b & 0xFFFF)
+	p.MaxStripeSize = uint16(b & math.MaxUint16)
 	return nil
 }
 
@@ -286,13 +284,13 @@ func (p *PageInformationSegment) readWidthAndHeight() error {
 	if err != nil {
 		return err
 	}
-	p.PageBMWidth = int(tempInt)
+	p.PageBMWidth = int(tempInt & math.MaxInt32)
 
 	tempInt, err = p.r.ReadBits(32)
 	if err != nil {
 		return err
 	}
-	p.PageBMHeight = int(tempInt)
+	p.PageBMHeight = int(tempInt & math.MaxInt32)
 	return nil
 }
 
diff --git a/internal/jbig2/segments/pattern-dictionary.go b/internal/jbig2/segments/pattern-dictionary.go
index 27ec08d05..e4ae8a60b 100644
--- a/internal/jbig2/segments/pattern-dictionary.go
+++ b/internal/jbig2/segments/pattern-dictionary.go
@@ -8,6 +8,7 @@ package segments
 import (
 	"errors"
 	"image"
+	"math"
 
 	"github.com/unidoc/unipdf/v3/common"
 
@@ -40,7 +41,7 @@ type PatternDictionary struct {
 	Patterns []*bitmap.Bitmap
 
 	// Largest gray-scale value 7.4.4.1.4
-	GrayMax int
+	GrayMax uint32
 }
 
 // GetDictionary gets the PatternDictionary segment Dictionary bitmaps.
@@ -54,7 +55,7 @@ func (p *PatternDictionary) GetDictionary() ([]*bitmap.Bitmap, error) {
 	}
 
 	genericRegion := NewGenericRegion(p.r)
-	genericRegion.setParametersMMR(p.IsMMREncoded, p.DataOffset, p.DataLength, int(p.HdpHeight), (p.GrayMax+1)*int(p.HdpWidth), p.HDTemplate, false, false, p.GBAtX, p.GBAtY)
+	genericRegion.setParametersMMR(p.IsMMREncoded, p.DataOffset, p.DataLength, uint32(p.HdpHeight), (p.GrayMax+1)*uint32(p.HdpWidth), p.HDTemplate, false, false, p.GBAtX, p.GBAtY)
 
 	collectiveBitmap, err := genericRegion.GetRegionBitmap()
 	if err != nil {
@@ -99,7 +100,7 @@ func (p *PatternDictionary) extractPatterns(collectiveBitmap *bitmap.Bitmap) err
 	patterns := make([]*bitmap.Bitmap, p.GrayMax+1)
 
 	// 4
-	for gray <= p.GrayMax {
+	for gray <= int(p.GrayMax) {
 		// 4 a)
 		x0 := int(p.HdpWidth) * gray
 		roi := image.Rect(x0, 0, x0+int(p.HdpWidth), int(p.HdpHeight))
@@ -192,7 +193,7 @@ func (p *PatternDictionary) readGrayMax() error {
 	if err != nil {
 		return err
 	}
-	p.GrayMax = int(temp & 0xffffffff)
+	p.GrayMax = uint32(temp & math.MaxUint32)
 	return nil
 }
 
diff --git a/internal/jbig2/segments/pattern-dictionary_test.go b/internal/jbig2/segments/pattern-dictionary_test.go
index 523aa46ff..97523ceca 100644
--- a/internal/jbig2/segments/pattern-dictionary_test.go
+++ b/internal/jbig2/segments/pattern-dictionary_test.go
@@ -55,7 +55,7 @@ func TestDecodePatternDictionary(t *testing.T) {
 			require.Equal(t, true, p.IsMMREncoded)
 			require.Equal(t, byte(4), p.HdpWidth)
 			require.Equal(t, byte(4), p.HdpHeight)
-			require.Equal(t, 15, p.GrayMax)
+			require.Equal(t, uint32(15), p.GrayMax)
 
 			dict, err := p.GetDictionary()
 			require.NoError(t, err)
diff --git a/internal/jbig2/segments/region.go b/internal/jbig2/segments/region.go
index ff4f4a835..32be73368 100644
--- a/internal/jbig2/segments/region.go
+++ b/internal/jbig2/segments/region.go
@@ -7,6 +7,7 @@ package segments
 
 import (
 	"fmt"
+	"math"
 	"strings"
 
 	"github.com/unidoc/unipdf/v3/common"
@@ -18,19 +19,14 @@ import (
 // RegionSegment is the model representing base jbig2 segment region - see 7.4.1.
 type RegionSegment struct {
 	r reader.StreamReader
-
 	// Region segment bitmap width, 7.4.1.1
-	BitmapWidth int
-
+	BitmapWidth uint32
 	// Region segment bitmap height, 7.4.1.2
-	BitmapHeight int
-
+	BitmapHeight uint32
 	// Region segment bitmap X location, 7.4.1.3
-	XLocation int
-
+	XLocation uint32
 	// Region segment bitmap Y location, 7.4.1.4
-	YLocation int
-
+	YLocation uint32
 	// Region segment flags, 7.4.1.5
 	CombinaionOperator bitmap.CombinationOperator
 }
@@ -62,25 +58,25 @@ func (r *RegionSegment) parseHeader() error {
 	if err != nil {
 		return err
 	}
-	r.BitmapWidth = int(temp & 0xffffffff)
+	r.BitmapWidth = uint32(temp & math.MaxUint32)
 
 	temp, err = r.r.ReadBits(32)
 	if err != nil {
 		return err
 	}
-	r.BitmapHeight = int(temp & 0xffffffff)
+	r.BitmapHeight = uint32(temp & math.MaxUint32)
 
 	temp, err = r.r.ReadBits(32)
 	if err != nil {
 		return err
 	}
-	r.XLocation = int(temp & 0xffffffff)
+	r.XLocation = uint32(temp & math.MaxUint32)
 
 	temp, err = r.r.ReadBits(32)
 	if err != nil {
 		return err
 	}
-	r.YLocation = int(temp & 0xffffffff)
+	r.YLocation = uint32(temp & math.MaxUint32)
 
 	// Bit 3-7
 	r.r.ReadBits(5) // dirty read
diff --git a/internal/jbig2/segments/symbol-dictionary.go b/internal/jbig2/segments/symbol-dictionary.go
index 789fef63f..42ece1da3 100644
--- a/internal/jbig2/segments/symbol-dictionary.go
+++ b/internal/jbig2/segments/symbol-dictionary.go
@@ -44,16 +44,16 @@ type SymbolDictionary struct {
 	sdrATY []int8
 
 	// Number of exported symbols, 7.4.2.1.4
-	numberOfExportedSymbols int
+	numberOfExportedSymbols uint32
 
 	// Number of new symbols 7.4.2.1.5
-	numberOfNewSymbols int
+	numberOfNewSymbols uint32
 
 	// Further parameters
 	Header                  *Header
-	numberOfImportedSymbols int
+	numberOfImportedSymbols uint32
 	importSymbols           []*bitmap.Bitmap
-	numberOfDecodedSymbols  int
+	numberOfDecodedSymbols  uint32
 	newSymbols              []*bitmap.Bitmap
 
 	// User-supplied tables
@@ -82,16 +82,16 @@ type SymbolDictionary struct {
 	cxIADT  *arithmetic.DecoderStats
 
 	cxIAID       *arithmetic.DecoderStats
-	sbSymCodeLen int
+	sbSymCodeLen int8
 }
 
 // NumberOfExportedSymbols defines how many symbols are being exported by this SymbolDictionary.
-func (s *SymbolDictionary) NumberOfExportedSymbols() int {
+func (s *SymbolDictionary) NumberOfExportedSymbols() uint32 {
 	return s.numberOfExportedSymbols
 }
 
 // NumberOfNewSymbols returns the amount of new symbols defined by the Symbol Dictionary.
-func (s *SymbolDictionary) NumberOfNewSymbols() int {
+func (s *SymbolDictionary) NumberOfNewSymbols() uint32 {
 	return s.numberOfNewSymbols
 }
 
@@ -140,8 +140,8 @@ func (s *SymbolDictionary) GetDictionary() ([]*bitmap.Bitmap, error) {
 			}
 			heightClassHeight += temp
 
-			var symbolWidth, totalWidth int
-			heightClassFirstSymbolIndex := s.numberOfDecodedSymbols
+			var symbolWidth, totalWidth uint32
+			heightClassFirstSymbolIndex := int64(s.numberOfDecodedSymbols)
 
 			// 6.5.5 4 c)
 			// Repeat until OOB - OOB sends a break
@@ -153,32 +153,31 @@ func (s *SymbolDictionary) GetDictionary() ([]*bitmap.Bitmap, error) {
 					return nil, err
 				}
 
-				if differenceWidth == math.MaxInt64 || s.numberOfDecodedSymbols >= s.numberOfNewSymbols {
+				if differenceWidth == int64(math.MaxInt64) || s.numberOfDecodedSymbols >= s.numberOfNewSymbols {
 					break
 				}
 
-				symbolWidth += int(differenceWidth)
+				symbolWidth += uint32(differenceWidth)
 				totalWidth += symbolWidth
 
 				//* 4 c) ii)
 				if !s.isHuffmanEncoded || s.useRefinementAggregation {
-
 					if !s.useRefinementAggregation {
 						// 6.5.8.1 - Directly coded
-						err = s.decodeDirectlyThroughGenericRegion(symbolWidth, int(heightClassHeight))
+						err = s.decodeDirectlyThroughGenericRegion(symbolWidth, uint32(heightClassHeight))
 						if err != nil {
 							return nil, err
 						}
 					} else {
 						// 6.5.8.2 - Refinement / Aggregate -coded
-						err = s.decodeAggregate(symbolWidth, int(heightClassHeight))
+						err = s.decodeAggregate(symbolWidth, uint32(heightClassHeight))
 						if err != nil {
 							return nil, err
 						}
 					}
 				} else if s.isHuffmanEncoded && !s.useRefinementAggregation {
 					// 4 c) iii)
-					newSymbolsWidth[s.numberOfDecodedSymbols] = symbolWidth
+					newSymbolsWidth[s.numberOfDecodedSymbols] = int(symbolWidth)
 				}
 				s.numberOfDecodedSymbols++
 			}
@@ -207,7 +206,7 @@ func (s *SymbolDictionary) GetDictionary() ([]*bitmap.Bitmap, error) {
 
 				var heightClassCollectiveBitmap *bitmap.Bitmap
 				heightClassCollectiveBitmap, err = s.decodeHeightClassCollectiveBitmap(
-					bmSize, int(heightClassHeight), totalWidth)
+					bmSize, uint32(heightClassHeight), totalWidth)
 				if err != nil {
 					return nil, err
 				}
@@ -345,10 +344,10 @@ func (s *SymbolDictionary) addSymbol(region Regioner) error {
 
 func (s *SymbolDictionary) decodeHeightClassBitmap(
 	heightClassCollectiveBitmap *bitmap.Bitmap,
-	heightClassFirstSymbol, heightClassHeight int,
+	heightClassFirstSymbol int64, heightClassHeight int,
 	newSymbolsWidths []int,
 ) error {
-	for i := heightClassFirstSymbol; i < s.numberOfDecodedSymbols; i++ {
+	for i := heightClassFirstSymbol; i < int64(s.numberOfDecodedSymbols); i++ {
 		var startColumn int
 
 		for j := heightClassFirstSymbol; j <= i-1; j++ {
@@ -366,7 +365,7 @@ func (s *SymbolDictionary) decodeHeightClassBitmap(
 	return nil
 }
 
-func (s *SymbolDictionary) decodeAggregate(symbolWidth, heightClassHeight int) error {
+func (s *SymbolDictionary) decodeAggregate(symbolWidth, heightClassHeight uint32) error {
 	var (
 		numberOfRefinementAggregationInstances int64
 		err                                    error
@@ -388,17 +387,14 @@ func (s *SymbolDictionary) decodeAggregate(symbolWidth, heightClassHeight int) e
 
 	if numberOfRefinementAggregationInstances > 1 {
 		// 6.5.8.2
-		return s.decodeThroughTextRegion(symbolWidth, heightClassHeight, numberOfRefinementAggregationInstances)
+		return s.decodeThroughTextRegion(symbolWidth, heightClassHeight, uint32(numberOfRefinementAggregationInstances))
 	} else if numberOfRefinementAggregationInstances == 1 {
 		return s.decodeRefinedSymbol(symbolWidth, heightClassHeight)
 	}
-
 	return nil
 }
 
-func (s *SymbolDictionary) decodeThroughTextRegion(
-	symbolWidth, heightClassHeight int, numberOfRefinementAggregationInstances int64,
-) error {
+func (s *SymbolDictionary) decodeThroughTextRegion(symbolWidth, heightClassHeight, numberOfRefinementAggregationInstances uint32) error {
 	if s.textRegion == nil {
 		s.textRegion = newTextRegion(s.r, nil)
 
@@ -426,9 +422,10 @@ func (s *SymbolDictionary) decodeThroughTextRegion(
 	return s.addSymbol(s.textRegion)
 }
 
-func (s *SymbolDictionary) decodeRefinedSymbol(symbolWidth, heightClassHeight int) error {
+func (s *SymbolDictionary) decodeRefinedSymbol(symbolWidth, heightClassHeight uint32) error {
 	var (
-		id, rdx, rdy int
+		id       int
+		rdx, rdy int32
 	)
 
 	if s.isHuffmanEncoded {
@@ -448,13 +445,13 @@ func (s *SymbolDictionary) decodeRefinedSymbol(symbolWidth, heightClassHeight in
 		if err != nil {
 			return err
 		}
-		rdx = int(iv)
+		rdx = int32(iv)
 
 		iv, err = st.Decode(s.r)
 		if err != nil {
 			return err
 		}
-		rdy = int(iv)
+		rdy = int32(iv)
 
 		st, err = huffman.GetStandardTable(1)
 		if err != nil {
@@ -501,7 +498,7 @@ func (s *SymbolDictionary) decodeRefinedSymbol(symbolWidth, heightClassHeight in
 	return nil
 }
 
-func (s *SymbolDictionary) decodeNewSymbols(symWidth, hcHeight int, ibo *bitmap.Bitmap, rdx, rdy int) error {
+func (s *SymbolDictionary) decodeNewSymbols(symWidth, hcHeight uint32, ibo *bitmap.Bitmap, rdx, rdy int32) error {
 	if s.genericRefinementRegion == nil {
 		s.genericRefinementRegion = newGenericRefinementRegion(s.r, nil)
 
@@ -521,7 +518,7 @@ func (s *SymbolDictionary) decodeNewSymbols(symWidth, hcHeight int, ibo *bitmap.
 	return s.addSymbol(s.genericRefinementRegion)
 }
 
-func (s *SymbolDictionary) decodeDirectlyThroughGenericRegion(symWidth, hcHeight int) error {
+func (s *SymbolDictionary) decodeDirectlyThroughGenericRegion(symWidth, hcHeight uint32) error {
 	if s.genericRegion == nil {
 		s.genericRegion = NewGenericRegion(s.r)
 	}
@@ -563,6 +560,9 @@ func (s *SymbolDictionary) decodeDifferenceWidth() (int64, error) {
 		if err != nil {
 			return 0, err
 		}
+		if i == math.MaxInt32 {
+			return int64(math.MaxInt64), nil
+		}
 		return int64(i), nil
 	}
 	return 0, nil
@@ -611,10 +611,10 @@ func (s *SymbolDictionary) decodeHeightClassDeltaHeightWithHuffman() (int64, err
 }
 
 func (s *SymbolDictionary) decodeHeightClassCollectiveBitmap(
-	bmSize int64, heightClassHeight, totalWidth int,
+	bmSize int64, heightClassHeight, totalWidth uint32,
 ) (*bitmap.Bitmap, error) {
 	if bmSize == 0 {
-		heightClassColleciveBitmap := bitmap.New(totalWidth, heightClassHeight)
+		heightClassColleciveBitmap := bitmap.New(int(totalWidth), int(heightClassHeight))
 		var (
 			b   byte
 			err error
@@ -645,8 +645,8 @@ func (s *SymbolDictionary) decodeHeightClassCollectiveBitmap(
 }
 
 // getSbSymCodeLen 6.5.8.2.3 sets the SBSYMCODES variable.
-func (s *SymbolDictionary) getSbSymCodeLen() int {
-	first := int(math.Ceil(
+func (s *SymbolDictionary) getSbSymCodeLen() int8 {
+	first := int8(math.Ceil(
 		math.Log(float64(s.numberOfImportedSymbols+s.numberOfNewSymbols)) / math.Log(2)))
 
 	if s.isHuffmanEncoded && first < 1 {
@@ -659,13 +659,13 @@ func (s *SymbolDictionary) getSbSymCodeLen() int {
 func (s *SymbolDictionary) getToExportFlags() ([]int, error) {
 	var (
 		currentExportFlag int
-		exRunLength       int
+		exRunLength       int32
 		err               error
-		totalNewSymbols   = s.numberOfImportedSymbols + s.numberOfNewSymbols
+		totalNewSymbols   = int32(s.numberOfImportedSymbols + s.numberOfNewSymbols)
 		exportFlags       = make([]int, totalNewSymbols)
 	)
 
-	for exportIndex := 0; exportIndex < totalNewSymbols; exportIndex += exRunLength {
+	for exportIndex := int32(0); exportIndex < totalNewSymbols; exportIndex += exRunLength {
 		if s.isHuffmanEncoded {
 			t, err := huffman.GetStandardTable(1)
 			if err != nil {
@@ -676,7 +676,7 @@ func (s *SymbolDictionary) getToExportFlags() ([]int, error) {
 			if err != nil {
 				return nil, err
 			}
-			exRunLength = int(i)
+			exRunLength = int32(i)
 		} else {
 			exRunLength, err = s.arithmeticDecoder.DecodeInt(s.cxIAEX)
 			if err != nil {
@@ -972,7 +972,7 @@ func (s *SymbolDictionary) readNumberOfExportedSymbols() error {
 	if err != nil {
 		return err
 	}
-	s.numberOfExportedSymbols = int(bits & 0xffffffff)
+	s.numberOfExportedSymbols = uint32(bits & math.MaxUint32)
 	return nil
 }
 
@@ -981,7 +981,7 @@ func (s *SymbolDictionary) readNumberOfNewSymbols() error {
 	if err != nil {
 		return err
 	}
-	s.numberOfNewSymbols = int(bits & 0xffffffff)
+	s.numberOfNewSymbols = uint32(bits & math.MaxUint32)
 	return nil
 }
 
@@ -1066,7 +1066,7 @@ func (s *SymbolDictionary) setCodingStatistics() error {
 }
 
 func (s *SymbolDictionary) setExportedSymbols(toExportFlags []int) {
-	for i := 0; i < s.numberOfImportedSymbols+s.numberOfNewSymbols; i++ {
+	for i := uint32(0); i < s.numberOfImportedSymbols+s.numberOfNewSymbols; i++ {
 		if toExportFlags[i] == 1 {
 			if i < s.numberOfImportedSymbols {
 				s.exportSymbols = append(s.exportSymbols, s.importSymbols[i])
diff --git a/internal/jbig2/segments/symbol-dictionary_test.go b/internal/jbig2/segments/symbol-dictionary_test.go
index 23652c47e..58ce493d0 100644
--- a/internal/jbig2/segments/symbol-dictionary_test.go
+++ b/internal/jbig2/segments/symbol-dictionary_test.go
@@ -13,6 +13,7 @@ import (
 
 	"github.com/unidoc/unipdf/v3/common"
 
+	"github.com/unidoc/unipdf/v3/internal/jbig2/bitmap"
 	"github.com/unidoc/unipdf/v3/internal/jbig2/reader"
 )
 
@@ -46,16 +47,15 @@ func TestSymbolDictionaryDecode(t *testing.T) {
 
 		assert.True(t, s.isHuffmanEncoded)
 		assert.False(t, s.useRefinementAggregation)
-		assert.Equal(t, 1, s.numberOfExportedSymbols)
-		assert.Equal(t, 1, s.numberOfNewSymbols)
+		assert.Equal(t, uint32(1), s.numberOfExportedSymbols)
+		assert.Equal(t, uint32(1), s.numberOfNewSymbols)
 
 		bm, err := s.GetDictionary()
 		require.NoError(t, err)
 
-		if assert.NotEmpty(t, bm) {
-			for _, b := range bm {
-				t.Logf("Bitmap: %s", b.String())
-			}
+		assert.NotEmpty(t, bm)
+		if assert.Len(t, bm, 1) {
+			isLetterP(t, bm[0])
 		}
 	})
 
@@ -88,16 +88,16 @@ func TestSymbolDictionaryDecode(t *testing.T) {
 
 		assert.True(t, s.isHuffmanEncoded)
 		assert.False(t, s.useRefinementAggregation)
-		assert.Equal(t, 2, s.numberOfExportedSymbols)
-		assert.Equal(t, 2, s.numberOfNewSymbols)
+		assert.Equal(t, uint32(2), s.numberOfExportedSymbols)
+		assert.Equal(t, uint32(2), s.numberOfNewSymbols)
 
 		bm, err := s.GetDictionary()
 		require.NoError(t, err)
 
-		if assert.NotEmpty(t, bm) {
-			for _, b := range bm {
-				t.Logf("Bitmap: %s", b.String())
-			}
+		if assert.Len(t, bm, 2) {
+			// first letter should be a 'c'
+			isLetterC(t, bm[0])
+			isLetterA(t, bm[1])
 		}
 	})
 
@@ -136,16 +136,15 @@ func TestSymbolDictionaryDecode(t *testing.T) {
 		assert.Equal(t, int8(2), s.sdATX[0])
 		assert.Equal(t, int8(-1), s.sdATY[0])
 
-		assert.Equal(t, 2, s.numberOfExportedSymbols)
-		assert.Equal(t, 2, s.numberOfNewSymbols)
+		assert.Equal(t, uint32(2), s.numberOfExportedSymbols)
+		assert.Equal(t, uint32(2), s.numberOfNewSymbols)
 
 		bm, err := s.GetDictionary()
 		require.NoError(t, err)
 
-		if assert.NotEmpty(t, bm) {
-			for _, b := range bm {
-				t.Logf("Bitmap: %s", b.String())
-			}
+		if assert.Len(t, bm, 2) {
+			isLetterC(t, bm[0])
+			isLetterA(t, bm[1])
 		}
 	})
 
@@ -204,16 +203,14 @@ func TestSymbolDictionaryDecode(t *testing.T) {
 			assert.Equal(t, s.sdATY[0], int8(-1))
 		}
 
-		assert.Equal(t, 1, s.numberOfExportedSymbols)
-		assert.Equal(t, 1, s.numberOfNewSymbols)
+		assert.Equal(t, uint32(1), s.numberOfExportedSymbols)
+		assert.Equal(t, uint32(1), s.numberOfNewSymbols)
 
 		bm, err := s.GetDictionary()
 		require.NoError(t, err)
 
-		if assert.NotEmpty(t, bm) {
-			for _, b := range bm {
-				t.Logf("Bitmap: %s", b.String())
-			}
+		if assert.Len(t, bm, 1) {
+			isLetterA(t, bm[0])
 		}
 	})
 }
@@ -225,3 +222,111 @@ func setLogger() {
 		common.SetLogger(common.NewConsoleLogger(common.LogLevelDebug))
 	}
 }
+
+func isLetterP(t *testing.T, b *bitmap.Bitmap) {
+	if b.Width != 5 || b.Height != 8 {
+		t.Fail()
+		return
+	}
+
+	for y := 0; y < b.Height; y++ {
+		for x := 0; x < b.Width; x++ {
+			pix := b.GetPixel(x, y)
+
+			switch y {
+			case 0, 4:
+				if x != 4 {
+					assert.True(t, pix)
+				} else {
+					assert.False(t, pix)
+				}
+			case 1, 2, 3:
+				if x == 0 || x == 4 {
+					assert.True(t, pix)
+				} else {
+					assert.False(t, pix)
+				}
+			case 5, 6, 7:
+				if x == 0 {
+					assert.True(t, pix)
+				} else {
+					assert.False(t, pix)
+				}
+			}
+		}
+	}
+}
+
+func isLetterC(t *testing.T, b *bitmap.Bitmap) {
+	if b.Width != 6 || b.Height != 6 {
+		t.Fail()
+		return
+	}
+
+	for y := 0; y < b.Height; y++ {
+		for x := 0; x < b.Width; x++ {
+			pix := b.GetPixel(x, y)
+
+			switch y {
+			case 0, 5:
+				if x == 0 || x == 5 {
+					assert.False(t, pix)
+				} else {
+					assert.True(t, pix)
+				}
+			case 1, 4:
+				if x == 0 || x == 5 {
+					assert.True(t, pix)
+				} else {
+					assert.False(t, pix)
+				}
+			default:
+				if x == 0 {
+					assert.True(t, pix)
+				} else {
+					assert.False(t, pix)
+				}
+			}
+		}
+	}
+}
+
+func isLetterA(t *testing.T, b *bitmap.Bitmap) {
+	if b.Width != 6 || b.Height != 6 {
+		t.Fail()
+		return
+	}
+
+	for y := 0; y < b.Height; y++ {
+		for x := 0; x < b.Width; x++ {
+			pix := b.GetPixel(x, y)
+
+			switch y {
+			case 0:
+				if x == 0 || x == 5 {
+					assert.False(t, pix)
+				} else {
+					assert.True(t, pix)
+				}
+			case 1:
+				if x == 5 {
+					assert.True(t, pix)
+				} else {
+					assert.False(t, pix)
+				}
+			case 2, 5:
+				if x == 0 {
+					assert.False(t, pix)
+				} else {
+					assert.True(t, pix)
+				}
+			default:
+				if x == 0 || x == 5 {
+					assert.True(t, pix)
+				} else {
+					assert.False(t, pix)
+				}
+			}
+		}
+	}
+}
diff --git a/internal/jbig2/segments/table_segment.go b/internal/jbig2/segments/table_segment.go
index 8091f575a..3484c2d50 100644
--- a/internal/jbig2/segments/table_segment.go
+++ b/internal/jbig2/segments/table_segment.go
@@ -7,6 +7,7 @@ package segments
 
 import (
 	"fmt"
+	"math"
 
 	"github.com/unidoc/unipdf/v3/internal/jbig2/decoder/huffman"
 	"github.com/unidoc/unipdf/v3/internal/jbig2/reader"
@@ -17,15 +18,15 @@ type TableSegment struct {
 	r reader.StreamReader
 
 	// Code Table Flags B.2.1
-	htOutOfBand int
-	htPS        int
-	htRS        int
+	htOutOfBand int32
+	htPS        int32
+	htRS        int32
 
 	// Code Table lowest value B.2.2
-	htLow int
+	htLow int32
 
 	// Code Table highest value B.2.3
-	htHight int
+	htHight int32
 }
 
 // Compile time check if the TableSegment implements huffman.BasicTabler.
@@ -39,27 +40,27 @@ func (t *TableSegment) Init(h *Header, r reader.StreamReader) error {
 }
 
 // HtPS implements huffman.BasicTabler interface.
-func (t *TableSegment) HtPS() int {
+func (t *TableSegment) HtPS() int32 {
 	return t.htPS
 }
 
 // HtRS implements huffman.BasicTabler interface.
-func (t *TableSegment) HtRS() int {
+func (t *TableSegment) HtRS() int32 {
 	return t.htRS
 }
 
 // HtLow implements huffman.BasicTabler interface.
-func (t *TableSegment) HtLow() int {
+func (t *TableSegment) HtLow() int32 {
 	return t.htLow
 }
 
 // HtHigh implements huffman.BasicTabler interface.
-func (t *TableSegment) HtHigh() int {
+func (t *TableSegment) HtHigh() int32 {
 	return t.htHight
 }
 
 // HtOOB implements huffman.BasicTabler interface.
-func (t *TableSegment) HtOOB() int {
+func (t *TableSegment) HtOOB() int32 {
 	return t.htOutOfBand
 }
 
@@ -87,24 +88,24 @@ func (t *TableSegment) parseHeader() error {
 	if bits, err = t.r.ReadBits(3); err != nil {
 		return err
 	}
-	t.htRS = (int(bits) + 1) & 0xf
+	t.htRS = (int32(bits) + 1) & 0xf
 
 	// Bit 1-3
 	if bits, err = t.r.ReadBits(3); err != nil {
 		return err
 	}
-	t.htPS = (int(bits) + 1) & 0xf
+	t.htPS = (int32(bits) + 1) & 0xf
 
 	// 4 bytes
 	if bits, err = t.r.ReadBits(32); err != nil {
 		return err
 	}
-	t.htLow = int(bits & 0xffffffff)
+	t.htLow = int32(bits & math.MaxInt32)
 
 	// 4 bytes
 	if bits, err = t.r.ReadBits(32); err != nil {
 		return err
 	}
-	t.htHight = int(bits & 0xffffffff)
+	t.htHight = int32(bits & math.MaxInt32)
 	return nil
 }
diff --git a/internal/jbig2/segments/text-region.go b/internal/jbig2/segments/text-region.go
index 921f9397e..a5abb4df4 100644
--- a/internal/jbig2/segments/text-region.go
+++ b/internal/jbig2/segments/text-region.go
@@ -52,11 +52,11 @@ type TextRegion struct {
 	sbrATY []int8
 
 	// Number of symbol instances 7.4.3.1.3.
-	numberOfSymbolInstances int64
+	numberOfSymbolInstances uint32
 
 	currentS        int64
-	sbStrips        int
-	numberOfSymbols int
+	sbStrips        int8
+	numberOfSymbols uint32
 
 	regionBitmap *bitmap.Bitmap
 	symbols      []*bitmap.Bitmap
@@ -77,7 +77,7 @@ type TextRegion struct {
 	cx      *arithmetic.DecoderStats
 
 	// symbolCodeTable includes a code to each symbol used in that region.
-	symbolCodeLength int
+	symbolCodeLength int8
 	symbolCodeTable  *huffman.FixedSizeTable
 	Header           *Header
 
@@ -214,7 +214,7 @@ func (t *TextRegion) computeSymbolCodeLength() error {
 		return t.symbolIDCodeLengths()
 	}
 
-	t.symbolCodeLength = int(math.Ceil(math.Log(float64(t.numberOfSymbols)) / math.Log(2)))
+	t.symbolCodeLength = int8(math.Ceil(math.Log(float64(t.numberOfSymbols)) / math.Log(2)))
 	return nil
 }
 
@@ -261,8 +261,7 @@ func (t *TextRegion) checkInput() error {
 
 func (t *TextRegion) createRegionBitmap() error {
 	// 6.4.5
-	t.regionBitmap = bitmap.New(t.regionInfo.BitmapWidth, t.regionInfo.BitmapHeight)
-
+	t.regionBitmap = bitmap.New(int(t.regionInfo.BitmapWidth), int(t.regionInfo.BitmapHeight))
 	if t.defaultPixel != 0 {
 		t.regionBitmap.SetDefaultPixel()
 	}
@@ -307,7 +306,7 @@ func (t *TextRegion) decodeStripT() (stripT int64, err error) {
 			}
 		}
 	} else {
-		var temp int
+		var temp int32
 		temp, err = t.arithmDecoder.DecodeInt(t.cxIADT)
 		if err != nil {
 			return 0, err
@@ -325,7 +324,10 @@ func (t *TextRegion) decodeSymbolInstances() error {
 	}
 
 	// Last two sentences of 6.4.5 2)
-	var firstS, instanceCounter int64
+	var (
+		firstS          int64
+		instanceCounter uint32
+	)
 
 	// 6.4.5 3)
 	for instanceCounter < t.numberOfSymbolInstances {
@@ -361,7 +363,7 @@ func (t *TextRegion) decodeSymbolInstances() error {
 					return err
 				}
 
-				if idS == math.MaxInt64 || instanceCounter >= t.numberOfSymbolInstances {
+				if idS == math.MaxInt32 || instanceCounter >= t.numberOfSymbolInstances {
 					break
 				}
 
@@ -424,7 +426,7 @@ func (t *TextRegion) decodeDT() (dT int64, err error) {
 			}
 		}
 	} else {
-		var temp int
+		var temp int32
 		temp, err = t.arithmDecoder.DecodeInt(t.cxIADT)
 		if err != nil {
 			return
@@ -545,17 +547,17 @@ func (t *TextRegion) decodeIb(r, id int64) (*bitmap.Bitmap, error) {
 
 	// 6)
 	ibo := t.symbols[id]
-	wo := ibo.Width
-	ho := ibo.Height
-	genericRegionReferenceDX := int(uint(rdw)>>1) + int(rdx)
-	genericRegionReferenceDY := int(uint(rdh)>>1) + int(rdy)
+	wo := uint32(ibo.Width)
+	ho := uint32(ibo.Height)
+	genericRegionReferenceDX := int32(uint32(rdw)>>1) + int32(rdx)
+	genericRegionReferenceDY := int32(uint32(rdh)>>1) + int32(rdy)
 
 	if t.genericRefinementRegion == nil {
 		t.genericRefinementRegion = newGenericRefinementRegion(t.r, nil)
 	}
 
 	t.genericRefinementRegion.setParameters(t.cx, t.arithmDecoder, t.sbrTemplate,
-		wo+int(rdw), ho+int(rdh), ibo, genericRegionReferenceDX, genericRegionReferenceDY, false, t.sbrATX, t.sbrATY)
+		wo+uint32(rdw), ho+uint32(rdh), ibo, genericRegionReferenceDX, genericRegionReferenceDY, false, t.sbrATX, t.sbrATY)
 
 	ib, err = t.genericRefinementRegion.GetRegionBitmap()
 	if err != nil {
@@ -883,7 +885,7 @@ func (t *TextRegion) initSymbols() error {
 			t.symbols = append(t.symbols, dict...)
 		}
 	}
-	t.numberOfSymbols = len(t.symbols)
+	t.numberOfSymbols = uint32(len(t.symbols))
 	return nil
 }
 
@@ -1136,10 +1138,8 @@ func (t *TextRegion) readAmountOfSymbolInstances() error {
 	if err != nil {
 		return err
 	}
-
-	bits &= 0xffffffff
-	t.numberOfSymbolInstances = int64(bits)
-	pixels := int64(t.regionInfo.BitmapWidth * t.regionInfo.BitmapHeight)
+	t.numberOfSymbolInstances = uint32(bits & math.MaxUint32)
+	pixels := t.regionInfo.BitmapWidth * t.regionInfo.BitmapHeight
 
 	if pixels < t.numberOfSymbolInstances {
 		common.Log.Debug("Limiting the number of decoded symbol instances to one per pixel ( %d instead of %d)", pixels, t.numberOfSymbolInstances)
@@ -1221,12 +1221,12 @@ func (t *TextRegion) setContexts(
 // setParameters sets the text region segment parameters.
 func (t *TextRegion) setParameters(
 	arithmeticDecoder *arithmetic.Decoder,
-	isHuffmanEncoded, sbRefine bool, sbw, sbh int,
-	sbNumInstances int64, sbStrips, sbNumSyms int,
+	isHuffmanEncoded, sbRefine bool, sbw, sbh uint32,
+	sbNumInstances uint32, sbStrips int8, sbNumSyms uint32,
 	sbDefaultPixel int8, sbCombinationOperator bitmap.CombinationOperator,
 	transposed int8, refCorner int16, sbdsOffset, sbHuffFS, sbHuffDS, sbHuffDT, sbHuffRDWidth,
 	sbHuffRDHeight, sbHuffRDX, sbHuffRDY, sbHuffRSize, sbrTemplate int8,
-	sbrATX, sbrATY []int8, sbSyms []*bitmap.Bitmap, sbSymCodeLen int,
+	sbrATX, sbrATY []int8, sbSyms []*bitmap.Bitmap, sbSymCodeLen int8,
 ) {
 	t.arithmDecoder = arithmeticDecoder
 
@@ -1277,7 +1277,7 @@ func (t *TextRegion) symbolIDCodeLengths() error {
 
 		prefLen := int(bits & 0xf)
 		if prefLen > 0 {
-			runCodeTable = append(runCodeTable, huffman.NewCode(prefLen, 0, i, false))
+			runCodeTable = append(runCodeTable, huffman.NewCode(int32(prefLen), 0, int32(i), false))
 		}
 	}
 
@@ -1289,7 +1289,7 @@ func (t *TextRegion) symbolIDCodeLengths() error {
 	// 3) - 5)
 	var (
 		previousCodeLength int64
-		counter            int
+		counter            uint32
 		sbSymCodes         []*huffman.Code
 		code               int64
 	)
@@ -1302,7 +1302,7 @@ func (t *TextRegion) symbolIDCodeLengths() error {
 
 		if code < 32 {
 			if code > 0 {
-				sbSymCodes = append(sbSymCodes, huffman.NewCode(int(code), 0, counter, false))
+				sbSymCodes = append(sbSymCodes, huffman.NewCode(int32(code), 0, int32(counter), false))
 			}
 			previousCodeLength = code
 			counter++
@@ -1335,7 +1335,7 @@ func (t *TextRegion) symbolIDCodeLengths() error {
 
 			for j := 0; j < int(runLength); j++ {
 				if currCodeLength > 0 {
-					sbSymCodes = append(sbSymCodes, huffman.NewCode(int(currCodeLength), 0, counter, false))
+					sbSymCodes = append(sbSymCodes, huffman.NewCode(int32(currCodeLength), 0, int32(counter), false))
 				}
 				counter++
 			}