Imported from firebitsbr/Writeups-claudeskills (claudeskills_test/writeup-0awawa0/SKILL.md). Install upstream with npx skills add firebitsbr/Writeups-claudeskills --skill writeup-0awawa0. Copyright stays with the author.

name: writeup-0awawa0 description: CTF writeups and security challenges by 0awawa0.

Writeups by 0awawa0

Source repository: /repos/0awawa0

Repository Index

• CTF-Writeups/README.md
• CTF-Writeups/b00t2root 2019/MISC/Can You Read Me/README.md
• CTF-Writeups/b00t2root 2019/MISC/Fight/README.md
• CTF-Writeups/b00t2root 2019/MISC/Treasure/README.md
• CTF-Writeups/b00t2root 2019/Forensics/Bird/README.md
• CTF-Writeups/b00t2root 2019/Forensics/Bird/README_ru.md
• CTF-Writeups/b00t2root 2019/Crypto/Scatter Me/README.md
• CTF-Writeups/YauzaCTF 2019/Stegano/Doberman/README.md
• CTF-Writeups/UUTCTF 2019/Reverse/Break My Record/README.md
• CTF-Writeups/UUTCTF 2019/Reverse/CorrectPass/README.md
• CTF-Writeups/UUTCTF 2019/Reverse/The Puzzle/README.md
• CTF-Writeups/Sunshine CTF/MISC/Big Bad/README.md
• CTF-Writeups/RealCTF 2019/Magic Brackets/README.md
• CTF-Writeups/PrayganCTF 2019/Forensics/Welcome/README.md
• CTF-Writeups/Newbie CTF 2019/Chat/README.md
• CTF-Writeups/Newbie CTF 2019/Contact Point/README.md
• CTF-Writeups/Newbie CTF 2019/Find the plain/README.md
• CTF-Writeups/Newbie CTF 2019/REC/README.md
• CTF-Writeups/Newbie CTF 2019/Top Secret/README.md
• CTF-Writeups/INSHACK 2019/Reverse/Obscure File Format/README.md
• CTF-Writeups/ENCRYPT CTF 2019/Web/Slash slash/README.md
• CTF-Writeups/ENCRYPT CTF 2019/Stegano/Into The Black/README.md
• CTF-Writeups/ENCRYPT CTF 2019/MISC/Way Back/README.md
• CTF-Writeups/ENCRYPT CTF 2019/MISC/ham-me-baby-2/README.md
• CTF-Writeups/ENCRYPT CTF 2019/Forensics/Journey to the centre of the file 2/README.md
• CTF-Writeups/ENCRYPT CTF 2019/Forensics/WrEP/README.md
• CTF-Writeups/AngstromCTF 2018/Binary/accumulator(50)/README.md
• CTF-Writeups/AngstromCTF 2018/Binary/cookie jar (60)/README.md
• CTF-Writeups/AngstromCTF 2018/Binary/number guess (70)/README.md
• CTF-Writeups/AngstromCTF 2018/Binary/personal letter (160)/README.md
• CTF-Writeups/AngstromCTF 2018/Binary/rop to the top (130)/README.md

Writeup Content

File: CTF-Writeups/AngstromCTF 2018/Binary/accumulator(50)/README.md

accumulator

Description

I found this program (accumulator64 file) that lets me add positive numbers to a variable, but it won't give me a flag unless that variable is negative! Can you help me out? Navigate to /problems/accumulator/ on the shell server to try your exploit out!

hint: How many bytes can an int store? How are positive and negative numbers represented in C?

Solving

Okay, we have the binary file and a source code. The flag is on the remote server that runs given binary. So we need to find and exploit the binary's vulnerability. Let's do this.

First, let's try to run the binary.

The programm just sums entered numbers with the accumulator. Fine, let's see the source code now.

#include <stdlib.h>
#include <stdio.h>

int main(){

	int accumulator = 0;
	int n;
	while (accumulator >= 0){
		printf("The accumulator currently has a value of %d.\n",accumulator);
		printf("Please enter a positive integer to add: ");

		if (scanf("%d",&n) != 1){
			printf("Error reading integer.\n");
		} else {
			if (n < 0){
				printf("You can't enter negatives!\n");
			} else {
				accumulator += n;
			}
		}
	}
	gid_t gid = getegid();
	setresgid(gid,gid,gid);
	
	printf("The accumulator has a value of %d. You win!\n", accumulator);
	system("/bin/cat flag");

}

There are two variables - accumulator and some integer value named "n". After that, we see the loop, that continues while the accumulator value is positive. After this loop ends, executes the system command that prints the flag.

So, we need to make the accumulator value negative, but the problem is we are not to enter any negative. What do we do?

We remember that int variables take only 4 bytes of memory and it's maxed value equals to 2,147,483,647, and if we sum 1 to the variable with this value, it will overflow and take the value of minimal possible int value -2,147,483,648. Now the solution is obvious, we will input 2,147,483,647 first, and after that, we enter 1. Accumulator will take the negative value and we will get the flag.

Let's do this:

File: CTF-Writeups/AngstromCTF 2018/Binary/cookie jar (60)/README.md

cookie jar

Description

Try to break this Cookie Jar that was compiled from this source Once you've pwned the binary, test it out by connecting to nc shell.angstromctf.com 1234 to get the flag.

hint: Look up some vulnerabilities associated with buffers.

Solivng

I have the binary and the source code. First, I will try to run binary to see what am I working with:

So, the programm asks to enter something, and after that it closes. Let's see the source code.

#include <stdio.h>
#include <stdlib.h>

#define FLAG "----------REDACTED----------"

int main(int argc, char **argv){
  
	gid_t gid = getegid();
	setresgid(gid, gid, gid);

	int numCookies = 0;

	char buffer[64];

	puts("Welcome to the Cookie Jar program!\n");
	puts("In order to get the flag, you will need to have 100 cookies!\n");
	puts("So, how many cookies are there in the cookie jar: ");
	fflush(stdout);
	gets(buffer);

	if (numCookies >= 100){
		printf("Congrats, you have %d cookies!\n", numCookies);
		printf("Here's your flag: %s\n", FLAG);
	} else {
		printf("Sorry, you only had %d cookies, try again!\n",numCookies);
	}
		
	return 0;
}

We have two variables: numCookies and the input buffer. The vulnarability is obvious, it is the buffer overflow. The thing is for buffer allocated 64 bytes of memory

char buffer[64]

but there is no limitation for input

gets(buffer)

So gets function is gonna write to the memory all I enter despite the input size. But the buffer has only 64 bytes of memory, and if I enter more than 64 bytes, this function will write data into the memory of variables located after the buffer. That's what we are gonna use. The first variable located after the buffer is numCookies, so we can rewrite this variable's value, overflowing the buffer. We will enter 64 bytes and than the numCookies value we want. Let's try it:

Ha! Didn't work! That was odd for me, so I decided to watch this in IDA. I opened the main function stack and noticed that for buffer there is allocated 71 bytes instead of 64. Okay, so now I need to enter 71 bytes. Trying:

Didn't work again, but there are some changes, that means we've overflow the buffer. I just add one more byte to input and got the flag:

