#La imagen
from IPython.display import Image
Image(filename='imagenes/desafioprogramador.png') 

Image(filename='imagenes/screen_identify.png') 

from PIL import Image

blanco=(255,255,255)
negro=(0,0,0)

punto = [blanco,negro,blanco]
barra = [negro,negro,negro]
fin_letra = [blanco,blanco,blanco]

morseAlphabet ={
        "A" : ".-",
        "B" : "-...",
        "C" : "-.-.",
        "D" : "-..",
        "E" : ".",
        "F" : "..-.",
        "G" : "--.",
        "H" : "....",
        "I" : "..",
        "J" : ".---",
        "K" : "-.-",
        "L" : ".-..",
        "M" : "--",
        "N" : "-.",
        "O" : "---",
        "P" : ".--.",
        "Q" : "--.-",
        "R" : ".-.",
        "S" : "...",
        "T" : "-",
        "U" : "..-",
        "V" : "...-",
        "W" : ".--",
        "X" : "-..-",
        "Y" : "-.--",
        "Z" : "--..",
        " " : "/",
        "?" : "..--..",
        "*" : ".-.-.-",
        "," : "--..--",
        "0" : "-----",
        "1" : ".----",
		"2" : "..---",
		"3" : "...--",
		"4" : "....-",
		"5" : ".....",
		"6" : "-....",
		"7" : "--...",
		"8" : "---..",
		"9" : "----."
}
inverseMorseAlphabet = dict((v,k) for (k,v) in morseAlphabet.items())

im = Image.open("imagenes/desafioprogramador.png") #Can be many different formats.
pix = im.load()
width, heigth = im.size
tipos_de_pixels = []

def indice_mas_a_la_izquierda(anImage):
	primera_linea = heigth
	ultima_linea = 0
	mas_a_la_izquierda = width
	mas_a_la_derecha = 0

	vi_la_primer_linea = False
	for j in range(0,heigth):
		vi_al_primer_punto_negro = False
		encontre_algo = False

		for i in range(0,width):
			if negro == pix[i,j]:

				mas_a_la_izquierda = min(i, mas_a_la_izquierda)

				primera_linea = min( j, primera_linea)

				mas_a_la_derecha = max( mas_a_la_derecha, i)

				ultima_linea = j

	return primera_linea, ultima_linea, mas_a_la_izquierda, mas_a_la_derecha


i_arriba,i_abajo,i_izq,i_der = indice_mas_a_la_izquierda(im)

contador_entero=0
for fila in range(0,heigth):
	for columna in range(0,width):
		if negro == pix[columna,fila]:
			contador_entero+=1

contador_recortado=0
texto = ""

letra_en_progreso = ""
espacios = 0
for fila in range(i_arriba,i_abajo+1,3):
	columna = i_izq

	if letra_en_progreso != "":
		texto += (inverseMorseAlphabet[letra_en_progreso])
		letra_en_progreso = ""
	
	espacios=0

	while columna < i_der+1:

		if punto == [pix[columna,fila],pix[columna+1,fila],pix[columna+2,fila]]:
			letra_en_progreso += "."
			contador_recortado +=1
			espacios=0

		if barra == [pix[columna,fila],pix[columna+1,fila],pix[columna+2,fila]]:
			letra_en_progreso += "-"
			contador_recortado += 3
			espacios=0

		if fin_letra == [pix[columna,fila],pix[columna+1,fila],pix[columna+2,fila]]:
			espacios +=1

			if 1 < espacios and letra_en_progreso != "":
				texto += (inverseMorseAlphabet[letra_en_progreso])
				letra_en_progreso = ""
			if 2 < espacios and espacios < 4:
				texto += " "

		columna +=4

#Si Recorri la misma cantidad de pixeles negros en la imagen esto deberia ser igual 
print (contador_recortado)
print (contador_entero)

print(texto)

#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <queue>
#include <set>
#include <map>
#include <vector>
#include <stack>
#include <algorithm>

#define MOD 1000000007
#define forn(a, n) for(int a = 0; a<(int) (n); ++a)
#define dforn(a, n) for(int a = (n)-1; a>=0; --a)
#define forall(a, all) for(__typeof(all.begin()) a = all.begin(); a != all.end(); ++a)
#define EPS 0.000000000001

typedef long long tint;

using namespace std;

#define tope 11501
bool primos[tope];
int combinaciones[tope][tope];
vector<int> lista_de_primos;

void criba(){
	memset(primos, true, sizeof(primos) );

	primos[0] = primos[1] = false;

	for (int i = 4; i < tope; i+=2)
		primos[i] = false;

	for (int i = 3; i*i <= tope; i+=2){
		if(primos[i]){
			for (int p = i*i; p < tope; p+=2*i)
				primos[p] = false;
		}
	}

	for(int i = 0; i < tope; i++)
		if (primos[i]) lista_de_primos.push_back(i);
}



int main(int argc, char* argv[]){
	ios::sync_with_stdio(false);

	criba();

	for(int x : lista_de_primos)
		cout << x << "\n";

	return 0;
}

