A tennis tournament with n participants is running. The participants are playing by an olympic system, so the winners move on and the losers drop out.The tournament takes place in the following way (below, m is the number of the participants of the current round):  let k be the maximal power of the number 2 such that k ≤ m,  k participants compete in the current round and a half of them passes to the next round, the other m - k participants pass to the next round directly,  when only one participant remains, the tournament finishes. Each match requires b bottles of water for each participant and one bottle for the judge. Besides p towels are given to each participant for the whole tournament.Find the number of bottles and towels needed for the tournament.Note that it's a tennis tournament so in each match two participants compete (one of them will win and the other will lose).

NoteIn the first example will be three rounds:  in the first round will be two matches and for each match 5 bottles of water are needed (two for each of the participants and one for the judge),  in the second round will be only one match, so we need another 5 bottles of water,  in the third round will also be only one match, so we need another 5 bottles of water. So in total we need 20 bottles of water.In the second example no participant will move on to some round directly.

The only line contains three integers n, b, p (1 ≤ n, b, p ≤ 500) — the number of participants and the parameters described in the problem statement.

Print two integers x and y — the number of bottles and towels need for the tournament.

Input: 5 2 3

Output:
20
15

Output: 20 15

Input: 8 2 4

Output:
35
32

Output: 35 32

Input: 10 1 500

Output: 27 5000

Output:
27
5000

Input: 20 500 1

Output:
19019
20

Output: 19019 20

Input: 100 123 99

Output:
24453
9900

Output: 24453 9900

Input: 500 1 1

Output: 1497 500

Output:
1497
500

Input: 500 500 500

Output:
499499
250000

Output: 499499 250000

Input: 500 237 474

Output: 237025 237000

Output:
237025
237000

Input: 1 2 3

Output:
0
3

Output: 0 3

Input: 1 2 133

Output: 0 133

Output:
0
133

Input: 1 2 100

Output: 0 100

Output:
0
100

Input: 1 3 4

Output:
0
4

Output: 0 4

Input: 1 10 15

Output: 0 15

Output:
0
15

Input: 1 1 1

Output: 0 1

Output:
0
1

Input: 1 2 5

Output: 0 5

Output:
0
5

Input: 1 500 500

Output:
0
500

Output: 0 500

Input: 1 3 8

Output: 0 8

Output:
0
8

Input: 10 10 10

Output:
189
100

Output: 189 100

Input: 1 3 5

Output: 0 5

Output:
0
5

Input: 1 2 1

Output: 0 1

Output:
0
1

Input: 1 2 4

Output:
0
4

Output: 0 4

Input: 1 10 10

Output:
0
10

Output: 0 10

Input: 1 345 345

Output: 0 345

Output:
0
345

Input: 7 12 13

Output:
150
91

Output: 150 91

Input: 1 500 1

Output: 0 1

Output:
0
1

Input: 1 12 13

Output: 0 13

Output:
0
13

Input: 1 500 499

Output:
0
499

Output: 0 499

Input: 1 100 90

Output: 0 90

Output:
0
90

Input: 2 100 90

Output: 201 180

Output:
201
180

Input: 53 1 1

Output:
156
53

Output: 156 53

Input: 73 73 73

Output: 10584 5329

Output:
10584
5329

Input: 67 1 1

Output: 198 67

Output:
198
67

Input: 63 1 1

Output:
186
63

Output: 186 63

Input: 59 1 1

Output:
174
59

Output: 174 59

Input: 57 1 1

Output: 168 57

Output:
168
57

Input: 13 1 1

Output: 36 13

Output:
36
13

Input: 349 2 5

Output:
1740
1745

Output: 1740 1745

Input: 456 456 456

Output:
415415
207936

Output: 415415 207936


The HR manager was disappointed again. The last applicant failed the interview the same way as 24 previous ones. "Do I give such a hard task?" — the HR manager thought. "Just raise number 5 to the power of n and get last two digits of the number. Yes, of course, n can be rather big, and one cannot find the power using a calculator, but we need people who are able to think, not just follow the instructions."Could you pass the interview in the machine vision company in IT City?

The only line of the input contains a single integer n (2 ≤ n ≤ 2·1018) — the power in which you need to raise number 5.

Output the last two digits of 5n without spaces between them.


