Votre tâche consiste à créer un programme qui imitera Big Ben (Twitter) .

Tâche

Chaque fois qu'une nouvelle heure a commencé (en fonction de l'heure locale ou de l'heure UTC de votre ordinateur), vous devez générer BONGdes hourtemps répétés (avec un espace entre les mots). Par exemple, quand il est 3 heures, vous devez sortir BONG BONG BONG. Le format de l'heure suit le format de l'heure de 12 heures, c'est-à-dire qu'après midi, nous en avons 1 et non pas 13. Le programme / la fonction doit être exécuté à l'infini.

Exemple:

^{ne pas sortir des choses à l'intérieur des crochets}

(start: 00:34 for example)
BONG               (01:00)
BONG BONG          (02:00)
(...)
BONG BONG BONG BONG BONG BONG BONG BONG BONG BONG BONG BONG (12:00)
BONG               (01:00 again)
(...)
(it continues forever)

Règles

• Chaque série de BONGs doit être séparée par une nouvelle ligne
• Les retours à la ligne sont autorisés
• Cependant, les espaces de début / fin ne sont pas autorisés
• La soumission doit durer éternellement
• Votre sortie peut être imprimée à ± 3 secondes du début de l'heure.
• Vous ne pouvez pas supposer que le programme est exécuté à une heure spécifique

C'est du code-golf , alors le programme avec le plus petit décompte gagne!

05AB1E , 43 octets

3600žcžb60*+->Lvw}["BONG "ža<12%>×,5°36*.W]

Essayez-le en ligne! (lol cela ne fonctionnera pas, il expirera dans 60 secondes. Téléchargez l' interpréteur 05AB1E pour cela)

Explication:

3600žcžb60*+->                          # Get amount of seconds (plus one) until next hour
              Lvw}                      # Wait said amount of seconds
                  [                     # Infinite loop start
                   "BONG "ža<12%>×,     # Print "BONG " multiplied by the amount of hours (12-hour clock)
                               5°36*.W  # Wait an hour (3600000 milliseconds)
                                      ] # Infinite loop end  

Cela m'a pris du temps au golf! Je pourrais peut-être jouer un peu plus au golf, mais ça bat *><>, alors c'est cool :)

Version rapide:

1Uw["BONG "X<12%>×,wX>U]

Attendra une seconde au début et une seconde entre les BONG

Frapper, 71, 70, 69 octets

EDITS:

• Optimisé un peu le calcul de l'intervalle de sommeil, -1 octet;
• Backticks remplacés par xargs, -1 octet (Merci @ jrtc27!).

Golfé

sleep `date +3600-%s%3600|bc`;yes BONG|sed $(date +%I)q|xargs;exec $0

A expliqué

#Compute the number of seconds left in the current hour and wait.
sleep `date +3600-%s%3600|bc`; 

#Print "hour" (1-12) worth of "BONG" strings, one per line,
#use xargs to merge them into a single space-separated string.
yes BONG|sed $(date +%I)q|xargs

#Re-execute itself (in the same process).
exec $0

Version d'essai

Fonctionne avec des minutes plutôt que des heures

sleep `date +60-%s%60|bc`;yes BONG|sed $(date +%I)q|xargs;exec $0

*> <> , 48 47 44 octets

>s?um?uhc%:?!c21.O
v$o" GNOB"oooo$1-:?!
\aofS

Essayez-le ici! ( ou cette version qui le fait chaque minute pour les tests )

Cela génère un nombre de BONGs séparés par des espaces en fonction de l'heure (et 13 correspond à 1, etc.). Il n'y a pas d'espace de fin après la finale BONGet il y a une nouvelle ligne.

Techniquement, cela ne fonctionne pas éternellement (mais c'est le cas fondamentalement). Il fuit ~ 28 octets par jour (en ignorant les frais généraux de l'interprète ...). Cela prendrait environ 105062 ans pour qu'il s'écoule 1GiB.

En se rapprochant des frais généraux d’interprète, la pile n’est qu’une tranche de float64s sur l’interprète de Golang. Je me suis donc contenté 28*8de créer 224 octets par jour. J'ai divisé ce nombre par le nombre d'octets dans un gibibyte (1073741824), puis 365 pour indiquer qu'il faudrait 13132,85 années pour perdre 1 Go.

Note sur les interprètes

