How to build the heliocentric algorithm?

Question

Given this problem:

Consider two of the planets in the orbital system: Earth and Mars. Assume the Earth orbits the Sun in exactly 365 Earth days, and Mars orbits the Sun in exactly 687 Earth days. Thus the Earth’s orbit starts at day 0 and continues to day 364, and then starts over at day 0. Mars orbits similarly, but on a 687-day time scale.

We would like to find out how long it will take until both planets are on day. 0 of their orbits simultaneously. Write a program that can determine this.

Input Format:

The first line of input contains an integer N indicating the number of test cases. N lines follow. Each test case contains two integers E and M. These indicate which days Earth and Mars are at their respective orbits.

Output Format:

For each case, display the case number followed by the smallest number of days until the two planets will both be on day 0 of their orbits. Follow the format of the sample output.

Sample Input 1

0 0

364 686

360 682

0 1

1 0

Sample Output 1

Case 1: 0

Case 2: 1

Case 3: 5

Case 4: 239075

Case 5: 11679

I tried solving the problem using modules but it doesn't seem correct

static string readInput;
static string firstStr = "";
static string secondStr = "";
static int firstInput;
static int secondInput;
static int testCases = 10;
static int caseNumber = 1;
static int outPut;
caseNumber <= testCases

static void Main(string[] args) {
  //recall runProcess as long caseNumber is less or equal testCases
  while (caseNumber <= testCases) {
    runProcess();
    Console.WriteLine("Case " + caseNumber + ": " + outPut);
    caseNumber++;
  }
}

Read input from console:

/// <summary>
/// This is the main process, is extracted to void so we can recall it.
/// </summary>
public static void runProcess() {
  readInput = Console.ReadLine();
  if (readInput != null) {
    for (int i = 0; i < readInput.Length; i++) {
      secondStr = secondStr + readInput[i];
      if (readInput[i] == ' ') {
        firstStr = secondStr;
        secondStr = "";
        continue;
      }
    }
  }
  firstInput = Convert.ToInt32(firstStr);
  secondInput = Convert.ToInt32(secondStr);
  outPut = atZero(firstInput, secondInput);
}

/// <summary>
/// This method takes the input data from the console to later determine the zero point
/// </summary>
/// <param name="earthDays"></param>
/// <param name="marsDays"></param>
/// <returns></returns>
public static int atZero(int earthDays, int marsDays) {
  int earthOrbit = 365;
  int marsOrbit = 687;
  int modEarth = earthOrbit;
  int modMars = marsOrbit;
  int earthDistinction = earthOrbit - earthDays;
  int marsDistinction = marsOrbit - marsDays;
  if ((modInverse(earthDistinction, marsDistinction, modMars)) == 0) {
    return (modInverse(marsDistinction, earthDistinction, modEarth)) * marsDistinction;
  } else {
    return (modInverse(earthDistinction, marsDistinction, modMars)) * earthDistinction;
  }
}

mod invert

/// <summary>
/// The method below takes a denominator, numerator and a mod to later invert the mod.
/// </summary>
/// <param name="denominator"></param>
/// <param name="numerator"></param>
/// <param name="mod"></param>
/// <returns>modInverse</returns>
static int modInverse(int denominator, int numerator, int mod) {
  int i = mod, outputAll = 0, d = numerator;
  while (denominator > 0) {
    int divided = i / denominator, x = denominator;
    denominator = i % x;
    i = x;
    x = d;
    d = outputAll - divided * x;
    outputAll = x;
  }
  outputAll %= mod;
  if (outputAll < 0) outputAll = (outputAll + mod) % mod;
  return outputAll;
}

Is there any way to solve the problem without modules?

Thanks.

Answer 1

One more solution for this problem

private static int DaysTillBothAt0(int currentEarthday, int currentMarsday) {
 int count = 365 - currentEarthday;
 currentMarsday = (currentMarsday + count) % 687;
 while (currentMarsday != 0) {
     currentMarsday = (currentMarsday + 365) % 687;
     count += 365;
}
return currentMarsday;
}