File: CTF-Writeups/AngstromCTF 2018/Binary/number guess (70)/README.md

number guess

Descripttion

Ian loves playing number guessing games, so he went ahead and wrote one himself (source). I hope it doesn't have any vulns. The service is running at nc shell.angstromctf.com 1235.

hint: Look up some vulnerabilities associated with the printf function.

Solving

We have the executable and the source code, classic. And again the first thing I do - run the binary.

The program generates two random numbers and asks me to guess their sum. Fine, let's see the source code now.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>


char *flag = "REDACTED";
char buf[50];

int main(int argc, char **argv) {

	
	puts("Welcome to the number guessing game!");
	puts("Before we begin, please enter your name (40 chars max): ");
	fflush(stdout);
	fgets(buf, 40, stdin);
	buf[strlen(buf)-1] = '\0';
		
	strcat(buf, "'s guess: ");	
	puts("I'm thinking of two random numbers (0 to 1000000), can you tell me their sum?");
	
	srand(time(NULL));
	int rand1 = rand() % 1000000;
	int rand2 = rand() % 1000000;

	printf(buf);
	fflush(stdout);
	int guess;
	char num[8];
	fgets(num,8,stdin);
	sscanf(num,"%d",&guess);

	if (guess == rand1+rand2){
		printf("Congrats, here's a flag: %s\n", flag);
	} else {
		printf("Sorry, the answer was %d. Try again :(\n", rand1+rand2); 
	}
	fflush(stdout);
	return 0;
}

This code has printf vulnerability here:

...
fgets(buf, 40, stdin);
...
printf(buf);
...

First, the program writes the string we enter to the stack, and after that it prints this string to stdout. The key is that printf function handles string format parameters. You can see this in the source code here:

printf("Sorry, the answer was %d. Try again:(\n", rand1+rand2);

The string contains %d parameter which means that the printf must take second argument, which is rand1+rand2, as a digit and insert it's value to the output. And that's why we dont's see %d in the output, but we see the number. But what if the string contains string format parameters but it's the only argument passed to printf? There won't be an error, the function will just take values from the stack and here is the way for us to find those rand1 and rand2 numbers, because they are located in the stack of "main" function.

So, here what I'm gonna do. I will type this string:

%d %d %d %d %d %d %d %d %d %d %d %d %d %d

to the input. The program will print stack content to the stdout and I will lose the game to see what the sum was. Knowing the sum, I will find two numbers which will be equals to this value when summed:

Now I know the sum was 1206643. Next, I look for two numbers with equals sum. Here: 800219 and 406424 will be equals 1206643 when summed. So it's third and ninth numbers in the stack.

Now, to get the flag I will just get nine numbers from the stack and calculate the sum of third and ninth numbers:

File: CTF-Writeups/AngstromCTF 2018/Binary/personal letter (160)/README.md

Foreword

First, I wanna say thanks to Umut Barış Öztunç and his team Break Point for their writeup to this task which you can find here: https://www.pwndiary.com/write-ups/angstrom-ctf-2018-personal-letter-write-up-pwn160/

I took the idea for the solution from here, although I tried to explain it in more details for people who, like me, have just started to play CTFs.

personal letter

Description

Have you ever gotten tired of writing your name in the header of a letter? Well now there's a program (source)to do it for you! Navigate to /problems/letter/ on the shell server to try your exploit out!

hint: It prints your name right in the letter!

Solution

Okay, let's start. First, as always I ran the binary to watch what am I working with.

So, the program just takes the input and inserts it to the formated output. Also we have the source code, but we don't actually need it if we just guess to try printf vulnerability. Anyway, I'll show you this vuln in code.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


void printFlag(int status){

    printf("Status Code: %d\n",status);

    char flag[50];
    FILE *flagFile;
    if ((flagFile = fopen("flag.txt","r")) == NULL) {
        printf("Error opening file.");
        return;
    }

    fscanf(flagFile, "%s", flag);
    printf("Here's a flag: %s\n", flag);

    _Exit(0);
}

void printCard(char name[]) {
    int nameLen = strlen(name);

    char *cardTop = malloc(300);
    strcpy(cardTop, "________________________________________\n");
    strcat(cardTop, "|                                      |\n");
    strcat(cardTop, "|                                      |\n");
    char *cardMid = malloc(140);
    strcpy(cardMid, "|  Dear ");
    strcat(cardMid, name);


    strcat(cardMid, ",");
    for (int i = 0; i < 30-nameLen; i++)
        strcat(cardMid, " ");
    strcat(cardMid, "|\n");
    char *cardBottom = malloc(300);
    strcpy(cardBottom, "");
    for (int i = 0; i < 17; i++)
        strcat(cardBottom, "|  __________________________________  |\n");
    strcat(cardBottom, "|______________________________________|\n");

    printf(cardTop);
    printf(cardMid);
    printf(cardBottom);

    return;
}


void main(int argc, char **argv) {

    char buf[100];
    memset(buf, 0 , 100);

    puts("Welcome to the personal letter program!");
    puts("Give us your name, and we will generate a letter just for you!");
    puts("Enter Name (100 Chars max): ");
    fgets(buf, 100, stdin);
    buf[strlen(buf)-1] = '\0';
    printCard(buf);
    puts("Exiting.\n");

    exit(0);
}

Here you can see that the main() function calls function printCard() and passes to it our input. In this function our input being inserted to the cardMid string, which then is passed to printf() function:

...
char *cardMid = malloc(140);
strcpy(cardMid, "|  Dear ");
strcat(cardMid, name);
...
printf(cardMid);

So we can use string format parameters in the input.

Also, you could just type some %x to the input just to check if there is a vulnerability in the program:

Now, what can we do with this? There is a function printFlag(), so it would be great to call it somehow. Using string format parameters we can write bytes to the memory and change the call of the function. Now it's not clear, but I'll explain it later.

First, I disassemble the program using IDA and find the function's printFlag() address:

printFlag_address

So it is 0804872b. Next, we will find a function, which address we will rewrite. Here on the screen you can see that after printCard() function there are two more calls: puts() and exit(). We will rewrite exit() function's address. Actually you could ask, why don't we rewrite puts() address. I'll be fair, it won't work if with puts() function, and I don't know why for sure. I guess it's because of different work with stack in exit() and puts() functions.

Okay, I click the exit() function's name and I see this:

exit_address1

exit_address2

It's just redirect, double click on the offset and here we see the address (08 04 a0 30) were stores 4 bytes of exit() function's real address:

exit_address3

exit_address4

It is stored like this c8 a0 04 08, so we need to rewrite first 2 bytes to get 2b 87 04 08 and this address will be printFlag() function's address and instead of exit() function the program will call printFlag().

Now we know what we have got to do. First part of input will be like this "\x30\xa0\x04\x08\x31\xa0\x04\x08". Those are addresses in memory we will rewrite. Second part must contain more interesting data. We must write something like this "%(digit1)x%(digit2)$hhn%(digit3)x%(digit4)$hhn".

First we need to find digit2 and digit4. Those are indexes of digits we will write to addresses. So how will we find them? We will debug the program with stop point on the printf() function call. And then we will inspect printCard() function's frame of stack to find them.

