import sys
sys.setrecursionlimit(int(1e9))

n, m = map(int, sys.stdin.readline().rstrip().split())
arr = [int(input()) for _ in range(n)]

explorer = []
answer = 0
cnt = 0
def dfs(depth, idx):
    global answer, cnt
    cnt += 1

    if depth == m:
        answer += 1
        # print(explorer)
        return

    for i in range(2):
        explorer.append(arr[i])
        dfs(depth+1, 1)
        explorer.pop()

dfs(0, 0)
print(answer, cnt)

import sys
sys.setrecursionlimit(int(1e9))

n, m = map(int, sys.stdin.readline().rstrip().split())
arr = [int(input()) for _ in range(n)]

explorer = []
answer = 0
cnt = 0
def dfs(depth, idx):
    global answer, cnt
    cnt += 1

    if depth == m:
        answer += 1
        # print(explorer)
        return

    for i in range(idx, n):
        explorer.append(arr[i])
        dfs(depth+1, i)
        explorer.pop()

dfs(0, 0)
print(answer, cnt)

a = 0.3 + 0.6

if a == 0.9:
    print(True)
else:
    print(False)

# round 처리를 통해 해결한다

if round(a, 1) == 0.9:
    print(True)
else:
    print(False)

# 나의 병맛같은 코드 예시

# 나의 병맛같은 코드 예시

arr = [1, 2, 3, 4, 5]
idx_list = [4, 7, 4]

for i in idx_list:    
    if i < 5:
        if arr[i] == 5:
            print("저는 5 입니다")

arr = [1, 2, 3, 4, 5]
idx_list = [4, 7, 4]
idx = 4

for i in idx_list:    
    if i < 5 and arr[i] == 5:
        print("저는 5 입니다")

graph = [
    [1,2,3],
    [4,5,6],
    [7,8,9]
]

for i in range(len(graph)):
    for j in range(len(graph)):
        print(graph[i][j])

print('*' * 10)

for i in range(len(graph)):
    for j in range(len(graph)):
        print(graph[j][i])

print('*' * 10)

for j in range(len(graph)):
    for i in range(len(graph)):
        print(graph[i][j])

import numpy as np

arr = np.arange(0,8000).reshape(8, 1000)

for i in arr:
    print(i.shape)      # arr[0]에 접근하면 shape이 (1000,)이 되는것 주목.
                        # 지금보면 당연해 보이지만 간혹 shape(1, 8) 아닌가 하면서 헷갈릴 수 있음
    print(i[0:20:-2])
    break

for i in arr:
    print(i[20:0:-2])
    break

for i in arr:
    print(i[::-1])
    break

for i in arr:
    print(i.argsort()[::])      # index 반환하는 정렬해서 반환하는것 가능

array = [i for i in range(1, 20) if i%2 == 1]
array

n = 3
m = 4
array = [[0] * m for _ in range(n)]
array

# 아래와 같이 코드를 짤 시 의도치 않은 결과가 나타날 수 있다.
n = 3
m = 4
array = [[0] * m] * n

array[1][1] = 5
array       # 내부적으로 포함된 3개의 리스트가 모두 동일한 객체에 대한 레퍼런스로 인식되기 때문에 3번이나 바뀐다

col_list = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']     # 리스트에서 특정 element의 index 반환하고 싶을 때 사용
col_coor = col_list.index('c')      # 단 찾고자 하는 원소를 처음 만나면 바로 종료시키므로 O(n)

a = [1, 2, 3, 3, 3]
a.remove(3)
print(f'한개 원소만 지워짐 -> {a}')

a = [1, 2, 3, 3, 3, 4, 5]
remove_set = [2, 3]
set = [i for i in a if i not in remove_set]
print(f'2, 3 원소가 모두 지워짐 {set}')

# a = {1:'a', 2:'b'}
a = {'a':'abc', 'b':'ddd'}
print(type(a.values()))
print(type(a.keys()))
print(type(a.items()))
for i,b in a.items():
    print(i)

print({1,1,2,3,4,5})

# 핵심코드는 list(input())

n, m = map(int, input().split())        # 맵의 가로, 세로 크기 입력
graph = []

for _ in range(n):
  graph.append(list(map(int, input())))     # 그냥 list(1111)하면 오류남. map(int, input())을 활용해야함
                                            # list() 에는 인자로 iterable한 객체를 넘겨줘야함

def func(*args):
    print(args)
    print(type(args))

func("hi", [1, 2, 3])

def kwpacking(**kwargs):
    print(kwargs)
    print(type(kwargs))

kwpacking(a=1, b=2, c=3)

def sum(a, b, c):
    return a + b + c

numbers = [1, 2, 3]
# sum(numbers) # error

print(sum(*numbers))

li = [0,7,2,1,3,5,2]

print(f"정렬된 리스트 반환하되 원본은 유지: {sorted(li)}")
print(f"원본 리스트: {li}")
print(f"원본까지 정렬: {li.sort()}")        # 이때 반환되는 것은 None임!
print(f"원본 리스트: {li}")
print(f"내림차순: {sorted(li, reverse=True)}")

li = [(24, 25), (2, 35), (2, 30), (29,30), (3, 30)]

li.sort(key=lambda x: (x[1]))
li

li = [(24, 25), (2, 35), (2, 30), (29,30), (3, 30)]

li.sort(key=lambda x: (x[1], -x[0]))
li

import sys

R = 5

for i in range(R):
    graph.append(sys.stdin.readline().rstrip())

min_r = min([1,2,3,4,5])
max_r = max([1,2,3,4,5])