L'interprète en ligne est en Javascript. La page doit être ouverte et visible pour pouvoir vérifier l'heure et afficher les BONG. L' interprète de Golang n'a pas cette limitation.

Explication

Main loop:

s?um?u          O     if seconds == 0 && minutes == 0:
      hc%               push hours % 12 (bongs) to the stack
         :?!c           if bongs is 0, push 12 to the stack
             21.        jump to "output bongs" coords (2, 1)


Output bongs:

Begins at `"` because of the jump.

   " GNOB"            push "BONG " to the stack
          oooo        output "BONG"
              $1-     subtract 1 from bongs
v                :?!  if bongs == 0, move to "newline and sleep"
 $o                   output " "


Newline and sleep:

\                     mirror the IP to the right
 ao                   output a newline
   fS                 sleep for 1.6s
\                     mirror to main loop

JavaScript (ES6), 99 93 octets

f=_=>setTimeout('alert("BONG ".repeat(new Date/36e5%12|0||12).trim(f()))',36e5-new Date%36e5)

Ceci utilise le temps UTC (qui s'aligne avec la chose réelle). En raison de la nature intempestive du code, vous pouvez essayer ce qui suit, qui fait la même chose, mais toutes les 60 secondes:

f=_=>setTimeout('alert("BONG ".repeat(new Date/36e5%12|0||12).trim(f()))',6e4-new Date%6e4)

f()

Voici une version bonus de 99 octets qui utilise l'heure locale:

f=_=>setTimeout('alert("BONG ".repeat(new Date().getHours()%12||12).trim(f()))',36e5-new Date%36e5)

JavaScript (ES6), 125 123 117 115 octets

Merci à @ Flp.Tkc pour avoir économisé 5 octets!

Merci à @BenAston d'avoir économisé 2 octets supplémentaires!

a=eval(b=`(new Date).getHours()`);setInterval(w=>eval(b)!=a?console.log(Array(++a%12+1).join`BONG `.trim()):"",1e3)

Snack Snippet

a=eval(b=`(new Date).getHours()`);setInterval(w=>eval(b)!=a?console.log(Array(++a%12+1).join`BONG `.trim()):"",1e3)

Lot, 142 octets

@timeout/t>nul 1
@if not %time:~3,5%==00:00 %0
@set/ah=-%time:~0,2%%12
@set s=............
@call set s=%%s:~%h%%%
@echo %s:.=BONG %
@%0

Comme le fichier fonctionne comme une boucle infinie, je commence par un retard de 1 seconde, car j'en ai besoin quand même après les bongs, ce qui économise les cycles de traitement. Le >nulest positionné avec soin pour sauvegarder un octet ( 1>nulle 1 serait mangé par la redirection). Nous bouclons ensuite jusqu'à ce que les minutes et les secondes soient à zéro. Les bangs sont construits en prenant l’heure négative modulo 12 et en demandant les derniers hcaractères d’une chaîne de 12 caractères. Quand hest égal à zéro, cela nous donne en fait la chaîne entière, donc 12 bangs. Il suffit alors de remplacer les caractères par le mot BONG. Lorsqu'elle est exécutée, elle ressemble à ceci (notez que l'image ne se boucle pas, vous devrez donc recharger de force pour voir à nouveau l'animation):

Bash + Linux crontab, 90

J'espérais que ce serait plus court que les autres réponses shell. Néanmoins, je pense que c'est une approche intéressante:

for i in {0..11};{
s+=\ BONG
echo "0 $i,$[i+12] * * * echo$s>/proc/$PPID/fd/1"
}|crontab -

Le script s'exécute une fois, remplit la crontab, puis se ferme. Toutefois, la sortie des tâches cron est envoyée au terminal à partir duquel le script a été exécuté. Je pense que cela satisfait la soumission doit courir pour toujours l' exigence.

Avertissement - cela effacera toutes les entrées de crontab existantes, alors assurez-vous de les avoir déjà sauvegardées.

Cela fonctionne sur Ubuntu 16.04, qui utilise Vixie cron par défaut.

Ruby, 112 à 99 octets

loop{sleep 2;n=Time.now;if(n.min==0);puts ('BONG '*n.strftime('%I').to_i).chop;sleep 60-n.sec end}

Ancienne version

loop{sleep(2);n=Time.now; if(n.min.zero?) then puts ('BONG ' * n.strftime('%I').to_i).chop;sleep(60-n.sec) end}

Merci à QPaysTaxes pour les astuces

Cheddar v1.0.5, 162 octets

Cheddar n'a pas de lecteur de temps intégré / lecteur de sortie cmd, j'ai donc dû improviser!

Golfé:

var f=->{IO.exec("time/t>c");(String::IO.read("c")).split(":")};var a=f()[0];for(;1;){var b=f();if(b[0]!=a){var c=Number::(a=b[0]);print("BONG "*c).head(5*c-1);}}

Ungolfed:

var f=->{
    IO.exec("time/t>c");
    (String::IO.read("c")).split(":")};
var a=f()[0];
for(;1;){
    var b=f();
    if(b[0]!=a){
        var c=Number::(a=b[0]);
        print("BONG "*c).head(5*c-1);
    }
}

Explication:

En raison de la bibliothèque standard limitée de Cheddar, j'ai dû utiliser cmd pour générer le temps. Je l'ai fait en sauvegardant la sortie de "time / t", qui affiche l'heure au format 12 heures, dans un fichier nommé "c". IO.read renvoie un tampon que j'ai converti en chaîne et scindé par ":", ce qui garantit que l'heure est toujours à l'indice zéro. J'ai sauvegardé toute cette opération dans une expression lambda qui m'a sauvé 44 octets. Il passe ensuite à la logique suivante: "si l'heure enregistrée ne correspond pas à l'heure courante, définissez l'heure précédente sur l'heure actuelle et imprimez BONG n fois, coupez l'espace de fin".

Le cheddar n'est peut-être pas le langage le moins bavard, mais il peut être amusant de trouver des solutions de rechange comme celle-ci!

Malheureusement, il s’agit d’une solution exclusivement Windows.

Éditer 1: deux octets sauvegardés en remplaçant "0 <1" dans la condition for par "1". Je ne m'attendais pas à ce que 1 soit évalué à true dans cette langue!

Ruby, 82 81 octets

loop{l=Time.new
puts ("BONG "*(l.hour%12+1)).chop if(l+1).hour!=l.hour
sleep 1}

Chaque seconde, nous vérifions si c'est la dernière seconde de l'heure et BONG en conséquence. Pourrait probablement être joué au golf plus loin avec quelques mauvais tours, mais je n'en connais pas beaucoup. En outre, cela fonctionne différemment de l'autre réponse Ruby.

Un octet économisé grâce à la courtoisie de QPaysTaxes.

Python 2 , 105 106 octets

import time
h=0
while 1:
 l=time.localtime();c=l[3]%12
 if l[4:6]==(0,0)and h!=c:print('BONG '*c)[:-1];h=c

modifier

Ajout d'un octet en remplaçant <en! = Après les commentaires de @ pinkfloydx33. Bon endroit.

Testé autant que possible localement, mais ne fonctionne pas sur TIO car il dépasse (évidemment) la limite d'exécution de 60 secondes. N'hésitez pas à tester localement :-)

