# ICFP Contest 2013

2013.10.15 18:05 updated: 2013.10.15 18:22

## Contest results

The contest report and results were presented at ICFP 2013. There should eventually be a video of that presentation online, but not yet. In the meantime, here's a powerpoint slide deck describing things.

The winners:

 Position Team Points Language(s) First place Unagi--The Synthesis 1696 Java, C#, C++, PHP, Ruby, and Haskell Second place F5 Attackers 1608 C++ and Python Third place Hack the Loop 1499 C#, C++, bash, awk, sed, and Excel Lightning division ITF 833 (after 24 hrs) C++ Judges' prize Kuma- N/A Ruby
2013.09.03 17:18 updated: 2013.09.03 17:28

## Equivalence of programs

Some of you are asking how we compared the programs. We used Z3 theorem prover. Let's say the secret program is S(x) and your guess is G(x). We would ask Z3 to find an x for which S(x) != G(x). The encoding of programs into Z3 formulas in the fixed size bitvector theory is rather straightforward, check out an example on rise4fun.com. You can also get Z3 locally an play with it.

For fold you need to unfold the expression yourself. Use variable bindings to avoid exponential blowup.

2013.08.12 00:24 updated: 2013.08.13 17:55

• We have clear separations between the scores of the top 3 teams.
• #11 is at around 1400.
• #25 is at around 1250.
• #50 is at around 1100.
• #75 is at 904
• #100 is at 701
• #125 is at 568
• #150 is at 428
• #175 is at 291
• #200 is at 206
• #225 is at 116
• #250 is at 38
• #275 is at 0

Due to popular demand, these are the scores for the lightening division:

• #5 is around 520
• #10 is at 457
• #25 is at 345
• #50 is at 249
• #75 is at 129
• #100 is at 67
• #125 is at 20
• #150 is at 3
2013.08.12 00:21 updated: 2013.08.12 00:28

## You got it up to 40req/sec, good job!

Server requests and CPU usage over last 52h
2013.08.11 23:51 updated: 2013.08.12 00:07
The ICFP Programming Contest 2013 is over!

Thank you for participating!

Hope you had as much fun playing as we did putting it together.

We're humbled by how awesome all of you are. You've exceeded our expectations by some orders of magnitude. Well done!

Come to ICFP 2013 in Boston for the official announcement of the winners. Winners will be notified individually in the next week or so. We will also be preparing a detailed contest report to share with all of you.

We will keep the servers running (at much reduced capacity) for the next few days. You will be able to work on training problems only.

Thanks again for playing! You've won!

-- Michał and Nik

And please, don't forget to take the survey!

2013.08.11 23:10 updated: 2013.08.11 23:15

## 45mins to go: Score update

• #1 - #11 are very close.
• #11 is at around 1350.
• #25 is at around 1200.
• #50 is at around 1000.
2013.08.11 22:56 updated: 2013.08.11 23:00

## We can see you're working on it!

Server requests and CPU usage over last 48h

We still have plenty of spare iron though :-)

Happy hacking!

2013.08.11 22:22 updated: 2013.08.11 22:33

## Alternative survey submission URL

If using the touchdevelop.com UI for submitting your survey for some reason doesn't work for you, you can use the alternative form

2013.08.11 20:57 updated: 2013.08.11 21:01

## Score update

3 hours to go and the race is still tight!

• #1 - #11 are very close.
• #11 is still around 1200.
• #25 is at around 1000.
• #50 is at around 800.
2013.08.11 20:33 updated: 2013.08.11 20:41

## SHA, Submission info, etc.

If you want to be eligible for the judges' prize, you must submit a SHA-256 hash of your code within 1 hour of the contest closing, and also answer the question about what language(s) you were using.

Please also answer as many of the other questions as you can---it will help us prepare a more thorough contest report.

If you are too tired to fill in the survey now, come back within 1 week to the survey site and fill it in. The site will be open for a week after the contest.

But do it ASAP, so that you don't forget!

2013.08.11 18:07 updated: 2013.08.11 18:13

