import java.io.BufferedReader;
import java.io.IOException;
import java.io.StringReader;
import java.util.Arrays;
import java.util.Scanner;
import java.util.Stack;

public class MainApp {
		
	// czytanie inputu z System.in
	static Scanner reader = new Scanner(System.in);  
	
	public static void main(String[] args) {
		
		// liczniki indeksow wielomianow
		int counterFirst = 0, counterSecond = 0;
		
		// wielomiany + pomocniczme stosy
		int polyOne[];
		Stack<Integer> p1 = new Stack<Integer>();
		int polyTwo[];
		Stack<Integer> p2 = new Stack<Integer>();

		// wspolczynnik n
		int n=1;
	
		
		String str;
        String input;
        
        char temp;
        
		input = args[0];
		
		BufferedReader read = new BufferedReader(
		  new StringReader(input));
		         
		// od poczatku pierwszego wielomianu '['
		int i = 3;
		try {
		  if ((str = read.readLine()) != null) {
		                 
		          if (str.length() > 0) {
		                 n = Character.getNumericValue(str.charAt(0));
		          }
		          temp = str.charAt(i);
		          while(temp != ']') {
		        	  
		        	  if(temp != ',') {
		        	    p1.push(Character.getNumericValue(temp));
		        	  	counterFirst++;
		        	  }
		        	  i++;
		        	  temp = str.charAt(i);
		          }
		          
		          // przejscie do drugiej tablicy (zakladamy ze wielomiany oddzielone sa spacja)
		          i += 3;
		          temp = str.charAt(i);
		          
		          while(temp != ']') {
			   
		        	  if(temp != ',') {
			        	    p2.push(Character.getNumericValue(temp));
			        	  	counterSecond++;
			        	  }
			          i++;
			       	  temp = str.charAt(i);
			     }
		          
		        // inicjalizacja tablic
		        polyOne = new int[counterFirst];
		  		polyTwo = new int[counterSecond];
		  		
		  		// wypelnianie tablic
		  		for(int j=polyOne.length-1; j>=0; j--) {
		  			
		  			polyOne[j] = p1.pop();
		  		}
		  		
		  		for(int j=polyTwo.length-1; j>=0; j--) {
		  			polyTwo[j] = p2.pop();
		  		}
		  		
		  		
				// wyswietl wielomiany
				System.out.println("f:" + Arrays.toString(polyOne));
				System.out.println("g:" + Arrays.toString(polyTwo));
				
				// 1.
				System.out.println("1. iloczyn f*g: ");
				int res[] = modTheTab(polynomialsMultiplication(polyOne, polyTwo),n);
				System.out.println(Arrays.toString(res));
				
				// 2.
				System.out.println("2. klasa reszty: ");
				res = polynomialsDivide(polyOne,polyTwo,n);
				if(res != null){
					System.out.println(Arrays.toString(res));
				}
				
				// 3.
				System.out.println("3. nwd: ");
				res = nwd(polyOne,polyTwo,n);
				System.out.println(Arrays.toString(res));
				
				reader.close();
		   }
		 
		} catch(IOException e) {
		  e.printStackTrace();
		}
		
		//input
		/*
		do{
			System.out.println("Podaj n: ");
			// wpisz liczbe
			n = reader.nextInt();

		}while(n > 1000 || n <= 0);
		
		
		System.out.println("Pierwszy wielomian: ");
		polyOne = fillPolynomial();
		
		System.out.println("Drugi wielomian: ");
		polyTwo = fillPolynomial();
		*/
		
		
		reader.close();
	}

	
	// uzupelnianie tablicy
	public static int[] fillPolynomial() {
		
		// zmienna pomocnicza 
		int temp = 0;
		
		System.out.println("Podaj liczbe wyrazow w wielomianie: ");
		temp = reader.nextInt();
		
		int[] tab = new int[temp];
		
		// uzupelnianie pierwszego wielomianu
		System.out.println("Podaj kolejne wyrazy wielomianu po przycisku enter");

		for(int i=0; i<tab.length; i++){
			
			temp = reader.nextInt();
			
			tab[i] = temp;
		}
		return tab;
	}
	
	
	// dzielenie modulo tablicy
	public static int[] modTheTab(int tab[], int mod) {
		
		for(int i=0; i<tab.length; i++) {
			tab[i] = tab[i] % mod;
		}
		return tab;
	}
	