After a probationary period in the game development company of IT City Petya was included in a group of the programmers that develops a new turn-based strategy game resembling the well known "Heroes of Might & Magic". A part of the game is turn-based fights of big squadrons of enemies on infinite fields where every cell is in form of a hexagon.Some of magic effects are able to affect several field cells at once, cells that are situated not farther than n cells away from the cell in which the effect was applied. The distance between cells is the minimum number of cell border crosses on a path from one cell to another.It is easy to see that the number of cells affected by a magic effect grows rapidly when n increases, so it can adversely affect the game performance. That's why Petya decided to write a program that can, given n, determine the number of cells that should be repainted after effect application, so that game designers can balance scale of the effects and the game performance. Help him to do it. Find the number of hexagons situated not farther than n cells away from a given cell.

The only line of the input contains one integer n (0 ≤ n ≤ 109).

Output one integer — the number of hexagons situated not farther than n cells away from a given cell.


Developing tools for creation of locations maps for turn-based fights in a new game, Petya faced the following problem.A field map consists of hexagonal cells. Since locations sizes are going to be big, a game designer wants to have a tool for quick filling of a field part with identical enemy units. This action will look like following: a game designer will select a rectangular area on the map, and each cell whose center belongs to the selected rectangle will be filled with the enemy unit.More formally, if a game designer selected cells having coordinates (x1, y1) and (x2, y2), where x1 ≤ x2 and y1 ≤ y2, then all cells having center coordinates (x, y) such that x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2 will be filled. Orthogonal coordinates system is set up so that one of cell sides is parallel to OX axis, all hexagon centers have integer coordinates and for each integer x there are cells having center with such x coordinate and for each integer y there are cells having center with such y coordinate. It is guaranteed that difference x2 - x1 is divisible by 2.Working on the problem Petya decided that before painting selected units he wants to output number of units that will be painted on the map.Help him implement counting of these units before painting.

The only line of input contains four integers x1, y1, x2, y2 ( - 109 ≤ x1 ≤ x2 ≤ 109,  - 109 ≤ y1 ≤ y2 ≤ 109) — the coordinates of the centers of two cells.

Output one integer — the number of cells to be filled.

Input: 1 1 5 5

Output: 13

Input: -1 -3 1 3

Output: 11

Input: -2 -2 2 2

Output: 13

Input: 0 0 2 2

Output: 5

Input: 0 0 2 0

Output: 2

Input: 0 0 0 0

Output: 1

Input: 0 -2 0 2

Output: 3

Input: -2 -2 -2 0

Output: 2

Input: -1000000000 -1000000000 1000000000 1000000000

Output: 2000000002000000001

Input: -999999999 -999999999 999999999 999999999

Output: 1999999998000000001

Input: -999999999 -999999999 -1 -1

Output: 499999999000000001

Input: -411495869 33834653 -234317741 925065545

Output: 78953311064369599

Input: -946749893 -687257665 -539044455 -443568671

Output: 49676664342971903

Input: -471257905 -685885153 782342299 909511043

Output: 999994499807710193

Input: -26644507 -867720841 975594569 264730225

Output: 567493356068872580

Input: -537640548 -254017710 62355638 588691834

Output: 252811256874252458

Input: 309857887 -687373065 663986893 403321751

Output: 193123336242128360

Input: -482406510 -512306894 412844236 -168036050

Output: 154104365578285608

Input: -330513944 -970064382 500608496 369852884

Output: 556817654843544374

Input: -157778763 218978791 976692563 591093087

Output: 211076500156631060

Input: 1000000000 1000000000 1000000000 1000000000

Output: 1

Input: 1 0 5 6

Output: 18

Input: -1 -4 1 4

Output: 14

Input: -2 -3 2 3

Output: 18

Input: 0 -1 2 3

Output: 8

Input: 0 -1 2 1

Output: 5

Input: 0 -1 0 1

Output: 2

Input: 0 -3 0 3

Output: 4

Input: -2 -3 -2 1

Output: 3

Input: -1000000000 -999999999 1000000000 999999999

Output: 2000000000000000000

Input: -999999999 -1000000000 999999999 1000000000

Output: 2000000000000000000

Input: -999999999 -1000000000 -1 0

Output: 500000000000000000

Input: -411495869 33834652 -234317741 925065546

Output: 78953311241547728

Input: -946749893 -687257666 -539044455 -443568670

Output: 49676664750677342

Input: -471257905 -685885154 782342299 909511044