## Score update

6 hours to go and the race is still tight!

• #1 - #11 are very close.
• #11 is at around 1200.
• #25 is at around 850.
• #50 is at around 650.

You're all in it! Keep going!

2013.08.11 17:40 updated: 2013.08.11 17:48

## Servers are heating up a bit...

Server requests and CPU usage over last 46h

...but worry you not, we have many more :-)

Keep it up, people!

2013.08.11 04:08 updated: 2013.08.11 04:28
Breaking news!

## More bonus problems

Just in case you didn't have enough problems to hunt for - we have enabled 200 more exciting bonus problems for each team! They are somewhat bigger than the previous ones. You can get training instances by asking for size 137.

2013.08.11 00:03 updated: 2013.08.11 00:03

## 24 hours to go!

2013.08.10 21:32 updated: 2013.08.10 21:50

## The race is wide open ... Press hard on the last day!

It’s a close race at the very top and the teams currently ranked #11-#50 have scores included in the range [550, 300], and it’s very closely bunched from #51 on down. Teams ranked in the top 25 will all receive an honorable mention. So, press hard for the next ~26 hours!

2013.08.10 20:02 updated: 2013.08.10 20:03

## Bonus problems are structurally different---study them closely!

The bonus problems are quite different from the others. Study the structure of a handful of the training bonus problems for clues. It may suggest different solving strategies.

2013.08.10 20:00 updated: 2013.08.10 20:01

## Low hanging fruit---no risk, no reward.

If you haven’t noticed already: there are lots of low hanging fruit hiding among the problems of large size, e.g, some secret programs of size 30 can be solved using guesses of size 5. But, there are also some problems among the large problems that are genuinely hard to find. No risk, no reward!

2013.08.10 11:55 updated: 2013.08.10 12:45
Breaking news!

## Getting bored with existing categories? Try new bonus problems!

Keeping in tradition of evolving the contest while it's running, we have added a new category of problems. They are indicated by having "bonus" in the operator list. This does not reflect any actual operator, but you will discover that the shape of the bonus problems is special. Bonus problems do not contain fold.

You will now find 200 new and shiny bonus problems in your /myproblems list. You can ask for training instances by asking for problems of size 42 at /train. This will give you a problem of unspecified size with "bonus" in operators.

2013.08.10 10:49 updated: 2013.08.10 10:50

## We'll be back to answer your questions in a few hours.

Emergency alerts are in place while we sleep.

2013.08.10 02:13 updated: 2013.08.10 02:18

## Everyone went to bed 2h ago?!

Number of server requests over the last 6h

Come on people!

2013.08.10 00:17 updated: 2013.08.10 00:20

## If you're done after the lightning division ...

Please remember to fill out the submission survey. You have until Sunday, 6pm PDT (i.e., one hour after the main contest ends) to do so, just like the contestants in the main division.

2013.08.10 00:04 updated: 2013.08.10 00:11

## We have a clear winner in the lightning division!

But we're not saying who : )

The winner will be notified once we've confirmed the scores, probably early next week.

2013.08.09 21:35 updated: 2013.08.09 21:44

## Resetting "Unable to decide equality" problems

We have also deployed a partial fix for the case where we returned an "Unable to decide equality" message. We cannot guarantee that you will no longer receive this message in the future.

To make up for any points that you may have lost, if you got an "Unable to decide equality", we have provided you with additional problems to solve, with the same size and Operators. You can now try to solve them---the new problems (if you were assigned one) are now in your /myproblems list.

FYI: in total, there were 8 teams affected and a total of 9 problems.

Note: we are only doing this reset because we deployed a fix and want to level the playing field. We will not be resetting any further problems for this reason.

2013.08.09 21:30 updated: 2013.08.09 21:44

## Resetting problems with 412

A handful of teams received odd results early last night when sending a /guess request to a problem before /eval. This was a bug on our end which is now fixed.

If you had this problem, we have given you additional problems of the same size and Operators as the ones you may have missed---one for each of them. These will show up in your /myproblems list now. You can try to solve them to make up for the points you may have lost earlier.

