qyliang/CodeNanoFix huggingface dataset:
AtCoDeer the deer has N cards with positive integers written on them. He considers a subset of the cards "good" if the sum of the numbers in the subset is at least K. For each card, he determines if it's "unnecessary" based on whether removing it from any good subset still leaves a good subset. The task is to find the number of unnecessary cards. Constraints: 1 ≤ N ≤ 5000, 1 ≤ K ≤ 5000, 1 ≤ ai ≤ 10^9 (1 ≤ i ≤ N). The input format is N K followed by the values of a1 to aN. The output should be the number of unnecessary cards.

# Buggy version:
n, k = map(int, input().split())
a = list(map(int, input().split()))

a = sorted(a)[::-1]
ans = n
sm = 0

for i in range(0, n):
    if sm + a[i] < k:
        sm += a[i];
    else:
        ans = min(ans, i);

print(ans)


# Fixed version:
n, k = map(int, input().split())
a = list(map(int, input().split()))

a = sorted(a)[::-1]
ans = n
sm = 0

for i in range(n):
    if sm + a[i] < k:
        sm += a[i]
    else:
        ans = min(ans, n - i - 1)

print(ans)
Score: 1600 points
Problem Statement:
There are N integers written on a blackboard. The i-th integer is A_i. Takahashi and Aoki will arrange these integers in a row. First, Takahashi will arrange the integers as he wishes. Then, Aoki will repeatedly swap two adjacent integers that are coprime, as many times as he wishes. Find the eventual sequence that will be produced.

Constraints:
1 ≤ N ≤ 2000
1 ≤ A_i ≤ 10^8

Input:
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N

Output:
Print the eventual sequence that will be produced, in a line.

Sample Input 1:
5
1 2 3 4 5

Sample Output 1:
5 3 2 4 1
If Takahashi arranges the given integers in the order (1,2,3,4,5), they will become (5,3,2,4,1) after Aoki optimally manipulates them.

Sample Input 2:
4
2 3 4 6

Sample Output 2:
2 4 6 3

# Buggy version:
def gcd(a,b):
    return gcd(b,a%b) if b else a

def merge(a,us,vs):
    i,j,res=0,0,[]
    while i<len(us) and j<len(vs):
        if a[us[i]]>=a[vs[j]]:
            res.append(us[i])
            i+=1
        else:
            res.append(vs[j])
            j+=1
    return res+us[i:]+vs[j:]

def dfs(g,a,u,vis):
    vis[u]=True
    res=[]
    for v in g[u]:
        if not vis[v]:
            res=merge(a,res,dfs(g,a,v,vis))
    return [u]+res

while 1:
    try:
        n=int(input())
        a=sorted(map(int,input().split()))
    except: break

    g=[[j for j in range(n) if i!=j and gcd(a[i],a[j])!=1] for i in range(n)]
    #vis=[False]*n
    #res=[]
    #for u in range(n):
    #    if not vis[u]:
    #        res=merge(a,res,dfs(g,a,u,vis))
    #print(' '.join(str(a[u]) for u in res))


# Fixed version:
import sys
sys.setrecursionlimit(1000000000)

def gcd(a: int, b:int):
    while b:
        a,b=b,a%b
    return a

def merge(a,us,vs):
    i,j,res=0,0,[]
    while i<len(us) and j<len(vs):
        if a[us[i]]>=a[vs[j]]:
            res.append(us[i])
            i+=1
        else:
            res.append(vs[j])
            j+=1
    return res+us[i:]+vs[j:]

def dfs(g,a,u,vis):
    vis[u]=True
    res=[]
    for v in g[u]:
        if not vis[v]:
            res=merge(a,res,dfs(g,a,v,vis))
    return [u]+res

while 1:
    try:
        n=int(input())
        a=sorted(map(int,input().split()))
    except: break

    g=[[] for _ in range(n)]
    for i in range(n):
        for j in range(i+1,n):
            if gcd(a[i],a[j])!=1:
                g[i].append(j)
                g[j].append(i)

    vis=[False]*n
    res=[]
    for u in range(n):
        if not vis[u]:
            res=merge(a,res,dfs(g,a,u,vis))
    print(' '.join(str(a[u]) for u in res))