	// 1. mnozenie wielomianow
	public static int[] polynomialsMultiplication(int polyOne[], int polyTwo[]) {
		
		// suma dlugosci
		int amount = polyOne.length + polyTwo.length;
		
		// nowa tablica bedzie dlugosci sumy poteg wyrazow wiodacych obu tablic -1
		int result[] = new int[amount-1];
		
		// wypelnienie nowej tablicy zerami
		for(int i=0; i<result.length; i++) {
			result[i] = 0;
		}
		// mnozenie
		for(int i=0; i<polyOne.length; i++) {
			
			for(int j=0; j<polyTwo.length; j++) {
				result[i+j] += polyOne[i] * polyTwo[j];
			}
		}
		return result;
	}
	
	public static int[] polynomialMultiplication(int poly[], int number) {
		
		for(int i=0; i<poly.length; i++) {
			poly[i] *= number;
		}
		
		return poly;
	}
	
	public static int[] polynomialsSubstraction(int polyOne[], int polyTwo[]) {
		
		int result[] = Arrays.copyOf(polyOne, polyOne.length);
		
		// wypelnienie tablicy zerami
		for(int i=0; i<result.length; i++) {
			result[i] = 0;
		}
		
		for(int i=0; i<polyOne.length; i++) {
			result[i] = polyOne[i] - polyTwo[i];
		}
		
		return result;
	}
	
	public static int multiplier(int lo, int lt, int mod) {
		
		for(int i=0; i<mod; i++) {
		
			if(lo ==  (lt*i) % mod) {
				return i;
			}
		}
		
		// error
		return -1;
	}

	public static int[] polynomialShift(int poly[], int places) {
			
		// jesli przesunac w lewo o 0 to kopiuj tablice
		if(places == 0) {
			int[] res = Arrays.copyOf(poly, poly.length);
			return res;
		}
		// bardzo brzydkie przesuwanie
		else {
			int[] res = new int[poly.length];
			
			for(int i=0; i<poly.length-places; i++) {
				res[i] = poly[i+places];
			}
			
			for(int j=poly.length - places + 1; j<res.length; j++) {
				res[j]=0;
			}
			
			return res;
		}
	}
	
	//2. Dzielenie wielomianow
	public static int[] polynomialsDivide(int polyOne[], int polyTwo[], int mod) {
		
		if(polyOne.length < polyTwo.length) {
			System.out.println("Division error");
			return null;
		}
		
		// druga tablica ale z rowna liczba indeksow co pierwsza
		int[] tempTab = new int[polyOne.length];
		// output
		int[] result;
		
		// wypelnienie tablicy zerami
		for(int i=0; i<tempTab.length; i++) {
			tempTab[i] = 0;
		}
		
		// wypelnienie tablicy od konca elementami z konca drugiego wielomianu
		for(int j=0; j<polyTwo.length; j++) {
			tempTab[tempTab.length - 1 - j] = polyTwo[polyTwo.length - 1 - j];
		}
		
		// stopnie wielomianow
		int pod = polyOne.length-1;
		int ptd = polyTwo.length-1;
		
		// liczba przez ktora bedziemy mnozyc tablice
		int temp,i=0;
		
		// dopóki wielomian w ostatnim rzędzie nie będzie stopnia mniejszego niż stopień dzielnika
		while(pod >= ptd) {
			
			// modulo dla ujemnych
			if(polyOne[pod]<0) {
				polyOne[pod] = mod + polyOne[pod];
			}
			
			// szukany mnoznik
			temp =  multiplier(polyOne[pod], polyTwo[ptd], mod);
			
			// przesuniecie tablicy
			tempTab = polynomialShift(tempTab,i);
			
			// mnozenie wielomianow
			tempTab = polynomialMultiplication(tempTab, temp);
			
			tempTab = modTheTab(tempTab, mod);
			
			// odejmowanie wielomianow
			polyOne = polynomialsSubstraction(polyOne,tempTab);
			
			// zmiejszamy stopien pierwszego wielomianu
			pod--;
			
			// zwiekszamy liczbe przesuniec drugiej tablicy
			i++;
			
		}
		result = Arrays.copyOf(polyOne, i-1);
		
		return result;
	}
	
	// 3.
	public static int[] nwd(int polyOne[], int polyTwo[], int mod) {
		
		if(polyTwo.length == 0) {
			return polyOne;
		}
		if(polyOne.length >= polyTwo.length) {
			return nwd(polyTwo, polynomialsDivide(polyOne,polyTwo,mod),mod);
		}
		else {
			return nwd(polyTwo, polynomialsDivide(polyTwo,polyOne,mod),mod);
		}
	}
		
}