FYI: in total, there were 10 teams that were affected by the 412 error and a total of 18 problems

2013.08.09 21:20 updated: 2013.08.09 21:25

## Bit more than 2.5 hours left in the lightning division

Some of you have been wondering what happens if you exhaust your quota of problems while attempting to win the lightning division:

Well, then unless your team is really good, you are unlikely to win the main division of the contest. So, if you haven't decided already: you should decide whether you want to compete to win the lightning division, or if you're going to continue to hack discriminately over the weekend.

2013.08.09 17:53 updated: 2013.08.09 18:00

## Unable to decide equality

Some of you are complaining about receiving this message on some of your guesses.

```The rules say:

Note, if the Game server is unable to prove that
your guess is functionally equivalent to the secret program,
then you do NOT score a point. You can either try another guess,
or move on to another problem.
```

So, this is not unexpected behavior. You have hit a case where it takes us too long to prove that the two programs are equal. You should move on to another problem, or guess again.

Precisely characterizing the cases where this may happen is not feasible. The contest rules are intentionally ambiguous about this possibility.

We are working on an update that may reduce the number of times you get the "Unable to decide equality" response. But, we cannot guarantee that this will not happen again. This behavior is part of the game---you will have to devise a strategy to account for it.

That said, we consider it highly unlikely that this will impact the final rankings significantly.

2013.08.09 13:21 updated: 2013.08.09 14:30

Back online ... late registrants in the last 4-5 hours: you have your tokens now. Also: currently also fielding questions on freenode #icfp-contest, since many contestants are there anyway. Can't promise to be on that channel indefinitely, though. This website remains the authoritative source for up-to-date information about the contest. Silly me: this post was hidden for the last ~2 hours.

2013.08.09 07:39 updated: 2013.08.09 07:42

## Sleepless in Seattle?

Well, not entirely. We'll soon be winding down here for the next four hours. That means response to questions and attending to late registrants will pause for a bit. But, we have various emergency alerts in place to wake us up, should there be any technical issues.

2013.08.09 04:24 updated: 2013.08.09 04:28

## Syntax of identifiers

Training programs include identifiers of the form "x_1234" which is outside what the grammar specifies. The spec has now been updated.

2013.08.09 04:00 updated: 2013.08.09 04:18

## [fixed] 412 when /guess is right

There was a problem when you /guess correctly on a contest problem without doing an /eval first. You would get 412, and only the second /guess would count as a win. As of 2013.08.09 04:16 GMT this is fixed. We're sorry for any problems it might have caused.

2013.08.09 02:55 updated: 2013.08.09 02:57

## TrainRequest.operators is a string[]

The operators field of a TrainRequest is a string[] not a string. Thanks to Sergio Garcia for pointing this out. The contest rules have been updated.

2013.08.09 02:34 updated: 2013.08.09 07:07

## tfold

```Quoting:

The binary relation "Operators" relates a program to
a set ranging over the set "ops", defined below:

ops ::= op1 | op2 | "if0" | "tfold" | "fold"
Operators (lambda (x) (fold x 0 (lambda (x y) e))) ({"tfold"} U Op e)
Operators (lambda (x) e) (Op e)

```

tfold tells you quite a lot about the secret program.

2013.08.09 01:21 updated: 2013.08.09 01:33

## Fixed number of problems per team: Play wisely

If you are unable to solve a problem in your myproblems set, your potential maximum score will be reduced. We would be pleasantly surprised if someone managed to solve every problem assigned to them, but it may be possible to do. So, choose which problems you solve wisely.

2013.08.09 00:55 updated: 2013.08.09 00:58

## Playground requirements

The playground under touchdevelop.com requires IE 10+, recent Chrome, Firefox, or Safari (on Mac). It will also work on most mobile devices. Make sure not to use private browsing, you'll get a 'forbidden' message in such case.

2013.08.09 00:36 updated: 2013.08.09 00:38

Some of you have been saying that you are not authorized to access the server. Remember to add the above string to the end of your token.

