#!/bin/python3

import math
import os
import random
import re
import sys



from collections import defaultdict
from typing import List

class Graph:
    def __init__(self, vertices: int):
        self.vertices = vertices
        self.adjacency_list = [[] for _ in range(vertices)]
#  Use of NoEdge(int, int)
        #prevents duplication of edges
    def add_edge(self, u: int, v: int):
        if self.no_edge(u, v):
            self.adjacency_list[u].append(v)
 
   
    # Returns true if there does NOT exist
    # any edge from u to v
    def no_edge(self, u: int, v: int):
        return v not in self.adjacency_list[u]
 
class WCC:
    def __init__(self, directed_graph: Graph):
        self.directed_graph = directed_graph

    def connected_components(self, undirected_graph: Graph):
        connected_components = []
        is_visited = [False for _ in range(undirected_graph.vertices)]

        for i in range(undirected_graph.vertices):
            if not is_visited[i]:
                component = []
                self.find_connected_component(i, is_visited, component, undirected_graph)
                connected_components.append(component)

        return connected_components

    def find_connected_component(self, src: int, is_visited: List[bool], component: List[int], undirected_graph: Graph):
        is_visited[src] = True
        component.append(src)

        for v in undirected_graph.adjacency_list[src]:
            if not is_visited[v]:
                self.find_connected_component(v, is_visited, component, undirected_graph)

    def weakly_connected_components(self):
        undirected_graph = Graph(self.directed_graph.vertices)
        for u in range(self.directed_graph.vertices):
            for v in self.directed_graph.adjacency_list[u]:
                undirected_graph.add_edge(u, v)
                undirected_graph.add_edge(v, u)

        connected_components = self.connected_components(undirected_graph)
        ans = 0
        for component in connected_components:
            if self.has_cycle(component):
                print(f"Component {component} has a cycle.")
                ans += len(component) - 1
            else:
                print(f"Component {component} does not have a cycle.")
                ans += len(component) 
        return ans
        
    def has_cycle(self, component: List[int]):
        def dfs(node, visited, parent):
            visited[node] = True
            for neighbor in self.directed_graph.adjacency_list[node]:
                if not visited[neighbor]:
                    if dfs(neighbor, visited, node):
                        return True
                elif neighbor == parent:
                    return True
            return False

        visited = [False] * self.directed_graph.vertices
        for node in component:
            if not visited[node]:
                if dfs(node, visited, -1):
                    return True
        return False
# Complete the tasks function below.
def tasks(n, a, b):
    directed_graph = Graph(n+1)
 
    for i in range(len(a)):
        directed_graph.add_edge(b[i], a[i])
 
    weakly_connected_components = WCC(directed_graph).weakly_connected_components()
 
    # for index, component in enumerate(weakly_connected_components, start=1):
    #     print("Component {}: {}".format(index, component))
    
    return weakly_connected_components - 1
    
   

if __name__ == '__main__':
    fptr = open(os.environ['OUTPUT_PATH'], 'w')

    n = int(input().strip())

    a_count = int(input().strip())

    a = []

    for _ in range(a_count):
        a_item = int(input().strip())
        a.append(a_item)

    b_count = int(input().strip())

    b = []

    for _ in range(b_count):
        b_item = int(input().strip())
        b.append(b_item)

    res = tasks(n, a, b)

    fptr.write(str(res) + '\n')

    fptr.close()

#!/bin/python3

import math
import os
import random
import re
import sys


#
# Complete the 'calculateWays' function below.
#
# The function is expected to return an INTEGER.
# The function accepts following parameters:
#  1. INTEGER wordLen
#  2. INTEGER maxVowels
#
def power(x, y, p):
    
    res = 1
    x = x % p

    if (x == 0):
        return 0

    while (y > 0):
        if (y & 1):
            res = (res * x) % p
            
        y = y >> 1
        x = (x * x) % p
        
    return res
def calculateWays(wordLen, maxVowels):
    # Write your code here

    i, j = 0, 0
    MOD = 1000000007
    K= maxVowels
    N = wordLen
    # Array dp to store number of ways
    dp = [[0 for i in range(K + 1)] 
            for i in range(N + 1)]

    sum = 1
    for i in range(1, N + 1):
        
        #dp[i][0] = (dp[i-1][0]+dp[i-1][1]..dp[i-1][k])*21
        dp[i][0] = sum * 21
        dp[i][0] %= MOD

        # Now setting sum to be dp[i][0]
        sum = dp[i][0]

        for j in range(1, K + 1):
            
            # If j>i, no ways are possible to create
            # a string with length i and vowel j
            if (j > i):
                dp[i][j] = 0
            elif (j == i):
                
                # If j = i all the character should
                # be vowel
                dp[i][j] = power(5, i, MOD)
            else:
                
                # dp[i][j] relation with dp[i-1][j-1]
                dp[i][j] = dp[i - 1][j - 1] * 5

            dp[i][j] %= MOD

            # Adding dp[i][j] in the sum
            sum += dp[i][j]
            sum %= MOD

    return sum
if __name__ == '__main__':
    fptr = open(os.environ['OUTPUT_PATH'], 'w')

    wordLen = int(input().strip())

    maxVowels = int(input().strip())

    result = calculateWays(wordLen, maxVowels)

    fptr.write(str(result) + '\n')

    fptr.close()