code: import typing
  import numpy as np
  import numba as nb
  
  
  
  
  @nb.njit
  def find_divisors(
    n: int,
  ) -> np.array:
    i = np.arange(int(n ** .5))
    i += 1
    i = i[n % i == 0]
    i = np.hstack((i, n // i))
    return np.unique(i)
  
  
  
  @nb.njit
  def gpf(
    n: int = 1 << 20,
  ) -> np.array:
    s = np.arange(n)
    s[:2] = -1
    i = 0
    while i * i < n - 1:
      i += 1
      if s[i] == i: s[i::i] = i
    return s
  
  
  @nb.njit
  def lpf(
    n: int = 1 << 20,
  ) -> np.array:
    s = np.arange(n)
    s[:2] = -1
    i = 0
    while i * i < n - 1:
      i += 1
      if s[i] != i: continue
      j = np.arange(i, n, i)
      s[j][s[j] == j] = i
    return s
  
  
  @nb.njit
  def sieve_of_eratosthenes(
    n: int = 1 << 20,
  ) -> np.array:
    return gpf(n) == np.arange(n)
  
  
  
  @nb.njit
  def prime_numbers(
    n: int = 1 << 20,
  ) -> np.array:
    s = sieve_of_eratosthenes(n)
    return np.flatnonzero(s)
  
  
  
  @nb.njit
  def euler_totient(
    n: int,
    prime_numbers: np.array,
  ) -> int:
    c = n
    for p in prime_numbers:
      if p * p > n: break
      if n % p: continue
      c = c // p * (p - 1)
      while not n % p: n //= p
    if n > 1:
      c = c // n * (n - 1)
    return c
  
  
  @nb.njit(
    (nb.i8, ),
    cache=True,
  )
  def solve(
    p: int,
  ) -> typing.NoReturn:
    n = p - 1
    divs = find_divisors(n)  
    pn = prime_numbers(1 << 20)
    mod = 998244353
    c = 1
    for d in divs:
      e = euler_totient(d, pn)
      e %= mod
      d %= mod
      c += e * d % mod 
      c %= mod
    print(c)
  
  
  def main() -> typing.NoReturn:
    p = int(input())
    solve(p)
  
  
  main() import typing
  import sys 
  import numpy as np 
  import numba as nb 
  
  
  @nb.njit 
  def cross(x0: int, y0: int, x1: int, y1: int) -> int:
    return x0 * y1 - x1 * y0
  
  
  
  @nb.njit((nb.i8, ) * 4 + (nb.i8[:, :], ), cache=True)
  def solve(
    x0: int,
    y0: int,
    x1: int,
    y1: int,
    xy: np.ndarray,
  ) -> typing.NoReturn:
    n = len(xy)
    xy = np.vstack((xy, xy[:1]))
    x, y = xy[:, 0], xy[:, 1]
    x2, y2 = x[:-1], y[:-1]
    x3, y3 = x[1:], y[1:]
    p0 = cross(x1 - x0, y1 - y0, x2 - x0, y2 - y0) 
    p0 *= cross(x1 - x0, y1 - y0, x3 - x0, y3 - y0)
    p1 = cross(x0 - x2, y0 - y2, x3 - x2, y3 - y2)
    p1 *= cross(x1 - x2, y1 - y2, x3 - x2, y3 - y2)
    cnt = 1 + np.count_nonzero((p0 < 0) & (p1 < 0)) // 2
    print(cnt)
    
  
  
  def main() -> typing.NoReturn:
    x0, y0, x1, y1 = map(int, input().split())
    n = int(input())
    xy = np.array(
      sys.stdin.read().split(),
      dtype=np.int64,
    ).reshape(n, 2)
    solve(x0, y0, x1, y1, xy)
  
  
  main()
apis: numpy.arange numpy.hstack numpy.flatnonzero numpy.unique
apis: numpy.vstack numpy.count_nonzero