Au fait, perdre cet encombrant espace de fuite m'a coûté 7 octets, sinon cela aurait été inférieur à 100.

En l'absence de TIO, la sortie est attendue après une heure. Prog a été lancé à 15h27 avec du code de débogage supplémentaire pour afficher l'heure de l'impression (format 12 heures).

python bigben.py
time is 4:0:0
BONG BONG BONG BONG
time is 5:0:0
BONG BONG BONG BONG BONG

C'est assez simple, mais voici une explication pour quiconque est intéressé.

import time                 #Import the time module
h=0                         #Create a variable to store the hour that has just been printed
while 1:                    #Loop forever
 l=time.localtime()         #Get the local time from the time module
 c=l[3]%12                  #Set a variable to the current hour in 12 hour format
 if l[4:6]==(0,0)and h!=c:   #If minutes=0 and hours=0 and the last hour that was printed is not the current hour
  print "time is "+`c`+":"+`l[4]`+":"+`l[5]`    #Debug code to show hour
  print('BONG '*c)[:-1]     #Print 'BONG '*number of hours and lose the space from the end 
  h=c                       #Update the last hour that was printed

Python 3 - 100 97 92 octets

from time import*
while 1:x=3600;sleep(x-time()%x);print(('BONG '*int(strftime("%I")))[:-1])[:-1])

