diff --git a/ftk/src/ftk.h b/ftk/src/ftk.h
index 300dc1d..f1a192b 100644
--- a/ftk/src/ftk.h
+++ b/ftk/src/ftk.h
@@ -1618,13 +1618,13 @@
 		virtual void FLMAPI randomize( void) = 0;
 
 		virtual void FLMAPI setSeed(
-			FLMINT32					i32seed) = 0;
+			FLMUINT32				ui32seed) = 0;
 			
-		virtual FLMINT32 FLMAPI getSeed( void) = 0;
+		virtual FLMUINT32 FLMAPI getSeed( void) = 0;
 
-		virtual FLMINT32 FLMAPI getINT32(
-			FLMINT32 				i32Low = FLM_MIN_INT32,
-			FLMINT32 				i32High = FLM_MAX_INT32) = 0;
+		virtual FLMUINT32 FLMAPI getUINT32(
+			FLMUINT32 				ui32Low = 0,
+			FLMUINT32 				ui32High = FLM_MAX_UINT32) = 0;
 
 		virtual FLMBOOL FLMAPI getBoolean( void) = 0;
 	};
diff --git a/ftk/src/ftkrand.cpp b/ftk/src/ftkrand.cpp
index a39c32d..a964894 100644
--- a/ftk/src/ftkrand.cpp
+++ b/ftk/src/ftkrand.cpp
@@ -73,24 +73,24 @@ public:
 	void FLMAPI randomize( void);
 
 	void FLMAPI setSeed(
-		FLMINT32		i32seed);
+		FLMUINT32	ui32seed);
 
-	FLMINT32 FLMAPI getINT32( void);
+	FLMUINT32 FLMAPI getUINT32( void);
 		
-	FLMINT32 FLMAPI getINT32(
-		FLMINT32 	i32Low,
-		FLMINT32 	i32High);
+	FLMUINT32 FLMAPI getUINT32(
+		FLMUINT32 	ui32Low,
+		FLMUINT32 	ui32High);
 
 	FLMBOOL FLMAPI getBoolean( void);
 
-	FLMINT32 FLMAPI getSeed( void)
+	FLMUINT32 FLMAPI getSeed( void)
 	{
-		return( m_i32Seed);
+		return( m_ui32Seed);
 	}
 
 private:
 
-	FLMINT32			m_i32Seed;
+	FLMUINT32			m_ui32Seed;
 };
 
 /****************************************************************************
@@ -122,18 +122,17 @@ void	F_RandomGenerator::randomize( void)
 Desc:	initialize the seed to a known value
 *************************************************************************/
 void F_RandomGenerator::setSeed(
-	FLMINT32				i32Seed)
+	FLMUINT32				ui32Seed)
 {
-	if( i32Seed > 0 && i32Seed <= MAX_RANDOM)
+	if( ui32Seed > 0 && ui32Seed <= MAX_RANDOM)
 	{
-		m_i32Seed = i32Seed;
+		m_ui32Seed = ui32Seed;
 	}
 	else
 	{
-		setSeed( (FLMUINT32) 
-			(i32Seed < 1
-				? i32Seed + MAX_RANDOM
-				: i32Seed - MAX_RANDOM));
+		setSeed( ui32Seed > MAX_RANDOM 
+						? ui32Seed - MAX_RANDOM 
+						: 1);
 	}
 }
 
@@ -143,7 +142,7 @@ Desc:	Generate the next number in the pseudo-random sequence
 		time,	on average.  Likewise, "f_randomLong( &r) & 0x1" has a 50-50
 		chance of being true.
 *************************************************************************/
-FLMINT32 F_RandomGenerator::getINT32( void)
+FLMUINT32 F_RandomGenerator::getUINT32( void)
 {
 #define M		2147483647
 #define A		48271
@@ -151,7 +150,7 @@ FLMINT32 F_RandomGenerator::getINT32( void)
 
 	FLMUINT32 	ui32High;
 	FLMUINT32 	ui32Low;
-	FLMUINT32 	ui32Seed = m_i32Seed;
+	FLMUINT32 	ui32Seed = m_ui32Seed;
 
 	ui32High = (ui32Seed >> 16);
 	ui32Low = ui32Seed & 0xFFFF;
@@ -171,39 +170,48 @@ FLMINT32 F_RandomGenerator::getINT32( void)
 		ui32Low++;
 	}
 
-	return( m_i32Seed = ui32Low);
+	return( m_ui32Seed = ui32Low);
 }
 
 /*************************************************************************
 Desc:	Returns a random integer between i32Low and i32High, inclusive.
 *************************************************************************/
