Site rehearsal

.cstaff: log in and open 🏷️ Badges. That screen lists the teams of your site with their login and password, laid out for printing on labels. Pick one team for the rehearsal and write its credential down.

If the list comes up empty, stop right here and call the organizers: your site scope is not configured, and on contest day you would be left with no credentials.

Team: on the machine running Maratona Linux, open the rehearsal address and log in with the credential from step 1. Put a real person in that chair, even if it is you: the rehearsal only works if the rehearsal machine is the contest machine.

This contest has no editor in the browser, and that is deliberate: the Marathon works the same way. The team writes the program in an editor on the machine, compiles it in the terminal, and submits the finished file.

Problem A — Ola Mundo reads nothing and prints one line. Take the program from Appendix A in whichever language you prefer, save it to a file and submit: click the problem's row, pick the file and press Submit.

The verdict arrives on its own in a few seconds, with no need to reload. What you want to see is Accepted, and the problem's row changes colour up above.

Now send three broken programs, one of each kind. The point is for the site to recognise each verdict when it shows up on contest day, and to know that none of them means the system is broken. The programs are in Appendix B.

Send	To problem	You will see	Which means
the wrong arithmetic	B — Soma 2	Wrong Answer	The program ran to the end, and the answer is not the expected one.
the early exit	C — Soma N	Runtime Error	The program broke while running.
the endless loop	D — EOF	Time Limit Exceeded	The program took longer than the problem allows.

In a contest, the verdict is all the team gets: no failing test, no diff, no partial score. That is on purpose — the test data is exam material.

Team: open the 🖨️ Printing tab, pick the file you have just submitted and press Request printing. The request shows up below as pending.

One detail worth learning now: the team only ever sees its own requests, and the number beside each one is the number printed on the cover sheet. That is how you check, at the counter, that the paper went to the right team.

.staff: on the machine that has the printer — Windows, macOS or any Linux, never Maratona Linux — open 🖨️ Print queue. The request from step 5 is there, at the top.

The cycle has three steps, always in the same order:

1. Claim — reserves the task for you, so two volunteers do not print the same thing.
2. 🖨️ Print — opens the PDF in a new tab and calls the printer. Allow pop-ups for this site now: if the browser blocks the tab, the task is never marked as printed, and the paper disappears from your list.
3. ✅ Delivered — after you hand the paper over at the team's desk. That click is what tells the organizers the paper arrived.

What comes out of the printer is a cover sheet followed by the team's document. The cover carries the team name, the university, the login and the task number, with a line to sign on delivery.

After it comes the code, in a monospaced font, with the team's own indentation and numbered lines. Look at the top and the bottom of each page: the date and the file name run along the top, and the team login, the file name again and the task number run along the bottom. That is what saves the day when a sheet comes loose from the pile — and with thirty printouts on the desk, one always does.

The text on that sheet comes out in Portuguese at every site, and that is on purpose: the delivery desk recognises the same piece of paper across the whole continent. The balloon colour is named in two languages, so that it matches the physical balloon.

Remember the Accepted from step 3? It became a balloon task, and it lands in the same queue, marked with 🎈 and carrying the problem's colour. And notice when it appears: the balloon is only created when somebody from the site opens the queue. If nobody opens it, it does not exist — that is not the system running late.

Treat a balloon like any other task: Claim, Print, and Delivered once the balloon reaches the desk. Carry the sheet along with the balloon — that sheet is the proof of delivery.

Each colour belongs to a letter, and the same letter has the same colour at every site. Check your balloons against the sheet before the contest starts.

In a busy contest, stopping at every print dialog is what slows the room down. That is what automatic mode is for: the checkbox at the top of the queue. With it on, every new task is claimed, printed and marked on its own. All that is left for you is the walk to the desk.

For the paper to come out with no dialog at all, the browser has to be in kiosk printing mode. Close Chrome and open it again like this:

Linux
  google-chrome --kiosk-printing https://mdp-teste-2026.moj.naquadah.com.br/contest/staff/

Windows  (Start menu → right-click Chrome → Properties → Target)
  "C:\Program Files\Google\Chrome\Application\chrome.exe" --kiosk-printing

macOS
  open -a "Google Chrome" --args --kiosk-printing

With Chrome in that mode, turn the checkbox on, ask for another printout from the team's window and do not touch anything. The paper comes out by itself. That is how the room runs on the day.

.cstaff: open the same queue. You see everything your team sees, with one difference: the actions column is empty. That is not a permission mistake, it is how the role is drawn — claiming and printing belong to the room team.

While you are there, confirm the two things only you can see. First: the queue shows the teams of your site and nobody else. Second: the badges from step 1 match the people who will sit in the room.

/* sol.c */
#include <stdio.h>
int main(void) { printf("Ola Mundo\n"); return 0; }

# sol.py
print("Ola Mundo")

// Main.java
public class Main {
    public static void main(String[] args) { System.out.println("Ola Mundo"); }
}

/* sol.c */
#include <stdio.h>
int main(void) {
    long a, b;
    scanf("%ld %ld", &a, &b);
    printf("%ld\n", a + b);
    return 0;
}

# sol.py
import sys
a, b = map(int, sys.stdin.read().split())
print(a + b)

/* sol.c */
#include <stdio.h>
int main(void) {
    long n, x, sum = 0;
    scanf("%ld", &n);
    for (long i = 0; i < n; i++) { scanf("%ld", &x); sum += x; }
    printf("%ld\n", sum);
    return 0;
}

# sol.py
import sys
nums = list(map(int, sys.stdin.read().split()))
print(sum(nums[1:1 + nums[0]]))

/* sol.c */
#include <stdio.h>
int main(void) {
    long x, count = 0;
    while (scanf("%ld", &x) == 1) count++;
    printf("%ld\n", count);
    return 0;
}

# sol.py
import sys
print(len(sys.stdin.read().split()))

/* wa.c — multiplies instead of adding */
#include <stdio.h>
int main(void) {
    long a, b;
    scanf("%ld %ld", &a, &b);
    printf("%ld\n", a * b);
    return 0;
}

# wa.py
import sys
a, b = map(int, sys.stdin.read().split())
print(a * b)

/* rte.c */
#include <stdio.h>
#include <stdlib.h>
int main(void) {
    long n;
    scanf("%ld", &n);
    exit(1);            /* leaving with anything other than zero means "it went wrong" */
}

# rte.py
import sys
n = int(sys.stdin.readline())
sys.exit(1)

/* tle.c */
int main(void) { while (1) { } return 0; }

# tle.py
while True:
    pass