Snuke is playing a game where the player runs a railway company. There are M+1 stations on Snuke Line, numbered 0 through M. A train stops at station 0 and every d-th station thereafter. There are N kinds of souvenirs sold in areas around Snuke Line. Each souvenir can be purchased when the train stops at specific stations. For M values of d, find the number of souvenirs that can be purchased if one takes a train with that value of d at station 0. Constraints: 1 ≤ N ≤ 3 × 10^5, 1 ≤ M ≤ 10^5, 1 ≤ l_i ≤ r_i ≤ M. Input format: N M, followed by l_i r_i for each souvenir. Output: M lines, each containing the maximum number of souvenirs that can be purchased if one takes a train stopping every i-th station.

# Buggy version:
import sys
input = sys.stdin.readline
from collections import defaultdict

N,M = map(int,input().split())
d_to_LR = defaultdict(list)
for _ in range(N):
    L,R = map(int,input().split())
    d_to_L[R-L+1].append(L)

tree = [0] * (M+1) # BIT で管理。左にあるLの個数 - (R+1)の個数 → いくつの[L,R]に入っているか
long = N # 長すぎて自動回収できる
answer = [0] * (M+1)

for m in range(1,M+1):
    for L in d_to_L[m]:
        R = L+m-1
        x = L
        while x <= M:
            tree[x] += 1
            x += x & (-x)
        x = R+1
        while x <= M:
            tree[x] -= 1
            x += x & (-x)
        long -= 1
    s = long
    for x in range(m,M+1,m):
        while x:
            s += tree[x]
            x -= x & (-x)
    answer[m] = s

print('\n'.join(map(str, answer[1:])))


# Fixed version:
import sys
input = sys.stdin.readline
from collections import defaultdict

N,M = map(int,input().split())
d_to_LR = defaultdict(list)
for _ in range(N):
    L,R = map(int,input().split())
    d_to_LR[R-L+1].append((L,R))

def BIT_update(tree,x,value):
    while x <= M:
        tree[x] += value
        x += x & (-x)

def BIT_sum(tree,x):
    s = 0
    while x:
        s += tree[x]
        x -= x & (-x)
    return s

tree = [0] * (M+1) # BIT で管理。左にあるLの個数 - (R+1)の個数 → いくつの[L,R]に入っているか
long = N # 長すぎて自動回収できる
answer = [0] * (M+1)

for m in range(1,M+1):
    for L,R in d_to_LR[m]:
        BIT_update(tree,L,1)
        BIT_update(tree,R+1,-1)
        long -= 1
    answer[m] = sum(BIT_sum(tree,x) for x in range(m,M+1,m)) + long

print('\n'.join(map(str, answer[1:])))
You are given N people, numbered 1 through N. You need to divide them into groups, each containing between A and B people, inclusive. Additionally, the number of groups containing exactly i people, denoted as F_i, must satisfy C ≤ F_i ≤ D for all i. Find the number of ways to divide the people into groups, considering two ways different if there exists two people belonging to the same group in only one of the ways. Output the count modulo 10^9+7. Constraints: 1 ≤ N ≤ 10^3, 1 ≤ A ≤ B ≤ N, 1 ≤ C ≤ D ≤ N. Input format: N A B C D. Output the number of ways to divide the people into groups under the given conditions, modulo 10^9+7. Example: Input: 3 1 3 1 2, Output: 4. Example 2: Input: 7 2 3 1 3, Output: 105. Example 3: Input: 1000 1 1000 1 1000, Output: 465231251. Example 4: Input: 10 3 4 2 5, Output: 0.