printfStopPoint

stackView

inputStackAddress

Here on the screenshots we see that our input are stored at indexes 26 and 27 in the printCard() stack. Now we need to find digit1 and digit3. In the stack are stored 16 bytes: "| Dear, " - it's first 8 and our input will be 8 bytes too. So now we have 16 bytes. It's 10h, and we need 2bh, so the digit1 will be 2bh-10h=1bh=27. Next, we will need 87h, but we have 2b. digit3 will be 87h-2bh=5ch=92. Now we have our input: \x30\xa0\x04\x08\x31\xa0\x04\x08%27x%26$hhn%92x%27$hhn. But we can't write bytes from keyboard so I will use echo -e. Let's try it.

File: CTF-Writeups/AngstromCTF 2018/Binary/rop to the top (130)/README.md

rop to the top

Description

Here's some binary and source. Navigate to /problems/roptothetop/ on the shell server to try your exploit out!

hint: Look up "Return Oriented Programming" (ROP) vulnerabilities and figure out how you might be able to change the return address.

Solving

First, as always, I ran the binary. Here is what I saw:

So the program takes one string argument and just does something with it. Now let's see the source code.

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

void the_top(){

    system("/bin/cat flag");

}

void fun_copy(char *input){

    char destination[32];
    strcpy(destination, input);
    puts("Done!");
}

int main (int argc, char **argv){
    gid_t gid = getegid();
    setresgid(gid,gid,gid);

    if (argc == 2){
        puts("Now copying input...");
        fun_copy(argv[1]);
    } else {
        puts("Usage: ./rop_to_the_top32 <inputString>");
    }

    return 0;
}

The program actually copies the input to the buffer (destination variable). Still, as I can see, there is no limitation for the input, but the buffer has only 32 bytes in length. So, I can overflow the buffer. Another important thing is that there is a function "the_top" which actually prints the flag. Now I need to figure out how can I use the buffer overflow to call "the_top", so I can get the flag.

I decided to look at this program in the IDA. I found function "fun_copy" and looked into its stack. Here's the destination variable's start

dest_starts

I need the buffer's start offset. It's -28h. And here I see the end of the buffer and the main thing is that here you can see the variable called 'r'. It's a return address (the address of the command that will be executed after the function finishes it's work). And I can rewrite its value, overflowing the buffer.

return_address

And I need its offset too. It's +04h. So, there is 4h-(-28h)=2Ch=44 bytes from the start of the buffer and to the start of the return address. Now, I need to write 44 bytes to the input and 4 more bytes to rewrite return address.

Next, I found the function's "the_top" address. Here you can see it (08 04 84 DB):

address

Okay, now I have everything to get the flag. But I can't write the address from the keyboard, cause it's non-printable bytes. So I will use Python to do it. So, let's do it:

File: CTF-Writeups/ENCRYPT CTF 2019/Forensics/Journey to the centre of the file 2/README.md

Journey to the centre of the file 2

Task

task

ziptunnel2

Solution

First, I look at this file through 010Editor:

hexview

So the file compressed with bzip2. Here's a script to decompress it:

import bz2

with open('ziptunnel2', "rb") as f:
	data = f.read()

data = bz2.decompress(data)

with open("flag", "wb") as f:
	f.write(data)

Decompressing gives us following file:

flag_hexview

That's zip. Decompressing it will give us gzip file. If we decompress it we will get bz2 file and so on. So decompress it without automation will last too long. That's why I wrote the following script:

import gzip
import bz2
import zipfile

while 1:
	try:
		with zipfile.ZipFile("flag") as z:
			z.extractall()
	except:
		with open("flag", "rb") as f:
			data = f.read()
			try:
				data = gzip.decompress(data)
				with open("flag", "wb") as f:
					f.write(data)
			except:
				try:
					data = bz2.decompress(data)
					with open("flag", "wb") as f:
						f.write(data)
				except:
					print(data)
					break

And here we go: flag

Flag: encryptCTF{f33ls_g00d_d0nt_it?}

File: CTF-Writeups/ENCRYPT CTF 2019/Forensics/WrEP/README.md

WrEP

Task

task

captured.cap

Solution

Just feed it to aircrack-ng and you will get the password:

Flag: encryptCTF{W45_17_R34L?!}

File: CTF-Writeups/ENCRYPT CTF 2019/MISC/Way Back/README.md

Way Back

Task

task

ENCRYPT.png

Solution

So we have the punch card:

ENCRYPT.png

All we need to do is to find how to read this. A bit googling and here u go: http://www.quadibloc.com/comp/cardint.htm I decoded the punch card using this pic:

alphabet

And I got this string: B4TCH_PR0CE551NG_155_N0T_G00D

So the flag is: encryptCTF{B4TCH_PR0CE551NG_155_N0T_G00D}

File: CTF-Writeups/ENCRYPT CTF 2019/MISC/ham-me-baby-2/README.md

ham-me-baby-2

Task

task

Solution

Connecting to the server gives us this:

So the task is actually to write a little script to recover data from hamming(7,4) code. A little bit googling and I have found this site: https://studylib.net/doc/8184421/hamming--7--4--3--code---cs1001.py

Using this code I wrote following script:

import socket
import re

def hamming_decode(y1,y2,y3 ,y4,y5,y6 ,y7):
    """  Hamming  decoding  of the 7 bits  signal  """
    b1= (y1+y3+y5+y7) % 2
    b2= (y2+y3+y6+y7) % 2
    b3= (y4+y5+y6+y7) % 2
    b=4*b3+2*b2+b1 
    # the  integer  value
    if b==0 or b==1 or b==2 or b==4:
        return (y3,y5,y6 ,y7)
    else:
        y=[y1,y2 ,y3,y4,y5 ,y6,y7]
        y[b-1]=(y[b -1]+1) % 2   # correct  bit b
        return (y[2],y[4],y[5],y[6])

s = socket.socket()
s.connect(("104.154.106.182", 6969))

print(s.recv(1024).decode())
print(s.recv(1024).decode())
data = s.recv(1024).decode()
pattern = re.compile("[01]{7}")
m = pattern.findall(data)

data = m[0]
ready = []

for i in data:
    ready.append(int(i))
print(data)
answer = b''
resp = hamming_decode(*ready)
for i in resp:
    if i == 1:
        answer += b"1"
    else:
        answer += b"0"
answer += b"\n"

while 1:
    s.send(answer)
    data = s.recv(1024).decode()
    m = pattern.findall(data)
    if len(m) == 0:
        print(data)
        data = s.recv(1024).decode()
        m = pattern.findall(data)
    data = m[0]
    ready = []
    for i in data:
        ready.append(int(i))
    resp = hamming_decode(*ready)
    answer = b""
    for i in resp:
        if i == 1:
            answer += b"1"
        else:
            answer += b"0"
    answer += b"\n"

Run this and here we go: solved

Flag: encryptCTF{1t_w4s_h4rd3r_th4n_1_th0ught}

File: CTF-Writeups/ENCRYPT CTF 2019/Stegano/Into The Black/README.md

Into The Black