Output: 999994501061310398

Input: -26644507 -867720842 975594569 264730226

Output: 567493357071111657

Input: -537640548 -254017711 62355638 588691835

Output: 252811257474248645

Input: 309857887 -687373066 663986893 403321752

Output: 193123336596257367

Input: -482406510 -512306895 412844236 -168036049

Output: 154104366473536355

Input: -330513944 -970064383 500608496 369852885

Output: 556817655674666815

Input: -157778763 218978790 976692563 591093088

Output: 211076501291102387

Input: 1000000000 999999999 1000000000 999999999

Output: 1


The city park of IT City contains n east to west paths and n north to south paths. Each east to west path crosses each north to south path, so there are n2 intersections.The city funded purchase of five benches. To make it seems that there are many benches it was decided to place them on as many paths as possible. Obviously this requirement is satisfied by the following scheme: each bench is placed on a cross of paths and each path contains not more than one bench.Help the park administration count the number of ways to place the benches.

The only line of the input contains one integer n (5 ≤ n ≤ 100) — the number of east to west paths and north to south paths.

Output one integer — the number of ways to place the benches.


To quickly hire highly skilled specialists one of the new IT City companies made an unprecedented move. Every employee was granted a car, and an employee can choose one of four different car makes.The parking lot before the office consists of one line of (2n - 2) parking spaces. Unfortunately the total number of cars is greater than the parking lot capacity. Furthermore even amount of cars of each make is greater than the amount of parking spaces! That's why there are no free spaces on the parking lot ever.Looking on the straight line of cars the company CEO thought that parking lot would be more beautiful if it contained exactly n successive cars of the same make. Help the CEO determine the number of ways to fill the parking lot this way.

NoteLet's denote car makes in the following way: A — Aston Martin, B —   Bentley, M — Mercedes-Maybach, Z — Zaporozhets. For n = 3 there are the following appropriate ways to fill the parking lot: AAAB AAAM AAAZ ABBB AMMM AZZZ BBBA BBBM BBBZ BAAA BMMM BZZZ MMMA MMMB MMMZ MAAA MBBB MZZZ ZZZA ZZZB ZZZM ZAAA ZBBB ZMMMOriginally it was planned to grant sport cars of Ferrari, Lamborghini, Maserati and Bugatti makes but this idea was renounced because it is impossible to drive these cars having small road clearance on the worn-down roads of IT City.

The only line of the input contains one integer n (3 ≤ n ≤ 30) — the amount of successive cars of the same make.

Output one integer — the number of ways to fill the parking lot by cars of four makes using the described way.


IT City company developing computer games decided to upgrade its way to reward its employees. Now it looks the following way. After a new game release users start buying it actively, and the company tracks the number of sales with precision to each transaction. Every time when the next number of sales is not divisible by any number from 2 to 10 every developer of this game gets a small bonus.A game designer Petya knows that the company is just about to release a new game that was partly developed by him. On the basis of his experience he predicts that n people will buy the game during the first month. Now Petya wants to determine how many times he will get the bonus. Help him to know it.

The only line of the input contains one integer n (1 ≤ n ≤ 1018) — the prediction on the number of people who will buy the game.

Output one integer showing how many numbers from 1 to n are not divisible by any number from 2 to 10.


The protection of a popular program developed by one of IT City companies is organized the following way. After installation it outputs a random five digit number which should be sent in SMS to a particular phone number. In response an SMS activation code arrives.A young hacker Vasya disassembled the program and found the algorithm that transforms the shown number into the activation code. Note: it is clear that Vasya is a law-abiding hacker, and made it for a noble purpose — to show the developer the imperfection of their protection.The found algorithm looks the following way. At first the digits of the number are shuffled in the following order <first digit><third digit><fifth digit><fourth digit><second digit>. For example the shuffle of 12345 should lead to 13542. On the second stage the number is raised to the fifth power. The result of the shuffle and exponentiation of the number 12345 is 455 422 043 125 550 171 232. The answer is the 5 last digits of this result. For the number 12345 the answer should be 71232.Vasya is going to write a keygen program implementing this algorithm. Can you do the same?

The only line of the input contains a positive integer five digit number for which the activation code should be found.

Output exactly 5 digits without spaces between them — the found activation code of the program.