# Buggy version:
def main():
    mod = 10**9+7
    inv_n = [0]*1001
    nCr = [[0]*(i+1) for i in range(1001)]
    for i in range(1001):
        inv_n[i] = pow(i, mod-2, mod)
    for i in range(1001):
        nCr[i][0] = 1
        nCr[i][i] = 1
    for i in range(2, 1001):
        for j in range(1, i):
            nCr[i][j] = (nCr[i-1][j-1]+nCr[i-1][j]) % mod
    n, a, b, c, d = map(int, input().split())
    f = [[[0]*(N//A-c+1) for A in range(a, b+1)] for N in range(1, n+1)]
    for N in range(1, n+1):
        for A in range(a, min(N//c, b)+1):
            temp = 1
            for C in range(1, c):
                temp = temp*nCr[N-(C-1)*A][A]*inv_n[C] % mod
            for C in range(c, min(d, N//A)+1):
                temp = temp*nCr[N-(C-1)*A][A]*inv_n[C] % mod
                f[N-1][A-a][C-c] = temp

    dp = [0]*(n+1)
    dp[0] = 1

    for A in range(a, b+1):
        dp2 = [i for i in dp]
        for C in range(c, d+1):
            for i in range(n-C*A+1):
                dp2[i+C*A] = (dp2[i+C*A]+f[n-i-1][A-a][C-c]*dp[i]) % mod
        dp = dp2
    print(dp[-1])


main()

# Fixed version:
def main():
    mod = 10**9+7
    inv_n = [0]*1001
    nCr = [[1]*(i+1) for i in range(1001)]
    for i in range(1001):
        inv_n[i] = pow(i, mod-2, mod)
    for i in range(2, 1001):
        for j in range(1, i):
            nCr[i][j] = (nCr[i-1][j-1]+nCr[i-1][j]) % mod
    n, a, b, c, d = map(int, input().split())
    dp = [0]*(n+1)
    dp[0] = 1

    for A in range(b, a-1, -1):
        dp2 = [i for i in dp]
        for N in range(n-c*A, -1, -1):
            e = dp[N]
            if e:
                temp = 1
                for C in range(1, c):
                    temp = temp*nCr[n-N-(C-1)*A][A]*inv_n[C] % mod
                for C in range(c, min(d, (n-N)//A)+1):
                    temp = temp*nCr[n-N-(C-1)*A][A]*inv_n[C] % mod
                    dp2[N+C*A] = (dp2[N+C*A]+temp*e) % mod
        dp = dp2
    print(dp[-1])


main()
Title: ヒットアンドブロー

Taro and Hanako decided to play a game called "Hit and Blow." The rules are as follows:
- The game is played between a questioner and an answerer.
- The questioner selects a 4-digit number (the correct answer) without any duplicate digits.
- The answerer tries to guess the 4-digit number (the answer).
- The questioner provides hints in the form of the number of hits and blows in response to the answer.
- A hit is when both the number and the position of a digit are correct, while a blow is when only the number is correct but the position is wrong. For example, if the correct answer is 1234 and the answer is 1354, the questioner would provide the hint "2 hits, 1 blow," and the process continues until the correct answer is guessed.
- The questioner and answerer take turns playing the game, and the winner is the one who guesses the correct answer with the fewest attempts.

Taro and Hanako find it a bit cumbersome to judge the number of hits and blows each time. Let's create a program that instantly determines the number of hits and blows for them.

Create a program that takes the correct answer (r) and the answer (a) as input and outputs the number of hits and blows. r and a are each a sequence of 4 digits ranging from 0 to 9.

Input:
Multiple datasets are provided as input. The end of the input is indicated by two consecutive zero lines. Each dataset provides r and a separated by a space on a single line.

The number of datasets does not exceed 12000.

Output:
For each input dataset, output the number of hits and blows on a single line.

Sample Input:
1234 5678
1234 1354
1234 1234
1230 1023
0123 1234
0 0

Output for the Sample Input:
0 0
2 1
4 0
1 3
0 3

# Buggy version:
while True:
    r, a= input().split()
    if r==a==0: break
    print(sum(1 for i, j in zip(r, a) if i==j), sum(1 for i in range(len(r)) for j in range(len(a)) if r[i]==a[j] and i!=j))

# Fixed version:
while True:
    r, a= input().split()
    if r==a=='0': break
    print(sum(1 for i, j in zip(r, a) if i==j), sum(1 for i in range(len(r)) for j in range(len(a)) if r[i]==a[j] and i!=j))
Title: 7 Segment

Digital displays showing numbers often seen on calculators are composed of 7 segments, hence called "7-segment displays."

A new product from Wakamatsu Corporation will incorporate a 7-segment display. As an employee, you are tasked to create a program to display given numbers on the 7-segment display.

The display remains unchanged until a switching instruction is received. A 7-bit signal is used to switch the corresponding segment display information. Here, 1 represents "switch" and 0 represents "as is."

The correspondence between each bit and segment is shown in the figure below. The signal consists of 7 bits sent in the order "gfedcba." For example, to display "0" from a hidden state, "0111111" must be sent. To change from "0" to "5," "1010010" is sent. Subsequently, to change "5" to "1," "1101011" is sent.

The program should take as input the number of digits to be displayed, followed by the digits themselves (1 ≤ n ≤ 100, 0 ≤ di ≤ 9), and output the required signal sequence to display these numbers correctly on the 7-segment display.

Input:
Multiple datasets are given. The input ends with a single -1. Each dataset is in the format:
n
d1
d2
:
dn
The number of datasets does not exceed 120.

Output:
For each input dataset, output the required signal sequence to display the numbers correctly.

Sample Input:
3
0
5
1
1
0
-1

Output for the Sample Input:
0111111
1010010
1101011
0111111

# Buggy version:
#!/usr/bin/env python3

seven_seg = {
        0: '0111111',
        1: '0000110',
        2: '1011011',
        3: '1001111',
        4: '1100110',
        5: '1101101',
        6: '1111101',
        7: '0100111',
        8: '1111111',
        9: '1101111'
        }

while True:
    seven_seg_state = ['0'] * 7
    n = int(input())
    if n == -1:
        break
    for _ in range(n):
        in_data = int(input())
        for i, s in enumerate(seven_seg_state):
            if seven_seg[in_data][i] == s:
                print("0", end="")
            else:
                print("1", end="")
            s = seven_seg[in_data][i]

        print()

# Fixed version:
#!/usr/bin/env python3

seven_seg = {
        0: '0111111',
        1: '0000110',
        2: '1011011',
        3: '1001111',
        4: '1100110',
        5: '1101101',
        6: '1111101',
        7: '0100111',
        8: '1111111',
        9: '1101111'
        }

while True:
    seven_seg_state = ['0'] * 7
    n = int(input())
    if n == -1:
        break
    for _ in range(n):
        in_data = int(input())
        for i in range(7):
            if seven_seg[in_data][i] == seven_seg_state[i]:
                print("0", end="")
            else:
                print("1", end="")
            seven_seg_state[i] = seven_seg[in_data][i]

        print()
DaiGo, a high school senior, loves games and struggles to manage study time during exam preparation. A program is needed to check if the total study time meets the daily goal, and if not, to calculate the shortfall based on study start and end times. The program should handle multiple datasets, each containing the daily study goal, the number of study sessions, and the start and end times for each session. The output should indicate "OK" if the goal is met, or the shortfall time if not.

# Buggy version:
t=int(input())
n=int(input())
b=0
for i in range(n):
    s,f=map(int,input().split())
    a=f-s
    b+=a
if t<=b:
    print("OK")
else:
    print(t-b)


# Fixed version:
while True:
    t=int(input())
    if t == 0:
        break
    n=int(input())
    b=0
    for i in range(n):
        s,f=map(int,input().split())
        a=f-s
        b+=a
    if t<=b:
        print("OK")
    else:
        print(t-b)
Title: Input Candidates

Mobile phones are equipped with a feature that displays input candidates to efficiently input text such as emails. This feature records frequently used words and suggests words that start with the input characters as input candidates. For example, if the word "computer" is frequently input, simply entering "c" will prompt "computer" as a candidate. Let's create the basic part of this functionality.

Create a program that takes input as text or characters and outputs words starting with those characters in order of occurrence. If multiple words have the same occurrence, output them in lexicographical order. Output up to 5 words. If no matching words exist, output "NA".

Input:
Multiple datasets are provided. The end of input is represented by a single zero. Each dataset is given in the following format:
- The first line contains the number of lines in the text, n (1 ≤ n ≤ 10). The following n lines contain the text. The text consists of lowercase English characters and spaces, with each line containing 1 to 1024 characters. Words separated by spaces are 1 to 20 characters long.
- The next line contains the initial character k in lowercase English.

The number of datasets does not exceed 100.

Output:
For each dataset, output words that start with the specified character or "NA".

Input Example:
1
ben likes bananas the best among many fruits because bananas are sweet and cheap
b
1
winners get to visit aizu and the university of aizu and make many friends as well
a
3
ask alex about
the answer for the
assignment on android apps
a
2
programming is both
a sport and an intellectual puzzle
c
0

Output Example:
bananas because ben best
aizu and as
about alex android answer apps
NA

# Buggy version:
while 1:
    n = int(input())
    if n == 0:break
    c = {}
    for _ in range(n):
        s = input().split()
        for e in s:
            if e in c:c[e] += 1
            else:c[e] = 1
    c = [(e, c[e]) for e in c.keys()]
    c.sort(key = lambda x:x[1], reverse = True)
    c.sort(key = lambda x:x[0])
    s = input()
    a = []
    for i in range(len(c)):
        if c[i][0][0] == s:a.append(c[i][0])
    if a == []:print("NA")
    else:print(*a)


# Fixed version:
while 1:
    n = int(input())
    if n == 0:break
    c = {}
    for _ in range(n):
        s = input().split()
        for e in s:
            if e in c:c[e] += 1
            else:c[e] = 1
    c = [(e, c[e]) for e in c.keys()]
    c.sort(key = lambda x:x[0])
    c.sort(key = lambda x:x[1], reverse = True)
    s = input()
    a = []
    for i in range(len(c)):
        if c[i][0][0] == s:a.append(c[i][0])
    if a == []:print("NA")
    else:print(*a[:5])
Title: Scoring After Solving 10 Questions

Players, welcome to the Computer Koshien. The number of questions and total points vary each year. Each question has a designated score based on its difficulty. Given the scores for 10 questions, create a program to output their total.

Input:
The input consists of 10 lines, where each line contains an integer s_i (0 ≤ s_i ≤ 100) representing the score for question i.

Output:
Output the total score on a single line.

Example 1:
Input
1
2
3
4
5
6
7
8
9
10
Output
55

Example 2:
Input
4
4
8
8
8
10
10
12
16
20
Output
100

# Buggy version:
print(sum([int(input()) for i in range(10)])

# Fixed version:
print(sum([int(input()) for i in range(10)]))
Title: Ticketing

To ride the Shinkansen, two tickets are required: a "boarding ticket" and an "express ticket." As there are routes where the Shinkansen is not used, these tickets are separate. However, for routes exclusively using the Shinkansen, a single "boarding and express ticket" may be issued.

At the automatic ticket gate, the correct ticket must be inserted to open the gate. A program is needed to determine if one "boarding ticket," one "express ticket," both, or a "boarding and express ticket" has been inserted, and to decide whether to open or close the gate.

Input:
The input consists of a single line containing three integers separated by a single space: b1, b2, and b3. b1 represents the state of the "boarding ticket" insertion, b2 represents the state of the "express ticket" insertion, and b3 represents the state of the "boarding and express ticket" insertion. The insertion state is represented by 0 or 1, where 0 indicates not inserted and 1 indicates inserted. The expected combinations of insertion states are as follows:

Input	State of Insertion	Door Operation
1 0 0	"Boarding ticket" only inserted	Close
0 1 0	"Express ticket" only inserted	Close
1 1 0	"Boarding ticket" and "Express ticket" inserted	Open
0 0 1	"Boarding and express ticket" inserted	Open
0 0 0	No insertion	Close

Output:
Output "Open" or "Close" on a single line to represent the operation of the automatic ticket gate.

Example Input 1:
0 0 1

Example Output 1:
Open

Example Input 2:
0 1 0

Example Output 2:
Close

# Buggy version:
a,b,c=map(int,input().split())
if a+b+c==1:
   print("Close")
elif a+b+c==2:
   print("Open")
else:
   print("Close")

# Fixed version:
a,b,c=map(int,input().split())
if a+b==2 or c==1:
    print("Open")
else:
    print("Close")
Title: All Numbers Lead to 6174

Given a four-digit number N composed of digits from 0 to 9, perform the following operations:
1. Arrange the digits of N in descending order to obtain L.
2. Arrange the digits of N in ascending order to obtain S.
3. Set the new N as the absolute difference between L and S.
4. Repeat steps 1-3 with the new N.

Every four-digit number, except those with identical digits (e.g., 0000, 1111), is known to eventually reach 6174. For example, with N = 2012:
1st iteration (N = 2012): L = 2210, S = 0122, L-S = 2088
2nd iteration (N = 2088): L = 8820, S = 0288, L-S = 8532
3rd iteration (N = 8532): L = 8532, S = 2358, L-S = 6174
Thus, it takes 3 iterations to reach 6174.

Create a program to calculate the number of iterations required to reach 6174 for a given four-digit number composed of digits from 0 to 9.

Input:
The input consists of multiple datasets. The end of input is indicated by a single line containing 0000. Each dataset is provided in the following format:
N

Each dataset is a single line, where N (1 ≤ N ≤ 9999) represents a four-digit number. If N < 1000, the leading digits are padded with 0.

The number of datasets does not exceed 10000.

Output:
For each dataset, output the number of iterations required to reach 6174 in a single line. If the input number consists of identical digits, output NA.

Input Example:
6174
2012
3333
0000

Output Example:
0
3
NA

# Buggy version:
from functools import reduce
while True:
	n = input()
	if n == "0000":
		break
	n = n if len(n) >= 4 else n.zfill(4)
	if reduce(lambda x,y:x and y,[n[0] == i for i in n]):
		print("NA")
	else:
		cnt = 0
		while n != "6174":
			s = ''.join(sorted(n))
			l = ''.join(sorted(n,reverse = True))
			n = str(int(l)-int(s))
			n = n if len(n) >= 4 else n.zfill(4)
			print(n)
			cnt += 1
		print(cnt)

# Fixed version:
from functools import reduce
while True:
	n = input()
	if n == "0000":
		break
	n = n if len(n) >= 4 else n.zfill(4)
	if reduce(lambda x,y:x and y,[n[0] == i for i in n]):
		print("NA")
	else:
		cnt = 0
		while n != "6174":
			s = ''.join(sorted(n))
			l = ''.join(sorted(n,reverse = True))
			n = str(int(l)-int(s))
			n = n if len(n) >= 4 else n.zfill(4)
			cnt += 1
		print(cnt)
Title: The Mayan Great Prophecy

Maya's Long Count Calendar consists of 13 Baktun (1,872,000 days) and is believed to have started on August 11, 3114 BC and end on December 21, 2012. The program aims to convert dates between the Gregorian calendar and the Maya Long Count calendar. The input consists of multiple datasets, each in the format b.ka.t.w.ki or y.m.d, representing the Maya Long Count date or the Gregorian date, respectively. The output should be in the same format as the input. The maximum values for the Gregorian date depend on the type of month and leap years. The range for the Maya Long Count date is from 0.0.0.0.0 to 12.19.19.17.19, and for the Gregorian date is from 2012.12.21 to 10,000,000.12.31. The number of datasets does not exceed 500. If the input Gregorian date results in the next cycle of the Maya Long Count, it should be output in the b.ka.t.w.ki format.

# Buggy version:
from datetime import date, timedelta

st = date(2012, 12, 21)
while True:
    s = input()
    if s == '#':
        break
    d = list(map(int, s.split('.')))
    if len(d) == 3:
        r = 0
        while d[0] > 3000:
            d[0] -= 400
            r += 365*400+97

        ed = date(d[0], d[1], d[2])
        r += (ed-st).days
        ki = r%20
        r//=20
        w = r%18
        r//=18
        t = r%20
        r//=20
        ka = r%20
        r//=20
        b = r%13
        print(str(b)+'.'+str(ka)+'.'+str(t)+'.'+str(w)+'.'+str(ki))
    else:
        r = d[0]
        r *= 20
        r += d[1]
        r *= 20
        r += d[2]
        r *= 18
        r += d[3]
        r *= 20
        r += d[4]
        print((st+timedelta(days=r)).strftime("%Y.%m.%d"))

# Fixed version:
from datetime import date, timedelta

st = date(2012, 12, 21)
while True:
    s = input()
    if s == '#':
        break
    d = list(map(int, s.split('.')))
    if len(d) == 3:
        r = 0
        while d[0] > 3000:
            d[0] -= 400
            r += 365*400+97

        ed = date(d[0], d[1], d[2])
        r += (ed-st).days
        ki = r%20
        r//=20
        w = r%18
        r//=18
        t = r%20
        r//=20
        ka = r%20
        r//=20
        b = r%13
        print(str(b)+'.'+str(ka)+'.'+str(t)+'.'+str(w)+'.'+str(ki))
    else:
        r = d[0]
        r *= 20
        r += d[1]
        r *= 20
        r += d[2]
        r *= 18
        r += d[3]
        r *= 20
        r += d[4]
        ed = st+timedelta(days=r)
        print(str(ed.year)+'.'+str(ed.month)+'.'+str(ed.day))