Problem:
Skyscraper "MinatoHarukas"

Mr. Port plans to start a new business renting one or more floors
of the new skyscraper with one giga floors, MinatoHarukas.

He wants to rent as many vertically adjacent floors as possible,
because he wants to show advertisement on as many vertically
adjacent windows as possible.

The rent for one floor is proportional to the floor number,
that is, the rent per month for the n-th floor is n times
that of the first floor.
Here, the ground floor is called the first floor in the American style,
and basement floors are out of consideration for the renting.

In order to help Mr. Port, you should write a program that computes
the vertically adjacent floors satisfying his requirement and
whose total rental cost per month is
exactly equal to his budget.

For example, when his budget is 15 units,
with one unit being the rent of the first floor,
there are four possible rent plans,
1+2+3+4+5, 4+5+6, 7+8, and 15.
For all of them, the sums are equal to 15.
Of course in this example the rent of maximal number of the floors
is that of 1+2+3+4+5, that is, the rent from the first floor to the fifth floor.

Input

The input consists of multiple datasets,
each in the following format.

b

A dataset consists of one line,
the budget of Mr. Port b as multiples of the rent of the first floor.
b  is a positive integer satisfying 1 < b < 109.

The end of the input is indicated by a line containing a zero.
The number of datasets does not exceed 1000.

Output

For each dataset, output a single line containing two positive integers
representing the plan with the maximal number of vertically adjacent floors
with its rent price exactly equal to the budget of Mr. Port.
The first should be the lowest floor number and
the second should be the number of floors.

Sample Input

15
16
2
3
9699690
223092870
847288609
900660121
987698769
999999999
0

Output for the Sample Input

1 5
16 1
2 1
1 2
16 4389
129 20995
4112949 206
15006 30011
46887 17718
163837 5994

Solution in JAVA (judge verdict: Accepted)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UncheckedIOException;
import java.util.StringTokenizer;

public class Main {
	public static void main(String[] args) {
		SC sc = new SC(System.in);
		while(true) {
			long b=sc.nextLong();
			if(b==0) {
				System.exit(0);
			}
			else {
				long root=root(2*b);
				for(long i=root; i>=1; i--) {
					//(n-k+1)<(n+k)で小さい方の約数探索
					if((2*b)%i==0) {
						//n-k+1が発見された
						long npk=(2*b)/i;		//(N+K)
						long n=(npk+i-1)/2;
						long k=-i+n;
						if((n*(n+1)/2)-(k*(k+1)/2)==b) {
							pl(k+1+" "+(n-k));
							break;
						}
					}
				}
			}
		}
	}
	static class SC {
		private BufferedReader reader = null;
		private StringTokenizer tokenizer = null;
		public SC(InputStream in) {
			reader = new BufferedReader(new InputStreamReader(in));
		}
		public String next() {
			if (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new UncheckedIOException(e);
				}
			}
			return tokenizer.nextToken();
		}
		public int nextInt() {
			return Integer.parseInt(next());
		}
		public long nextLong() {
			return Long.parseLong(next());
		}
		public double nextDouble() {
			return Double.parseDouble(next());
		}
		public String nextLine() {
			try {
				return reader.readLine();
			} catch (IOException e) {
				throw new UncheckedIOException(e);
			}
		}
	}
	public static void pl(Object o) {
		System.out.println(o);
	}
	public static void pl() {
		System.out.println();
	}
	public static void p(Object o) {
		System.out.print(o);
	}
	static long root(long a) {

		int ketasu=0;
		long tmp=a;
		while(tmp>0) {
			ketasu++;
			tmp/=10;
		}
		int constant=(ketasu+1)/2;	//よく使うので定数化
		if(ketasu>=1) {
			long[] suuji=new long[constant];
			tmp=a;
			for(int i=0; i<constant; i++) {
				suuji[constant-1-i]=a%100L;
				a/=100L;
			}
			long ans=0;
			long kai=0;
			long mae=0;
			if(constant<=1) {
				for(long i=10L; i>=0L; i--) {
					if(suuji[0]>=i*i) {
						return i;
					}
				}
			}
			else {
				for(long i=0L; i<((long)constant); i++) {
					mae+=kai*2;
					for(long j=9L; j>=0L; j--) {
						if((mae*10L+j)*j<=suuji[(int)i]) {
							ans=ans*10+j;
							mae*=10;
							kai=j;
							if(i+1<((long)constant)) {
								suuji[(int)i+1]+=(suuji[(int)i]-(mae+j)*j)*100;
							}
							break;
						}
					}
				}
			}
			return ans;
		}
		else {
			return 0;
		}
	}
}