public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int[] a = new int[n];
        for(int a_i=0; a_i < n; a_i++){
            a[a_i] = in.nextInt();
        }
        int[] b = new int[m];
        for(int b_i=0; b_i < m; b_i++){
            b[b_i] = in.nextInt();
        }
        
        int f = lcm(a);
        int l = gcd(b);
        int count = 0;
        for(int i = f, j =2; i<=l; i=f*j,j++){
            if(l%i==0){ count++;}
        }
        System.out.println(count);
    }

    
    private static int gcd(int a, int b) {
        while (b > 0) {
            int temp = b;
            b = a % b; // % is remainder
            a = temp;
        }
        return a;
    }

    private static int gcd(int[] input) {
        int result = input[0];
        for (int i = 1; i < input.length; i++) {
            result = gcd(result, input[i]);
        }
        return result;
    }

    private static int lcm(int a, int b) {
        return a * (b / gcd(a, b));
    }

    private static int lcm(int[] input) {
        int result = input[0];
        for (int i = 1; i < input.length; i++) {
            result = lcm(result, input[i]);
        }
        return result;
    }

#!/bin/python3

import sys
from functools import reduce


def lcm(a: int, b: int) -> int:
    return a * b // gcd(a, b)


def lcm_list(lst: list) -> int:
    return reduce(lcm, lst)


def gcd(a: int, b: int) -> int:
    while a % b != 0:
        a, b = b, (a % b)
    return b


def gcd_list(lst: list) -> int:
    return reduce(gcd, lst)


def evenly_divides(number: int, divisor: int) -> bool:
    return (number % divisor) == 0


def get_input():
    n, m = input().strip().split()
    n, m = [int(n), int(m)]
    a = [int(a_temp) for a_temp in input().strip().split()]
    b = [int(b_temp) for b_temp in input().strip().split()]
    return n, m, a, b


def main():
    n, m, a, b = get_input()
    
    # Find LCM of all integers of a
    lcm_value = lcm_list(a)
    
    # Find GCD of all integers of b
    gcd_value = gcd_list(b)
    
    # Count the number of multiples of LCM that evenly divides the GCD.
    counter = 0
    multiple_of_lcm = lcm_value
    while multiple_of_lcm <= gcd_value:
        if evenly_divides(gcd_value, multiple_of_lcm):
            counter += 1
        multiple_of_lcm += lcm_value

    print(counter)

    
if __name__ == "__main__":
    main()

import sys
def lcm(a):
    if len(a)==1:
        return a[0]
    if len(a)==2:
        return a[0]*a[1]//gcd((a[0],a[1]))
    return lcm((a[0],lcm(a[1:])))

def gcd(a):
    if len(a)==1:
        return a[0]
    if len(a)==2:
        return gcd((a[1],a[0]%a[1])) if a[1]!=0 else a[0] # Euclid's alg
    return gcd((a[0],gcd(a[1:])))

input()
lcm_a = lcm([x for x in map(int,input().strip().split())])
gcd_b = gcd([x for x in map(int,input().strip().split())])
print(sum(1 for x in range(lcm_a,gcd_b+1,lcm_a) if gcd_b%x==0))

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;


class solution
{

  int gcd(int m,int n)
  {
      if(n==0) //gcd(m,0) ==>gcd ends ==> m (is the gcd)
      {
        return m;
      }
      else
      {
          return gcd(n,m%n);
      }
  }

  int lcm(int[] a,int n)
  {
      int res =1,i;
      for (i=0;i<n;i++)
      {
          res =res*a[i]/gcd(res,a[i]);
      }
      return res;
  }


  public static void main(String[] args)
  {
      Scanner scan = new Scanner(System.in);
      //finding lcm of a no using now reduction of gcd to lcm

      solution ob = new solution();


      int n = scan.nextInt();
      int m =scan.nextInt();

      int[] a = new int[n]; //find lcm
      int[] b = new int[m]; //find only gcd

      for (int i=0;i<n;i++)
      {
          a[i] = scan.nextInt();
      }
      //finding lcm of the first array
      int result = ob.lcm(a,n);
      int result2=1;
      for (int i=0;i<m;i++)
      {
          int r =1;
          b[i] = scan.nextInt();
      }

      // Finding only the gcd of the second array
      int no =b[0];
      for(int i=1;i<m;i++)
      {

          no=ob.gcd(no,b[i]);

      }
      //count the no of multiples of lcm that evenly divides gcd




      //System.out.println("Results:"+result);
      //System.out.println("Result2:"+no);
      int count = 0;
      //count the no of multiples
      int f = result; //lcm
      int l = no; //gcd
      for (int i=f;i<=l;i+=f)
     {
          if(l%i==0){ count++;}
      }

      System.out.println(count);


  }
}

def gcd(a: Int, b: Int):Int=if (b==0) a.abs else gcd(b, a%b)
def lcm(a: Int, b: Int)=(a*b).abs/gcd(a,b)
val g = a.reduceLeft((x,y) => lcm(x,y))
val l = b.reduceLeft((x,y) => gcd(x,y))
val ans = (1 to l/g) count(x => l%(x*g) == 0 )
println(ans.toInt)

#include <vector>
#include <iostream>
#include <algorithm>
#include <numeric>
#include <iterator>
using namespace std;

int gcd(int num1, int num2) {
    auto divisor = min(num1, num2);
    for(; divisor > 0; --divisor)
        if ((num1 % divisor == 0) && (num2 % divisor == 0))
            break;
    return divisor;
}

int gcd_element(const vector<int>& v)
{
    return accumulate(begin(v), end(v), *begin(v), gcd);
}

int lcm(int num1, int num2)
{
    return (num1 * num2) / gcd(num1, num2);
}

int lcm_element(const vector<int>& v)
{
    return accumulate(begin(v), end(v), *begin(v), lcm);
}

int is_divisible(int num1, int num2)
{
    return num1 % num2 == 0 ? 1 : 0;
}

int main() {
    int m, n;
    cin >> m >> n;
    
    vector<int> A(m);
    vector<int> B(n);
    
    copy_n(istream_iterator<int>(cin), m, begin(A));
    copy_n(istream_iterator<int>(cin), n, begin(B));
    
    auto lcmOfA = lcm_element(A);
    auto gcdOfB = gcd_element(B);
    
    auto counter = 0;
    auto multipleOfLcm = lcmOfA;
    
    while (multipleOfLcm <= gcdOfB)
    {
        counter += is_divisible(gcdOfB, multipleOfLcm);
        multipleOfLcm += lcmOfA;
    }
    
    cout << counter << endl;
    
    return 0;
}

int between(vector < int > a, vector < int > b, int x){
    if(x <= 100)
    {
        bool good_x = true;
        for(int i = 0; i < a.size(); ++i)
            good_x &= x%a[i] == 0;
        for(int i = 0; i < b.size(); ++i)
            good_x &= b[i]%x == 0;
        return good_x + between(a, b, x+1);
    }
    else
        return 0;
}

main :: IO ()
countFac :: Int -> Int -> Int

main = do
    getLine
    a_temp <- getLine
    let a = map read $ words a_temp :: [Int]
    b_temp <- getLine
    let b = map read $ words b_temp :: [Int]
    let l = foldl lcm (head a) (tail a)
    let g = foldl gcd (head b) (tail b)
    let s = g `div` l
    if s * l /= g
        then do
            print 0
            return ()
        else do
    print (countFac s 1)
    return ()

countFac n c
    | c > n `div` 2 = 1
    | n `div` c * c == n = 1 + countFac n (c+1)
    | otherwise = countFac n (c+1)