Task

task

IntoTheBlack.png

Solution

We have got the image: IntoTheBlack.png

Open it through stegsolve and process a little:

stegsolve

Flag: encryptCTF{L1GH7_17_UP}

File: CTF-Writeups/ENCRYPT CTF 2019/Web/Slash slash/README.md

Slash slash

Task

task

handout_slashslash.7z

Solution

Extracting file will give us folder with web application. I think, author thought we will run this, but all I did is looked through files. In the app/env/bin/activate file I found this:

active

And I tried to decode base64 and here is the flag: encryptCTF{comments_&_indentations_makes_johnny_a_good_programmer}

File: CTF-Writeups/INSHACK 2019/Reverse/Obscure File Format/README.md

Obscure File Format

Task

task

obscure-file-format.zip

Solution

Understanding archive

Unpacking archive gives me three files: a, k and l. I open them with 010Editor to find out what are these files. a and k have strange headers and l file is the Python script.

a:

a

k:

k

l:

l

Let's look at the script closer:

#!/usr/bin/env python3
import zlib;exec(zlib.decompress(<long_string_of_bytes>))

Script executes decompressed bytes. I change exec to print to look what code is being executed:

decompressed

And again I have hex string, which being executed after unhexlify. I again change exec to print and get zlib.decompress again. That's just annoing... But after doing this:

#!/usr/bin/env python3
import zlib
s = zlib.decompress(<long_string_of_bytes>)

s = s.replace(b"exec", b"s1 = ")
exec(s)
print(s1)
s1 = s1.replace(b"exec", b"s2 = ")
exec(s1)
#print(s2)
s2 = s2.replace(b"exec", b"s3 = ")
exec(s2)
#print(s3)
s3 = s3.replace(b"exec", b"s4 = ")
exec(s3)
#print(s4)
s4 = s4.replace(b"exec", b"s5 = ")
exec(s4)
print(s5.decode())

I finnaly get the real code:

