#!/usr/bin/env ruby

def solve(m,n)
	nil
end

require 'test/unit'

class TestNumericMaze < Test::Unit::TestCase
	
	def test_invalid
		# these cases were determined invalid for the quiz, though 
		# not necessarily invalid for the math problem
		assert_equal(nil, solve(1,0))
		assert_equal(nil, solve(2,0))
		assert_equal(nil, solve(3,0))
		assert_equal(nil, solve(4,0))
		assert_equal(nil, solve(0,0))
		assert_equal(nil, solve(0,-1))
		assert_equal(nil, solve(-1,0))
		assert_equal(nil, solve(-1,-1))
	end
	
	def test_sames
		# identical inputs require zero steps
		assert_equal([1], solve(1,1))
		assert_equal([2], solve(2,2))
		assert_equal([3], solve(3,3))
		assert_equal([4], solve(4,4))
		assert_equal([5], solve(5,5))
		assert_equal([6], solve(6,6))
		assert_equal([7], solve(7,7))
		assert_equal([8], solve(8,8))
		assert_equal([9], solve(9,9))
	end
		
	def test_small
		# solutions for i=[0,10], j=[1,10]
		assert_equal( [0,2,1], solve(0,1) )
		assert_equal( [0,2], solve(0,2) )
		assert_equal( [0,2,1,3], solve(0,3) )
		assert_equal( [0,2,4], solve(0,4) )
		assert_equal( [0,2,1,3,5], solve(0,5) )
		assert_equal( [0,2,4,6], solve(0,6) )
		assert_equal( [0,2,1,3,5,7], solve(0,7) )
		assert_equal( [0,2,4,8], solve(0,8) )
		assert( [0,2,1,3,5,7,9] == solve(0,9) || [0,2,4,8,16,18,9] == solve(0,9) )
		assert_equal( [1,2], solve(1,2) )
		assert_equal( [1,3], solve(1,3) )
		assert_equal( [1,2,4], solve(1,4) )
		assert_equal( [1,3,5], solve(1,5) )
		assert_equal( [1,3,6], solve(1,6) )
		assert_equal( [1,3,5,7], solve(1,7) )
		assert( [1,2,4,8] == solve(1,8) || [1,3,6,8] == solve(1,8) )
		assert_equal( [1,3,5,7,9], solve(1,9) )
		assert_equal( [2,1], solve(2,1) )
		assert_equal( [2,1,3], solve(2,3) )
		assert_equal( [2,4], solve(2,4) )
		assert_equal( [2,1,3,5], solve(2,5) )
		assert_equal( [2,4,6], solve(2,6) )
		assert_equal( [2,1,3,5,7], solve(2,7) )
		assert_equal( [2,4,8], solve(2,8) )
		assert( [2,1,3,5,7,9] == solve(2,9) || [2,4,8,16,18,9] == solve(2,9) )
		assert_equal( [3,6,8,4,2,1], solve(3,1) )
		assert_equal( [3,6,8,4,2], solve(3,2) )
		assert_equal( [3,6,8,4], solve(3,4) )
		assert_equal( [3,5], solve(3,5) )
		assert_equal( [3,6], solve(3,6) )
		assert_equal( [3,5,7], solve(3,7) )
		assert_equal( [3,6,8], solve(3,8) )
		assert_equal( [3,5,7,9], solve(3,9) )
		assert_equal( [4,2,1], solve(4,1) )
		assert_equal( [4,2], solve(4,2) )
		assert_equal( [4,6,3], solve(4,3) )
		assert( [4,6,3,5] == solve(4,5) || [4,8,10,5] == solve(4,5) )
		assert_equal( [4,6], solve(4,6) )
		assert( [4,6,12,14,7] == solve(4,7) || [4,6,3,5,7] == solve(4,7) || [4,8,10,5,7] == solve(4,7) )
		assert_equal( [4,8], solve(4,8) )
		assert_equal( [4,8,16,18,9], solve(4,9) )
		assert( [5,10,12,6,8,4,2,1] == solve(5,1) || [5,7,14,16,8,4,2,1] == solve(5,1) )
		assert( [5,10,12,6,8,4,2] == solve(5,2) || [5,7,14,16,8,4,2] == solve(5,2) )
		assert_equal( [5,10,12,6,3], solve(5,3) )
		assert( [5,10,12,6,8,4] == solve(5,4) || [5,7,14,16,8,4] == solve(5,4) )
		assert_equal( [5,10,12,6], solve(5,6) )
		assert_equal( [5,7], solve(5,7) )
		assert( [5,10,12,6,8] == solve(5,8) || [5,7,14,16,8] == solve(5,8) )
		assert_equal( [5,7,9], solve(5,9) )
		assert_equal( [6,8,4,2,1], solve(6,1) )
		assert_equal( [6,8,4,2], solve(6,2) )
		assert_equal( [6,3], solve(6,3) )
		assert_equal( [6,8,4], solve(6,4) )	
		assert_equal( [6,3,5], solve(6,5) )
		assert( [6,12,14,7] == solve(6,7) || [6,3,5,7] == solve(6,7) )
		assert_equal( [6,8], solve(6,8) )
		assert( [6,12,14,7,9] == solve(6,9) || [6,3,5,7,9] == solve(6,9) || [6,8,16,18,9] == solve(6,9) )
		assert_equal( [7,14,16,8,4,2,1], solve(7,1) )
		assert_equal( [7,14,16,8,4,2], solve(7,2) )
		assert_equal( [7,14,16,8,4,6,3], solve(7,3) )
		assert_equal( [7,14,16,8,4], solve(7,4) )
		assert( [7,14,16,8,10,5] == solve(7,5) || [7,9,18,20,10,5] == solve(7,5) )
		assert_equal( [7,14,16,8,4,6], solve(7,6) )
		assert_equal( [7,14,16,8], solve(7,8) )
		assert_equal( [7,9], solve(7,9) )
		assert_equal( [8,4,2,1], solve(8,1) )
		assert_equal( [8,4,2], solve(8,2) )
		assert_equal( [8,4,6,3], solve(8,3) )
		assert_equal( [8,4], solve(8,4) )
		assert_equal( [8,10,5], solve(8,5) )
		assert_equal( [8,4,6], solve(8,6) )
		assert_equal( [8,10,5,7], solve(8,7) )
		assert_equal( [8,16,18,9], solve(8,9) )
		assert( [9,11,22,24,12,6,8,4,2,1] == solve(9,1) || [9,18,20,10,12,6,8,4,2,1] == solve(9,1) )
		assert( [9,11,22,24,12,6,8,4,2] == solve(9,2) || [9,18,20,10,12,6,8,4,2] == solve(9,2) )
		assert( [9,11,22,24,12,6,3] == solve(9,3) || [9,18,20,10,12,6,3] == solve(9,3) )
		assert( [9,11,22,24,12,6,8,4] == solve(9,4) || [9,18,20,10,12,6,8,4] == solve(9,4) )
		assert_equal( [9,18,20,10,5], solve(9,5) )
		assert( [9,11,22,24,12,6] == solve(9,6) || [9,18,20,10,12,6] == solve(9,6) )
		assert_equal( [9,18,20,10,5,7], solve(9,7) )
		assert( [9,11,22,24,12,6,8] == solve(9,8) || [9,18,20,10,12,6,8] == solve(9,8) )
	end
	
	def test_big_vs_small
		# solutions for i=[0,10), j=[100,1000) (step=100), and vice versa
		assert_equal( [0,2,4,6,12,24,48,50,100], solve(0,100) )
		assert_equal( [0,2,4,6,12,24,48,50,100,200], solve(0,200) )
		assert_equal( [0,2,4,8,16,18,36,72,74,148,150,300], solve(0,300) )
		assert_equal( [0,2,4,6,12,24,48,50,100,200,400], solve(0,400) )
		assert_equal( [0,2,4,6,12,14,28,30,60,62,124,248,250,500], solve(0,500) )
		assert_equal( [0,2,4,8,16,18,36,72,74,148,150,300,600], solve(0,600) )
		assert_equal( [0,2,4,8,10,20,40,42,84,86,172,174,348,350,700], solve(0,700) )
		assert_equal( [0,2,4,6,12,24,48,50,100,200,400,800], solve(0,800) )
		assert_equal( [0,2,4,6,12,14,28,56,112,224,448,450,900], solve(0,900) )
		assert_equal( [1,3,6,12,24,48,50,100], solve(1,100) )
		assert_equal( [100,50,52,26,28,14,16,8,4,2,1], solve(100,1) )
		assert_equal( [1,3,6,12,24,48,50,100,200], solve(1,200) )
		assert_equal( [200,100,50,52,26,28,14,16,8,4,2,1], solve(200,1) )
		assert( [1,2,4,8,16,18,36,72,74,148,150,300] == solve(1,300) || [1,3,5,7,9,18,36,72,74,148,150,300] == solve(1,300) || [1,3,6,8,16,18,36,72,74,148,150,300] == solve(1,300) )
		assert_equal( [300,150,152,76,38,40,20,10,12,6,8,4,2,1], solve(300,1) )
		assert_equal( [1,3,6,12,24,48,50,100,200,400], solve(1,400) )
		assert_equal( [400,200,100,50,52,26,28,14,16,8,4,2,1], solve(400,1) )
		assert( [1,3,5,7,14,28,30,60,62,124,248,250,500] == solve(1,500) || [1,3,6,12,14,28,30,60,62,124,248,250,500] == solve(1,500) )
		assert_equal( [500,250,252,126,128,64,32,16,8,4,2,1], solve(500,1) )
		assert( [1,2,4,8,16,18,36,72,74,148,150,300,600] == solve(1,600) || [1,3,5,7,9,18,36,72,74,148,150,300,600] == solve(1,600) || [1,3,6,8,16,18,36,72,74,148,150,300,600] == solve(1,600) )
		assert_equal( [600,300,150,152,76,38,40,20,10,12,6,8,4,2,1], solve(600,1) )
		assert_equal( [1,3,5,10,20,40,42,84,86,172,174,348,350,700], solve(1,700) )
		assert( [700,350,352,176,88,44,46,48,24,12,6,8,4,2,1] == solve(700,1) || [700,702,704,352,176,88,44,22,24,12,6,8,4,2,1] == solve(700,1) )
		assert_equal( [1,3,6,12,24,48,50,100,200,400,800], solve(1,800) )
		assert_equal( [800,400,200,100,50,52,26,28,14,16,8,4,2,1], solve(800,1) )
		assert( [1,3,5,7,14,28,56,112,224,448,450,900] == solve(1,900) || [1,3,6,12,14,28,56,112,224,448,450,900] == solve(1,900) )
		assert_equal( [900,450,452,454,456,228,114,116,58,60,62,64,32,16,8,4,2,1], solve(900,1) )
		assert_equal( [2,4,6,12,24,48,50,100], solve(2,100) )
		assert_equal( [100,50,52,26,28,14,16,8,4,2], solve(100,2) )
		assert_equal( [2,4,6,12,24,48,50,100,200], solve(2,200) )
		assert_equal( [200,100,50,52,26,28,14,16,8,4,2], solve(200,2) )
		assert_equal( [2,4,8,16,18,36,72,74,148,150,300], solve(2,300) )
		assert( [300,150,152,76,38,40,20,10,12,14,16,8,4,2] == solve(300,2) || [300,150,152,76,78,80,40,20,10,12,6,8,4,2] == solve(300,2) )
		assert_equal( [2,4,6,12,24,48,50,100,200,400], solve(2,400) )
		assert_equal( [400,200,100,50,52,26,28,14,16,8,4,2], solve(400,2) )
		assert_equal( [2,4,6,12,14,28,30,60,62,124,248,250,500], solve(2,500) )
		assert_equal( [500,250,252,126,128,64,32,16,8,4,2], solve(500,2) )
		assert_equal( [2,4,8,16,18,36,72,74,148,150,300,600], solve(2,600) )
		assert_equal( [600,300,150,152,76,38,40,20,10,12,6,8,4,2], solve(600,2) )
		assert_equal( [2,4,8,10,20,40,42,84,86,172,174,348,350,700], solve(2,700) )
		assert_equal( [700,350,352,176,88,44,22,24,12,6,8,4,2], solve(700,2) )
		assert_equal( [2,4,6,12,24,48,50,100,200,400,800], solve(2,800) )
		assert_equal( [800,400,200,100,50,52,26,28,14,16,8,4,2], solve(800,2) )
		assert_equal( [2,4,6,12,14,28,56,112,224,448,450,900], solve(2,900) )
		assert_equal( [900,450,452,226,113,226,228,114,116,58,60,62,64,32,16,8,4,2], solve(900,2) )
		assert_equal( [3,6,12,24,48,50,100], solve(3,100) )
		assert_equal( [100,50,52,26,28,14,16,8,4,6,3], solve(100,3) )
		assert_equal( [3,6,12,24,48,50,100,200], solve(3,200) )
		assert_equal( [200,100,50,52,26,28,14,16,8,4,6,3], solve(200,3) )
		assert( [3,5,7,9,18,36,72,74,148,150,300] == solve(3,300) || [3,6,8,16,18,36,72,74,148,150,300] == solve(3,300) )
		assert_equal( [300,150,152,76,38,40,20,10,12,6,3], solve(300,3) )
		assert_equal( [3,6,12,24,48,50,100,200,400], solve(3,400) )
		assert_equal( [400,200,100,50,52,26,28,14,16,8,4,6,3], solve(400,3) )
		assert( [3,5,7,14,28,30,60,62,124,248,250,500] == solve(3,500) || [3,6,12,14,28,30,60,62,124,248,250,500] == solve(3,500) )
		assert_equal( [500,250,252,126,128,64,32,16,8,4,6,3], solve(500,3) )
		assert( [3,5,7,9,18,36,72,74,148,150,300,600] == solve(3,600) || [3,6,8,16,18,36,72,74,148,150,300,600] == solve(3,600) )
		assert_equal( [600,300,150,152,76,38,40,20,10,12,6,3], solve(600,3) )
		assert_equal( [3,5,10,20,40,42,84,86,172,174,348,350,700], solve(3,700) )
		assert_equal( [700,350,352,176,88,44,22,24,12,6,3], solve(700,3) )
		assert_equal( [3,6,12,24,48,50,100,200,400,800], solve(3,800) )
		assert( [800,400,200,100,50,52,26,28,14,16,8,4,2,1,3] == solve(800,3) || [800,400,200,100,50,52,26,28,30,32,16,8,4,6,3] == solve(800,3) )
		assert( [3,5,7,14,28,56,112,224,448,450,900] == solve(3,900) || [3,6,12,14,28,56,112,224,448,450,900] == solve(3,900) )
		assert( [900,450,452,226,113,226,228,114,116,58,60,30,32,16,8,4,2,1,3] == solve(900,3) || [900,450,452,226,228,230,232,116,118,120,60,30,32,16,8,4,2,1,3] == solve(900,3) )
		assert_equal( [4,6,12,24,48,50,100], solve(4,100) )
		assert_equal( [100,50,52,26,28,14,16,8,4], solve(100,4) )
		assert_equal( [4,6,12,24,48,50,100,200], solve(4,200) )
		assert_equal( [200,100,50,52,26,28,14,16,8,4], solve(200,4) )
		assert_equal( [4,8,16,18,36,72,74,148,150,300], solve(4,300) )
		assert_equal( [300,150,152,76,38,40,20,10,12,6,8,4], solve(300,4) )
		assert_equal( [4,6,12,24,48,50,100,200,400], solve(4,400) )
		assert_equal( [400,200,100,50,52,26,28,14,16,8,4], solve(400,4) )
		assert_equal( [4,6,12,14,28,30,60,62,124,248,250,500], solve(4,500) )
		assert_equal( [500,250,252,126,128,64,32,16,8,4], solve(500,4) )
		assert_equal( [4,8,16,18,36,72,74,148,150,300,600], solve(4,600) )
		assert_equal( [600,300,150,152,76,38,40,20,10,12,6,8,4], solve(600,4) )
		assert_equal( [4,8,10,20,40,42,84,86,172,174,348,350,700], solve(4,700) )
		assert_equal( [700,350,352,176,88,44,22,24,12,6,8,4], solve(700,4) )
		assert_equal( [4,6,12,24,48,50,100,200,400,800], solve(4,800) )
		assert_equal( [800,400,200,100,50,52,26,28,14,16,8,4], solve(800,4) )
		assert_equal( [4,6,12,14,28,56,112,224,448,450,900], solve(4,900) )
		assert( [900,450,225,450,452,226,228,114,116,58,60,30,32,16,8,4] == solve(900,4) || [900,450,452,226,228,114,116,118,120,60,62,64,32,16,8,4] == solve(900,4) || [900,450,452,226,228,114,57,114,116,58,60,30,32,16,8,4] == solve(900,4) || [900,450,452,226,228,114,57,59,118,120,60,30,32,16,8,4] == solve(900,4) || [900,450,452,226,228,230,232,116,118,120,60,30,32,16,8,4] == solve(900,4) )
		assert_equal( [5,10,12,24,48,50,100], solve(5,100) )
		assert_equal( [100,50,52,26,28,14,16,8,10,5], solve(100,5) )
		assert_equal( [5,10,12,24,48,50,100,200], solve(5,200) )
		assert_equal( [200,100,50,52,26,28,14,16,8,10,5], solve(200,5) )
		assert_equal( [5,7,9,18,36,72,74,148,150,300], solve(5,300) )
		assert_equal( [300,150,152,76,38,40,20,10,5], solve(300,5) )
		assert_equal( [5,10,12,24,48,50,100,200,400], solve(5,400) )
		assert_equal( [400,200,100,50,52,26,28,14,16,8,10,5], solve(400,5) )
		assert_equal( [5,7,14,28,30,60,62,124,248,250,500], solve(5,500) )
		assert_equal( [500,250,252,126,128,64,32,16,8,10,5], solve(500,5) )
		assert_equal( [5,7,9,18,36,72,74,148,150,300,600], solve(5,600) )
		assert_equal( [600,300,150,152,76,38,40,20,10,5], solve(600,5) )
		assert_equal( [5,10,20,40,42,84,86,172,174,348,350,700], solve(5,700) )
		assert_equal( [700,350,352,176,88,44,22,24,12,6,3,5], solve(700,5) )
		assert_equal( [5,10,12,24,48,50,100,200,400,800], solve(5,800) )
		assert_equal( [800,400,200,100,50,52,26,28,14,16,8,10,5], solve(800,5) )
		assert_equal( [5,7,14,28,56,112,224,448,450,900], solve(5,900) )
		assert_equal( [900,450,452,226,228,114,116,58,60,30,32,16,18,20,10,5], solve(900,5) )
		assert_equal( [6,12,24,48,50,100], solve(6,100) )
		assert_equal( [100,50,52,26,28,14,16,8,4,6], solve(100,6) )
		assert_equal( [6,12,24,48,50,100,200], solve(6,200) )
		assert_equal( [200,100,50,52,26,28,14,16,8,4,6], solve(200,6) )
		assert_equal( [6,8,16,18,36,72,74,148,150,300], solve(6,300) )
		assert_equal( [300,150,152,76,38,40,20,10,12,6], solve(300,6) )
		assert_equal( [6,12,24,48,50,100,200,400], solve(6,400) )
		assert_equal( [400,200,100,50,52,26,28,14,16,8,4,6], solve(400,6) )
		assert_equal( [6,12,14,28,30,60,62,124,248,250,500], solve(6,500) )
		assert_equal( [500,250,252,126,128,64,32,16,8,4,6], solve(500,6) )
		assert_equal( [6,8,16,18,36,72,74,148,150,300,600], solve(6,600) )
		assert_equal( [600,300,150,152,76,38,40,20,10,12,6], solve(600,6) )
		assert_equal( [6,8,10,20,40,42,84,86,172,174,348,350,700], solve(6,700) )
		assert_equal( [700,350,352,176,88,44,22,24,12,6], solve(700,6) )
		assert_equal( [6,12,24,48,50,100,200,400,800], solve(6,800) )
		assert_equal( [800,400,200,100,50,52,26,28,14,16,8,4,6], solve(800,6) )
		assert_equal( [6,12,14,28,56,112,224,448,450,900], solve(6,900) )
		assert_equal( [900,450,452,226,228,230,232,116,118,120,60,30,32,16,8,4,6], solve(900,6) )
		assert_equal( [7,9,11,22,24,48,50,100], solve(7,100) )
		assert_equal( [100,50,52,26,28,14,7], solve(100,7) )
		assert_equal( [7,9,11,22,24,48,50,100,200], solve(7,200) )
		assert_equal( [200,100,50,52,26,28,14,7], solve(200,7) )
		assert_equal( [7,9,18,36,72,74,148,150,300], solve(7,300) )
		assert_equal( [300,150,152,76,38,40,20,10,5,7], solve(300,7) )
		assert_equal( [7,9,11,22,24,48,50,100,200,400], solve(7,400) )
		assert_equal( [400,200,100,50,52,26,28,14,7], solve(400,7) )
		assert_equal( [7,14,28,30,60,62,124,248,250,500], solve(7,500) )
		assert_equal( [500,250,252,126,128,64,32,16,8,10,5,7], solve(500,7) )
		assert_equal( [7,9,18,36,72,74,148,150,300,600], solve(7,600) )
		assert_equal( [600,300,150,152,76,38,40,20,10,5,7], solve(600,7) )
		assert_equal( [7,9,18,20,40,42,84,86,172,174,348,350,700], solve(7,700) )
		assert_equal( [700,350,352,176,88,44,22,24,12,14,7], solve(700,7) )
		assert_equal( [7,9,11,22,24,48,50,100,200,400,800], solve(7,800) )
		assert_equal( [800,400,200,100,50,52,26,28,14,7], solve(800,7) )
		assert_equal( [7,14,28,56,112,224,448,450,900], solve(7,900) )
		assert_equal( [900,450,452,226,228,114,116,118,120,60,30,32,16,8,10,5,7], solve(900,7) )
		assert_equal( [8,10,12,24,48,50,100], solve(8,100) )
		assert_equal( [100,50,52,26,28,14,16,8], solve(100,8) )
		assert_equal( [8,10,12,24,48,50,100,200], solve(8,200) )
		assert_equal( [200,100,50,52,26,28,14,16,8], solve(200,8) )
		assert_equal( [8,16,18,36,72,74,148,150,300], solve(8,300) )
		assert_equal( [300,150,152,76,38,40,20,10,12,6,8], solve(300,8) )
		assert_equal( [8,10,12,24,48,50,100,200,400], solve(8,400) )
		assert_equal( [400,200,100,50,52,26,28,14,16,8], solve(400,8) )
		assert_equal( [8,10,12,14,28,30,60,62,124,248,250,500], solve(8,500) )
		assert_equal( [500,250,252,126,128,64,32,16,8], solve(500,8) )
		assert_equal( [8,16,18,36,72,74,148,150,300,600], solve(8,600) )
		assert_equal( [600,300,150,152,76,38,40,20,10,12,6,8], solve(600,8) )
		assert_equal( [8,10,20,40,42,84,86,172,174,348,350,700], solve(8,700) )
		assert_equal( [700,350,352,176,88,44,22,24,12,6,8], solve(700,8) )
		assert_equal( [8,10,12,24,48,50,100,200,400,800], solve(8,800) )
		assert_equal( [800,400,200,100,50,52,26,28,14,16,8], solve(800,8) )
		assert_equal( [8,10,12,14,28,56,112,224,448,450,900], solve(8,900) )
		assert_equal( [900,902,904,452,226,228,114,116,58,60,30,32,16,8], solve(900,8) )
		assert_equal( [9,11,22,24,48,50,100], solve(9,100) )
		assert_equal( [100,50,52,26,28,14,7,9], solve(100,9) )
		assert_equal( [9,11,22,24,48,50,100,200], solve(9,200) )
		assert_equal( [200,100,50,52,26,28,14,7,9], solve(200,9) )
		assert_equal( [9,18,36,72,74,148,150,300], solve(9,300) )
		assert_equal( [300,150,152,76,38,40,20,10,5,7,9], solve(300,9) )
		assert_equal( [9,11,22,24,48,50,100,200,400], solve(9,400) )
		assert_equal( [400,200,100,50,52,26,28,14,7,9], solve(400,9) )
		assert_equal( [9,11,13,15,30,60,62,124,248,250,500], solve(9,500) )
		assert_equal( [500,250,252,126,128,64,32,16,18,9], solve(500,9) )
		assert_equal( [9,18,36,72,74,148,150,300,600], solve(9,600) )
		assert_equal( [600,300,150,152,76,38,40,20,10,5,7,9], solve(600,9) )
		assert_equal( [9,18,20,40,42,84,86,172,174,348,350,700], solve(9,700) )
		assert_equal( [700,350,352,176,88,44,22,24,12,14,7,9], solve(700,9) )
		assert_equal( [9,11,22,24,48,50,100,200,400,800], solve(9,800) )
		assert_equal( [800,400,200,100,50,52,26,28,14,7,9], solve(800,9) )
		assert_equal( [9,11,13,26,28,56,112,224,448,450,900], solve(9,900) )
		assert_equal( [900,450,452,226,228,114,116,58,60,30,32,16,18,9], solve(900,9) )		
	end
	
	def test_plus_one_two_three_five_and_ten
		# solutions for i=[159,178], j=[i+1, i+2, i+3, i+5, i+10]
		assert_equal( [159,318,320,160], solve(159,160) )
		assert_equal( [159,161], solve(159,161) )
		assert( [159,161,322,324,162] == solve(159,162) || [159,318,320,160,162] == solve(159,162) )
		assert( [159,161,163,326,328,164] == solve(159,164) || [159,161,322,324,162,164] == solve(159,164) || [159,318,320,160,162,164] == solve(159,164) )
		assert_equal( [159,161,163,165,167,169], solve(159,169) )
		assert_equal( [160,320,322,161], solve(160,161) )
		assert_equal( [160,162], solve(160,162) )
		assert( [160,162,324,326,163] == solve(160,163) || [160,320,322,161,163] == solve(160,163) )
		assert( [160,162,164,328,330,165] == solve(160,165) || [160,162,324,326,163,165] == solve(160,165) || [160,320,322,161,163,165] == solve(160,165) )
		assert( [160,162,164,166,168,170] == solve(160,170) || [160,162,81,83,85,170] == solve(160,170) || [160,80,82,84,168,170] == solve(160,170) )
		assert_equal( [161,322,324,162], solve(161,162) )
		assert_equal( [161,163], solve(161,163) )
		assert( [161,163,326,328,164] == solve(161,164) || [161,322,324,162,164] == solve(161,164) )
		assert( [161,163,165,330,332,166] == solve(161,166) || [161,163,326,328,164,166] == solve(161,166) || [161,322,324,162,164,166] == solve(161,166) )
		assert_equal( [161,163,165,167,169,171], solve(161,171) )
		assert_equal( [162,324,326,163], solve(162,163) )
		assert_equal( [162,164], solve(162,164) )
		assert( [162,164,328,330,165] == solve(162,165) || [162,324,326,163,165] == solve(162,165) )
		assert( [162,164,166,332,334,167] == solve(162,167) || [162,164,328,330,165,167] == solve(162,167) || [162,324,326,163,165,167] == solve(162,167) )
		assert( [162,164,166,168,170,172] == solve(162,172) || [162,164,82,84,86,172] == solve(162,172) || [162,81,83,85,170,172] == solve(162,172) )
		assert_equal( [163,326,328,164], solve(163,164) )
		assert_equal( [163,165], solve(163,165) )
		assert( [163,165,330,332,166] == solve(163,166) || [163,326,328,164,166] == solve(163,166) )
		assert( [163,165,167,334,336,168] == solve(163,168) || [163,165,330,332,166,168] == solve(163,168) || [163,326,328,164,166,168] == solve(163,168) )
		assert_equal( [163,165,167,169,171,173], solve(163,173) )
		assert_equal( [164,328,330,165], solve(164,165) )
		assert_equal( [164,166], solve(164,166) )
		assert( [164,166,332,334,167] == solve(164,167) || [164,328,330,165,167] == solve(164,167) )
		assert( [164,166,168,336,338,169] == solve(164,169) || [164,166,332,334,167,169] == solve(164,169) || [164,328,330,165,167,169] == solve(164,169) )
		assert( [164,166,168,170,172,174] == solve(164,174) || [164,166,83,85,87,174] == solve(164,174) || [164,82,84,86,172,174] == solve(164,174) )
		assert_equal( [165,330,332,166], solve(165,166) )
		assert_equal( [165,167], solve(165,167) )
		assert( [165,167,334,336,168] == solve(165,168) || [165,330,332,166,168] == solve(165,168) )
		assert( [165,167,169,338,340,170] == solve(165,170) || [165,167,334,336,168,170] == solve(165,170) || [165,330,332,166,168,170] == solve(165,170) )
		assert_equal( [165,167,169,171,173,175], solve(165,175) )
		assert_equal( [166,332,334,167], solve(166,167) )
		assert_equal( [166,168], solve(166,168) )
		assert( [166,168,336,338,169] == solve(166,169) || [166,332,334,167,169] == solve(166,169) )
		assert( [166,168,170,340,342,171] == solve(166,171) || [166,168,336,338,169,171] == solve(166,171) || [166,332,334,167,169,171] == solve(166,171) )
		assert( [166,168,170,172,174,176] == solve(166,176) || [166,168,84,86,88,176] == solve(166,176) || [166,83,85,87,174,176] == solve(166,176) )
		assert_equal( [167,334,336,168], solve(167,168) )
		assert_equal( [167,169], solve(167,169) )
		assert( [167,169,338,340,170] == solve(167,170) || [167,334,336,168,170] == solve(167,170) )
		assert( [167,169,171,342,344,172] == solve(167,172) || [167,169,338,340,170,172] == solve(167,172) || [167,334,336,168,170,172] == solve(167,172) )
		assert_equal( [167,169,171,173,175,177], solve(167,177) )
		assert_equal( [168,336,338,169], solve(168,169) )
		assert_equal( [168,170], solve(168,170) )
		assert( [168,170,340,342,171] == solve(168,171) || [168,336,338,169,171] == solve(168,171) )
		assert( [168,170,172,344,346,173] == solve(168,173) || [168,170,340,342,171,173] == solve(168,173) || [168,336,338,169,171,173] == solve(168,173) )
		assert( [168,170,172,174,176,178] == solve(168,178) || [168,170,85,87,89,178] == solve(168,178) || [168,84,86,88,176,178] == solve(168,178) )
		assert_equal( [169,338,340,170], solve(169,170) )
		assert_equal( [169,171], solve(169,171) )
		assert( [169,171,342,344,172] == solve(169,172) || [169,338,340,170,172] == solve(169,172) )
		assert( [169,171,173,346,348,174] == solve(169,174) || [169,171,342,344,172,174] == solve(169,174) || [169,338,340,170,172,174] == solve(169,174) )
		assert_equal( [169,171,173,175,177,179], solve(169,179) )
		assert_equal( [170,340,342,171], solve(170,171) )
		assert_equal( [170,172], solve(170,172) )
		assert( [170,172,344,346,173] == solve(170,173) || [170,340,342,171,173] == solve(170,173) )
		assert( [170,172,174,348,350,175] == solve(170,175) || [170,172,344,346,173,175] == solve(170,175) || [170,340,342,171,173,175] == solve(170,175) )
		assert( [170,172,174,176,178,180] == solve(170,180) || [170,172,86,88,90,180] == solve(170,180) || [170,85,87,89,178,180] == solve(170,180) )
		assert_equal( [171,342,344,172], solve(171,172) )
		assert_equal( [171,173], solve(171,173) )
		assert( [171,173,346,348,174] == solve(171,174) || [171,342,344,172,174] == solve(171,174) )
		assert( [171,173,175,350,352,176] == solve(171,176) || [171,173,346,348,174,176] == solve(171,176) || [171,342,344,172,174,176] == solve(171,176) )
		assert_equal( [171,173,175,177,179,181], solve(171,181) )
		assert_equal( [172,344,346,173], solve(172,173) )
		assert_equal( [172,174], solve(172,174) )
		assert( [172,174,348,350,175] == solve(172,175) || [172,344,346,173,175] == solve(172,175) )
		assert( [172,174,176,352,354,177] == solve(172,177) || [172,174,348,350,175,177] == solve(172,177) || [172,344,346,173,175,177] == solve(172,177) )
		assert( [172,174,176,178,180,182] == solve(172,182) || [172,174,87,89,91,182] == solve(172,182) || [172,86,88,90,180,182] == solve(172,182) )
		assert_equal( [173,346,348,174], solve(173,174) )
		assert_equal( [173,175], solve(173,175) )
		assert( [173,175,350,352,176] == solve(173,176) || [173,346,348,174,176] == solve(173,176) )
		assert( [173,175,177,354,356,178] == solve(173,178) || [173,175,350,352,176,178] == solve(173,178) || [173,346,348,174,176,178] == solve(173,178) )
		assert_equal( [173,175,177,179,181,183], solve(173,183) )
		assert_equal( [174,348,350,175], solve(174,175) )
		assert_equal( [174,176], solve(174,176) )
		assert( [174,176,352,354,177] == solve(174,177) || [174,348,350,175,177] == solve(174,177) )
		assert( [174,176,178,356,358,179] == solve(174,179) || [174,176,352,354,177,179] == solve(174,179) || [174,348,350,175,177,179] == solve(174,179) )
		assert( [174,176,178,180,182,184] == solve(174,184) || [174,176,88,90,92,184] == solve(174,184) || [174,87,89,91,182,184] == solve(174,184) )
		assert_equal( [175,350,352,176], solve(175,176) )
		assert_equal( [175,177], solve(175,177) )
		assert( [175,177,354,356,178] == solve(175,178) || [175,350,352,176,178] == solve(175,178) )
		assert( [175,177,179,358,360,180] == solve(175,180) || [175,177,354,356,178,180] == solve(175,180) || [175,350,352,176,178,180] == solve(175,180) )
		assert_equal( [175,177,179,181,183,185], solve(175,185) )
		assert_equal( [176,352,354,177], solve(176,177) )
		assert_equal( [176,178], solve(176,178) )
		assert( [176,178,356,358,179] == solve(176,179) || [176,352,354,177,179] == solve(176,179) )
		assert( [176,178,180,360,362,181] == solve(176,181) || [176,178,356,358,179,181] == solve(176,181) || [176,352,354,177,179,181] == solve(176,181) )
		assert( [176,178,180,182,184,186] == solve(176,186) || [176,178,89,91,93,186] == solve(176,186) || [176,88,90,92,184,186] == solve(176,186) )
		assert_equal( [177,354,356,178], solve(177,178) )
		assert_equal( [177,179], solve(177,179) )
		assert( [177,179,358,360,180] == solve(177,180) || [177,354,356,178,180] == solve(177,180) )
		assert( [177,179,181,362,364,182] == solve(177,182) || [177,179,358,360,180,182] == solve(177,182) || [177,354,356,178,180,182] == solve(177,182) )
		assert_equal( [177,179,181,183,185,187], solve(177,187) )
		assert_equal( [178,356,358,179], solve(178,179) )
		assert_equal( [178,180], solve(178,180) )
		assert( [178,180,360,362,181] == solve(178,181) || [178,356,358,179,181] == solve(178,181) )
		assert( [178,180,182,364,366,183] == solve(178,183) || [178,180,360,362,181,183] == solve(178,183) || [178,356,358,179,181,183] == solve(178,183) )
		assert( [178,180,182,184,186,188] == solve(178,188) || [178,180,90,92,94,188] == solve(178,188) || [178,89,91,93,186,188] == solve(178,188) )
	end
	
	def test_minus_one_two_three_five_and_ten
		# solutions for i=[159,178], j=[i-1, i-2, i-3, i-5, i-10]
		assert_equal( [159,318,320,160,80,40,20,10,5,7,9,18,36,72,74,76,78,156,158], solve(159,158) )
		assert_equal( [159,318,320,160,80,40,42,44,22,11,13,15,17,19,38,76,78,156,312,314,157], solve(159,157) )
		assert_equal( [159,318,320,160,80,40,20,22,11,13,15,17,19,38,76,78,156], solve(159,156) )
		assert( [159,318,320,160,80,40,20,10,5,7,9,18,36,38,76,152,154] == solve(159,154) || [159,318,320,160,80,40,20,22,11,13,15,17,19,38,76,152,154] == solve(159,154) )
		assert_equal( [159,318,320,160,80,40,20,10,5,7,9,18,36,72,144,288,290,145,147,149], solve(159,149) )
		assert_equal( [160,80,40,20,10,5,7,9,18,36,38,76,78,156,312,314,157,159], solve(160,159) )
		assert( [160,80,40,20,10,12,14,16,18,36,38,76,78,156,158] == solve(160,158) || [160,80,40,20,10,5,7,9,18,36,38,76,78,156,158] == solve(160,158) || [160,80,40,20,22,11,13,15,17,19,38,76,78,156,158] == solve(160,158) )
		assert( [160,80,40,20,10,12,14,16,18,36,38,76,78,156,312,314,157] == solve(160,157) || [160,80,40,20,10,5,7,9,18,36,38,76,78,156,312,314,157] == solve(160,157) )
		assert( [160,80,40,20,10,5,7,9,18,36,38,76,152,154,308,310,155] == solve(160,155) || [160,80,40,20,22,11,13,15,17,19,38,76,152,304,306,153,155] == solve(160,155) )
		assert( [160,80,40,20,10,12,14,16,18,36,72,74,148,150] == solve(160,150) || [160,80,40,20,10,5,7,9,18,36,72,74,148,150] == solve(160,150) )
		assert( [161,163,165,167,334,336,168,84,42,44,22,11,13,15,17,19,38,40,80,160] == solve(161,160) || [161,163,326,328,164,166,168,84,42,44,22,11,13,15,17,19,38,40,80,160] == solve(161,160) || [161,322,324,162,164,82,84,42,44,22,24,12,6,3,5,10,20,40,80,160] == solve(161,160) )
		assert_equal( [161,163,326,328,164,82,41,43,86,88,44,22,11,13,15,17,19,38,76,152,304,306,153,155,310,312,314,157,159], solve(161,159) )
		assert( [161,163,165,167,334,336,168,84,42,21,23,25,27,29,31,33,35,37,39,78,156,158] == solve(161,158) || [161,163,326,328,164,82,84,42,21,42,44,22,11,13,15,17,19,38,76,78,156,158] == solve(161,158) || [161,163,326,328,164,82,84,42,44,22,11,13,15,17,19,38,76,152,154,77,79,158] == solve(161,158) )
		assert_equal( [161,163,326,328,164,166,168,84,42,44,22,11,13,15,17,19,38,76,78,156], solve(161,156) )
		assert_equal( [161,322,324,162,164,82,41,43,45,90,92,46,23,25,27,29,31,33,35,37,74,148,150,300,302,151], solve(161,151) )
		assert_equal( [162,164,82,84,42,44,22,11,13,15,17,19,38,76,78,156,312,314,316,318,159,161], solve(162,161) )
		assert_equal( [162,164,82,84,42,44,22,11,13,15,17,19,38,40,80,160], solve(162,160) )
		assert_equal( [162,81,162,164,82,84,42,44,46,23,25,27,29,31,33,35,37,39,78,156,312,314,157,159], solve(162,159) )
		assert_equal( [162,164,82,41,82,84,42,21,23,25,27,29,31,33,35,37,39,78,156,312,314,157], solve(162,157) )
		assert_equal( [162,164,82,84,42,44,22,11,13,15,17,19,38,76,152], solve(162,152) )
		assert( [163,326,328,164,166,168,84,42,44,22,24,12,14,16,18,36,38,40,80,160,162] == solve(163,162) || [163,326,328,164,166,168,84,42,44,22,24,26,13,15,17,19,38,40,80,160,162] == solve(163,162) )
		assert( [163,165,167,334,336,168,84,42,44,22,11,13,15,17,19,38,76,78,80,160,320,322,161] == solve(163,161) || [163,326,328,164,82,84,42,21,42,44,22,24,12,6,8,10,20,40,80,160,320,322,161] == solve(163,161) )
		assert_equal( [163,326,328,164,82,84,42,44,22,24,12,14,16,18,20,40,80,160], solve(163,160) )
		assert_equal( [163,165,330,332,166,168,84,42,21,23,25,27,29,31,33,35,37,39,78,156,158], solve(163,158) )
		assert_equal( [163,326,328,164,82,84,42,44,22,11,13,15,17,19,38,76,152,304,306,153], solve(163,153) )
		assert_equal( [164,82,84,42,44,22,11,13,15,17,19,38,40,80,160,320,322,161,163], solve(164,163) )
		assert( [164,82,84,42,44,22,11,13,15,17,19,38,40,80,160,162] == solve(164,162) || [164,82,84,42,44,22,24,12,14,16,18,20,40,80,160,162] == solve(164,162) )
		assert_equal( [164,166,168,84,42,44,22,24,12,6,8,10,20,40,80,160,320,322,161], solve(164,161) )
		assert_equal( [164,82,84,42,44,22,11,13,15,17,19,38,76,78,156,312,314,157,159], solve(164,159) )
		assert_equal( [164,82,84,42,44,22,11,13,15,17,19,38,76,152,154], solve(164,154) )
		assert_equal( [165,167,334,336,168,84,42,21,23,25,27,29,31,33,35,37,39,41,82,164], solve(165,164) )
		assert_equal( [165,167,334,336,168,84,42,21,23,25,27,29,31,33,35,37,39,78,80,160,162,324,326,163], solve(165,163) )
		assert( [165,167,334,336,168,84,42,44,22,11,13,15,17,19,38,40,80,160,162] == solve(165,162) || [165,330,332,166,168,84,42,44,22,11,13,15,17,19,38,40,80,160,162] == solve(165,162) )
		assert( [165,167,334,336,168,84,42,44,22,11,13,15,17,19,38,40,80,160] == solve(165,160) || [165,167,334,336,168,84,42,44,22,24,12,6,8,10,20,40,80,160] == solve(165,160) )
		assert( [165,167,334,336,168,84,42,44,22,11,13,15,17,34,36,72,144,146,148,150,300,302,151,153,155] == solve(165,155) || [165,330,332,334,336,168,84,42,84,86,88,44,22,11,13,15,17,19,38,76,152,304,306,153,155] == solve(165,155) )
		assert_equal( [166,168,84,42,21,23,25,27,29,31,33,35,37,74,76,78,80,82,164,328,330,165], solve(166,165) )
		assert_equal( [166,168,84,42,44,22,11,13,15,17,19,38,40,80,82,164], solve(166,164) )
		assert_equal( [166,168,84,42,44,22,24,26,28,14,16,18,20,40,80,160,320,322,161,163], solve(166,163) )
		assert_equal( [166,168,84,42,44,22,11,13,15,17,19,38,40,80,160,320,322,161], solve(166,161) )
		assert_equal( [166,168,84,42,44,22,11,13,15,17,19,38,76,78,156], solve(166,156) )
		assert_equal( [167,334,336,168,84,42,44,22,11,13,15,17,19,38,40,80,160,162,81,162,164,166], solve(167,166) )
		assert_equal( [167,169,171,342,344,172,86,43,86,88,44,22,11,13,15,17,19,38,40,80,82,41,82,164,328,330,165], solve(167,165) )
		assert( [167,334,336,168,84,42,21,23,25,27,29,31,33,35,37,39,41,82,164] == solve(167,164) || [167,334,336,168,84,42,44,22,11,13,15,17,19,38,40,80,160,162,164] == solve(167,164) || [167,334,336,168,84,42,44,22,11,13,15,17,34,36,38,40,80,82,164] == solve(167,164) || [167,334,336,168,84,42,44,22,24,12,6,8,10,20,40,80,160,162,164] == solve(167,164) )
		assert_equal( [167,334,336,168,84,42,44,22,11,13,15,17,19,38,40,80,160,162], solve(167,162) )
		assert_equal( [167,334,336,168,84,42,21,23,25,27,29,31,33,35,37,39,78,156,312,314,157], solve(167,157) )
		assert( [168,84,42,44,22,24,12,14,16,8,10,20,40,80,82,164,166,332,334,167] == solve(168,167) || [168,84,42,44,22,24,12,6,3,5,10,20,40,80,82,164,166,332,334,167] == solve(168,167) )
		assert( [168,84,42,44,22,11,13,15,17,19,38,40,80,82,164,166] == solve(168,166) || [168,84,42,44,22,24,12,6,8,10,20,40,80,82,164,166] == solve(168,166) )
		assert( [168,84,42,44,22,11,13,15,17,19,38,40,80,160,162,324,326,163,165] == solve(168,165) || [168,84,42,44,22,11,13,15,17,19,38,40,80,160,320,322,161,163,165] == solve(168,165) || [168,84,42,44,22,24,12,6,8,16,18,20,40,80,82,164,328,330,165] == solve(168,165) )
		assert( [168,84,42,44,22,11,13,15,17,19,38,40,80,160,162,324,326,163] == solve(168,163) || [168,84,42,44,22,11,13,15,17,19,38,40,80,160,320,322,161,163] == solve(168,163) )
		assert_equal( [168,84,42,44,22,11,13,15,17,19,38,76,78,156,158], solve(168,158) )
		assert( [169,171,342,344,172,86,43,86,88,44,22,11,13,15,17,19,21,42,84,168] == solve(169,168) || [169,171,342,344,172,86,88,44,46,48,24,12,14,16,18,20,40,42,84,168] == solve(169,168) || [169,338,340,170,85,170,172,86,88,44,22,11,13,15,17,19,21,42,84,168] == solve(169,168) )
		assert( [169,171,173,346,348,174,176,88,44,22,11,13,15,17,19,38,76,78,80,82,164,166,332,334,167] == solve(169,167) || [169,171,342,344,172,86,88,44,22,11,13,15,17,19,38,40,80,82,41,82,164,166,332,334,167] == solve(169,167) )
		assert_equal( [169,171,342,344,172,86,88,44,22,24,26,13,15,17,19,38,40,80,82,164,166], solve(169,166) )
		assert( [169,171,173,175,350,352,176,88,44,22,11,13,15,17,34,36,38,40,80,82,164] == solve(169,164) || [169,171,173,346,348,174,176,88,44,22,11,13,15,17,19,38,76,78,80,82,164] == solve(169,164) || [169,171,342,344,172,174,176,88,44,22,11,13,15,17,34,36,38,40,80,82,164] == solve(169,164) || [169,171,342,344,172,86,88,44,22,11,13,15,30,32,34,36,38,40,80,82,164] == solve(169,164) || [169,338,340,342,344,172,86,88,44,22,24,12,6,3,5,10,20,40,80,82,164] == solve(169,164) )
		assert_equal( [169,171,342,344,346,348,174,176,88,44,22,11,13,15,17,19,38,76,78,156,158,316,318,159], solve(169,159) )
		assert_equal( [170,172,86,88,44,22,11,13,15,17,19,21,42,84,168,336,338,169], solve(170,169) )
		assert_equal( [170,172,86,88,44,22,11,13,15,17,19,21,42,84,168], solve(170,168) )
		assert( [170,172,174,176,88,44,22,11,13,15,17,19,38,40,80,160,320,322,161,163,165,167] == solve(170,167) || [170,172,86,88,44,46,23,25,27,29,31,33,35,37,39,41,82,164,166,332,334,167] == solve(170,167) )
		assert_equal( [170,172,174,176,88,44,22,11,13,15,17,19,38,40,80,82,164,328,330,165], solve(170,165) )
		assert( [170,172,86,88,44,22,11,13,15,17,19,38,40,80,160] == solve(170,160) || [170,172,86,88,44,22,24,12,14,16,18,20,40,80,160] == solve(170,160) || [170,172,86,88,44,22,24,12,6,8,10,20,40,80,160] == solve(170,160) )
		assert_equal( [171,173,175,350,352,176,88,44,22,11,13,15,17,19,38,40,42,84,168,170], solve(171,170) )
		assert_equal( [171,342,344,172,174,176,88,44,46,23,25,50,52,26,13,15,17,19,21,42,84,168,336,338,169], solve(171,169) )
		assert_equal( [171,342,344,172,86,88,44,22,11,13,15,17,19,21,42,84,168], solve(171,168) )
		assert_equal( [171,342,344,172,86,88,44,22,24,12,14,16,18,9,18,20,40,80,82,164,166], solve(171,166) )
		assert_equal( [171,342,344,172,86,88,44,22,24,12,6,8,10,20,40,80,160,320,322,161], solve(171,161) )
		assert_equal( [172,86,88,44,22,11,13,15,17,19,21,42,84,168,336,338,169,171], solve(172,171) )
		assert_equal( [172,86,88,44,22,11,13,15,17,19,21,42,84,168,170], solve(172,170) )
		assert_equal( [172,86,88,44,22,11,13,15,17,19,21,42,84,168,336,338,169], solve(172,169) )
		assert_equal( [172,86,88,44,46,48,24,12,6,8,10,20,40,80,82,164,328,330,165,167], solve(172,167) )
		assert( [172,86,88,44,22,11,13,15,17,19,38,40,80,160,162] == solve(172,162) || [172,86,88,44,22,24,12,6,8,10,20,40,80,160,162] == solve(172,162) )
		assert( [173,175,350,352,176,88,44,22,11,13,15,17,19,21,42,84,86,172] == solve(173,172) || [173,346,348,174,176,88,44,22,11,13,15,17,19,21,42,84,86,172] == solve(173,172) )
		assert_equal( [173,175,350,352,176,88,44,22,11,13,15,17,19,21,42,84,168,336,338,169,171], solve(173,171) )
		assert_equal( [173,346,348,174,176,88,44,22,11,13,15,17,19,21,42,84,168,170], solve(173,170) )
		assert_equal( [173,175,350,352,176,88,44,22,11,13,15,17,19,21,42,84,168], solve(173,168) )
		assert_equal( [173,175,350,352,176,88,44,22,11,13,15,17,19,38,76,78,80,160,320,322,161,322,324,326,163], solve(173,163) )
		assert_equal( [174,176,88,44,22,11,13,15,17,19,21,42,84,86,172,344,346,173], solve(174,173) )
		assert_equal( [174,176,88,44,22,11,13,15,17,19,21,42,84,86,172], solve(174,172) )
		assert_equal( [174,176,88,44,22,11,13,15,17,19,21,42,84,168,336,338,169,171], solve(174,171) )
		assert_equal( [174,176,88,44,22,11,13,15,17,19,21,42,84,168,336,338,169], solve(174,169) )
		assert( [174,176,88,44,22,11,13,15,17,19,38,40,80,82,164] == solve(174,164) || [174,176,88,44,22,24,12,14,16,18,20,40,80,82,164] == solve(174,164) )
		assert_equal( [175,350,352,176,88,44,22,11,13,15,17,19,21,42,84,86,172,174], solve(175,174) )
		assert_equal( [175,350,700,702,704,352,176,88,44,22,11,13,15,17,19,38,40,42,84,86,172,344,346,173], solve(175,173) )
		assert_equal( [175,350,352,176,88,44,22,11,13,15,17,19,21,42,84,86,172], solve(175,172) )
		assert_equal( [175,350,352,176,88,44,22,11,13,15,17,19,21,42,84,168,170], solve(175,170) )
		assert_equal( [175,350,352,176,88,44,22,11,13,15,17,19,38,76,78,156,158,316,318,159,161,163,165], solve(175,165) )
		assert_equal( [176,88,44,22,11,13,15,17,19,21,42,84,86,172,344,346,173,175], solve(176,175) )
		assert_equal( [176,88,44,22,11,13,15,17,19,21,42,84,86,172,174], solve(176,174) )
		assert_equal( [176,88,44,22,11,13,15,17,19,21,42,84,86,172,344,346,173], solve(176,173) )
		assert( [176,88,44,22,11,13,15,17,19,21,42,84,168,170,340,342,171] == solve(176,171) || [176,88,44,22,11,13,15,17,19,21,42,84,168,336,338,169,171] == solve(176,171) )
		assert_equal( [176,88,44,22,11,13,15,17,19,38,40,80,82,164,166], solve(176,166) )
		assert_equal( [177,179,181,362,364,182,184,92,46,48,24,12,14,7,9,11,22,44,88,176], solve(177,176) )
		assert_equal( [177,179,358,360,180,90,45,47,94,96,48,24,26,13,15,17,19,38,40,42,84,86,172,344,346,348,174,348,350,175], solve(177,175) )
		assert_equal( [177,179,181,183,366,368,184,92,46,23,25,27,29,31,33,35,37,39,41,43,86,172,174], solve(177,174) )
		assert_equal( [177,179,181,362,364,182,184,92,46,23,25,27,29,31,33,35,37,39,41,43,86,172], solve(177,172) )
		assert_equal( [177,179,358,360,180,90,92,46,48,24,12,6,8,10,20,40,80,82,164,166,83,166,332,334,167], solve(177,167) )
		assert_equal( [178,180,90,92,46,48,24,12,6,3,5,10,20,22,44,88,176,352,354,177], solve(178,177) )
		assert_equal( [178,180,90,92,46,48,24,12,14,7,9,11,22,44,88,176], solve(178,176) )
		assert_equal( [178,180,90,92,46,48,24,12,6,8,16,18,20,40,80,82,41,82,84,168,336,338,169,171,173,175], solve(178,175) )
		assert( [178,180,90,45,90,92,46,48,24,26,28,30,15,17,19,21,42,84,168,336,338,169,171,173] == solve(178,173) || [178,180,90,92,46,48,24,12,6,8,16,18,20,40,80,82,41,82,84,86,172,344,346,173] == solve(178,173) || [178,180,90,92,46,48,50,25,27,29,31,33,35,37,39,41,82,84,168,170,172,344,346,173] == solve(178,173) )
		assert_equal( [178,180,90,92,46,48,24,26,13,15,17,19,21,42,84,168], solve(178,168) )
	end
	
	def test_powers_of_two
		# solutions for some simple powers of 2 cases
		assert_equal( [2,4], solve(2,4) )
		assert_equal( [2,4,8], solve(2,8) )
		assert_equal( [2,4,8,16], solve(2,16) )
		assert_equal( [2,4,8,16,32], solve(2,32) )
		assert_equal( [2,4,8,16,32,64], solve(2,64) )
		assert_equal( [2,4,8,16,32,64,128], solve(2,128) )
		assert_equal( [2,4,8,16,32,64,128,256], solve(2,256) )
		assert_equal( [2,4,8,16,32,64,128,256,512], solve(2,512) )
		assert_equal( [2,4,8,16,32,64,128,256,512,1024], solve(2,1024) )
		assert_equal( [4,2], solve(4,2) )
		assert_equal( [8,4,2], solve(8,2) )
		assert_equal( [16,8,4,2], solve(16,2) )
		assert_equal( [32,16,8,4,2], solve(32,2) )
		assert_equal( [64,32,16,8,4,2], solve(64,2) )
		assert_equal( [128,64,32,16,8,4,2], solve(128,2) )
		assert_equal( [256,128,64,32,16,8,4,2], solve(256,2) )
		assert_equal( [512,256,128,64,32,16,8,4,2], solve(512,2) )
		assert_equal( [1024,512,256,128,64,32,16,8,4,2], solve(1024,2) )
	end
	
	def test_primes
		# just a few prime cases
		assert_equal( [23,25,27,29], solve(23,29) )
		assert( [23,25,27,29,58,116,118,236,238,476,478,956,958,479] == solve(23,479) || [23,25,27,29,58,116,118,236,238,476,952,954,477,479] == solve(23,479) )
		assert_equal( [479,958,960,480,240,120,60,30,15,17,19,21,23], solve(479,23) )
		assert_equal( [479,481,483,485,487,489,491,493,495,497,499], solve(479,499) )
	end
	
end