IT City company developing computer games invented a new way to reward its employees. After a new game release users start buying it actively, and the company tracks the number of sales with precision to each transaction. Every time when the next number of sales is divisible by all numbers from 2 to 10 every developer of this game gets a small bonus.A game designer Petya knows that the company is just about to release a new game that was partly developed by him. On the basis of his experience he predicts that n people will buy the game during the first month. Now Petya wants to determine how many times he will get the bonus. Help him to know it.

Output one integer showing how many numbers from 1 to n are divisible by all numbers from 2 to 10.


There is a legend in the IT City college. A student that failed to answer all questions on the game theory exam is given one more chance by his professor. The student has to play a game with the professor.The game is played on a square field consisting of n × n cells. Initially all cells are empty. On each turn a player chooses and paint an empty cell that has no common sides with previously painted cells. Adjacent corner of painted cells is allowed. On the next turn another player does the same, then the first one and so on. The player with no cells to paint on his turn loses.The professor have chosen the field size n and allowed the student to choose to be the first or the second player in the game. What should the student choose to win the game? Both players play optimally.

The only line of the input contains one integer n (1 ≤ n ≤ 1018) — the size of the field.

Output number 1, if the player making the first turn wins when both players play optimally, otherwise print number 2.


Dante is engaged in a fight with "The Savior". Before he can fight it with his sword, he needs to break its shields. He has two guns, Ebony and Ivory, each of them is able to perform any non-negative number of shots.For every bullet that hits the shield, Ebony deals a units of damage while Ivory deals b units of damage. In order to break the shield Dante has to deal exactly c units of damage. Find out if this is possible.

NoteIn the second sample, Dante can fire 1 bullet from Ebony and 2 from Ivory to deal exactly 1·3 + 2·2 = 7 damage. In the third sample, Dante can fire 1 bullet from ebony and no bullets from ivory to do 1·6 + 0·11 = 6 damage.

The first line of the input contains three integers a, b, c (1 ≤ a, b ≤ 100, 1 ≤ c ≤ 10 000) — the number of units of damage dealt by Ebony gun and Ivory gun, and the total number of damage required to break the shield, respectively.

Print "Yes" (without quotes) if Dante can deal exactly c damage to the shield and "No" (without quotes) otherwise.

Input: 4 6 15

Output: No

Output: NO

Input: 3 2 7

Output: YES

Output: Yes

Input: 6 11 6

Output: YES

Output: Yes

Input: 3 12 15

Output: YES

Output: Yes

Input: 5 5 10

Output: YES

Output: Yes

Input: 6 6 7

Output: No

Output: NO

Input: 1 1 20

Output: YES

Output: Yes

Input: 12 14 19

Output: No

Output: NO

Input: 15 12 26

Output: No

Output: NO

Input: 2 4 8

Output: YES

Output: Yes

Input: 4 5 30

Output: YES

Output: Yes

Input: 4 5 48

Output: YES

Output: Yes

Input: 2 17 105

Output: YES

Output: Yes

Input: 10 25 282

Output: No

Output: NO

Input: 6 34 323

Output: No

Output: NO

Input: 2 47 464

Output: YES

Output: Yes

Input: 4 53 113

Output: YES

Output: Yes

Input: 6 64 546

Output: YES

Output: Yes

Input: 1 78 725

Output: YES

Output: Yes

Input: 1 84 811

Output: YES

Output: Yes

Input: 3 100 441

Output: YES

Output: Yes

Input: 20 5 57

Output: No

Output: NO

Input: 14 19 143

Output: No

Output: NO

Input: 17 23 248

Output: No

Output: NO

Input: 11 34 383

Output: YES

Output: Yes

Input: 20 47 568

Output: YES

Output: Yes

Input: 16 58 410

Output: YES

Output: Yes

Input: 11 70 1199

Output: YES

Output: Yes

Input: 16 78 712

Output: YES

Output: Yes

Input: 20 84 562

Output: No

Output: NO

Input: 19 100 836

Output: YES

Output: Yes

Input: 23 10 58

Output: No

Output: NO

Input: 25 17 448

Output: YES

Output: Yes

Input: 22 24 866

Output: YES

Output: Yes

Input: 24 35 67

Output: No

Output: NO

Input: 29 47 264

Output: YES

Output: Yes

Input: 23 56 45

Output: No

Output: NO

Input: 25 66 1183

Output: YES

Output: Yes

Input: 21 71 657