import os as _4491ba09efd64d32a7c316a89ed23540
import uuid as _9c0223fbd33e432cad291e3626fa8375
import zlib as _75efb4b5390e450f86339bb370cf9798
import struct as _460dcfe1367b4351bfd11161e6afb4bc
import random as _93208a26d2354ca58a2d63a1775b429e
import pathlib as _fc2e6885d4f6459c9173119853a9b941
import argparse as _d80254fe3b7f406a91ec7ea2a813e6ee
import cryptography.hazmat.backends as _95637ffc24f64183a0e5cab581866201
import cryptography.hazmat.primitives.ciphers as _12fe06755daf4d66ac222ee97d41fa8f
_d92c89d5c8e6480ab83f62d04ac6968e = zip
_2a054c268d044e6ab9b9ba49b0c99ac2 = vars
_efe18136e1d14a66b014f121b6cdc599 = type
_9013c61b775f4709917f60cfb4c4d0bd = tuple
_c78251a8b4ef4e5c975562404153eca2 = super
_05314ca66c8241329018829d41388221 = sum
_edce3f96a97f4268b7f758ebbee92e39 = str
_f1216e22142a40e6b2f2bef9bad97dc8 = staticmethod
_db7a1923e60b407e8946626fbda97a39 = sorted
_d3cfb7be150c4d6b9165bd6b4f256280 = slice
_777f2cfa06f040478891a09e204ce442 = setattr
_419debbaf6fa40fe8eed1a33ff7b5054 = set
_c0bd2003dfbd4a949b356f6691484af0 = round
_b95dfc84bafb470689533c3746352ddb = reversed
_a011ae99a45b40099121c0fd1a164aab = repr
_3fa9f86ba17f44e7b990bb639c51f3bf = range
_5a9ea9db9e3443f4ab9f4e2e7172d69f = quit
_0aa77fc2a6db4be4b58865ae4d13913a = property
_7337aa3caf7c4d9f855a7a241a9db8be = print
_639a2e6f41b041688856eac61a7ef244 = pow
_c4754cee9f0f4a5186b99594618a9117 = ord
_a66abde4ce3048488263de1cf9695616 = open
_31a7f57a7890416bbfdfa14fac4b4494 = oct
_0614c181390346469e56dd3c5cc69382 = object
_4dc860aba19640d18df6a9fa82ea8812 = next
_5b7d659104324bb6b5174effb661c82c = min
_2a279817dc8d4df19368574962ec6989 = memoryview
_4fd1101920684bd3927e0078ffb7d058 = max
_5dbd8f8702d54135af11719ac747cfe2 = map
_7cfbebcc486f4728be51e3a5d1f71647 = locals
_348deb41107f440ea6e05f9eda40e243 = list
_c87f53df47af43549034cffa618848db = license
_c8ab51b417d843f8982ae6704e9764b7 = len
_2bd4fb19079542f5af4f05eadb9daba3 = iter
_e2a25b47df0e4314bfd8f6ffe9046488 = issubclass
_81359519d9044e34873e4053c9463167 = isinstance
_f10babe329654a188b28f15547ad4266 = int
_e3c36eecddfc40808308f7ac76f7e3da = input
_3b194946a125498bb9bee24a49474cdd = id
_ea130bd1ad0c4582b7bbfffcede80554 = hex
_65c9b6af369543f5a71b061ff59d96c8 = help
_e2fa667106eb4c60b93fe4229ea6d139 = hash
_72892c873557438e8eb844be66a3ff85 = hasattr
_e0fc264a76004088918712d418a5e58f = globals
_522c60ce347148b48ebad87bf7068b52 = getattr
_899c6496c4b44e4391a948383a48fada = frozenset
_0e010ed24c9943e0b9013beb5fc4ccf3 = format
_51b28eae00284b80a9defd2e01091ded = float
_e6701fe56f97478aae26772cabfcd254 = filter
_3c391a07ac7e477693cf839aebb7f398 = exit
_f848d99ec4e944bea232e5030c19a95a = exec
_aa2bcc1974fa4423b2050897cd493316 = eval
_b2261f5204dc405292771a0b6133b2a2 = enumerate
_ddb7c8ba43364282bbca52e4ec4da69d = divmod
_0bafc82047ed441eb6d2ce8aedb627b8 = dir
_b03bf30bc9934bbc94a982a98e62d177 = dict
_997004a17c604134a99ff104997794d5 = delattr
_346d22a2f78b490eb4abf1776039ac93 = credits
_d18ec62a1b564a37aca192701c307993 = copyright
_25b999825d284b07a1177f207e00f46b = complex
_2030c6bde0b04af28e1b6c2ac1994c03 = compile
_24c6add9b5f643b7af9ac9adc7a8f88e = classmethod
_6eae669a5caa49d3b2cf0ca94f1db62a = chr
_7e5a105ca35c401f8baf2399f841bf48 = callable
_6437cd5ae5444b6ea6b5517489961678 = bytes
_b17c67f75d1f4950b5d9bf1b9bae0977 = bytearray
_0d8659b28a63481797b57a6cbd45979b = breakpoint
_16d9ebd528c54cfcab70919505c51c47 = bool
_093c82ee06b04c548518d151aadeff09 = bin
_9ec3c131d0704d198077b653f534f2e3 = ascii
_a5eadde352fc4e9185c23382c6609d05 = any
_478d1f17762441ffbcdf51ad03452e5e = all
_6e47d9017bfc4bb0b457e8fc7d37e061 = abs
_c003e61a683c4d48992c5968730f88de = __spec__
_120f0ca155a54f17b3a8a7139481d201 = __package__
_0725a4328dac4b608bca988314e49535 = __name__
_d04e26a1c11b42e6b6d4a19928378a10 = __loader__
_0afcf66370f24a46833b16ad68e51f33 = __import__
_936c716b36354788811726a511d820be = __doc__
_55b22c1393fd4ddb92e5b741516a9b49 = __debug__
_2fa87f4a68a34d7585f804c2d1f41d8b = __build_class__
_98fc8056914d49c18cfc6f2219605829 = ZeroDivisionError
_e0c1d917c66d4bf9bff6985270d24836 = Warning
_c1f0aa22b0414c10a669df1dd85dcc5b = ValueError
_d6198e1bf52740108a3a42c6aad41bb4 = UserWarning
_f751b328ae0f485981b8bd5eb4e9bce9 = UnicodeWarning
_7dec97b6daf0458894941228aca1bfb1 = UnicodeTranslateError
_4268dd7edaf9417fa43e9be4aab0cd79 = UnicodeError
_d847bf32c8704332ace814998a0b55fc = UnicodeEncodeError
_0e36ecc15fd84c75a50b8f59ff5a5633 = UnicodeDecodeError
_6f42769b59284276b9847cf82cb9e732 = UnboundLocalError
_23325e647bc447be86fdde3963c18734 = TypeError
_33186cdf76944c1d8b235829cede199b = True
_d021c6575bbc469cb3dc2a7be381022d = TimeoutError
_014da739ca3a4b06be1a815eb0fd2bc0 = TabError
_9385ba93ab3d4765b062e08dee9baf24 = SystemExit
_ebc7db66319b4ba1a5a7865325d86019 = SystemError
_b7ebf253050d4e67813b1fba8ca241c1 = SyntaxWarning
_8243d700f5e5400c9e6ffa38f41fe0b7 = SyntaxError
_77d15c4c7fe74e309d9141093345fc8f = StopIteration
_e1d49ccdec594d3683ddef929fb2de1d = StopAsyncIteration
_831260914b4548099ba08b15626ef911 = RuntimeWarning
_8efed85bd266402d96f4aa0c69ca8148 = RuntimeError
_66a9c8f0a7d9470d944ee5e14ab8e79d = ResourceWarning
_634016e1846b4a7b923053fcb3e1565e = ReferenceError
_29f4425faf3d4c8899cc92292af76672 = RecursionError
_8b8ff3f8f43e462c9855121ecbfea04e = ProcessLookupError
_63e9fbc6e17147099f6a47451c9e82f8 = PermissionError
_cab5b8077f6c45e09ca00e004ccd400b = PendingDeprecationWarning
_ff4432d6f55b400d95328f612b5ba96f = OverflowError
_205032881b6a45358361d372f9a459e5 = OSError
_9f17921228d94053ab5e9be06564e00b = NotImplementedError
_45bd2ece2d8144089db1250e693b6955 = NotImplemented
_525e02de1e7d4052902b617bd217a120 = NotADirectoryError
_5187fd7516d543cc9e8f5f4d07af0127 = None
_979aadb5a42b4700be5b1aeb4e5a6126 = NameError
_a57f0c320cbb460caebb3e6d60d1ab49 = ModuleNotFoundError
_4aa3364354404416bf653110db8b5f17 = MemoryError
_2d8d17a034f944f492f77a3090eb58e4 = LookupError
_738d1cfd7d2542c68658c7d3d017c0a2 = KeyboardInterrupt
_d48277b0ec574d2489a7b2d612172bc7 = KeyError
_e8d81e7a193e41c2bf29c3899eb80c23 = IsADirectoryError
_4b32820c8f774440a5513983342f567f = InterruptedError
_bd3d00948899431abe6bd1c175f2b73b = IndexError
_d59fd9d5e9354600947cda5b3c6df251 = IndentationError
_d7b077fba764425393caa4af02032a04 = ImportWarning
_3a24cea06d114692b9a9c30440d97463 = ImportError
_d3339297e89141e0816639ead8eda554 = IOError
_584d0ff625c64024bc1290696f9b7277 = GeneratorExit
_443b13233cef4242afbf624336c4d455 = FutureWarning
_45f63936e0d2414f81f97e9fe562c734 = FloatingPointError
_66299359ebad416a9be7d03a54485ba7 = FileNotFoundError
_091dbd374eac4d218391f5d651aa5242 = FileExistsError
_9656b9e60ace40ab958f7005bb4ca86f = False
_78174034c577445f8c0a1c0379d54c86 = Exception
_7609428dbb2a4d0e93506071a0ba0003 = EnvironmentError
_aa69ae8b32464738b560cc318d6d6cbd = Ellipsis
_31b362ac0a864b0f891a514ad2b99774 = EOFError
_a651b511b6c3433daa715ca47ab70bd1 = DeprecationWarning
_1139f6d266694855b98ba9164af9d6c4 = ConnectionResetError
_7c1ff231fd4c49b28f09dc7df8e7dcbf = ConnectionRefusedError
_de6cd85ed278495fa686516e82cba23e = ConnectionError
_1f76b7498c3c4835acc4360d0a1999bf = ConnectionAbortedError
_23ab01b513664ab48df51f48da1d043e = ChildProcessError
_7e3d650f08f144c7b45458259a3f086a = BytesWarning
_97bed9e33fe144929a25040decd80656 = BufferError
_edac437610fd4c07844622f0fd1baffa = BrokenPipeError
_3ee3a1fac5014afea896ce4211ef02d8 = BlockingIOError
_c434de818c704fa3a27552ce0b8322a7 = BaseException
_c7b4e9c604d048629516921ebc82f6bb = AttributeError
_502a41dc53fa48f38a23fd45fa028128 = AssertionError
_3eeb35891ea0407bb5e23cb15b3d2877 = ArithmeticError
_f82b10a5ace546908c2c36dbebfcf17b = _6437cd5ae5444b6ea6b5517489961678([0])
_e1548e812dba46738c65df7858044dcd = (0x484203ad//0xd2ece70f+0x4b8bbafd-0xd2ece70f//0x484203ad+0xd2ece70f//0x484203ad+0x00000010-0x484203ad//0xd2ece70f-0x4b8bbafd)
_bc51f568ca504f20ad983c0606d64c46 = (0xd7097633//0xd78412ad+0x4e6c894a-0xd78412ad//0xd7097633+0xd78412ad//0xd7097633+0x00000010-0xd7097633//0xd78412ad-0x4e6c894a)
_bcf41878aadd4b6295ae4593ed070e51 = _95637ffc24f64183a0e5cab581866201.default_backend()

class _6c9939e78b674d19a284a5c6c83fc918():

    def __init__(_81d6b4d26118467ba5c0ea1aad0cf09c):
        _81d6b4d26118467ba5c0ea1aad0cf09c._9b97d955e1944c5b9e692d9b9f4a8098 = _4491ba09efd64d32a7c316a89ed23540.urandom(_e1548e812dba46738c65df7858044dcd)
        _81d6b4d26118467ba5c0ea1aad0cf09c._5a07b64d8f2f4a47812b6422c0c97507 = _4491ba09efd64d32a7c316a89ed23540.urandom(_bc51f568ca504f20ad983c0606d64c46)
        _81d6b4d26118467ba5c0ea1aad0cf09c._5521d2a7fcd54ee78c0db20c3da05c68 = _12fe06755daf4d66ac222ee97d41fa8f.Cipher(_12fe06755daf4d66ac222ee97d41fa8f.algorithms.AES(_81d6b4d26118467ba5c0ea1aad0cf09c._5a07b64d8f2f4a47812b6422c0c97507), _12fe06755daf4d66ac222ee97d41fa8f.modes.CBC(_81d6b4d26118467ba5c0ea1aad0cf09c._9b97d955e1944c5b9e692d9b9f4a8098), backend=_bcf41878aadd4b6295ae4593ed070e51)

    def __str__(_7f540a4ea31f4927af8f0e0ef73adb1c):
        return f'[{_7f540a4ea31f4927af8f0e0ef73adb1c._9b97d955e1944c5b9e692d9b9f4a8098.hex()}|{_7f540a4ea31f4927af8f0e0ef73adb1c._5a07b64d8f2f4a47812b6422c0c97507.hex()}]'

    def _0c1a9f7b3f49433ca2783206451f4646(_4999e3dbda004a2396d371a4e1956e6a, _2ccf64e8350f440bb5e89bedcc5edbde: 'bytes'):
        _83e1be4e03e041cbb2b03e76c03d0dd2 = _4999e3dbda004a2396d371a4e1956e6a._5521d2a7fcd54ee78c0db20c3da05c68.encryptor()
        return (_83e1be4e03e041cbb2b03e76c03d0dd2.update(_2ccf64e8350f440bb5e89bedcc5edbde) + _83e1be4e03e041cbb2b03e76c03d0dd2.finalize())

    def _815d1afe44124d8eae315380e4e8287c(_3456f3a7553c40309300a1d491ee4cb0):
        _7de3041e057e4d07afdd1ee49ebfb830 = _348deb41107f440ea6e05f9eda40e243((_3456f3a7553c40309300a1d491ee4cb0._9b97d955e1944c5b9e692d9b9f4a8098 + _3456f3a7553c40309300a1d491ee4cb0._5a07b64d8f2f4a47812b6422c0c97507))
        _7de3041e057e4d07afdd1ee49ebfb830.reverse()
        return _6437cd5ae5444b6ea6b5517489961678(_7de3041e057e4d07afdd1ee49ebfb830)

def _9a7489b61e0c42afa68070b62b9efcda(_c60c2dd6274144e18db87caf5f72ee6b: 'bytes', _182d6337ab934a42a416f1b049dab775: 'int'):
    _6531a429ed3943deb55803b86aec919a = (_182d6337ab934a42a416f1b049dab775 - (_c8ab51b417d843f8982ae6704e9764b7(_c60c2dd6274144e18db87caf5f72ee6b) % _182d6337ab934a42a416f1b049dab775))
    return (_c60c2dd6274144e18db87caf5f72ee6b + _6437cd5ae5444b6ea6b5517489961678(([_6531a429ed3943deb55803b86aec919a] * _6531a429ed3943deb55803b86aec919a)))

class _d1eebf20b14449edbfa0f916a8d3c8f6():
    _9c21f72031e04cb98f099d1a0246503e = (0xd3de8ee8//0x872037f1+0xe2b856ef-0x872037f1//0xd3de8ee8+0x872037f1//0xd3de8ee8+0x00000080-0xd3de8ee8//0x872037f1-0xe2b856ef)
    _148c8eb638934dcba67f900088441ac7 = (0x2f714779//0x7cdb17aa+0x5c50d277-0x7cdb17aa//0x2f714779+0x7cdb17aa//0x2f714779+0x00000010-0x2f714779//0x7cdb17aa-0x5c50d277)

    def __init__(_534f921a4393497d9ac94015aeae5617, _6b7fb1826bb440d587a96e53f26a46b4: 'ArchiveEntry'):
        _534f921a4393497d9ac94015aeae5617._ece9d23a9efd40d4850480dca4d2e7d2 = _6b7fb1826bb440d587a96e53f26a46b4
        _534f921a4393497d9ac94015aeae5617._44f49761f6d84834afed02a29d89be25 = _6c9939e78b674d19a284a5c6c83fc918()
        _534f921a4393497d9ac94015aeae5617._ef37cdce325341e9a26eb9f803685760 = {
            
        }

    def __str__(_e9fc5e044bd1411582713d70fd9149d1):
        return f'[{_e9fc5e044bd1411582713d70fd9149d1._ece9d23a9efd40d4850480dca4d2e7d2._06ee492dd4d84f7da54871038bd812cc}|{_e9fc5e044bd1411582713d70fd9149d1._44f49761f6d84834afed02a29d89be25}]'

    def _9fa3e14a60214abe9bbe0270ed83bd0f(_c1b2f8c8e69c4f9185a724d3b121eb7c):
        if (not _c1b2f8c8e69c4f9185a724d3b121eb7c._ef37cdce325341e9a26eb9f803685760):
            raise _8efed85bd266402d96f4aa0c69ca8148('Serializing key before data...')
        _2aa47d4050d142bbba7a44fc1ed9b1b0 = _c1b2f8c8e69c4f9185a724d3b121eb7c._ece9d23a9efd40d4850480dca4d2e7d2._06ee492dd4d84f7da54871038bd812cc.bytes
        _2aa47d4050d142bbba7a44fc1ed9b1b0 += _c1b2f8c8e69c4f9185a724d3b121eb7c._44f49761f6d84834afed02a29d89be25._815d1afe44124d8eae315380e4e8287c()
        _2aa47d4050d142bbba7a44fc1ed9b1b0 += _460dcfe1367b4351bfd11161e6afb4bc.pack('I', _c8ab51b417d843f8982ae6704e9764b7(_c1b2f8c8e69c4f9185a724d3b121eb7c._ef37cdce325341e9a26eb9f803685760))
        for (_363dc44808094e7c8101d0341f382bd5, _b2438fe367754c95a518970372122531) in _c1b2f8c8e69c4f9185a724d3b121eb7c._ef37cdce325341e9a26eb9f803685760.items():
            _2aa47d4050d142bbba7a44fc1ed9b1b0 += _460dcfe1367b4351bfd11161e6afb4bc.pack('2I', _363dc44808094e7c8101d0341f382bd5, _b2438fe367754c95a518970372122531)
        return _2aa47d4050d142bbba7a44fc1ed9b1b0

    def _0631e8b42e7c454594b97b0ab0a16d24(_1062e8f7bca247b892aa26f6d18192ed):
        with _1062e8f7bca247b892aa26f6d18192ed._ece9d23a9efd40d4850480dca4d2e7d2._d585684e5ba04013a5b1da4d6f098aef.open('rb') as _1cad6e83fa5148088137ef948a1e73fe:
            _bd435700d5854578b4ad470e171e93a2 = _1cad6e83fa5148088137ef948a1e73fe.read()
        _575abe6bd801421dac69f5dde8f554b1 = _9a7489b61e0c42afa68070b62b9efcda(_75efb4b5390e450f86339bb370cf9798.compress(_bd435700d5854578b4ad470e171e93a2), _d1eebf20b14449edbfa0f916a8d3c8f6._148c8eb638934dcba67f900088441ac7)
        _bef41c19b31748e9b54b7698e429cd4e = _9a7489b61e0c42afa68070b62b9efcda(_1062e8f7bca247b892aa26f6d18192ed._44f49761f6d84834afed02a29d89be25._0c1a9f7b3f49433ca2783206451f4646(_575abe6bd801421dac69f5dde8f554b1), _d1eebf20b14449edbfa0f916a8d3c8f6._9c21f72031e04cb98f099d1a0246503e)
        _624e802533af4165b6f016788854b728 = (_c8ab51b417d843f8982ae6704e9764b7(_bef41c19b31748e9b54b7698e429cd4e) // _d1eebf20b14449edbfa0f916a8d3c8f6._9c21f72031e04cb98f099d1a0246503e)
        _e3b9b0397c574e4fb7126b8c8c327587 = _348deb41107f440ea6e05f9eda40e243(_3fa9f86ba17f44e7b990bb639c51f3bf(_624e802533af4165b6f016788854b728))
        _93208a26d2354ca58a2d63a1775b429e.shuffle(_e3b9b0397c574e4fb7126b8c8c327587)
        for (_ff9542e4689548338f158d8e1574695c, _3e9224086d094d1fa7fb33361e7953d1) in _d92c89d5c8e6480ab83f62d04ac6968e(_348deb41107f440ea6e05f9eda40e243(_3fa9f86ba17f44e7b990bb639c51f3bf(_624e802533af4165b6f016788854b728)), _e3b9b0397c574e4fb7126b8c8c327587):
            _1062e8f7bca247b892aa26f6d18192ed._ef37cdce325341e9a26eb9f803685760[_ff9542e4689548338f158d8e1574695c] = _3e9224086d094d1fa7fb33361e7953d1
        _7621859a4b254bbf8bacb0c28f4c469b = [_bef41c19b31748e9b54b7698e429cd4e[(_26d188067b8b491cae5aa64baec35f96 * _d1eebf20b14449edbfa0f916a8d3c8f6._9c21f72031e04cb98f099d1a0246503e):((_26d188067b8b491cae5aa64baec35f96 + (0x0e0901e2//0x2938e1ad+0xe38ba340-0x2938e1ad//0x0e0901e2+0x2938e1ad//0x0e0901e2+0x00000001-0x0e0901e2//0x2938e1ad-0xe38ba340)) * _d1eebf20b14449edbfa0f916a8d3c8f6._9c21f72031e04cb98f099d1a0246503e)] for _26d188067b8b491cae5aa64baec35f96 in _3fa9f86ba17f44e7b990bb639c51f3bf(_624e802533af4165b6f016788854b728)]
        _fe1a85c9c22949ceb1fd6a1020ab792b = _6437cd5ae5444b6ea6b5517489961678([])
        for _97b6123ce4224cec95a5b822de64d6ef in _3fa9f86ba17f44e7b990bb639c51f3bf(_624e802533af4165b6f016788854b728):
            _fe1a85c9c22949ceb1fd6a1020ab792b += _7621859a4b254bbf8bacb0c28f4c469b[_1062e8f7bca247b892aa26f6d18192ed._ef37cdce325341e9a26eb9f803685760[_97b6123ce4224cec95a5b822de64d6ef]]
        return _fe1a85c9c22949ceb1fd6a1020ab792b

class _c1f55bb831d144058e27ac1a85645c87():

    def __init__(_731b530ad0da4d808027d9ef88d282ca, _dabc8ad63e2742d0b88bc5ceff3cd3af: 'pathlib.Path'):
        _731b530ad0da4d808027d9ef88d282ca._0a0ba676f62e40e5bca6eb786b6694a5 = _dabc8ad63e2742d0b88bc5ceff3cd3af
        _731b530ad0da4d808027d9ef88d282ca._bfa105cae18142edad7cf6334c9f92c6 = _9c0223fbd33e432cad291e3626fa8375.uuid4()
        _731b530ad0da4d808027d9ef88d282ca._8e6a7835576e4afab10617ad8a8d5e71 = _dabc8ad63e2742d0b88bc5ceff3cd3af.stat()

    def __str__(_6588976a457e416d85caf62be9ef0ba7):
        return f'[{_6588976a457e416d85caf62be9ef0ba7._bfa105cae18142edad7cf6334c9f92c6}|{_6588976a457e416d85caf62be9ef0ba7._0a0ba676f62e40e5bca6eb786b6694a5}]'

    @_0aa77fc2a6db4be4b58865ae4d13913a
    def _06ee492dd4d84f7da54871038bd812cc(_e7336ee71b4e43a591322f2a1167cd9d):
        return _e7336ee71b4e43a591322f2a1167cd9d._bfa105cae18142edad7cf6334c9f92c6

    @_0aa77fc2a6db4be4b58865ae4d13913a
    def _d585684e5ba04013a5b1da4d6f098aef(_2245263e25e144e6aed88e5758487e80):
        return _2245263e25e144e6aed88e5758487e80._0a0ba676f62e40e5bca6eb786b6694a5

    @_0aa77fc2a6db4be4b58865ae4d13913a
    def _c01f8a123fcd45018820d0d67e56a4d4(_46b1595b6f394d81849b5a4412d9fdc4):
        return _edce3f96a97f4268b7f758ebbee92e39(_46b1595b6f394d81849b5a4412d9fdc4._0a0ba676f62e40e5bca6eb786b6694a5)

    @_0aa77fc2a6db4be4b58865ae4d13913a
    def _8d47c3e6f91b4457ab4824a94c3ca559(_d300fea64ef54946b37feadbbb4e740c):
        return _d300fea64ef54946b37feadbbb4e740c._8e6a7835576e4afab10617ad8a8d5e71.st_size

    @_0aa77fc2a6db4be4b58865ae4d13913a
    def _ef27e5ccb5fc441db57e7f4c7054edd4(_b986946400594a2bb288b726d0d92266):
        return _b986946400594a2bb288b726d0d92266._8e6a7835576e4afab10617ad8a8d5e71.st_mode

    @_0aa77fc2a6db4be4b58865ae4d13913a
    def _d408bf1956a34e4c9cc044210d3c4e0b(_3bd1d32bede34ba89abf3565f6c2b62e):
        return _3bd1d32bede34ba89abf3565f6c2b62e._8e6a7835576e4afab10617ad8a8d5e71.st_atime

    @_0aa77fc2a6db4be4b58865ae4d13913a
    def _3d786168c4324120bf3b148b16eec9b4(_0f431376582e4df59c8ddf733f1bb2bd):
        return _0f431376582e4df59c8ddf733f1bb2bd._8e6a7835576e4afab10617ad8a8d5e71.st_mtime

    @_0aa77fc2a6db4be4b58865ae4d13913a
    def _d22c57dbf295449c9b2503225362d1e3(_74a0878367e3470ca5a4fd155ca46977):
        return _74a0878367e3470ca5a4fd155ca46977._8e6a7835576e4afab10617ad8a8d5e71.st_ctime

    def _b7fb031ea43143438b91cbe9a209b22b(_b27272ac04484118af6833b5f783e0ca):
        _99e3ec18a596462a99d2615c3455dcf3 = (_b27272ac04484118af6833b5f783e0ca._c01f8a123fcd45018820d0d67e56a4d4.encode() + _f82b10a5ace546908c2c36dbebfcf17b)
        _ba75d39306554e4ca3d16e0827d701fa = _460dcfe1367b4351bfd11161e6afb4bc.pack('I', _c8ab51b417d843f8982ae6704e9764b7(_99e3ec18a596462a99d2615c3455dcf3))
        _ba75d39306554e4ca3d16e0827d701fa += _99e3ec18a596462a99d2615c3455dcf3
        _ba75d39306554e4ca3d16e0827d701fa += _b27272ac04484118af6833b5f783e0ca._06ee492dd4d84f7da54871038bd812cc.bytes
        _ba75d39306554e4ca3d16e0827d701fa += _460dcfe1367b4351bfd11161e6afb4bc.pack('2I', _b27272ac04484118af6833b5f783e0ca._8d47c3e6f91b4457ab4824a94c3ca559, _b27272ac04484118af6833b5f783e0ca._ef27e5ccb5fc441db57e7f4c7054edd4)
        _ba75d39306554e4ca3d16e0827d701fa += _460dcfe1367b4351bfd11161e6afb4bc.pack('3d', _b27272ac04484118af6833b5f783e0ca._d408bf1956a34e4c9cc044210d3c4e0b, _b27272ac04484118af6833b5f783e0ca._3d786168c4324120bf3b148b16eec9b4, _b27272ac04484118af6833b5f783e0ca._d22c57dbf295449c9b2503225362d1e3)
        return _ba75d39306554e4ca3d16e0827d701fa

class _9420e2c7260442d3866a58615a4cc0ba():
    _53bb332cf4574683a5a8a0e16b163bb8 = _6437cd5ae5444b6ea6b5517489961678([76, 48, 76, 75, 83, 84, 82, 0])

    def __init__(_e95f5bf0402146d9a32868b2f4511410):
        _e95f5bf0402146d9a32868b2f4511410._6c6e11fd99354ff3a889fc5fb70f5ab2 = []

    def _41ea90d86def4a5788d1c69c92d19522(_6167aa2502d64e2f8560e87aa79753fe, _35a5ca3044904ab1b5b686a315bbb3a8: 'ArchiveEntry'):
        _65ea863f7e5b4065976030b97f50bebd = _d1eebf20b14449edbfa0f916a8d3c8f6(_35a5ca3044904ab1b5b686a315bbb3a8)
        _7337aa3caf7c4d9f855a7a241a9db8be(_65ea863f7e5b4065976030b97f50bebd)
        _6167aa2502d64e2f8560e87aa79753fe._6c6e11fd99354ff3a889fc5fb70f5ab2.append(_65ea863f7e5b4065976030b97f50bebd)
        return _65ea863f7e5b4065976030b97f50bebd

    def _db89af45a2c6466882953dad123fb736(_60642284da8c41378cb71474dc31f8ab, _edefccf2a66b4f819dcc4d8d9143ffc3: 'pathlib.Path'):
        _9c790f7015d6415aa1bea20eadf61c03 = _9420e2c7260442d3866a58615a4cc0ba._53bb332cf4574683a5a8a0e16b163bb8
        _9c790f7015d6415aa1bea20eadf61c03 += _460dcfe1367b4351bfd11161e6afb4bc.pack('I', _c8ab51b417d843f8982ae6704e9764b7(_60642284da8c41378cb71474dc31f8ab._6c6e11fd99354ff3a889fc5fb70f5ab2))
        for _f9f492192b064ab9b5426a1ecd6a85dc in _60642284da8c41378cb71474dc31f8ab._6c6e11fd99354ff3a889fc5fb70f5ab2:
            _9c790f7015d6415aa1bea20eadf61c03 += _f9f492192b064ab9b5426a1ecd6a85dc._9fa3e14a60214abe9bbe0270ed83bd0f()
        _edefccf2a66b4f819dcc4d8d9143ffc3.joinpath('keystore').write_bytes(_9c790f7015d6415aa1bea20eadf61c03)

class _9b5737cb2ddb4cafac4e8fa8db81fb4b():
    _c4a58d87b0b64df2a3abb595be3d37bb = _6437cd5ae5444b6ea6b5517489961678([76, 48, 76, 65, 82, 67, 72, 0])
    _ebbec7423e3a49a5ba676913d5592eea = (((0xd1e6024e//0x2cac1fd8+0xd516fdc5-0x2cac1fd8//0xd1e6024e+0x2cac1fd8//0xd1e6024e+0x00000400-0xd1e6024e//0x2cac1fd8-0xd516fdc5) * (0xce9939ce//0x65d2f2bb+0x2b7f2291-0x65d2f2bb//0xce9939ce+0x65d2f2bb//0xce9939ce+0x00000400-0xce9939ce//0x65d2f2bb-0x2b7f2291)) * (0xd2fd3a25//0xf0fc6a15+0x93f468d5-0xf0fc6a15//0xd2fd3a25+0xf0fc6a15//0xd2fd3a25+0x00000001-0xd2fd3a25//0xf0fc6a15-0x93f468d5))

    def __init__(_2679665fa7b44c2b8fac921d46efe124):
        _2679665fa7b44c2b8fac921d46efe124._6ec0b5915a0a48fd83b697329bce98ee = []
        _2679665fa7b44c2b8fac921d46efe124._923eb7b1bd0f40ad8bf244a1a91b729c = _9420e2c7260442d3866a58615a4cc0ba()

    def _5f8f129324e640809d01bddc294aaa1e(_0d49b8045b8a478daf0c8283646bc5dc, _2ab9ed96502445a0b224909942537c76: 'pathlib.Path'):
        _a6ba007b0281481da62829a693bfd4a4 = _c1f55bb831d144058e27ac1a85645c87(_2ab9ed96502445a0b224909942537c76)
        _7337aa3caf7c4d9f855a7a241a9db8be(_a6ba007b0281481da62829a693bfd4a4)
        if (_a6ba007b0281481da62829a693bfd4a4._8d47c3e6f91b4457ab4824a94c3ca559 > _9b5737cb2ddb4cafac4e8fa8db81fb4b._ebbec7423e3a49a5b

*Truncated - read the full file at https://github.com/firebitsbr/Writeups-claudeskills/blob/db01f8ea1415b822a763707e8e902e97174420fb/claudeskills_test/writeup-0awawa0/SKILL.md.*