pylcg

diff --git a/README.md b/README.md
@@ -10,7 +10,7 @@ PyLCG is a high-performance Python implementation of a memory-efficient IP addre
 - High-performance LCG implementation
 - Support for sharding across multiple machines
 - Zero dependencies beyond Python standard library
-- Simple command-line interface
+- Simple command-line interface and library usage
 
 ## Installation
 
@@ -24,6 +24,21 @@ pip install pylcg
 
 ```bash
 pylcg 192.168.0.0/16 --shard-num 1 --total-shards 4 --seed 12345
+
+# Resume from previous state
+pylcg 192.168.0.0/16 --shard-num 1 --total-shards 4 --seed 12345 --state 987654321
+
+# Pipe to dig for PTR record lookups
+pylcg 192.168.0.0/16 --seed 12345 | while read ip; do
+    echo -n "$ip -> "
+    dig +short -x $ip
+done
+
+# One-liner for PTR lookups
+pylcg 198.150.0.0/16 | xargs -I {} dig +short -x {}
+
+# Parallel PTR lookups
+pylcg 198.150.0.0/16 | parallel "dig +short -x {} | sed 's/^/{} -> /'"
 ```
 
 ### As a Library
@@ -31,55 +46,103 @@ pylcg 192.168.0.0/16 --shard-num 1 --total-shards 4 --seed 12345
 ```python
 from pylcg import ip_stream
 
-# Generate IPs for the first shard of 4 total shards
+# Basic usage
 for ip in ip_stream('192.168.0.0/16', shard_num=1, total_shards=4, seed=12345):
     print(ip)
+
+# Resume from previous state
+for ip in ip_stream('192.168.0.0/16', shard_num=1, total_shards=4, seed=12345, state=987654321):
+    print(ip)
+```
+
+## State Management & Resume Capability
+
+PyLCG automatically saves its state every 1000 IPs processed to enable resume functionality in case of interruption. The state is saved to a temporary file in your system's temp directory (usually `/tmp` on Unix systems or `%TEMP%` on Windows).
+
+The state file follows the naming pattern:
+```
+pylcg_[seed]_[cidr]_[shard]_[total].state
+```
+
+For example:
+```
+pylcg_12345_192.168.0.0_16_1_4.state
+```
+
+The state is saved in memory-mapped temporary storage to minimize disk I/O and improve performance. To resume from a previous state:
+
+1. Locate your state file in the temp directory
+2. Read the state value from the file
+3. Use the same parameters (CIDR, seed, shard settings) with the `--state` parameter
+
+Example of resuming:
+```bash
+# Read the last state
+state=$(cat /tmp/pylcg_12345_192.168.0.0_16_1_4.state)
+
+# Resume processing
+pylcg 192.168.0.0/16 --shard-num 1 --total-shards 4 --seed 12345 --state $state
 ```
 
+Note: When using the `--state` parameter, you must provide the same `--seed` that was used in the original run.
+
 ## How It Works
 
+### IP Address Integer Representation
+
+Every IPv4 address is fundamentally a 32-bit number. For example, the IP address "192.168.1.1" can be broken down into its octets (192, 168, 1, 1) and converted to a single integer:
+```
+192.168.1.1 = (192 × 256³) + (168 × 256²) + (1 × 256¹) + (1 × 256⁰)
+             = 3232235777
+```
+
+This integer representation allows us to treat IP ranges as simple number sequences. A CIDR block like "192.168.0.0/16" becomes a continuous range of integers:
+- Start: 192.168.0.0   → 3232235520
+- End:   192.168.255.255 → 3232301055
+
+By working with these integer representations, we can perform efficient mathematical operations on IP addresses without the overhead of string manipulation or complex data structures. This is where the Linear Congruential Generator comes into play.
+
 ### Linear Congruential Generator
 
-PyLCG uses an optimized LCG implementation with carefully chosen parameters:
+PyLCG uses an optimized LCG implementation with three carefully chosen parameters that work together to generate high-quality pseudo-random sequences:
+
 | Name       | Variable | Value        |
 |------------|----------|--------------|
 | Multiplier | `a`      | `1664525`    |
 | Increment  | `c`      | `1013904223` |
 | Modulus    | `m`      | `2^32`       |
 
