<html><head><style type="text/css"><!-- DIV {margin:0px;} --></style></head><body><div style="font-family:'times new roman', 'new york', times, serif;font-size:12pt"><div style="color: black; font-family: 'times new roman', 'new york', times, serif; font-size: 12pt; "></div><div><font class="Apple-style-span" face="'times new roman', 'new york', times, serif" size="3">Steven, en serio </font><font class="Apple-style-span" face="'times new roman', 'new york', times, serif">muchísimas</font><font class="Apple-style-span" face="'times new roman', 'new york', times, serif" size="3"> gracias</font></div><div><font class="Apple-style-span" face="'times new roman', 'new york', times, serif"><br></font></div><div><font class="Apple-style-span" face="'times new roman', 'new york', times, serif" size="3"></font><font class="Apple-style-span" face="'times new roman', 'new york', times, serif">(Uint16 *)p -> realiza el casting; una vez realizado el
casting entonces que vuelva a apuntar a la dirección de memoria *p, juntando las dos cosas da como resultado la expresión *(Uint16 *)p.</font></div><div><font class="Apple-style-span" face="'times new roman', 'new york', times, serif"><br></font></div><div><font class="Apple-style-span" face="'times new roman', 'new york', times, serif">En base a esto, permíteme tratar de explicar la siguiente expresión:</font></div><div><font class="Apple-style-span" face="'times new roman', 'new york', times, serif"><span class="Apple-style-span" style="font-family: arial, helvetica, sans-serif; font-size: 13px; "><br></span></font></div><div><font class="Apple-style-span" face="'times new roman', 'new york', times, serif"><span class="Apple-style-span" style="font-family: arial, helvetica, sans-serif; font-size: 13px; ">Nota: superficie->pixels está definido dentro de la estructura SDL_Surface como un puntero a void, o sea, "void
*pixels".</span></font></div><div><font class="Apple-style-span" face="'times new roman', 'new york', times, serif"><span class="Apple-style-span" style="font-family: arial, helvetica, sans-serif; font-size: 13px; "><br></span></font></div><div><font class="Apple-style-span" face="'times new roman', 'new york', times, serif"><span class="Apple-style-span" style="font-family: arial, helvetica, sans-serif; font-size: 13px; ">Uint8 *p = (Uint8 *)superficie->pixels + y * superficie->pitch + x * bpp;</span></font></div><div><font class="Apple-style-span" face="'times new roman', 'new york', times, serif"><span class="Apple-style-span" style="font-family: arial, helvetica, sans-serif; font-size: 13px; "><br></span></font></div><div><font class="Apple-style-span" face="'times new roman', 'new york', times, serif"><span class="Apple-style-span" style="font-family: arial, helvetica, sans-serif; font-size: 13px; ">1.- Se realiza el casting de (void *) a
(Uint8 *) sobre el puntero superficie->pixels.</span></font></div><div><font class="Apple-style-span" face="'times new roman', 'new york', times, serif"><span class="Apple-style-span" style="font-family: arial, helvetica, sans-serif; font-size: 13px; ">2.- Se multiplica x * bpp</span></font></div><div><font class="Apple-style-span" face="'times new roman', 'new york', times, serif"><span class="Apple-style-span" style="font-family: arial, helvetica, sans-serif; font-size: 13px; ">3.- Se multiplica y * superficie->pitch</span></font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2">4.- Se suma el resultado del punto 2 y 3</font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2">5.- Y por último el resultado del punto 4 es sumado a la dirección de memoria de superficie->pixels.</font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif"
size="2"><br></font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2">Otra forma de verlo sería así:</font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2">Uint8 *p = (Uint8 *)superficie->pixels; //p apunta a la dirección superficie->pixels.</font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2">p[ (y * superficie->pitch) + (x * bpp) ]; //obtener la dirección del pixel.</font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2"><br></font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2">Así se obtiene la posición del pixel y nos permite luego ir a p[R], p[G] y p[B] sin mayor riesgo ya que para este caso cada uno de los pixeles está compuesto por 24 bits y p es de 8 bits, por lo que 8 x 3 = 24. Entonces teniendo la posición del pixel en la superficie,
podemos movernos entre los 24 bits que componen el pixel sin problemas debido a que R=0 G=1 B=2 son consecutivos.</font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2"><br></font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2">En cuanto al último punto, cuando escribiste la siguiente expresión me quedó clara la idea:</font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2"><br></font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2"><span class="Apple-style-span" style="font-size: 13px; ">return ((Uint32)p[R]) | ((Uint32)p[G]) << 8 | ((Uint32)p[B]) << 16;</span></font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2"><span class="Apple-style-span" style="font-size: 13px; "><br></span></font></div><div><font class="Apple-style-span" face="arial,
helvetica, sans-serif" size="2"><span class="Apple-style-span" style="font-size: 13px; ">Para mí ahora si tiene sentido, aunque me diste la clave también cuando me recordaste que la función devuelve un valor de 32 bits, con lo que el return se encargaría de empaquetar el resultado, permitiendo la expresión como sigue:</span></font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2"><span class="Apple-style-span" style="font-size: 13px; "><br></span></font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2"><span class="Apple-style-span" style="font-size: 13px; ">return p[R] | p[G] << 8 | p[B] << 16; //Aquí se pude construir un bloque de 32 bits.</span></font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2"><span class="Apple-style-span" style="font-size: 13px; "><br></span></font></div><div><font class="Apple-style-span"
face="arial, helvetica, sans-serif" size="2"><span class="Apple-style-span" style="font-size: 13px; ">Todo está entendido, muchas gracias Steven, si en realidad es muy fácil, sólo hay que tener los conceptos claros.</span></font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2"><span class="Apple-style-span" style="font-size: 13px; "><br></span></font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2"><span class="Apple-style-span" style="font-size: 13px; ">Una pregunta más, la función GetPixel en mi arquitectura me devuelve [B, G, R], sin embargo cuando el resultado en una variable, llamemosle color, al verlo en hexadecimal me muestra [R, G, B].</span></font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2"><span class="Apple-style-span" style="font-size: 13px; ">El compilador hace una transformación de forma automática por ser
little-endian?</span></font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2"><span class="Apple-style-span" style="font-size: 13px; "><br></span></font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2"><span class="Apple-style-span" style="font-size: 13px; ">Para que veas más claro a lo que me refiero te coloco la porción de código:</span></font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2"><span class="Apple-style-span" style="font-size: 13px; "><br></span></font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2"><span class="Apple-style-span" style="font-size: 13px; ">//Defino el color que quiero mostrar en la pantalla o superficie...</span></font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2">Uint32 color = SDL_MapRGB(pantalla->format, 255, 0, 0); //Color
rojo..</font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2"><span class="Apple-style-span" style="font-size: 13px; "><br></span></font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2">//Pinto el pixel del color rojo en la superficie:</font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2">PutPixel(pantalla, 100, 100, color);</font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2"><br></font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2">//Obtengo el valor del color de la pantalla...</font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2">Uint32 comprobar = GetPixel(pantalla, 100, 100); //Aquí se obtiene el valor rojo...</font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif"
size="2"><br></font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2">//Muestro el valor hexadecimal de la variable "comprobar"...</font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2">cout << "Valor hex: " << hex << comprobar << endl;</font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2"><br></font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2">El resultado que me da es:</font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2">Valor hex: <span class="Apple-style-span" style="color: rgb(255, 0, 127); ">ff </span><span class="Apple-style-span" style="color: rgb(128, 255, 0); ">00 </span></font><span class="Apple-style-span" style="color: rgb(0, 128, 255); font-family: arial, helvetica, sans-serif; font-size: small;
">00</span></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2"><br></font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2">Sin embargo, si te fijas en el retorno de la función (</font><span class="Apple-style-span" style="font-family: arial, helvetica, sans-serif; font-size: 13px; ">return p[R] | p[G] << 8 | p[B] << 16;) lo que interpreto es lo siguiente</span></div><div><span class="Apple-style-span" style="font-family: arial, helvetica, sans-serif; font-size: 13px; "><br></span></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2">Devuelve el rojo <font class="Apple-style-span" color="#FF007F">ff</font>, desplázate 8 bits hacia la izquierda y devuelve el valor del verde <font class="Apple-style-span" color="#80FF00">00</font>, desplázate 16 bits y devuelve el valor de azul <font class="Apple-style-span"
color="#0080FF">00</font> dejando como resultado:</font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2"><br></font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2"><span class="Apple-style-span" style="color: rgb(0, 128, 255); ">00</span> <span class="Apple-style-span" style="color: rgb(128, 255, 0); ">00</span> </font><span class="Apple-style-span" style="color: rgb(255, 0, 127); font-family: arial, helvetica, sans-serif; font-size: small; ">ff</span></div><div><font class="Apple-style-span" face="'times new roman', 'new york', times, serif"><br></font></div><div><font class="Apple-style-span" face="'times new roman', 'new york', times, serif">Y claro aquí me confundo porque una cosa es lo que estoy interpretando y otra muy distinta el valor real devuelto.</font></div><div><font class="Apple-style-span" face="'times new roman', 'new york', times, serif"><span
class="Apple-style-span" style="font-family: 'Times New Roman'; "><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2"><span class="Apple-style-span" style="color: rgb(255, 0, 127); ">ff </span><span class="Apple-style-span" style="color: rgb(128, 255, 0); ">00 </span></font></span><span class="Apple-style-span" style="font-family: 'Times New Roman'; "><span class="Apple-style-span" style="color: rgb(0, 128, 255); font-family: arial, helvetica, sans-serif; font-size: small; ">00 <> </span></span></font><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2"><span class="Apple-style-span" style="color: rgb(0, 128, 255); ">00</span> <span class="Apple-style-span" style="color: rgb(128, 255, 0); ">00</span> </font><span class="Apple-style-span" style="color: rgb(255, 0, 127); font-family: arial, helvetica, sans-serif; font-size: small; ">ff</span></div><div><span
class="Apple-style-span" style="color: rgb(255, 0, 127); font-family: arial, helvetica, sans-serif; font-size: small; "><br></span></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2">Un cordial saludo, y Steven de nuevo muchísimas gracias, cada vez entiendo más y mejor.</font></div><div><font class="Apple-style-span" face="arial, helvetica, sans-serif" size="2"><br></font></div><font class="Apple-style-span" face="'times new roman', 'new york', times, serif" size="3"><span><a target="_blank" href="http://xdrtas.coolpage.biz/">http://xdrtas.coolpage.biz/</a></span></font><br><font class="Apple-style-span" face="'times new roman', 'new york', times, serif" size="3"><span><a target="_blank" href="http://xdrtas.blogspot.com/">http://xdrtas.blogspot.com/</a></span></font><div style="color: black; font-family: 'times new roman', 'new york', times, serif; font-size: 12pt; "><br></div><div style="font-family:
'times new roman', 'new york', times, serif; font-size: 12pt; color: black; "><br><div style="font-family:arial, helvetica, sans-serif;font-size:10pt"><font size="2" face="Tahoma"><hr size="1"><b><span style="font-weight: bold;">De:</span></b> Steven Davidson <srd4121@njit.edu><br><b><span style="font-weight: bold;">Para:</span></b> Lista de correo sobre C y C++ <cconclase@listas.conclase.net><br><b><span style="font-weight: bold;">Enviado:</span></b> vie,25 febrero, 2011 14:14<br><b><span style="font-weight: bold;">Asunto:</span></b> Re: [C con Clase] SDL operaciones bitwise y punteros.<br></font><br>Hola David,<br><br>On 2/25/2011 7:24 AM, David wrote:<br>> Hola, buenas a todos, estoy siguiendo el tutorial de SDL:<br><br>[CORTE]<br><br>> Mi primera pregunta es:<br>> ¿Cómo se interpreta la siguiente sentencia?: *(Uint16 *)p = pixel.<br>> La primera parte lo entiendo, si el sistema trabaja con una<br>> profundidad de color
de 16 bits o 2 bytes entonces se hace un cast a<br>> *p para que apunte a variables del tipo Uint16 y así *p en vez de<br><br>Técnicamente, no hacemos un cásting a '*p', sino a 'p', el puntero.<br><br>> usar un byte o 8 bits para apuntar a el valor, ahora podrá apuntar a<br>> variables de2 bytes o 16 bits, pero qué pasa con el otro operador de<br>> indirección "*" el que está de rojo, *(Uint16 *)p, no entiendo a que<br>> apunta aquí.<br>> <br><br>Apunta al valor que está en esa misma dirección guardada en 'p'. Lo que pasa es que ahora conseguirá un valor de 2 bytes en lugar de un valor de 1 byte, como indicaba 'p', originalmente. El operador * es de indirección y por tanto está accediendo al valor apuntado. En otras palabras, estamos asignando el valor de 'pixel' a la memoria apuntada por 'p'. Esto es similar al caso 1 del 'switch/case':<br>*p = pixel;<br><br>Lo que pasa es que, en el caso de 16 bits, tenemos que hacer un
cásting. Podríamos haber hecho esto:<br><br>Uint16 *p16 = (Uint16 *)p;<br>*p16 = pixel;<br><br>Si quieres, te pongo un vector descriptor, para que veas lo que ocurre en memoria. Anterior a esta sentencia, tenemos lo siguiente en memoria:<br><br>Dirección<br>de Memoria Nombre Tipo Valor<br>--------------------------------------------------<br>0x1122FF00 pixel Uint32 0xFF770000 (color RGB)<br>...<br>0x11AAEE00 p Uint8 * 0x33FFCC00<br>...<br>0x33FFCC00 ---- Uint8 0x00<br>0x33FFCC01 ---- Uint8 0x00<br>0x33FFCC02 ---- Uint8
0x00<br>0x33FFCC03 ---- Uint8 0x00<br>0x33FFCC04 ---- Uint8 0x00<br>0x33FFCC05 ---- Uint8 0x00<br>...<br><br>Después de la asignación, veríamos lo siguiente en memoria:<br><br>Dirección<br>de Memoria Nombre Tipo Valor<br>--------------------------------------------------<br>0x1122FF00 pixel Uint32 0xFF770000 (color RGB)<br>...<br>0x11AAEE00 p Uint8 * 0x33FFCC00<br>...<br>0x33FFCC00 ---- Uint8
0xFF<br>0x33FFCC01 ---- Uint8 0x77<br>0x33FFCC02 ---- Uint8 0x00<br>0x33FFCC03 ---- Uint8 0x00<br>0x33FFCC04 ---- Uint8 0x00<br>0x33FFCC05 ---- Uint8 0x00<br>...<br><br>El puntero 'p' sigue apuntando al mismo lugar, pero ahora hemos copiado el valor en 'pixel' a la memoria apuntada por 'p'. Previamente, tuvimos que indicar a C/C++ que tratase 'p' como un puntero a 'Uint16'.<br><br>La verdad es que deberíamos hacer un cásting de 'pixel' (de tipo 'Uin32') al tipo 'Uint16', ya que perderíamos datos y por tanto el compilador no puede realizar esta operación implícitamente. Esto
es,<br><br>*(Uint16 *)p = (Uint16)pixel;<br><br>> Mi segunda pregunta es sobre el siguiente bloque:<br>> <br>> p[R] = pixel & 0xFF;<br>> p[G] = (pixel >> 8) & 0xFF;<br>> p[B] = (pixel >> 16) & 0xFF;<br>> <br>> Tratándose de punteros, sé que se pueden hacer cosas como esa, pero<br>> cómo sabe el compilador que p[1] y p[2], (p[G] y p[B]<br>> respectivamente) no están ocupadas con información de otra<br>> aplicación, no es esto peligroso?, manipular direcciones de memoria<br>> que no se han declarado?<br><br>En general, sí. Por eso el programador de C/C++ debe poner especial atención y mucho cuidado al usar punteros.<br><br>> Sé que declare *p, pero no declaré p[1], ni p[2], ni p[..n].<br><br>Creo que estás confundiendo el operador [] con arrays. El operador [] puede servir tanto para arrays como para punteros. Por ejemplo,<br><br>int lista[10];<br><br>lista[0] = 10;<br>lista[1] =
100;<br>...<br><br>Pero también podemos usar la nomenclatura de punteros:<br><br>*lista = 10;<br>*(lista+1) = 100;<br>...<br><br>Estas operaciones son equivalentes entre sí. También podemos hacer lo mismo con punteros:<br><br>int *p = lista;<br><br>*p = 10;<br>*(p+1) = 100;<br>...<br><br>o incluso,<br><br>int *p = array;<br><br>p[0] = 10;<br>p[1] = 100;<br>...<br><br>La diferencia está en que 'lista' es un array y por tanto el compilador creará la memoria necesaria para que "exista". Además, un array no puede ser modificado, pero sus elementos sí. Por lo tanto, podemos decir que un array es como un puntero constante. Esto es,<br><br>lista = new int[100]; // incorrecto: 'lista' es constante<br>p = new int[100]; // correcto: 'p' apunta a una nueva dirección<br><br>Deberías revisar este tema de punteros de C/C++ en la documentación. En nuestro curso, puedes dirigirte al capítulo 12: <a
href="http://c.conclase.net/curso/index.php?cap=012b#PUNT_Correspondencia" target="_blank">http://c.conclase.net/curso/index.php?cap=012b#PUNT_Correspondencia</a><br><br>Por consiguiente, 'p' apunta a una dirección de memoria basada en 'superficie->pixels'. Al comienzo de esta función, escribes:<br><br>Uint8 *p = (Uint8 *)superficie->pixels + y * superficie->pitch + x * bpp;<br><br>Por lo tanto, 'p[0]', 'p[1]', etc. son los valores en esas direcciones de memoria.<br><br>> p[R], p[G], p[B], son de 32 bits o 4 bytes cada uno? O p[R], p[G],<br>> p[B] representa cada uno un byte de los 4 que tiene p. Me explico con<br><br>Para responder a esta pregunta, simplemente mira el tipo del dato apuntado por 'p'. Como 'p' es de tipo 'Uint8 *', entonces los valores apuntados son de tipo 'Uint8' que seguramente se define como 'unsigned char' en alguna parte.<br><br>> un esquema:<br>> <br>> Recordemos que *p es de 4 bytes y para el caso de
profundidad de<br><br>No. 'p' es de tipo 'Uint *', así que '*p' es de tipo 'Uint8', que como acabo de explicar, es 1 byte.<br><br>Lo que seguramente es cierto es que 'p', como puntero, ocupa 32 bits, si estamos en una plataforma de 32 bits y por tanto las direcciones de memoria son de 32 bits.<br><br>> <br><br>[CORTE]<br><br>> Mi tercera pregunta viene en relación a la siguiente función:<br>> <br>> Uint32 GetPixel(SDL_Surface *superficie, int x, int y)<br><br>[CORTE]<br><br>> El siguiente "return " no lo entiendo bien, alguien me podría<br>> explicar a nivel de bits que hace lo siguiente:<br>> <br>> return p[R] | p[G] << 8 | p[B] << 16;<br>> <br>> Porque si p[R], p[G] y p[B] son cada uno de un Byte o 8 bits entonces<br>> no tiene sentido el desplazamiento de bits.<br>> O, lo que hace es que: escribe los 8 bits del rojo, luego que<br>> desplace 8 bits el verde y y escriba el valor en bits del verde y
por<br>> último que desplace 16 bits el azul para que el return devuelva los<br>> 24 bits como [B, G, R], o sea, una concatenación de bits.<br><br>Esta última explicación es la correcta para aclarar tu duda.<br><br>En parte, tienes razón en la primera duda que planteas. Los operandos son de tipo 'Uint8' y por tanto estos operadores darán resultados de tipo 'Uint8'. Sin embargo, el tipo resultante es de 'Uint32', por lo que el compilador entiende que el resultado será de 32 bits.<br><br>De todas maneras, estoy de acuerdo contigo; esto no sería la forma correcta de escribir esta operación. Aconsejaría hacer cástingas a cada operando para que las expresiones fueren del tipo correcto. Esto es,<br><br>return ((Uint32)p[R]) | ((Uint32)p[G]) << 8 | ((Uint32)p[B]) << 16;<br><br>Ciertamente, esto es algo engorroso y poco legible, pero al menos nos aseguramos que las expresiones son correctas.<br><br>> Aunque lo que yo veo es que
se está usando un OR entre los tres.<br>> <br><br>Correcto. Realizamos dos operaciones de OR a nivel de bits. Esto es mejor verlo con un ejemplo en binario,<br><br> 11001110<br>OR 00111000<br>-----------<br> 11111110<br><br>En el caso de la expresión anterior, obtendríamos algo así:<br><br> 1100111000000000<br>OR 0000000000111000<br>-------------------<br> 1100111000111000<br><br>Básicamente, agregamos una parte a la parte "superior" del resultado y la otra parte a la parte "inferior" del resultado. Es casi como empaquetar la información en otro tipo de dato - en otro formato. Visto de una forma general:<br><br> aaaaaaaa00000000<br>OR 00000000bbbbbbbb<br>-------------------<br> aaaaaaaabbbbbbbb<br><br>donde 'a' y 'b' son cualesquier bits.<br><br>Te aconsejo que consultes el capítulo 18 de nuestro curso de C++, yendo a: <a href="http://c.conclase.net/curso/index.php?cap=018#inicio"
target="_blank">http://c.conclase.net/curso/index.php?cap=018#inicio</a><br><br><br>Espero que todo esto te aclare las dudas.<br><br>Steven<br><br><br>_______________________________________________<br>Lista de correo Cconclase <a ymailto="mailto:Cconclase@listas.conclase.net" href="mailto:Cconclase@listas.conclase.net">Cconclase@listas.conclase.net</a><br><a href="http://listas.conclase.net/mailman/listinfo/cconclase_listas.conclase.net" target="_blank">http://listas.conclase.net/mailman/listinfo/cconclase_listas.conclase.net</a><br>Bajas: <a href="http://listas.conclase.net/index.php?gid=2&mnu=FAQ" target="_blank">http://listas.conclase.net/index.php?gid=2&mnu=FAQ</a><br></div></div><div style="position: fixed; color: black; font-family: 'times new roman', 'new york', times, serif; font-size: 12pt; "></div>
</div><br>
</body></html>