Explication:

import time;
while 1:
 t=time;x=3600;
 t.sleep(x-t.time()%x);#sleep for the remaining seconds until the next hour
 print(('BONG '*int(t.strftime("%I")))[:-1])#strftime("%")=nr of hours (1-12). Print the bongs and remove the last char

C, 238 octets

#include<time.h>
#include<unistd.h>
i,j;f(){time_t t=time(0);struct tm l=*localtime(&t);for(;;){t=time(0),l=*localtime(&t),j=l.tm_hour;sleep(1);if(!(l.tm_min+l.tm_sec)){j=j%12?j<12?j:j-12:12;for(i=0;i<=j;i++)printf("BONG%c",i^j?32:10);}}}

Je ne sais pas si cela fonctionne correctement, je suis mobile et mon téléphone ne dispose pas d'un compilateur C. (Fonctionne uniquement sur les systèmes de type UNIX)

sh, 66 octets

yes 'echo `yes BONG|sed $(date +%I)q`'|sh -s|awk '$0!=a&&a;{a=$0}'

A expliqué

#Pipe a command into a subshell repeatedly
yes 'some command'|sh -s

#Print "hour" (1-12) worth of "BONG" strings, one per line,
#use backticks to merge them into a single space-separated string.
#(stolen from zeppelin's answer)
echo `yes BONG|sed $(date +%I)q`

#Print every time the output changes
awk '$0!=a&&a;{a=$0}

C, 198 octets

#import<time.h>
h,i;f(){time_t t=time(0);struct tm l=*localtime(&t);for(h=l.tm_hour;;t=time(0),l=*localtime(&t))if(h-l.tm_hour%12){h=l.tm_hour%12;for(i=h?h%12:12;--i;)printf("BONG ");puts("BONG");}}

Javascript ES6 87 octets

Edit: Empruntez le new Date/36e5%12|0||12code de @ETHProductions sans vergogne pour économiser 6 octets

setInterval('Date().match`:00:00`?alert("BONG ".repeat(new Date/36e5%12|0||12)):5',1e3)

R, 104 105 octets

f=format;repeat{Sys.sleep(1);q=Sys.time();if(f(q,"%M%S")=="0000")print(rep("BONG",as.double(f(q,"%I"))))}

À chaque seconde, il va (devrait) vérifier si nous en sommes au bout d'une heure, puis afficher cette quantité de BONGs.

JavaScript ES2015, 100 99 98 96 94 88 octets

h=_=>new Date/36e5%12|0,p=h();for(;;)h()!=p&&(p=h(),alert('BONG '.repeat(p||12).trim()))

Explication:

hest une fonction qui obtient l'heure du jour sur une base de 12 heures en utilisant l'opérateur restant ( %12). 36e5est le nombre de millisecondes en une heure en utilisant la syntaxe exponentielle pour sauvegarder les caractères. Par newconséquent, l'opérateur n'exige pas que les parenthèses soient utilisées avec des fonctions new Date. JavaScript a uniquement une arithmétique en virgule flottante, l' |opérateur OU au niveau du bit force le nombre à être un entier car les opérateurs au niveau du bit JS fonctionnent avec le sous-ensemble entier des nombres représentés par la virgule flottante IEEE 754.

La virgule délimite les sous-expressions. pest initialisé à l'heure courante ( p=h()).

for(;;)est utilisé pour vérifier à plusieurs reprises si des BONGs doivent être alertés. La vérification est effectuée aussi rapidement que le temps d'exécution le permet.

Si l'heure a changé ( h()!=p), alors nous mettons à jour p, puis nous alertons le BONGs. L'opérateur AND logique sert de garde (il court-circuite si h()===p) pour déterminer si les BONGs sont sortis.

String.prototype.repeatest nouvelle dans ES2015 et enregistre certains caractères en utilisant quelque chose comme ES5 Array.prototype.join.