Output: YES

Output: Yes

Input: 29 81 629

Output: No

Output: NO

Input: 23 95 2226

Output: YES

Output: Yes

Input: 32 4 62

Output: No

Output: NO

Input: 37 15 789

Output: YES

Output: Yes

Input: 39 24 999

Output: YES

Output: Yes

Input: 38 32 865

Output: No

Output: NO

Input: 32 50 205

Output: No

Output: NO

Input: 31 57 1362

Output: YES

Output: Yes

Input: 38 68 1870

Output: YES

Output: Yes

Input: 36 76 549

Output: No

Output: NO

Input: 35 84 1257

Output: No

Output: NO

Input: 39 92 2753

Output: YES

Output: Yes

Input: 44 1 287

Output: YES

Output: Yes

Input: 42 12 830

Output: No

Output: NO

Input: 42 27 9

Output: No

Output: NO

Input: 49 40 1422

Output: No

Output: NO

Input: 44 42 2005

Output: No

Output: NO

Input: 50 55 2479

Output: No

Output: NO

Input: 48 65 917

Output: No

Output: NO

Input: 45 78 152

Output: No

Output: NO

Input: 43 90 4096

Output: YES

Output: Yes

Input: 43 94 4316

Output: YES

Output: Yes

Input: 60 7 526

Output: YES

Output: Yes

Input: 53 11 735

Output: YES

Output: Yes

Input: 52 27 609

Output: YES

Output: Yes

Input: 57 32 992

Output: YES

Output: Yes

Input: 52 49 421

Output: No

Output: NO

Input: 57 52 2634

Output: YES

Output: Yes

Input: 54 67 3181

Output: YES

Output: Yes

Input: 52 73 638

Output: No

Output: NO

Input: 57 84 3470

Output: No

Output: NO

Input: 52 100 5582

Output: No

Output: NO

Input: 62 1 501

Output: YES

Output: Yes

Input: 63 17 858

Output: YES

Output: Yes

Input: 70 24 1784

Output: YES

Output: Yes

Input: 65 32 1391

Output: YES

Output: Yes

Input: 62 50 2775

Output: No

Output: NO

Input: 62 58 88

Output: No

Output: NO

Input: 66 68 3112

Output: YES

Output: Yes

Input: 61 71 1643

Output: No

Output: NO

Input: 69 81 3880

Output: No

Output: NO

Input: 63 100 1960

Output: YES

Output: Yes

Input: 73 6 431

Output: YES

Output: Yes

Input: 75 19 736

Output: YES

Output: Yes

Input: 78 25 247

Output: No

Output: NO

Input: 79 36 2854

Output: YES

Output: Yes

Input: 80 43 1864

Output: YES

Output: Yes

Input: 76 55 2196

Output: YES

Output: Yes

Input: 76 69 4122

Output: YES

Output: Yes

Input: 76 76 4905

Output: No

Output: NO

Input: 75 89 3056

Output: YES

Output: Yes

Input: 73 100 3111

Output: YES

Output: Yes

Input: 84 9 530

Output: No

Output: NO

Input: 82 18 633

Output: No

Output: NO

Input: 85 29 2533

Output: YES

Output: Yes

Input: 89 38 2879

Output: YES

Output: Yes

Input: 89 49 2200

Output: YES

Output: Yes

Input: 88 60 4140

Output: YES

Output: Yes

Input: 82 68 1299

Output: No

Output: NO

Input: 90 76 2207

Output: No

Output: NO

Input: 83 84 4923

Output: YES

Output: Yes

Input: 89 99 7969

Output: YES

Output: Yes

Input: 94 9 168

Output: No

Output: NO

Input: 91 20 1009

Output: No

Output: NO

Input: 93 23 2872

Output: YES

Output: Yes

Input: 97 31 3761

Output: YES

Output: Yes

Input: 99 46 1341

Output: YES

Output: Yes

Input: 98 51 2845

Output: No

Output: NO

Input: 93 66 3412

Output: No

Output: NO

Input: 95 76 3724

Output: YES

Output: Yes

Input: 91 87 6237

Output: YES

Output: Yes

Input: 98 97 7886

Output: YES

Output: Yes

Input: 12 17 15

Output: No

Output: NO

Input: 93 94 95

Output: No

Output: NO

Input: 27 43 27

Output: YES

Output: Yes

Input: 17 43 68