-FLMINT32 F_RandomGenerator::getINT32(
-	FLMINT32				i32Low,
-	FLMINT32				i32High)
+FLMUINT32 F_RandomGenerator::getUINT32(
+	FLMUINT32			ui32Low,
+	FLMUINT32			ui32High)
 {
-	FLMINT32 	i32Range = i32High - i32Low + 1;
-
-	if( i32Range < (1L << 20))
+	FLMUINT32 			ui32Range;
+	
+	if( ui32Low > ui32High)
 	{
-		return( i32Low + getINT32() % i32Range);
+		ui32Range = ui32Low - ui32High + 1;
 	}
 	else
 	{
-		FLMINT32 	i32Mask = 0;
-		FLMINT32 	i32Val;
+		ui32Range = ui32High - ui32Low + 1;
+	}
 
-		i32Range--;
-		for( i32Val = i32Range; i32Val > 0; i32Val >>= 1)
+	if( ui32Range < (1L << 20))
+	{
+		return( ui32Low + getUINT32() % ui32Range);
+	}
+	else
+	{
+		FLMUINT32 	ui32Mask = 0;
+		FLMUINT32 	ui32Val;
+
+		ui32Range--;
+		for( ui32Val = ui32Range; ui32Val > 0; ui32Val >>= 1)
 		{
-			i32Mask = (i32Mask << 1) | 1;
+			ui32Mask = (ui32Mask << 1) | 1;
 		}
 
 		do
 		{
-			i32Val = getINT32() & i32Mask;
-		}	while( i32Val > i32Range);
+			ui32Val = getUINT32() & ui32Mask;
+		}	while( ui32Val > ui32Range);
 
-		return( i32Low + i32Val);
+		return( ui32Low + ui32Val);
 	}
 }
 
@@ -212,5 +220,5 @@ Desc:
 *************************************************************************/
 FLMBOOL F_RandomGenerator::getBoolean( void)
 {
-	return( (getINT32( 1, 100) <= 50 ? TRUE : FALSE));
+	return( (getUINT32( 1, 100) <= 50 ? TRUE : FALSE));
 }
diff --git a/xflaim/src/fbtrset.cpp b/xflaim/src/fbtrset.cpp
index f4da94d..1271321 100644
--- a/xflaim/src/fbtrset.cpp
+++ b/xflaim/src/fbtrset.cpp
@@ -132,7 +132,7 @@ TryAgain:
 
 			// Randomly select a collection number to use.
 
-			uiCollection = pRandGen->getINT32( 100, XFLM_MAX_COLLECTION_NUM);
+			uiCollection = pRandGen->getUINT32( 100, XFLM_MAX_COLLECTION_NUM);
 
 			// Check to see if it already exists.
 			if (RC_BAD( rc = pDatabase->lFileCreate( m_pResultSetDb,
diff --git a/xflaim/src/flchkdb.cpp b/xflaim/src/flchkdb.cpp
index 8c5053b..cac9990 100644
--- a/xflaim/src/flchkdb.cpp
+++ b/xflaim/src/flchkdb.cpp
@@ -95,7 +95,7 @@ RCODE F_DbCheck::createAndOpenResultSetDb( void)
 		// Generate a random file name
 		
 		f_sprintf( m_szResultSetDibName,
-					  "%d.db", (int)m_pRandGen->getINT32( 100, 20000));
+					  "%d.db", (int)m_pRandGen->getUINT32( 100, 20000));
 		
 		if (RC_OK( rc = dbSystem.dbCreate( m_szResultSetDibName, NULL, NULL,
 								NULL, NULL, &createOpts, TRUE,
@@ -189,7 +189,7 @@ RCODE F_DbCheck::getBtResultSet(
 
 		// Now create a new collection.  Randomly select a collection number to use.
 		
-		uiCollection = m_pRandGen->getINT32( 100, XFLM_MAX_COLLECTION_NUM);
+		uiCollection = m_pRandGen->getUINT32( 100, XFLM_MAX_COLLECTION_NUM);
 	
 		// Check to see if it already exists.
 		
diff --git a/xflaim/src/fsysdata.cpp b/xflaim/src/fsysdata.cpp
index 2f4e57d..94fb00c 100644
--- a/xflaim/src/fsysdata.cpp
+++ b/xflaim/src/fsysdata.cpp
@@ -135,8 +135,8 @@ RCODE flmAllocHashTbl(
 	{
 		for( uiCnt = 0; uiCnt < uiHashTblSize - 1; uiCnt++)
 		{
-			uiRandVal = (FLMBYTE) pRandGen->getINT32( (FLMINT32)uiCnt,
-										(FLMINT32)(uiHashTblSize - 1));
+			uiRandVal = (FLMBYTE) pRandGen->getUINT32( (FLMUINT32)uiCnt,
+										(FLMUINT32)(uiHashTblSize - 1));
 			if( uiRandVal != uiCnt)
 			{
 				uiTempVal = (FLMBYTE)pHashTbl [uiCnt].uiHashValue;
diff --git a/xflaim/util/binarytest.cpp b/xflaim/util/binarytest.cpp
index ebeb0dc..9dfb9d0 100644
--- a/xflaim/util/binarytest.cpp
+++ b/xflaim/util/binarytest.cpp
@@ -534,7 +534,7 @@ RCODE IBinaryTestImpl::encryptionTest(
 	{
 		if ( uiTotalBytesRead < ui64TotalSize)
 		{
-			uiChunkSize = pRand->getINT32( 1, 
+			uiChunkSize = pRand->getUINT32( 1, 
 									(FLMUINT32)(ui64TotalSize - uiTotalBytesRead));
 
 			if ( pszBuffer)