"""Date
Wed Mar 12 03:31:14 2003 +0900
Fri Mar 7 03:31:14 2003 +0900
"""
def con(m):
    if m == "Jan":
        return 1
    if m == "Feb":
        return 2
    if m == "Mar":
        return 3
    if m == "Apr":
        return 4
    if m == "May":
        return 5
    if m == "Jun":
        return 6
    if m == "Jul":
        return 7
    if m == "Aug":
        return 8
    if m == "Sep":
        return 9
    if m == "Oct":
        return 10
    if m == "Nov":
        return 11
    if m == "Dec":
        return 12
    return -1

def vert(s):
    days2002 = [31,28,31,30,31,30,31,31,30,31,30,31]
    days = [31,28,31,30,31,30,31,31,30,31,30,31]
    # s[0] s[1] s[2]
    d = 0
    if s[0] == 2002:
        for i in range(s[1]-1):
            d += days[i]
        d += s[2]
        return d
    if s[0] == 2003:
        for i in range(s[1]-1):
            d += days[i]
        d += s[2]
        d += sum(days)
        print(sum(days))
        return d
    
with open("./Date", "r") as f:
    s = f.read()
    ss = s.split("\n")
    # print(ss)
    al = []
    for iss in ss:
        m = iss.split(" ")[1]
        d = iss.split(" ")[2]
        y = iss.split(" ")[4]
        al.append([int(y),con(m),int(d)])
    print(al)
    ans = ["x"]*365*2
    print(ans)
    for eac in al:
        ans[vert(eac)] = "#"
    print(ans)
    for h in range(7):
        for w in range(365*2//7):
            if ans[7*w+h] == "#":
                print("#", end="")
            else:
                print(" ", end="")
        print("")

package main

import (
	"context"
	"encoding/json"
	"log"
	"net/http"
	"os"
	"os/signal"
	"strconv"
	"syscall"
	"time"
)

func main() {
	srv := &http.Server{Addr: ":3334"}
	http.HandleFunc("/", gachaHandler)

	go func() {
		if err := srv.ListenAndServe(); err != nil {
			log.Printf("shutdown the server with error: %+v\n", err)
		}
	}()

	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGTERM)
	log.Printf("SIGNAL %d received, then shutting down...\n", <-quit)

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	if err := srv.Shutdown(ctx); err != nil {
		log.Println("failed to shutdown: %+v", err)
		os.Exit(1)
	}
}

func gachaHandler(w http.ResponseWriter, r *http.Request) {
	seed := r.FormValue("seed")
	if len(seed) == 0 {
		seed = "1"
	}
	seedInt, err := strconv.Atoi(seed)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	// get current time(HHmmss)
	jst := time.FixedZone("Asia/Tokyo", 9*60*60)
	nowStr := time.Now().In(jst).Format("150405")
	log.Println(nowStr)
	nowInt, err := strconv.Atoi(nowStr)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	sm := (seedInt + nowInt) % 100000
	log.Println(sm)
	var flag map[string]string

	if sm == 1337 {
		flag = map[string]string{
			"flag": "taskctf{this_is_dummy_flag}",
		}
	} else {
		flag = map[string]string{
			"flag": "You might not have a luck...",
			"sum":  strconv.Itoa(sm),
		}
	}
	res, _ := json.Marshal(flag)
	w.WriteHeader(http.StatusOK)
	_, err = w.Write(res)
    if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
}