Output: YES

Output: Yes

Input: 44 12 12

Output: YES

Output: Yes

Input: 44 50 150

Output: YES

Output: Yes

Input: 1 1 10000

Output: YES

Output: Yes

Input: 2 3 10000

Output: YES

Output: Yes

Input: 100 1 10

Output: YES

Output: Yes

Input: 3 2 1

Output: No

Output: NO

Input: 1 1 1

Output: YES

Output: Yes

Input: 9 9 10000

Output: No

Output: NO

Input: 2 3 9995

Output: YES

Output: Yes

Input: 3 5 4

Output: No

Output: NO

Input: 99 98 100

Output: No

Output: NO

Input: 6 10 2

Output: No

Output: NO

Input: 1 6 5

Output: YES

Output: Yes

Input: 1 4 3

Output: YES

Output: Yes

Input: 3 2 3

Output: YES

Output: Yes

Input: 1 7 6

Output: YES

Output: Yes

Input: 2 3 9871

Output: YES

Output: Yes

Input: 10 5 5

Output: YES

Output: Yes

Input: 10 8 2

Output: No

Output: NO


Mr. Santa asks all the great programmers of the world to solve a trivial problem. He gives them an integer m and asks for the number of positive integers n, such that the factorial of n ends with exactly m zeroes. Are you among those great programmers who can solve this problem?

NoteThe factorial of n is equal to the product of all integers from 1 to n inclusive, that is n! = 1·2·3·...·n.In the first sample, 5! = 120, 6! = 720, 7! = 5040, 8! = 40320 and 9! = 362880.

The only line of input contains an integer m (1 ≤ m ≤ 100 000) — the required number of trailing zeroes in factorial.

First print k — the number of values of n such that the factorial of n ends with m zeroes. Then print these k integers in increasing order.

Output:
5
5 6 7 8 9

Output:
5
10 11 12 13 14

Output:
5
15 16 17 18 19

Output:
5
30 31 32 33 34

Output:
5
50 51 52 53 54

Output:
5
65 66 67 68 69

Output:
5
75 76 77 78 79

Output:
5
155 156 157 158 159

Output:
5
195 196 197 198 199

Output:
5
240 241 242 243 244

Output:
5
270 271 272 273 274

Output:
5
285 286 287 288 289

Output:
5
365 366 367 368 369

Output:
5
1675 1676 1677 1678 1679

Output:
5
3265 3266 3267 3268 3269

Output:
5
1585 1586 1587 1588 1589

Output:
5
2035 2036 2037 2038 2039

Output:
5
1630 1631 1632 1633 1634

Output:
5
2290 2291 2292 2293 2294

Output:
5
455 456 457 458 459

Output:
5
2925 2926 2927 2928 2929

Output:
5
18425 18426 18427 18428 18429

Output:
5
35140 35141 35142 35143 35144

Output:
5
26575 26576 26577 26578 26579

Output:
5
37425 37426 37427 37428 37429

Output:
5
7250 7251 7252 7253 7254

Output:
5
32640 32641 32642 32643 32644

Output:
5
12070 12071 12072 12073 12074

Output:
5
30640 30641 30642 30643 30644

Output:
5
37140 37141 37142 37143 37144

Output:
5
10450 10451 10452 10453 10454

Output:
5
8345 8346 8347 8348 8349

Output:
5
104620 104621 104622 104623 104624

Output:
5
258640 258641 258642 258643 258644

Output:
5
186690 186691 186692 186693 186694

Output:
5
382235 382236 382237 382238 382239

Output:
5
208140 208141 208142 208143 208144

Output:
5
44110 44111 44112 44113 44114

Output:
5
252885 252886 252887 252888 252889

Output:
5
160390 160391 160392 160393 160394

Output:
5
170910 170911 170912 170913 170914

Output:
5
97530 97531 97532 97533 97534

Output:
5
292570 292571 292572 292573 292574

Output:
5
373400 373401 373402 373403 373404

Output:
5
73370 73371 73372 73373 73374

Output:
5
170660 170661 170662 170663 170664

Output:
5
324900 324901 324902 324903 324904

Output:
5
400005 400006 400007 400008 400009

Output:
5
390625 390626 390627 390628 390629

Output:
5
50000 50001 50002 50003 50004

Output:
5
265 266 267 268 269

Output:
5
170 171 172 173 174

