use strict;
use warnings;
use List::Util qw(max min);
use Time::HiRes qw(time);

# this builds a structure that is usually retrieved from disk.
# in this example we will use this structure again and again,
# but in the real program we obviously retrieve a fresh structure
# at each iteration

my $simulation_h = {};
for ( 1 .. 70000 ) {
	my $random_start  = int( rand(5235641) );
	my $random_length = int( rand(40000) );
	push @{ $simulation_h->{$random_start} }, $random_length;
}

my $zone_o = {
	_chromosome_length => 5235641,
	_legal_range       => [ { FROM => 100000, TO => 200000 } ]
};

my $start_time = time;
scenario();
print "total loop time: " . ( time - $start_time ) . " seconds\n";
my $temp_gene_to_legal_range;
my $gene_to;

sub scenario {
	for ( my $i = 0 ; $i < 50 ; $i++ ) {
		print "i=$i time=" . ( time - $start_time ) . " seconds\n";

		# originally there was a retreive of $simulation_h from disk here

		# iterate genes

		foreach my $gene_from ( keys %{$simulation_h} ) {
			foreach my $gene_length ( @{ $simulation_h->{$gene_from} } ) {

### inlining gene_to_legal_range 
				$gene_to =
				  ( ( $gene_from + $gene_length - 1 )
					% ( $zone_o->{_chromosome_length} ) ) + 1;

				if ( $gene_to < $gene_from ) {

					# split
					# low range first
					$temp_gene_to_legal_range = [
						{ FROM => 0, TO => $gene_to },
						{
							FROM => $gene_from,
							TO   => $zone_o->{_chromosome_length}
						}
					];
				}
				else {

					# single
					$temp_gene_to_legal_range =
					  [ { FROM => $gene_from, TO => $gene_to } ];
				}


			}
		}
	}
}

##</code><code>##

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;

public class InLine {

	public static void main(String[] args) {
		int count = 0;
		Random rand = new Random();
		Map<Integer, List<Integer>> genes = new HashMap<Integer, List<Integer>>();
		for (int i = 0; i < 70000; i++) {
			Integer randStart = rand.nextInt(5235641);
			Integer randLength = rand.nextInt(40000);
			if (!genes.containsKey(randStart)) {
				List<Integer> list = new ArrayList<Integer>();
				genes.put(randStart, list);
			}
			genes.get(randStart).add(randLength);
		}

		int chromosomeLength = 5235641;
		SimpleRange simpleRange = new SimpleRange(100000, 200000);
		Set<SimpleRange> setSimpleRanges = new HashSet<SimpleRange>();
		setSimpleRanges.add(simpleRange);

		long startTimeMillis = System.currentTimeMillis();

		for (int i = 0; i < 50; i++) {
			System.out
					.println("Iter = "
							+ i
							+ " Time from start: "
							+ ((double) (System.currentTimeMillis() - startTimeMillis) / 1000));
			for (int geneFrom : genes.keySet()) {
				for (int geneLength : genes.get(geneFrom)) {
					int geneTo = (geneFrom + geneLength - 1) % chromosomeLength
							+ 1;
					if (geneTo < geneFrom) {

						// split
						// low range first
						SimpleRange lowSimpleRange = new SimpleRange(0, geneTo);
						SimpleRange highSimpleRange = new SimpleRange(geneFrom,
								chromosomeLength);
						Set<SimpleRange> setSimpleRanges1 = new HashSet<SimpleRange>();
						setSimpleRanges1.add(lowSimpleRange);
						setSimpleRanges1.add(highSimpleRange);
						count++;

					} else {

						// single
						SimpleRange simpleRange1 = new SimpleRange(geneFrom,
								geneTo);
						Set<SimpleRange> setSimpleRanges1 = new HashSet<SimpleRange>();
						setSimpleRanges1.add(simpleRange1);
						count++;
					}
				}
			}
		}
		System.out
				.println("Time from start: "
						+ ((double) (System.currentTimeMillis() - startTimeMillis) / 1000)
						+ " count=" + count);
	}
}

class LegalRange {
	Set<SimpleRange> set;

	public LegalRange(Set<SimpleRange> set) {
		this.set = set;
	}
}

class SimpleRange {
	int from;
	int to;

	public SimpleRange(int from, int to) {
		this.from = from;
		this.to = to;
	}

}