hrenvoie zéro pour les multiples exacts de 12 (c'est-à-dire 12h, 12h), nous le changeons en 12 en utilisant le OU logique p||12.

Merci à Kritixi Lithos et à ETHProductions pour leurs idées.

Excel VBA, 143 octets

Sorties de code dans la fenêtre Immédiatement VBE

Sub b:Do:n=Now
If Minute(n)=0 Then:s="":For i=1To Hour(n) Mod 12:s=s &"BONG ":Next:Debug.?Trim(s):Application.Wait n+#0:1#:End If:Loop:End Sub

Version amusante, 143 octets (non compétitif)

Bien qu’il soit assez difficile d’obtenir Excel pour aller au BONG, c’est assez simple d’obtenir l’excellence pour aller Beep. L' Beepappel émet un bip et le code ci-dessous l'utilise pour émettre des bips indiquant l'heure, heure par heure, séparés par des pauses d'une seconde.

Comme avec ce qui précède, ce code donne l'impression que Excel ne répond pas et :DoEventsil est recommandé d' ajouter un appel à la fin de la première ligne car cela améliore l'expérience de l'utilisateur. Toutefois, cela n'est pas nécessaire pour une exécution correcte du code.

Sub b:Set a=Application:Do:n=Now
If Minute(n)=0 Then:For i=1To Hour(n) Mod 12:Beep:a.Wait(Now+#0:0:1#):Next:a.Wait(n+#0:1#):End If:Loop:End Sub

Version non-golfée

Public Sub BigBen()
    Dim i As Byte
    Dim n As Date
    Dim w As Worksheet
    Dim a As Excel.Application
    Set a = Application
    Set w = a.ThisWorkbook.Sheets(1)
    Let w.Name = "Big Ben"

    Let w.[A1] = Now
    w.Columns("A:A").AutoFit

    Do
        DoEvents
        Let n = Now
        If Minute(n) = 0 Then

            ''  Print BONG
            Let s = ""
            For i = 1 To Hour(n) Mod 12 Step 1
                Let s = s & "BONG "
            Next i
            Debug.Print Trim(s)

            ''  Go Beep
            For i = 1 To Hour(n) Mod 12 Step 1
                Beep
                a.Wait (Now + #12:00:01 AM#) ''  <- #0:0:1# resolves to #12:00:01 AM#
            Next i

            ''  Keep Ticking After Going BONG
            While Now < n + #12:01:00 AM#    ''  <- #0:1# resolves to #12:01:00 AM#
                Let w.[A1] = Now
                Let a.StatusBar = IIf(Second(Now) Mod 2, "Tick", "Tock")
                DoEvents
            Wend
        End If

        ''  Tick Tock until its time to Go BONG again
        Let a.StatusBar = IIf(Second(n) Mod 2, "Tick", "Tock")
        Let w.[A1] = Now
    Loop

End Sub

C # 234 octets

Je ne prévois pas de gagner de prix ici, mais une implémentation de C # est obligatoire.

using System;
using System.Linq;namespace B{class P{static void Main(){Func<int> h=()=>DateTime.Now.Hour % 12;var p=h();while (true){var t=h();if (t!=p)Console.WriteLine(string.Concat(Enumerable.Repeat("BONG",t== 0?12:t)));p=t;}}}}

Ungolfed avec des commentaires:

using System;
using System.Linq;

namespace B
{
    class P
    {
        static void Main()
        {
            Func<int> h = () => DateTime.Now.Hour % 12; // h(): the hour in the range [0, 11], making this a lambda saves a few chars
            var p = h(); // p: Previous time
            while (true)
            {
                var t = h(); // t: Current time
                if (t != p) // If current hour is different to previous hour
                    Console.WriteLine(string.Concat(Enumerable.Repeat("BONG", t == 0 ? 12 : t))); // Print "BONG" t times (also correcting t = 0 to 12)
                p = t; // Current time is now previous time
            } // Repeat ad nauseum
        }
    }
}

Groovy, 72 octets

{x={new Date().getHours()};y=x();while(1){if(y!=(y==x()){print "BONG "*y}}​}​​​

Comment?

Stocker une méthode pour obtenir les heures actuelles.

x={new Date().getHours()};

Stocker les premières heures.

y=x();

Si vrai, si l’heure actuelle n’est pas la même que l’heure précédente, affichez l’heure actuelle multipliée par "BONG" pour afficher l’heure actuelle des bongs.

while(1){if(y!=(y==x()){print "BONG "*y}}

+3 octets %12pour les bangs non militaires.

perl, 60 octets

Mise à jour

Remplacé " "par $", enlevé CORE::, nombre corrigé.

Le golf

say join$",(BONG)x(time/3600%12||12)while sleep -time%3600+1

Cela doit être exécuté avec perl -E.

Remarques

• En perl, x while yest équivalent à while(y){x}(où xest une seule déclaration) mais n'a pas besoin des crochets. sleepest exécuté la première fois avant que quoi que ce soit est imprimé.
• timeutilise UTC. Le Big Ben original est à l'heure d'été (heure d'été britannique, BST) de la fin mars à la fin octobre.
• Une seconde est ajoutée au temps d'attente afin de garantir que le programme attend au moins une seconde. Cela signifie que les BONG seront toujours imprimés avec une seconde de retard, ce qui est légal selon les règles. Disons que vous vous tenez sur le pont de Westminster, ca. À 300 m de Big Ben. Du côté positif, cela signifie également que le programme imprimera la quantité correcte de BONGs s'il est démarré exactement au début d'une heure (au lieu d'attendre 3600 secondes).
• sleeprenvoie le nombre de secondes attendu. Ce sera toujours vrai.

QBIC , 82 octets

X=$left$|(_d,2){Y=left$$|(_d,2)~Y<>X|x=!Y!%12~x=0|x=12]B=C[x|B=B+@BONG |]?_tB|]X=Y

Vraiment besoin de changer le jeton pour les littéraux de code ( $) et d’implémenter une fonctionnalité de sous-chaîne ( left$(x,y)peut être plus courte).

Le fonctionnement interne:

In the first part, we want to set X$ to the hour-component
of our system's time. The DATE is implemented in QBIC, but
Substring (LEFT$, RIGHT$ and MID$ in QBasic) is not (yet).
We need to use the QBasic LEFT$ function, and QBIC can do 
that using a 'code literal': everything from '$' to '|'
is not parsed by QBIC but passed on to QBasic.
X=               Set X$ to
$left$|(         the leftmost (note the '$' and '|' for the code literal)
_d,2)            2 characters of TIME$ (hh:mm format)
{                DO - infinite loop
Y=left$$|(_d,2)  Set Y$ in the same way
~Y<>X            If Y$ is not equal to X$ the hour has changed
|x=!Y!%12        THEN set x to the modulo 12 of Y$ cast to number
~x=0|x=12]       If Y% happens to be divisible by 12, set x to 12
B=C              Clear B$ (c$ never gets assiged a value)
[x|B=B+@BONG |]  For the given number of hours, add "BONG " to B$
?_tB|            Print B$, trim the trailing space
]                end if
X=Y              Update X$
<DO LOOP is implicitly closed>

Mise à jour (NC): le $n'est plus utilisé dans le jeu d'instructions QBIC, il peut donc maintenant être utilisé librement comme code pour QBasic sans nécessiter de littéraux de code. Dans ce cas, il enregistre 4 octets, ce qui porte la QBIC à 78 octets:

X=left$(_d,2){Y=left$(_d,2)~Y<>X|x=!Y!%12~x=0|x=12]B=C[x|B=B+@BONG `]?_tB|]X=Y

SmileBASIC, 74 67 octets

WAIT 61TMREAD OUT H,M,S?("BONG"+" BONG"*((H+11)MOD 12))*!(M+S)EXEC.

Génère un grand nombre de sauts de ligne "de fuite";)

Edit: sauvegardé 7 octets avec un meilleur algorithme 24-> 12 heures.

PHP, 63 octets

Je pourrais économiser deux octets supplémentaires avec ASCII étendu. Mais je suis actuellement trop paresseux pour cela.

for(;;sleep(1))+date(is)?:print str_pad("
",5*date(h),"BONG ");

imprime les BONG avec un saut de ligne de tête précisément à l'heure complète. Courez avec -nr.

C, 152

int a=0,i,L=25;main(){char s[9];for(i=-1;++i<48;){sprintf(s,"%02i:00:00",i);if(!strcmp(s,__TIME__)&&i!=L)a=L=i,i=-1;printf(a-->0?"BONG ":"\n");}main();}

Lisible:

int a=0,i,L=25;

main(){
    char s[9];
    for(i=-1;++i<48;){
        sprintf(s,"%02i:00:00",i);
        if(!strcmp(s,__TIME__)&&i!=L)
            a=L=i,i=-1;
        printf(a-->0?"BONG ":"\n");
    }
    main();
}