sort = sorted([1, 52, 5, 21])
sort_re = sorted([1, 52, 5, 21], reverse=True)
sort_re_key = sorted([('홍길동', 35), ('이순신', 75), ('아무개', 50)], key = lambda x: x[1], reverse=True)       # 이런식으로 lambda와 섞어서 활용도 가능
result = eval("(3+5) * 7")   # eval함수는 수학 수식이 문자열 형식으로 들어오면 해당 수식 계산 결과 반영

print(min_r)
print(max_r)
print(sort)
print(sort_re)
print(sort_re_key)
print(result)

arr = [3, 5, 7, 9]
print(list(reversed(arr)))

print(f"arr 리스트는 변경되지 않음 {arr}" )

arr.reverse()
print(f"arr 리스트 변경됨 {arr}" )

arr = ['a', 'b', 'c']

print('_'.join(arr))
print(''.join(arr))     # ''와 같이 공백으로 둘 경우는 모든 문자가 붙은 문자열이 출력된다.

from itertools import permutations, combinations

data = ['A', 'B', 'C']
print(list(permutations(data, 3)))      # 3개를 뽑는 모든 경우의 수 -> 순열
print(list(combinations(data, 2)))      # 순서를 고려하지 않고 2개를 뽑는 모든 경우의 수 -> 조합

num = 0
for a in range(6):
  for b in range(6):
    for c in range(6):
      for d in range(6):
        for e in range(6):
          for f in range(6):
            if a!=b and a!=c and a!=d and a!=e and a!=f and b!=c and b!=d and b!=e and b!=f and c!=d and c!=e and c!=f and d!=e and d!=f and e!=f:
              print(a,b,c,d,e,f)
              num+=1

print(num)

import heapq

def heapsort(iterable):
    h = []
    result = []

    # 모든 원소를 차례대로 힙에 삽입
    for value in iterable:
        heapq.heappush(h, value)
    
    # 힙에 삽입된 모든 원소를 차례대로 꺼내서 담음
    for _ in range(len(h)):
        result.append(heapq.heappop(h))

    return result

result = heapsort([1,3,5,7,9,2,4,6,8,0])
print(result)

# 최대힙을 위해서는 부호를 반대로 취해준다
def max_heapsort(iterable):
    h = []
    result = []

    # 모든 원소를 차례대로 힙에 삽입
    for value in iterable:
        heapq.heappush(h, -value)
    
    # 힙에 삽입된 모든 원소를 차례대로 꺼내서 담음
    for _ in range(len(h)):
        result.append(-heapq.heappop(h))

    return result

result = max_heapsort([1,3,5,7,9,2,4,6,8,0])
print(result)

from bisect import bisect_left, bisect_right

a = [1,2,4,4,8]
x = 4

# 각각 값이 들어가야하는 인덱스 값 반환
print(bisect_left(a, x))
print(bisect_right(a, x))

def count_by_range(data, left_value, right_value):
    left_index = bisect_left(data, left_value)
    right_index = bisect_right(data, right_value)
    return right_index - left_index

data = [1,2,3,3,3,3,4,4,8,9]
print(count_by_range(data, 4, 8))

from collections import deque

data = deque([2, 3, 4])
data.append(1)
data.append(5)

print(data)
print(list(data))

from collections import Counter

counter = Counter(['red', 'blue', 'red', 'green', 'blue', 'blue'])

print(counter['blue'])
print(counter['green'])
print(dict(counter))

import math

print(math.factorial(5))

print(math.sqrt(7))

print(math.gcd(21, 14))

print(math.pi)

print(math.e)

print(int(10 / 3))
print(10 // 3)

print(int(-10 / 3))
print(-10// 3)

n = 3
for i in range(n):
    for j in range(n):
        print(graph[i][j])

n = 3
for i in range(n):
    for j in range(n):
        print(graph[j][i])

n = 3
for j in range(n):
    for i in range(n):
        print(graph[i][j])

for i in range(n):
    for j in range(n):
        # 이 부분을 구현하기 전에, i는 row용, j는 column용 이라는 고정관념을 버려라!
        # graph[i][j]로 하면 i, j가 각각 row, column 접근 인덱스 역할을 하는 것이고
        # graph[j][i]로 하면 i, j가 각각 column, row 접근 인덱스 역할을 하는 것이다!

r, c = map(int, input().split())        # 2차원 매트릭스의 행, 열 크기 입력 받기 ex) 5, 7

matrix = [[0 for _ in range(c)] for _ in range(r)]  # c, r 순으로 정보 활용

matrix[2][6]        # r, c 순서로 접근

r, c, num = map(int, input().split())

matrix = [[[0 for _ in range(c)]for _ in range(r)] for _ in range(3)]   # 좌표값을 제외하고 3개의 값들을 저장해야 한다고 가정하자. 그러기 위해선 3채널이 필요하다.

matrix[1][2][6]     # 채널, r, c 순서로 접근

def is_primary(n):
    if n == 1:
        return False
    for i in range(2, n):
        if n % i == 0:
            return False
    return True

import math

def is_primary(n):
    if n == 1:
        return False

    for i in range(2, int(math.sqrt(n)) + 1):       # 2.8xx 와 같이 나오면 2까지는
                                                    # 나눠봐야함. 그래서 + 1 붙음
        if n % i == 0:
            return False
    return True

is_primary(1), is_primary(3), is_primary(10), is_primary(25)

import math

answer = []

num = 33

def factorization(num):
    d = num

    for i in range(2, int(math.sqrt(d)) + 1):
        while d %i == 0:
            answer.append(i)
            d //= i
    
    if d > 1:
        answer.append(d)        # 아직도 d가 1 이상이면 그 숫자는 소수임

factorization(num)

print(answer)