-This generates a deterministic sequence of pseudo-random numbers using the formula:
-```
-next = (a * current + c) mod m
-```
+###### Modulus
+The modulus value of `2^32` serves as both a mathematical and performance optimization choice. It perfectly matches the CPU's word size, allowing for extremely efficient modulo operations through simple bitwise AND operations. This choice means that all calculations stay within the natural bounds of CPU arithmetic while still providing a large enough period for even the biggest IP ranges we might encounter.
 
-### Memory-Efficient IP Processing
+###### Multiplier
+The multiplier value of `1664525` was originally discovered through extensive mathematical analysis for the Numerical Recipes library. It satisfies the Hull-Dobell theorem's strict requirements for maximum period length in power-of-2 modulus LCGs, being both relatively prime to the modulus and one more than a multiple of 4. This specific value also performs exceptionally well in spectral tests, ensuring good distribution properties across the entire range while being small enough to avoid intermediate overflow in 32-bit arithmetic.
 
-Instead of loading entire IP ranges into memory, PyLCG:
-1. Converts CIDR ranges to start/end integers
-2. Uses generator functions for lazy evaluation
-3. Calculates IPs on-demand using index mapping
-4. Maintains constant memory usage regardless of range size
+###### Increment
+The increment value of `1013904223` is a carefully selected prime number that completes our parameter trio. When combined with our chosen multiplier and modulus, it ensures optimal bit mixing throughout the sequence and helps eliminate common LCG issues like short cycles or poor distribution. This specific value was selected after extensive testing showed it produced excellent statistical properties and passed rigorous spectral tests for dimensional distribution.
 
-### Sharding Algorithm
+### Applying LCG to IP Addresses
+
+Once we have our IP addresses as integers, the LCG is used to generate a pseudo-random sequence that permutes through all possible values in our IP range:
 
-The sharding system uses an interleaved approach:
-1. Each shard is assigned a subset of indices based on modulo arithmetic
-2. The LCG randomizes the order within each shard
-3. Work is distributed evenly across shards
-4. No sequential scanning patterns
+1. For a given IP range *(start_ip, end_ip)*, we calculate the range size: `range_size = end_ip - start_ip + 1`
 
-## Performance
+2. The LCG generates a sequence using the formula: `X_{n+1} = (a * X_n + c) mod m`
 
-PyLCG is designed for maximum performance:
-- Generates millions of IPs per second
-- Constant memory usage (~100KB)
-- Minimal CPU overhead
-- No disk I/O required
+3. To map this sequence back to valid IPs in our range:
+   - Generate the next LCG value
+   - Take modulo of the value with range_size to get an offset: `offset = lcg_value % range_size`
+   - Add this offset to start_ip: `ip = start_ip + offset`
 
-Benchmark results on a typical system:
-- IP Generation: ~5-10 million IPs/second
-- Memory Usage: < 1MB for any range size
-- LCG Operations: < 1 microsecond per number
+This process ensures that:
+- Every IP in the range is visited exactly once
+- The sequence appears random but is deterministic
+- We maintain constant memory usage regardless of range size
+- The same seed always produces the same sequence
+
+### Sharding Algorithm
+
+The sharding system employs an interleaved approach that ensures even distribution of work across multiple machines while maintaining randomness. Each shard operates independently using a deterministic sequence derived from the base seed plus the shard index. The system distributes IPs across shards using modulo arithmetic, ensuring that each IP is assigned to exactly one shard. This approach prevents sequential scanning patterns while guaranteeing complete coverage of the IP range. The result is a system that can efficiently parallelize work across any number of machines while maintaining the pseudo-random ordering that's crucial for network scanning applications.
 
 ## Contributing
 