#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <queue>
#include <set>
#include <map>
#include <vector>
#include <stack>
#include <algorithm>

#define MOD 1000000007
#define forn(a, n) for(int a = 0; a<(int) (n); ++a)
#define dforn(a, n) for(int a = (n)-1; a>=0; --a)
#define forall(a, all) for(__typeof(all.begin()) a = all.begin(); a != all.end(); ++a)
#define EPS 0.000000000001

typedef long long tint;

using namespace std;

#define tope 11501
bool primos[tope];
__int128 combinaciones[2][tope];
vector<int> lista_de_primos;


int main(int argc, char* argv[]){
	ios::sync_with_stdio(false);

	memset(primos,false,sizeof(primos));
	int lenght,aux;
	cin>>lenght;
	while(lenght--){
		cin >> aux;
		primos[aux] = true;
		lista_de_primos.push_back(aux);
	}

	int swap_row = 0;
	combinaciones[0][0] = combinaciones[1][0] = 1;

	for (int p=0; p< lista_de_primos.size(); p++){
		swap_row^=1;
		//Aca no puedo cambiar nada lo copio
		//cout << lista_de_primos[p] << "," << 1;
		for(int i = 1; i < lista_de_primos[p]; i++){
			combinaciones[swap_row][i] = combinaciones[swap_row^1][i];
			//cout << "," << combinaciones[swap_row][i];
		}

		//Aca puedo llegar a hacer algo
		for (int i =lista_de_primos[p]; i < tope; i++){
			//if(0 < combinaciones[swap_row^1][i-lista_de_primos[p]])
				//cout << i<<"=" << i-lista_de_primos[p] << "+" << lista_de_primos[p] << "\n";
			combinaciones[swap_row][i] = combinaciones[swap_row^1][i] + combinaciones[swap_row^1][i-lista_de_primos[p]];
			//cout << "," << combinaciones[swap_row][i];
			if(combinaciones[swap_row][i] < 0){
				cout << "overflow en indice " << i << " con primo " << lista_de_primos[p]<< "\n";
			}
		}
		//cout <<"\n";
	}

	primos[0] = true;
	__int128 acum=0;
	for(int i =0; i < tope; i++){
		if ( acum < 0 ){
			cout << "overflow en indice " << i << "\n";
			acum = 0;
		}
		//cout << "formas del " << i << " " << combinaciones[swap_row][i]<< "\n";
		acum += combinaciones[swap_row][i] - primos[i];
	}

	//cout << acum << "\n";
	return 0;
}

import fileinput

tope = 11501

primos_hasta_11500 = [0 for i in range(tope)]

## necesito generar el 0
combinaciones = [ [0 for i in range(tope)], [0 for i in range(tope)]]

for i in range(0, tope):
	primos_hasta_11500[i] = 0
	combinaciones[0][i] = 0
	combinaciones[1][i] = 0

combinaciones[0][0]=1
combinaciones[1][0]=1
lista_de_primos = []

for line in fileinput.input():
	num = int(line)
	lista_de_primos.append(num)
	primos_hasta_11500[num]=1

swap_row=0

for i in range(len(lista_de_primos)):

	swap_row = swap_row^1

	for j in range(1, lista_de_primos[i]):
		combinaciones[swap_row][j] = combinaciones[swap_row^1][j]

	for j in range(lista_de_primos[i], tope):
		combinaciones[swap_row][j] = combinaciones[swap_row^1][j] + combinaciones[swap_row^1][j-lista_de_primos[i]]
		#if combinaciones[swap_row][j] != combinaciones[swap_row^1][j]:
		#	print("{}={}+{}".format(j,j-lista_de_primos[i],lista_de_primos[i]))


acum = 0
primos_hasta_11500[0] = 1
for i in range(tope):
	acum += combinaciones[swap_row][i] - primos_hasta_11500[i]

print (acum)

X = 540992328500517893750391624101174224
otraCadena = "673dbc07b736642ba64d2da5557056377674"

X_en_str = str(X)
X_en_lista = ["0x"+X_en_str[i*2]+X_en_str[i*2+1] for i in range(18)]

otraCadena_en_str = str(otraCadena)
otraCadena_en_lista = ["0x"+otraCadena_en_str[i*2]+otraCadena_en_str[i*2+1] for i in range(18)]


resultado = [int(otraCadena_en_lista[i],16)^int(X_en_lista[i],16) for i in range(18)]
resultado_hex = [hex(int(otraCadena_en_lista[i],16)^int(X_en_lista[i],16)) for i in range(18)]

resultado_corrido=""
resultado_hex_corrido=""

for i in range(18):
	resultado_corrido+=str(resultado[i])
	resultado_hex_corrido += str(resultado_hex[i])[2:]

print("Resultado secuencia en int {}".format(resultado_corrido))
print("Resultado secuencia en hex {}".format(str(resultado_hex_corrido)))

print("Y ahora a String esto es: ")

print ([bytes.fromhex(resultado_hex[i][2:]).decode('utf-8') for i in range(18)])
print (bytes.fromhex(resultado_hex_corrido))