Output:
5
125 126 127 128 129


The main street of Berland is a straight line with n houses built along it (n is an even number). The houses are located at both sides of the street. The houses with odd numbers are at one side of the street and are numbered from 1 to n - 1 in the order from the beginning of the street to the end (in the picture: from left to right). The houses with even numbers are at the other side of the street and are numbered from 2 to n in the order from the end of the street to its beginning (in the picture: from right to left). The corresponding houses with even and odd numbers are strictly opposite each other, that is, house 1 is opposite house n, house 3 is opposite house n - 2, house 5 is opposite house n - 4 and so on.  Vasya needs to get to house number a as quickly as possible. He starts driving from the beginning of the street and drives his car to house a. To get from the beginning of the street to houses number 1 and n, he spends exactly 1 second. He also spends exactly one second to drive the distance between two neighbouring houses. Vasya can park at any side of the road, so the distance between the beginning of the street at the houses that stand opposite one another should be considered the same.Your task is: find the minimum time Vasya needs to reach house a.

NoteIn the first sample there are only four houses on the street, two houses at each side. House 2 will be the last at Vasya's right.The second sample corresponds to picture with n = 8. House 5 is the one before last at Vasya's left.

The first line of the input contains two integers, n and a (1 ≤ a ≤ n ≤ 100 000) — the number of houses on the street and the number of the house that Vasya needs to reach, correspondingly. It is guaranteed that number n is even.

Print a single integer — the minimum time Vasya needs to get from the beginning of the street to house a.

Input: 4 2

Output: 2

Input: 8 5

Output: 3

Input: 2 1

Output: 1

Input: 2 2

Output: 1

Input: 10 1

Output: 1

Input: 10 10

Output: 1

Input: 100000 100000

Output: 1

Input: 100000 2

Output: 50000

Input: 100000 3

Output: 2

Input: 100000 99999

Output: 50000

Input: 100 100

Output: 1

Input: 3000 34

Output: 1484

Input: 2000 1

Output: 1

Input: 100000 1

Output: 1

Input: 24842 1038

Output: 11903

Input: 1628 274

Output: 678

Input: 16186 337

Output: 169

Input: 24562 2009

Output: 1005

Input: 9456 3443

Output: 1722

Input: 5610 332

Output: 2640

Input: 1764 1288

Output: 239

Input: 28588 13902

Output: 7344

Input: 92480 43074

Output: 24704

Input: 40022 26492

Output: 6766

Input: 85766 64050

Output: 10859

Input: 67808 61809

Output: 30905

Input: 80124 68695

Output: 34348

Input: 95522 91716

Output: 1904

Input: 7752 2915

Output: 1458

Input: 5094 5058

Output: 19

Input: 6144 4792

Output: 677

Input: 34334 20793

Output: 10397

Input: 23538 10243

Output: 5122

Input: 9328 7933

Output: 3967

Input: 11110 9885

Output: 4943

Input: 26096 2778

Output: 11660

Input: 75062 5323

Output: 2662

Input: 94790 7722

Output: 43535

Input: 90616 32240

Output: 29189

Input: 96998 8992

Output: 44004

Input: 95130 19219

Output: 9610

Input: 92586 8812

Output: 41888

Input: 3266 3044

Output: 112

Input: 5026 4697

Output: 2349

Input: 3044 2904

Output: 71

Input: 6022 5396

Output: 314

Input: 31270 25522

Output: 2875

Input: 82156 75519

Output: 37760

Input: 34614 27913

Output: 13957

Input: 88024 61143

Output: 30572

Input: 91870 55672

Output: 18100

Input: 95718 4868

Output: 45426

Input: 99564 358

Output: 49604

Input: 89266 13047

Output: 6524

Input: 90904 16455

Output: 8228

Input: 94750 13761

Output: 6881

Input: 100000 23458

Output: 38272

Input: 100000 23457

Output: 11729

Input: 59140 24272

Output: 17435

Input: 9860 8516

Output: 673

Input: 25988 2733

Output: 1367

Input: 9412 5309

Output: 2655

Input: 25540 23601

Output: 11801

Input: 76260 6050

Output: 35106

Input: 92388 39118

Output: 26636

Input: 8516 5495

Output: 2748

Input: 91940 37847

Output: 18924

Input: 30518 286

Output: 15117

Input: 46646 19345

Output: 9673