Parte I. Listar rutas completas de todos los paquetes almacenados en SSIS
Imaginemos que en nuestra base de datos tenemos el siguiente árbol de directorios (encerrados entre corchetes) y paquetes SSIS (archivos .dtsx).
+--item
+--procesa cubo
+--descarga ftps
+--[Saz Dwh]
| +--[Saz Predwh]
| +--[Saz Estrella]
| +--ceco
| +--productos
| +--tiempo
+--[System Databases]
+--tempdb
+--msdb
+--model
+--master
Nuestro objetivo es obtener las rutas absolutas de todos los paquetes, es decir, recorrer todos los caminos posibles desde la raíz hasta cada una de las hojas (paquetes SSIS).
El árbol de directorios de los paquetes se almacena en dos tablas de sistema: una con los nombres de los paquetes y otra con el de las carpetas.
Recreamos las tablas de la siguiente manera:
(
folderid int
,parentfolderid int
,foldername varchar(30)
)
(
nombre varchar(20)
,folderid int
)
INSERT INTO folders VALUES(2,1,'System Databases')
INSERT INTO folders VALUES(3,1,'Saz Dwh')
INSERT INTO folders VALUES(4,3,'Saz Predwh')
INSERT INTO folders VALUES(5,4,'Saz Estrella')
INSERT INTO packages VALUES('model',2)
INSERT INTO packages VALUES('msdb',2)
INSERT INTO packages VALUES('tempdb',2)
INSERT INTO packages VALUES('tiempo',5)
INSERT INTO packages VALUES('productos',5)
INSERT INTO packages VALUES('ceco', 5)
INSERT INTO packages VALUES('procesa cubo',1)
INSERT INTO packages VALUES('descarga ftps',1)
INSERT INTO packages VALUES('item',NULL)
SELECT * FROM Folders
-----------------------------------
1 NULL DATABASES
2 1 System DATABASES
3 1 Saz Dwh
4 3 Saz Predwh
5 4 Saz Estrella
SELECT * FROM Packages
----------------------
master 2
model 2
msdb 2
tempdb 2
tiempo 5
productos 5
ceco 5
procesa cubo 1
descarga ftps 1
item NULL
La forma más sencilla de realizar esta tarea es realizar un query recursivo, en SQL Server se puede realizar utilizando una CTE (Common Table Expresisions), cuya plantilla es muy parecida a la de una función recursivo implementada en un lenguaje de programación.
El query se divide en dos secciones: el query inicial (To) y el query recursivo; ambos se encuentran encapsulados dentro de la tabla CTE.
AS
(
SELECT f.folderid, f.parentfolderid, f.foldername,
case when f.foldername IS NULL then cast(p.nombre AS varchar(1000))
else cast(f.foldername + '\' + p.nombre as varchar(1000)) end as ruta
from packages p
left join folders f
on(f.folderid = p.folderid)
union all
select f.folderid, f.parentfolderid, f.foldername, cast(f.foldername+ '\' + ruta as varchar(1000)) as ruta
from folders f
inner join cte_name c
on (c.parentfolderid = f.folderid)
)
select ruta from cte_name
where parentfolderid is null
Resultado del query
Databases\descarga ftps
item
Databases\Saz Dwh\Saz Predwh\Saz Estrella\ceco
Databases\Saz Dwh\Saz Predwh\Saz Estrella\productos
Databases\Saz Dwh\Saz Predwh\Saz Estrella\tiempo
Databases\System Databases\tempdb
Databases\System Databases\msdb
Databases\System Databases\model
Databases\System Databases\master
Espero muy pronto poder postear la segunda y última parte 
.
Introducción a MongoDB
MongoDB es un sistema de base de datos NoSQL, es decir, no es un sistema de base de datos relacional (RDBMS por sus siglas en inglés). Se trata de un sistema de código abierto, orientado a documentos y escrito en C++; utiliza colecciones de documentos BSON (Binary JSON), formato binario para representar estructuras de datos simples y arreglos asociativos.
Ejemplo:
10gen inició el desarrollo de MongoDB inició en octubre de 2007 y se liberó por primera vez al público en 2009. Los binarios están disponibles par Windows, Linux, OS X y Solaris.
mongodb.org Supported
Instalar MongoDB
En estos momentos tengo una HP mini con win7, así que estos son los pasos que tuve que seguir para realizar la instalación:
1. Ir al sitio de MongoDB y descargar la versión 2.0.2, liberada el 12/14/2011 para la plataforma win de 32 bits.
2. Instalar el driver para la el lenguaje de programación preferido, en mi caso, instalé el módulo de python pyMongo, se descarga desde aquí y para instalarlo use el script de easy_install que bajé desde aquí.
Esta es la línea que usé para instalar el módulo
Cómo usar MongoDB
1. Recreamos el directorio C:\data\db, directorio por default.
2. Levantamos el servicio con la siguiente sentencia
Utilizar driver en Python
1. Abrimos un interprete de Python.
2. Importamos el módulo pymongo.
3. Realizamos las siguientes pruebas.
>>> connection = pymongo.Connection("localhost", 27017)
>>> db = connection.test
>>> db.name
u'test'
>>> db.my_collection
Collection(Database(Connection('localhost', 27017), u'test'), u'my_collection')
>>> db.my_collection.save({"x": 10})
ObjectId('4aba15ebe23f6b53b0000000')
>>> db.my_collection.save({"x": 8})
ObjectId('4aba160ee23f6b543e000000')
>>> db.my_collection.save({"x": 11})
ObjectId('4aba160ee23f6b543e000002')
>>> db.my_collection.find_one()
{u'x': 10, u'_id': ObjectId('4aba15ebe23f6b53b0000000')}
>>> for item in db.my_collection.find():
... print item["x"]
...
10
8
11
>>> db.my_collection.create_index("x")
u'x_1'
>>> for item in db.my_collection.find().sort("x", pymongo.ASCENDING):
... print item["x"]
...
8
10
11
>>> [item["x"] for item in db.my_collection.find().limit(2).skip(1)]
[8, 11]
y ya está!, ahora podemos usar MongoDB como sistema de base de datos y Python como lenguaje .
Getting started with Sinatra
¿Who write code in ruby? Sinatra is a web-framework that use ruby and this is the recipe to install it
run on terminal
gem install sinatra #if you have problems try export PATH=$PATH:/var/lib/gems/1.8/bin
sudo apt-get install ruby
add this line to ~/.profile
create a hi.rb whit this code
get '/' do
"Hello World!"
end
run it using this command
browse to
http://localhost:4567/
Getting started with Python
Recently I installed Ubuntu 10.04 and I wanna start to write code in python, this the way that I get
an IDE for do it.
Ready? turn off your mind and follow the recipe and you will got an IDE in two minutes 
!
sudo apt-get install guake
sudo apt-get install gedit-plugins
Download third party plugins for gedit
- Class Browser Plugin.
- iPython Console
- Autocomplete
- Python Code Completion
- Python indentation
- Pair Character Completion
Then unpack all of them on ~/.gnome2/gedit/plugins. If the folder dosn’t exists, creat it!
After that, you must check components for enable them. Go to Editar > Preferencias > Complementos.
It’s done!, enjoy your IDE!
Controla tu banshee desde tu cel con Remuco y Ubuntu
En ubuntu karmic debes seguir la siguiente receta
Agregar al repositorio las siguientes entradas (sudo gedit /etc/apt/sources.list)
deb-src http://ppa.launchpad.net/remuco-team/ppa/ubuntu karmic main
Actualizamos el repositorio:
Instalamoso el cliente Remuco para nuestro reproductor favorito (en mi caso es el banshee)
Bajamos e instalamos el cliente (midlet) en nuestro celular con soporte para aplicaciones java.
Descargamos la última versión de aquí, descomprimimos el .rar y buscamos en la siguiente ruta la aplicación .jar, en mi caso:
Enviamos por bluetooth el .jar a nuestro teléfono, aceptamos la aplicación y el Remuco queda instalado. Ahora hay que levantar el cliente en nuestro ubuntu de la siguiente forma:
Log output will be stored in /home/dennys/.cache/remuco/banshee/log
Contribute to Remuco: Please run 'remuco-report' once a client has connected, thanks!
Para no hacer el paso anterior cada vez que encendemos la compu, lo agregamos como una aplicación de inicio:
Sistemas>Preferencias>Aplicaciones de Inicio
Luego el botón Añadir y escribimos:
También tenemos que abrir nuestro Banshee y agregar canciones a la cola de reproducción, las cuales podrá “ver” el cliente Remuco en el teléfono.
¡Listo!, abre la aplicación en el teléfono y disfruta tu controlo remoto .
Más información:
Using mobile phone as remote for linux media players is fun!
Recorrido sobre un árbol de Jerarquías en SQL Server
Necesitarás la estructura de la tabla y unos cuantos datos de prueba que puedes copiar de aquí, lo he tomado de la página Recursive Queries Using Common Table Expressions del msdn.
CREATE TABLE dbo.MyEmployees
(
EmployeeID smallint NOT NULL,
FirstName nvarchar(30) NOT NULL,
LastName nvarchar(40) NOT NULL,
Title nvarchar(50) NOT NULL,
DeptID smallint NOT NULL,
ManagerID int NULL,
CONSTRAINT PK_EmployeeID PRIMARY KEY CLUSTERED (EmployeeID ASC)
);
-- Populate the table with values.
INSERT INTO dbo.MyEmployees VALUES
(1, N'Ken', N'Sanchez', N'Chief Executive Officer',16,NULL)
,(273, N'Brian', N'Welcker', N'Vice President of Sales',3,1)
,(274, N'Stephen', N'Jiang', N'North American Sales Manager',3,273)
,(275, N'Michael', N'Blythe', N'Sales Representative',3,274)
,(276, N'Linda', N'Mitchell', N'Sales Representative',3,274)
,(285, N'Syed', N'Abbas', N'Pacific Sales Manager',3,273)
,(286, N'Lynn', N'Tsoflias', N'Sales Representative',3,285)
,(16, N'David',N'Bradley', N'Marketing Manager', 4, 273)
,(23, N'Mary', N'Gibson', N'Marketing Specialist', 4, 16);
Tenemos un árbol de jerarquías como este:
-- / | \
--16 274 285
--/ / \ \
--23 275 276 286
¿Como puedo conocer los nodos ancestros del nodo 286?
Este query soluciona el problema, empleando un CTE (Common Table Expression) que entre cosas permite ser autoreferenciado.
AS
(
-- Anchor member definition
SELECT e.ManagerID, e.EmployeeID, e.Title, 0 AS Level
FROM dbo.MyEmployees AS e
INNER JOIN HumanResources.EmployeeDepartmentHistory AS edh
ON e.EmployeeID = edh.EmployeeID AND edh.EndDate IS NULL
WHERE e.EmployeeID IN (1,274,276,275) --COMO PARAMETRO LAS HOJAS
UNION ALL
-- Recursive member definition
SELECT e.ManagerID, e.EmployeeID, e.Title, Level + 1
FROM dbo.MyEmployees AS e
INNER JOIN HumanResources.EmployeeDepartmentHistory AS edh
ON e.EmployeeID = edh.EmployeeID AND edh.EndDate IS NULL
INNER JOIN DirectReports AS d
ON e.EmployeeID = d.ManagerID
)
SELECT * FROM MyEmployees
-- Statement that executes the CTE
SELECT DISTINCT ManagerID, EmployeeID--, Title, Level
FROM DirectReports
Cuando el número de nodos se encuentra en el orden de los miles, el tiempo de ejecución toma importancia y es mejor tener una versión iterativa de la solución.
CREATE TABLE #Tree
(
cid INT NOT NULL,
pid INT NULL,
lvl INT NOT NULL,
);
declare @lvl AS int
SET @lvl = 0
--Inserta al conjunto los nodos raíz
INSERT INTO #Tree(lvl,cid, pid)
SELECT @lvl,EmployeeID, ManagerID
FROM dbo.MyEmployees
WHERE EmployeeID IN (1,274,276,275)
-- select * from #Tree
WHILE @@rowcount > 0
BEGIN
SET @lvl = @lvl + 1;
INSERT INTO #Tree(lvl,cid, pid)
SELECT @lvl, C.EmployeeID, C.ManagerID
FROM #Tree AS P
JOIN dbo.MyEmployees AS C
ON P.lvl = @lvl - 1 AND
P.pid = C.EmployeeID;
END
SELECT DISTINCT cid,pid FROM #Tree
Increible tetris en 19 líneas escrito en c
Código ganador del “The International Obfuscated C Code Contest“ del 2007 hecho en México.
¡Completamente inspirador!
=0,i=276,j,k,q[276],Q[276],*n=q,*m,x=17,f[]={7,-13,-12,1,8,-11,-12,-1,9,-1,1,
12,3,-13,-12,-1,12,-1,11,1,15,-1,13,1,18,-1,1,2,0,-12,-1,11,1,-12,1,13,10,-12,
1,12,11,-12,-1,1,2,-12,-1,12,13,-12,12,13,14,-11,-1,1,4,-13,-12,12,16,-11,-12,
12,17,-13,1,-1,5,-12,12,11,6,-12,12,24};u(){for(i=11;++i<264;)if((k=q[i])-Q[i]
){Q[i]=k;if(i-++I||i%12<1)printf("\033[%d;%dH",(I=i)/12,i%12*2+28);printf(
"\033[%dm "+(K-k?0:5),k);K=k;}Q[263]=c=getchar();}G(b){for(i=4;i--;)if(q[i?b+
n[i]:b])return 0;return 1;}g(b){for(i=4;i--;q[i?x+n[i]:x]=b);}main(C,V,a)char*
*V,*a;{h[3]=1000000/(l=C>1?atoi(V[1]):2);for(a=C>2?V[2]:"jkl pq";i;i--)*n++=i<
25||i%12<2?7:0;srand(getpid());system("stty cbreak -echo stop u");sigvec(14,v,
0);t();puts("\033[H\033[J");for(n=f+rand()%7*4;;g(7),u(),g(0)){if(c<0){if(G(x+
12))x+=12;else{g(7);++w;for(j=0;j<252;j=12*(j/12+1))for(;q[++j];)if(j%12==10){
for(;j%12;q[j--]=0);u();for(;--j;q[j+12]=q[j]);u();}n=f+rand()%7*4;G(x=17)||(c
=a[5]);}}if(c==*a)G(--x)||++x;if(c==a[1])n=f+4**(m=n),G(x)||(n=m);if(c==a[2])G
(++x)||--x;if(c==a[3])for(;G(x+12);++w)x+=12;if(c==a[4]||c==a[5]){s=sigblock(
8192);printf("\033[H\033[J\033[0m%d\n",w);if(c==a[5])break;for(j=264;j--;Q[j]=
0);while(getchar()-a[4]);puts("\033[H\033[J\033[7m");sigsetmask(s);}}d=popen(
"stty -cbreak echo stop \023;sort -mnr -o HI - HI;cat HI","w");fprintf(d,
"%4d from level %1d by %s\n",w,l,getlogin());pclose(d);}
Para verlo en acción abran una terminal, compilen y ejecuten:
$ gcc tetris.c -o tetris
$ ./tetris
Concurso de Programación ANPA10
Faltan pocos días para el ANPA 2010
El próximo concurso de la ANPA será el 24 de Abril del presente año en León, Guanajuato; no es necesario pertenecer a alguna institución para poder participar y para que se animen a participar, este es uno de los problemas del ANPA07.
Problema: Cajas (ANPA 07 Semifinal)
Autor: Fory
Historia
El encargado de “Empresa productora de cartón” decidió lanzar una línea nueva de cajas. La línea consiste en una colección de cajas cúbicas de diferentes tamaños. Como promoción de lanzamiento se hicieron paquetes de cajas de tal forma que al abrir una puedas encontrar otra y dentro de esta una más y así sucesivamente hasta abrir la caja más pequeña incluida en el paquete. De improviso llega un cliente a la fábrica pidiendo un paquete de lanzamiento; desafortunadamente todos los paquetes ya fueron enviados a las tiendas. Dado que tú eres el responsable de armarlos decides formar uno con el mayor número posible de cajas existentes en la fábrica.
ProblemaHacer un programa que lea el tamaño de cada una de las cajas que hay en la fábrica y escriba el mayor número de cajas que puede tener el paquete. Dentro de una caja de tamaño T puedes meter otra de tamaño t sólo sí t < T.
Entrada
La primer línea de la entrada contendrá un sólo número entero n (1 ≤ n ≤ 100). Dicho número representa el número de casos de prueba para este problema. Cada una de las siguientes n líneas describirá un caso de prueba. En cada caso debes leer primero un entero k (1 ≤ k ≤ 1000) que indica cuantas cajas hay en la fábrica y después leer el tamaño de cada una de las cajas. El tamaño de cada caja será un entero entre 1 y 1000.
Ejemplo:
4
11 1 2 3 4 5 6 7 8 9 10 11
1 10
4 2 2 2 2
5 1 2 2 3 10Salida
Para cada caso de prueba debes escribir una línea de texto con el mensaje “El paquete mayor tiene N cajas.”, siendo N el número de cajas en el paquete más grande. Ejemplo (estas salidas corresponden al ejemplo que se da en Entrada):
El paquete mayor tiene 11 cajas.
El paquete mayor tiene 1 cajas.
El paquete mayor tiene 1 cajas.
El paquete mayor tiene 4 cajas.Nombre del programa
cajas.cpp, cajas.java, cajas.cs, cajas.vb
Como pueden ver, no es nada del otro mundo y la solución se puede escribir en pocas lineas en c++:
#include <cstdio>
#include <set>
using namespace std;
int main(){
int casos, ncajas, tamCaja;
scanf("%d",&casos);
while(casos--){
set<int>cajas_no_repetidas;
scanf("%d",&ncajas);
for(int i=0; i<ncajas;i++){
scanf("%d",&tamCaja);
cajas_no_repetidas.insert(tamCaja);
}
printf("El paquete mayor tiene %d cajas.\n",cajas_no_repetidas.size());
}
}
Les dejo algunos de los problemas aquí para que se terminen de animar.
¿Cómo pasar parámetros por default en C#?
¿Cuántas veces nos encontramos con funciones que por algún ajuste o cambio funcionarían mejor si contarán con otro parámetro más? Esto es muy común cuando tenemos proyectos “grandes” o de tiempo atrás y estamos tratando de realizar una modificación. El problema toma especial importancia si el código que deseamos modificar no fue escrito por nosotros o si no conocemos su funcionamiento del todo.
Un enfoque podría ser sobrecargar la función agregando el segundo parámetro, pero muchos de nosotros (desarrolladores) no nos agrada mucho la idea de repetir código. La solución idonea para mí es pasar el segundo argumento que necesitamos en la misma función y establecer un valor por default que no afecte el comportamiento actual de dicha función.
Es ahí donde entran en juego el uso de parámetros por default, en c++ la sintaxis nos ayuda y la solución se vuelve simple:
using namespace std;
int potencia(int a, int b=2)
{
int factor=1;
for(int i=0; i<b; i++)
factor*=a;
return factor;
}
int main()
{
cout << potencia(2,3) << endl;
cout << potencia(2) << endl;
}
¿Qué pasa si deseamos hacerlo en C#?
Resulta que el lenguaje no soporta esta sintaxis (C# 4.0 sí lo hace), por lo que necesitamos buscar otra manera de hacerlo. La manera sencilla es definiendo el prototipo de la función con una lista de argumentos de longitud variable.
¿cómo hacemos esto?
Podremos “llamar” a nuestra función potencia con uno, dos o cualquier cantidad de parámetros que queramos de tipo entero separados por coma. Al reescribir nuestro programa de ejemplo en C#, nos queda de la siguiente manera:
{
int valor = args[0];
int potencia = 2;
if(args.Length > 0)
potencia = args[1]
int factor=1;
for(int i=0; i<potencia; i++)
factor*=valor;
return factor;
}
Marquesina basada en Arduino
Después del sketch del Knight Rider, fue imposible evitar la tentación de escribir otro sketch para el Arduino, que transformará la matriz de leds de 8×8 en una mini-banner. Solo bastaron un pocos cambios en el contador 4017 para ¡tener el hardware listo! (eliminar el reset autómatico al llegar al Output 8).
banner
La mayor parte del código está basado en el instructivo de Syst3mX.
//22 Noviembre de 2009
int col[] = {0,1, 2, 3, 4, 5, 6, 7};
int clock = 9;// goes to the clock pin on the 4017 IC
int reset = 8;//goes to the reset pin on the 4017 IC
const int numPatterns = 18 ;
byte patterns[numPatterns][8]={space,M,lit_a,lit_k,lit_e,dos_pts,space,lit_e,lit_n,space,E,lit_s,lit_p,lit_a,lit_nh,lit_o,lit_l,space};
void setup(){
//simple stuff here
pinMode(clock,OUTPUT);
pinMode(reset,OUTPUT);
//simple stuff here
for (int thisPin = 0; thisPin < 8; thisPin++) {
// initialize the output pins for matrix 1:
pinMode(col[thisPin], OUTPUT);
}
//reseting the 4017 IC, you have to do this
digitalWrite(reset,HIGH);
delayMicroseconds(5);
digitalWrite(reset,LOW);
}
void display_pattern(int loops)
{
//for each pattern
for(int x=0; x<numPatterns-1; x++){
for (int z=0;z<8;z++){
//scrolls one bite at a time
// the delay we get with loops
for(int t=0;t<loops;t++){
//reseting the 4017 IC, you have to do this
digitalWrite(reset,HIGH);
delayMicroseconds(5);
digitalWrite(reset,LOW);
for(int y=0; y<8; y++){
byte temp = patterns[x][y];
byte temp_2=patterns[x+1][y];
//writes digital outputs, Z is for how much bites it need to scroll
PORTD = B11111111 - ((temp<<z) + (temp_2>>7-z));
delayMicroseconds(400);// the time every row is one
PORTD= B11111111;// all pins are low, fixes the ghosting effect
digitalWrite(clock,HIGH);
delayMicroseconds(50);
digitalWrite(clock,LOW);
}
}
}
}
}
void loop(){
display_pattern(50); // int loop = 15(if you do more loop the pattern whould scrrol slower).
}
Aquí esta la representación de los caracteres para la matriz de 8×8
#define B {B01111100,B01000010,B01000010,B01111100,B01000010,B01000010,B01000010,B01111100}
#define C {B00111110,B01000000,B01000000,B01000000,B01000000,B01000000,B01000000,B00111110}
#define D {B01111100,B01000010,B01000010,B01000010,B01000010,B01000010,B01000010,B01111100}
#define E {B01111110,B01000000,B01000000,B01111100,B01000000,B01000000,B01000000,B01111110}
#define F {B01111110,B01000000,B01000000,B01111100,B01000000,B01000000,B01000000,B01000000}
#define G {B00111100,B01000010,B01000010,B01000000,B01000111,B01000010,B01000010,B00111100}
#define H {B01000010,B01000010,B01000010,B01111110,B01000010,B01000010,B01000010,B01000010}
#define I {B00111000,B00010000,B00010000,B00010000,B00010000,B00010000,B00010000,B00111000}
#define J {B00011100,B00001000,B00001000,B00001000,B00001000,B01001000,B01001000,B00110000}
#define K {B01000100,B01001000,B01010000,B01100000,B01010000,B01001000,B01000100,B01000010}
#define L {B01000000,B01000000,B01000000,B01000000,B01000000,B01000000,B01000000,B01111110}
#define M {B10000010,B11000110,B10101010,B10010010,B10000010,B10000010,B10000010,B10000010}
#define N {B01000010,B01100010,B01010010,B01001010,B01001010,B01001010,B01000110,B01000010}
#define O {B00111100,B01000010,B01000010,B01000010,B01000010,B01000010,B01000010,B00111100}
#define P {B01111100,B01000010,B01000010,B01000010,B01111100,B01000000,B01000000,B01000000}
#define Q {B00111100,B01000010,B01000010,B01000010,B01000010,B01000110,B00111110,B00000001}
#define R {B01111100,B01000010,B01000010,B01000010,B01111100,B01000100,B01000010,B01000010}
#define S {B00111100,B01000010,B01000000,B01000000,B00111100,B00000010,B01000010,B00111100}
#define T {B11111110,B00010000,B00010000,B00010000,B00010000,B00010000,B00010000,B00010000}
#define U {B01000010,B01000010,B01000010,B01000010,B01000010,B01000010,B01000010,B00111100}
#define V {B01000010,B01000010,B01000010,B01000010,B01000010,B01000010,B00100100,B00011000}
#define W {B10000010,B10000010,B10000010,B10000010,B10010010,B10010010,B10101010,B01000100}
#define X {B01000010,B01000010,B00100100,B00011000,B00011000,B00100100,B01000010,B01000010}
#define Y {B10000010,B01000100,B00101000,B00010000,B00010000,B00010000,B00010000,B00010000}
#define Z {B01111110,B00000010,B00000100,B00001000,B00010000,B00100000,B01000000,B01111110}
#define lit_a {B00000000,B00110000,B01001000,B00001000,B00111000,B01001000,B01001000,B00110100}
#define lit_b {B00000000,B00100000,B00100000,B00100000,B00111100,B00100010,B00100010,B00111100}
#define lit_c {B00000000,B00000000,B00000000,B00111100,B01000000,B01000000,B01000000,B00111100}
#define lit_d {B00000000,B00000100,B00000100,B00000100,B00111100,B01000100,B01000100,B00111100}
#define lit_e {B00000000,B00111000,B01000100,B01000100,B01111100,B01000000,B01000100,B00111000}
#define lit_f {B00011000,B00100100,B00100000,B00100000,B01110000,B00100000,B00100000,B00100000}
#define lit_g {B00011100,B00100010,B00100010,B00011100,B00001000,B00001100,B00100010,B00011100}
#define lit_h {B01000000,B01000000,B01000000,B01000000,B01111000,B01000100,B01000100,B01000100}
#define lit_i {B00000000,B00010000,B00000000,B00010000,B00010000,B00010000,B00010000,B00010000}
#define lit_j {B00000000,B00010000,B00000000,B00010000,B00010000,B00010000,B01010000,B00100000}
#define lit_k {B00000000,B01000000,B01001000,B01010000,B01100000,B01100000,B01010000,B01001000}
#define lit_l {B01000000,B01000000,B01000000,B01000000,B01000000,B01000000,B01000000,B01000000}
#define lit_m {B00000000,B00000000,B10110110,B01001001,B01001001,B01001001,B01001001,B01001001}
#define lit_n {B00000000,B00000000,B10111000,B01000100,B01000100,B01000100,B01000100,B01000100}
#define lit_nh {B01111100,B00000000,B10111000,B01000100,B01000100,B01000100,B01000100,B01000100}
#define lit_o {B00000000,B00000000,B00000000,B00011100,B00100010,B00100010,B00100010,B00011100}
#define lit_p {B00000000,B00011100,B00100010,B00100010,B00111100,B00100000,B00100000,B00100000}
#define lit_q {B00000000,B00000000,B00111000,B01000100,B01000100,B00111100,B00000100,B00000100}
#define lit_r {B00000000,B00000000,B00111000,B01000000,B01000000,B01000000,B01000000,B01000000}
#define lit_s {B00000000,B00111000,B01000100,B01000000,B00111000,B00000100,B01000100,B00111000}
#define lit_t {B00100000,B00100000,B00100000,B01111100,B00100000,B00100000,B00100100,B00011000}
#define lit_u {B00000000,B00000000,B00000000,B01000100,B01000100,B01000100,B01000100,B00111000}
#define lit_v {B00000000,B00000000,B01000100,B01000100,B01000100,B01000100,B00101000,B00010000}
#define lit_w {B00000000,B00000000,B00000000,B01000100,B01000100,B01010100,B01010100,B00101000}
#define lit_x {B00000000,B00000000,B00000000,B00000000,B00100100,B00011000,B00011000,B00100100}
#define lit_y {B00000000,B01000100,B01000100,B00111100,B00000100,B00000100,B01000100,B00111000}
#define lit_z {B00000000,B00000000,B00000000,B01111100,B00001000,B00010000,B00100000,B01111100}
#define space {B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000}
#define num_0 {B00111100,B01000110,B01001010,B01001010,B01001010,B01010010,B01100010,B00111100}
#define num_1 {B00001000,B00011000,B00001000,B00001000,B00001000,B00001000,B00001000,B00011100}
#define num_2 {B00111100,B01000010,B00000100,B00001000,B00010000,B00100000,B01000000,B01111110}
#define num_3 {B01111110,B00000010,B00000010,B00011100,B00000010,B00000010,B01000010,B00111100}
#define num_4 {B00000100,B00001100,B00010100,B00100100,B01000100,B01111110,B00000100,B00000100}
#define num_5 {B01111110,B01000000,B01000000,B00111100,B00000010,B00000010,B00000010,B01111100}
#define num_6 {B00111100,B01000000,B01000000,B01111100,B01000010,B01000010,B01000010,B00111100}
#define num_7 {B01111110,B00000010,B00000100,B00001000,B00010000,B00010000,B00010000,B00010000}
#define num_8 {B00111100,B01000010,B01000010,B00111100,B01000010,B01000010,B01000010,B00111100}
#define num_9 {B00111100,B01000010,B01000010,B01000010,B00111110,B00000010,B00000010,B00111100}
#define times {B00000000,B01000010,B00100100,B00011000,B00011000,B00100100,B01000010,B00000000}
#define dos_pts{B00000000,B00000000,B00110000,B00110000,B00000000,B00110000,B00110000,B00000000}