2013.08.08 22:08 updated: 2013.08.10 22:41

## Let the games begin!

```Rules of the ICFP Contest 2013
==============================

Prologue
~~~~~~~~

Game:    I have a program A, and I want you to guess it.
Player:  Can you tell me what is A(16), A(42) and A(128)?
Game:    Sure, A(16) = 17, A(42) = 43, and A(128) = 129.
Player:  Is the program B0, where B0(x) = x + 1?
Game:    No dice, A(9) = 9, but B0(9) = 10.
Player:  What is A(11), A(12) then?
Game:    Since you ask so nicely: A(11) = 11, A(12) = 13.
Player:  Is the program B1, where
B1(x) = if ((x & 1) ^ 1) = 0 then x else x + 1
Game:    That's right! You score one point.
I have a program A', and want you to guess it.
Player:  Argh!!!

We want you to guess a few thousand such programs, some slightly
smaller, many a bit bigger. You will have 5 minutes to guess each
one. You will most likely want to program a computer to do this.

~~~~~~~~~~~~~~~~~~~

The role of the "Game" will be played by a web service that we (the
contest organizers) have programmed. You, the "Player", have to guess
a sequence of secret functions over 64-bit vectors programmed in a
small language called \BV (defined below).

There are three kinds of requests you can make to the Game server:

0. myproblems: In response to this request, the Game makes known
to the Player the IDs of a set of secret programs. These
are all the problems assigned to you for the duration of the
program is revealed, e.g., its size and the operators it
contains.

1. eval: The Player supplies an ID of a secret program, and an
array of up to 256 input 64-bit vectors, each an argument to
the secret program. The Game responds by revealing the value
on the inputs of the secret function corresponding to ID.

2. guess: The Player supplies the ID of the secret program and a
guessed program. If the Game decides that the Player's guess
computes the same function as the secret program, the Player
scores one point. Otherwise, the Game responds with a
counter-example, an input bit-vector and the differing
outputs of the secret and guessed programs on that input.

Once you begin to eval or guess a problem with a particular ID,
you will have 5 minutes to score one point. After 5 minutes, the
problem ID expires; you will have to start over with a fresh
problem ID.

The team with the highest score after 72 hours wins.

The team with the highest score after 24 hours wins the lightning
division.

Additionally, the Game server provides a training mode. By making a
"train" request to the server, the Player can obtain a training
program ID as well as the text of program. Thereafter, the Player can
make eval and guess requests with respect to this training program ID
for an unlimited time period. Of course, successfully guessing a
training program does not contribute to your score.

--------------------------------------------------------------------------------
Details
--------------------------------------------------------------------------------

Definition of \BV
~~~~~~~~~~~~~~~~~

0. Syntax

program    P ::= "(" "lambda" "(" id ")" e ")"
expression e ::= "0" | "1" | id
| "(" "if0" e e e ")"
| "(" "fold" e e "(" "lambda" "(" id id ")" e ")" ")"
| "(" op1 e ")"
| "(" op2 e e ")"
op1 ::= "not" | "shl1" | "shr1" | "shr4" | "shr16"
op2 ::= "and" | "or" | "xor" | "plus"
id  ::= [a-z][a-z_0-9]*

A valid program P contains at most one occurrence of "fold".
The only constants in a source program are 0 and 1.
However, \BV programs can be evaluated on arbitrary 64-bit values.

1. Semantics

All programs are functions from 64-bit vectors to 64-bit vectors.

The expression "(fold e0 e1 (lambda (x y) e2))" uses the lambda-term
to fold over each byte of e0 bound to x (starting from the least
significant), and with the accumulator y initially bound to e1.

For example, given P = (lambda (x) (fold x 0 (lambda (y z) (or y z)))),

P(0x1122334455667788)

reduces to

(or 0x0000000000000011
(or 0x0000000000000022
(or 0x0000000000000033
(or 0x0000000000000044
(or 0x0000000000000055
(or 0x0000000000000066
(or 0x0000000000000077
(or 0x0000000000000088
0x0000000000000000))))))))

Other operators have the usual (bitwise) interpretation.

You are most welcome to figure out the details by experimenting with
the game system :-)

The function |.| determines the size of an \BV expression or program.

|0| = 1
|1| = 1
|x| = 1
|(if0 e0 e1 e2)| = 1 + |e0| + |e1| + |e2|
|(fold e0 e1 (lambda (x y) e2))| = 2 + |e0| + |e1| + |e2|
|(op1 e0)| = 1 + |e0|
|(op2 e0 e1)| = 1 + |e0| + |e1|
|(lambda (x) e)| = 1 + |e|

The function "Op" determines the set of operators in an expression,
where "U" is set union.

Op 0 = {}
Op 1 = {}
Op x = {}
Op (if0 e0 e1 e2) = {"if0"}  U Op e0 U Op e1 U Op e2
Op (fold e0 e1 (lambda (x y) e2)) = {"fold"} U Op e0 U Op e1 U Op e2
Op (op1 e0) = {op1}    U Op e0
Op (op2 e0 e1) = {op2}    U Op e0 U Op e1

The binary relation "Operators" relates a program to a set ranging over
the set "ops", defined below:

ops ::= op1 | op2 | "if0" | "tfold" | "fold"
Operators (lambda (x) (fold x 0 (lambda (x y) e))) ({"tfold"} U Op e)
Operators (lambda (x) e) (Op e)

The Web API
~~~~~~~~~~~

All interactions with the Game should use GET or POST requests
directed to:

http://icfpc2013.cloudapp.net/

0. Authorization

Your submission to EasyChair, and more precisely its abstract, now
contains a user_id that you will use to authorize with the server
running the game.

Throughout this document, we assume that your user_id is
0000abcdefghijklmnopqrstuvwxyz0123456789. You should substitute it for

All requests need to be directed to the URL below (note the "vpsH1H"
suffix):

http://icfpc2013.cloudapp.net/path?auth=0000abcdefghijklmnopqrstuvwxyz0123456789vpsH1H

where path is "myproblems", "train", "eval", or "guess".

You can start to experiment by pointing your browser to:

http://icfpc2013.cloudapp.net/play.html?auth=0000abcdefghijklmnopqrstuvwxyz0123456789vpsH1H

Type "myproblems" or "status" into the url field, and click on the
POST button. There is also a bit more user friendly playground
interface at:

https://www.touchdevelop.com/users/MichalMoskal/icfpc2013

Enter "0000abcdefghijklmnopqrstuvwxyz0123456789vpsH1H" as the "auth key",
then click on [new] to get a new training problem, try to evaluate it
on some inputs, try to guess it.

Each authorization token grants you the privilege of making up to 5
requests to the game server in any 20 second window. Depending on
load, you may be rate-limited further.

1. Getting problems

Use the following API to initiate a new problem instance:

POST /myproblems
response 200 body Problem []
response 403 authorization required
response 429 try again later

A succesful response (response 200) from the Game server will return
in the response body an array of Problem structures (defined
below), formatted using JSON (http://www.json.org).

interface Problem {
id: string;
size: number;
operators: string[];
solved?: boolean;
timeLeft?: number
}

In response to a /myproblems request, each problem p in response
array has the following properties:

-- p.id is a problem ID corresponding to some program P.

-- p.size is in the range [3,30], and |P| = p.size

-- When interpreted as a set, the relation
(Operators P p.operators) is valid.

-- The field "solved" may or may not be present. If present,
p.solved indicates whether or not a point has been scored on
this problem.

-- The field "timeLeft" may or may not be present. If present,
p.timeLeft records the time in seconds remaining to solve the
problem. If absent, you have 300 seconds to solve the
problem---the clock starts ticking as soon as you make an /eval
or /guess request for that problem.

For example, a valid response may be:

[
{"id":"dKdeIAoZMyb5y3a74iTcLXyr",
"size":30,
"operators":["shr16","if0","xor","plus","not","fold"]},
{"id":"hx2XLtS756IvDv9ZNuILizxJ",
"size":3,
"operators":["not"],
"solved":true,
"timeLeft":0},
{"id":"af82718a7fhla74cal8faf7a",
"size":3,
"operators":["not"],
"timeLeft":192.61}
]

2. Evaluating programs

Use the following API to evaluate a program on some inputs:

POST /eval
request body EvalRequest
response 200 body EvalResponse
response 400 Bad Request   (some input is not well-formed)
response 401 Unauthorized  problem was not requested by the current user
response 410 Gone          problem requested more than 5 minutes ago
response 412               problem was already solved (by current user)
response 413               request too big

The request body is a JSON-formatted EvalRequest:

interface EvalRequest {
id?: string;
program?: string;
arguments: string[];
}

An EvalRequest must contain either an id field or a program field,
but not both.

-- id: A program ID obtained previously from the Game server.

-- program: A \BV program P formatted as a string. The program must
be 1024 characters or less, and |P| is less than or
equal to 100

-- arguments: Up to 256 64-bit unsigned numbers encoded in

An example of a valid EvalRequest:

{"program":"(lambda (x) (shl1 x))",
"arguments":["0x00000000000001",
"0xEFFFFFFFFFFFFF"]}

A successful request produces an EvalResponse in the response body:

interface EvalResponse {
status: string;
outputs?: string[];
message?: string;
}

Given an EvalRequest r, an EvalResponse s to r has the following
properties:

-- s.status is either "ok" or "error"

-- If s.status is "error", s.outputs is not present.

-- If s.status is "ok", then s.outputs is an array of hexadecimal
formatted 64-bit unsigned numbers, in 1-1 correspondence with
r.arguments, such that, if P is the program corresponding to
r.id or r.program, s.outputs[i] = P (r.arguments[i]).

-- If s.status is "error", s.message is an error message; otherwise
s.message is not present.

3. Submitting guesses

Use the following API to submit guesses (and test if they are valid
solutions to the challenge):

POST /guess
request body Guess
response 200 body GuessResponse
response 400 Bad Request   (some input is not well-formed)
response 401 Unauthorized  problem was not requested by the current user
response 410 Gone          problem requested more than 5 minutes ago
response 412               problem was already solved (by current user)
response 413               request too big

The request body is a Guess (formatted as JSON):

interface Guess {
id: string;
program: string;
}

-- id is a problem ID obtained from the Game server

-- program is a \BV program, guessed to be equivalent to the secret

An example Guess is:

{"id":"afa696afglajf696af",
"program":"(lambda (x) (plus x 1))"}

A valid guess request g produces a GuessResponse r:

interface GuessResponse {
status: string;
values?: string[];
message?: string;
lightning?: bool;
}

-- r.status is either "win", "mismatch" or "error"

-- If r.status is "win" if you guessed correctly. The other fields
are absent. You score one point if g.id is not a training ID.

-- If r.status is "mismatch", then values contains three 64-bit
unsigned integers encoded as hexadecimal strings: the first is
an input argument; the second is the result of the challenge;
and the third is the result of your guessed program.

-- If r.status is "error", then the message field contains an
explanation. Note, if the Game server is unable to prove that
your guess is functionally equivalent to the secret program,
then you do NOT score a point. You can either try another guess,
or move on to another problem. If you make reasonable guesses,
we do not expect this to happen.

-- If r.lightning is present and true, then your guess was counted
for the lightning division.

4. Training

Use the following API to obtain training programs:

POST /train
request body TrainRequest
response 200 body TrainingProblem
response 403 authorization required
response 429 try again later

The request body is a JSON-formatted TrainRequest:

interface TrainRequest {
size?: number;
operators?: string[];
}

The request body contains two optional fields:

-- size: The size of the problem requested, in the range [3,30].

-- operators: Is either [], ["tfold"], or ["fold"]

In response to a valid TrainRequest t, the server returns a
TrainingProblem p:

interface TrainingProblem {
challenge: string;
id: string;
size: number;
operators: string[];
}

The response p to a valid request t has the following properties:

-- p.challenge is some \BV program P.

-- p.id is a training problem ID associated with P.

-- p.size = |P| and if t.size is defined then t.size = p.size

-- (Operators P p.operators) is valid, and
if t.operators is []
then "fold" and "tfold" do not occur in p.operators
else if t.operators is defined
then t.operators is included in p.operators

5. Status

POST /status
response 200 body Status
response 403 authorization required
response 429 try again later

A valid request produces a JSON-formatted Status as a response.

interface Status {
easyChairId: string;
contestScore: number;
lightningScore: number;
trainingScore: number;
mismatches: number;
numRequests: number;
requestWindow: {
resetsIn: number;
amount: number;
limit: number
};
cpuWindow: {
resetsIn: number;
amount: number;
limit: number
};
cpuTotalTime:number;
}

Most of the fields in a Status object are self-explanatory.

The requestWindow object shows how many requests you are currently
allocated in each 20-second window.

-- resetsIn is the time in seconds until the current 20-second
window expires and your allocation is reset.

-- amount is the number of requests you have already made in the
current window.

-- limit is maximum number of requests you are allowed to make
in the current window.

The cpuWindow object is similar, except it shows you how much CPU
time you have allocated to you on the server in the current 60
second window.

-- resetsIn is the time in seconds until the current 60-second
window expires and your allocation is reset.

-- amount is the amount of CPU time you have already consumed in
the current window.

-- limit is maximum number of CPU time you have available to you
in the current window.

Depending on load, we may change the window sizes and number of
requests/cpu time allotted to you.

Rules, regulations, and other notes
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
0. Do not cheat.

1. Please do not attempt to attack the Game server. That will spoil
the fun for the other 500+ teams and us, the game administrators.

2. Each team should compete independently of other teams. Do not
collude.

3. Each team is assigned a unique authorization token which grants
them the ability to make a fixed number of requests to the Game
server. Do not attempt to obtain or use more than one such
token. If you attempt to use the token of another team, both you
and the other team could be disqualified.

4. Remember, you only have up to 5 requests every 20 seconds.
So, make your requests wisely. In particular,
/train, /status and /myproblems requests also count.

5. At most one hour after the contest closes, you should complete the
submission form at the URL below. This involves providing answers
want to be considered for the judges' prize, you should provide a

Submission form:

https://www.touchdevelop.com/users/MichalMoskal/icfpc2013

(first provide your auth token and then click on [survey] button)

6. At the end of 72 hours, if your team's score is among the top 20,
you will be contacted (at the email address you provided in
EasyChair) and asked to submit a two-page abstract describing your
solution. Thereafter, you will have 48 hours to respond, if you
wish to be considered for the judges' prize. Based on your
abstract, you may be requested to make your code available for
further review, under some mutually acceptable license.

7. All decisions made by the organizers are final.
```
2013.08.08 18:34 updated: 2013.08.08 18:56

## For late registrants:

If your EasyChair submission contains an authorization token (with the first 4 characters matching your EasyChair submission id) then you have been registered for the contest.

If you still have not registered, you can still follow the late registration instructions posted here.

2013.08.08 06:57 updated: 2013.08.08 07:01

## Questions?

Send email to icfpcontest2013@easychair.org

2013.08.07 21:46 updated: 2013.08.09 00:26

## Authorization tokens and team memberships

To all teams that have registered on EasyChair: The abstract of your EasyChair submission now contains an authorization token (its first 4 characters should contain your EasyChair paper id). Each participant in the contest should be a member of a single team, and each team should have just one authorization token. At this point, you are free to alter your team memberships, so long as you adhere to the above rule. If you do not intend to field a team that was pre-registered, please change that team's name to "CANCELLED".

If your team uses a token assigned to another team, both teams will be disqualified.

2013.08.07 02:02 updated: 2013.08.07 21:58

## Welcome!

This is the website for the 2013 edition of the ICFP programming competition. The rules and instructions for connecting to the service will be posted here once the contest starts.