@@ -92,40 +155,11 @@ We welcome contributions that improve PyLCG's performance. When submitting optim
 python3 unit_test.py
 ```
 
-2. Include before/after benchmark results for:
-- IP generation speed
-- Memory usage
-- LCG sequence generation
-- Shard distribution metrics
-
-3. Consider optimizing:
-- Number generation algorithms
-- Memory access patterns
-- CPU cache utilization
-- Python-specific optimizations
-
-4. Document any tradeoffs between:
-- Speed vs memory usage
-- Randomness vs performance
-- Complexity vs maintainability
-
-### Benchmark Guidelines
-
-When running benchmarks:
-1. Use consistent hardware/environment
-2. Run multiple iterations
-3. Test with various CIDR ranges
-4. Measure both average and worst-case performance
-5. Profile memory usage patterns
-6. Test shard distribution uniformity
-
 ## Roadmap
 
 - [ ] IPv6 support
 - [ ] Custom LCG parameters
 - [ ] Configurable chunk sizes
-- [ ] State persistence
-- [ ] Resume capability
 - [ ] S3/URL input support
 - [ ] Extended benchmark suite
 

diff --git a/pylcg/__init__.py b/pylcg/__init__.py
@@ -1,5 +1,5 @@
 from .core import LCG, IPRange, ip_stream
 
-__version__ = "1.0.0"
+__version__ = "1.0.3"
 __author__ = "acidvegas"
 __all__ = ["LCG", "IPRange", "ip_stream"] 
 \ No newline at end of file

diff --git a/pylcg/cli.py b/pylcg/cli.py
@@ -6,7 +6,8 @@ def main():
 	parser.add_argument('cidr', help='Target IP range in CIDR format')
 	parser.add_argument('--shard-num', type=int, default=1, help='Shard number (1-based)')
 	parser.add_argument('--total-shards', type=int, default=1, help='Total number of shards (default: 1, no sharding)')
-	parser.add_argument('--seed', type=int, default=0, help='Random seed for LCG')
+	parser.add_argument('--seed', type=int, required=True, help='Random seed for LCG (required)')
+	parser.add_argument('--state', type=int, help='Resume from specific LCG state (must be used with same seed)')
 
 	args = parser.parse_args()
 
@@ -19,7 +20,10 @@ def main():
 	if args.shard_num < 1:
 		raise ValueError('Shard number must be at least 1')
 
-	for ip in ip_stream(args.cidr, args.shard_num, args.total_shards, args.seed):
+	if args.state is not None and not args.seed:
+		raise ValueError('When using --state, you must provide the same --seed that was used originally')
+
+	for ip in ip_stream(args.cidr, args.shard_num, args.total_shards, args.seed, args.state):
 		print(ip)
 
 if __name__ == '__main__':

diff --git a/pylcg/core.py b/pylcg/core.py
@@ -38,7 +38,7 @@ class IPRange:
 		return str(ipaddress.ip_address(self.start + index))
 
 
-def ip_stream(cidr: str, shard_num: int = 1, total_shards: int = 1, seed: int = 0):
+def ip_stream(cidr: str, shard_num: int = 1, total_shards: int = 1, seed: int = 0, state: int = None):
 	'''
 	Stream random IPs from the CIDR range. Optionally supports sharding.
 	Each IP in the range will be yielded exactly once in a pseudo-random order.
@@ -47,6 +47,7 @@ def ip_stream(cidr: str, shard_num: int = 1, total_shards: int = 1, seed: int = 
 	:param shard_num: Shard number (1-based), defaults to 1
 	:param total_shards: Total number of shards, defaults to 1 (no sharding)
 	:param seed: Random seed for LCG (default: random)
+	:param state: Resume from specific LCG state (default: None)
 	'''
 
 	# Convert to 0-based indexing internally
@@ -61,6 +62,10 @@ def ip_stream(cidr: str, shard_num: int = 1, total_shards: int = 1, seed: int = 
 
 	# Initialize LCG
 	lcg = LCG(seed + shard_index)
+	
+	# Set LCG state if provided
+	if state is not None:
+		lcg.current = state
 
 	# Calculate how many IPs this shard should generate
 	shard_size = ip_range.total // total_shards
@@ -77,3 +82,7 @@ def ip_stream(cidr: str, shard_num: int = 1, total_shards: int = 1, seed: int = 
 		if total_shards == 1 or index % total_shards == shard_index:
 			yield ip_range.get_ip_at_index(index)
 			remaining -= 1
+			# Save state every 1000 IPs
+			if remaining % 1000 == 0:
+				from .state import save_state
+				save_state(seed, cidr, shard_num, total_shards, lcg.current)

diff --git a/pylcg/state.py b/pylcg/state.py
@@ -0,0 +1,20 @@
+import os
+import tempfile
+
+def save_state(seed: int, cidr: str, shard: int, total: int, lcg_current: int):
+	'''
+	Save LCG state to temp file
+
+	:param seed: Random seed for LCG
+	:param cidr: Target IP range in CIDR format
+	:param shard: Shard number (1-based)
+	:param total: Total number of shards
+	:param lcg_current: Current LCG state
+	'''
+
+	file_name = f'pylcg_{seed}_{cidr.replace("/", "_")}_{shard}_{total}.state'
+
+	state_file = os.path.join(tempfile.gettempdir(), file_name)
+    
+	with open(state_file, 'w') as f:
+		f.write(str(lcg_current))
+\ No newline at end of file

diff --git a/setup.py b/setup.py
@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
 	name="pylcg",
-	version="1.0.2",
+	version="1.0.3",
 	author="acidvegas",
 	author_email="acid.vegas@acid.vegas",
 	description="Linear Congruential Generator for IP Sharding",

diff --git a/unit_test.py b/unit_test.py
@@ -1,9 +1,10 @@
-#!/usr/bin/env python3
 import unittest
 import ipaddress
 import time
+
 from pylcg import IPRange, ip_stream, LCG
 
+
 class Colors:
 	BLUE   = '\033[94m'
 	GREEN  = '\033[92m'
@@ -17,15 +18,19 @@ def print_header(message: str) -> None:
 	print(f'TEST: {message}')
 	print(f'{"="*80}{Colors.ENDC}\n')
 
+
 def print_success(message: str) -> None:
 	print(f'{Colors.GREEN}✓ {message}{Colors.ENDC}')
 
+
 def print_info(message: str) -> None:
 	print(f"{Colors.CYAN}ℹ {message}{Colors.ENDC}")
 
+
 def print_warning(message: str) -> None:
 	print(f"{Colors.YELLOW}! {message}{Colors.ENDC}")
 
+
 class TestIPSharder(unittest.TestCase):
 	@classmethod
 	def setUpClass(cls):
@@ -39,6 +44,7 @@ class TestIPSharder(unittest.TestCase):
 		cls.all_ips = {str(ip) for ip in network}
 		print_success(f"Initialized test environment with {len(cls.all_ips):,} IPs")
 
+
 	def test_ip_range_initialization(self):
 		print_header('Testing IPRange initialization')
 		start_time = time.perf_counter()
@@ -54,6 +60,7 @@ class TestIPSharder(unittest.TestCase):
 		print_info(f'IP range spans from {first_ip} to {last_ip}')
 		print_info(f'Total IPs in range: {ip_range.total:,}')
 
+
 	def test_lcg_sequence(self):
 		print_header('Testing LCG sequence generation')
 
@@ -80,6 +87,7 @@ class TestIPSharder(unittest.TestCase):
 
 		print_success(f'Verified LCG determinism in {elapsed:.6f}s')
 
+
 	def test_shard_distribution(self):
 		print_header('Testing shard distribution and randomness')
 
@@ -128,6 +136,8 @@ class TestIPSharder(unittest.TestCase):
 
 		print_info(f'Sequential IP pairs in first 1000: {sequential_percentage:.2f}% (lower is more random)')
 
+
+
 if __name__ == '__main__':
 	print(f"\n{Colors.CYAN}{'='*80}")
 	print(f"Starting IP Sharder Tests - Testing with 65,536 IPs (/16 network)")