text:
<?php
global $users, $torrents, $seeds, $leechers, $percent;
// $language['rtl']='rtl'; // if your language is  right to left then uncomment this line
$language['charset']='ISO-8859-1'; // uncomment this line with specific language charset if different than tracker's one
$language['ACCOUNT_CONFIRM']='Confirmación de cuenta de '.$SITENAME.'.';
$language['ACCOUNT_CONGRATULATIONS']='Tu cuenta ha sido validada!
Ahora puedes logearte en la web usando tu cuenta.';
$language['ACCOUNT_CREATE']='Crear Cuenta';
$language['ACCOUNT_DELETE']='Eliminar Cuenta';
$language['ACCOUNT_DETAILS']='Detalles de la cuenta';
$language['ACCOUNT_EDIT']='Editar cuenta';
$language['ACCOUNT_MGMT']='Administrar cuenta';
$language['ACCOUNT_MSG']='Hola,'."\n\n".'Este email ha sido enviado porque alguien se ha registrado en nuestra web.'."\n".'Si crees que es una equivocación ignora este email, sino confirma la cuenta.'."\n\n".'Un saludo del equipo.';
$language['ACTION']='Action';
$language['ACTIVATED']='Activo';
$language['ACTIVE']='Estado';
$language['ACTIVE_ONLY']='Sólo Activos';
$language['ADD']='Añadir';
$language['ADDED']='Añadidos';
$language['ADMIN_CPANEL']='Administración';
$language['ADMINCP_NOTES']='Aquí puedes configurar tu tracker...';
$language['ALL']='Todos';
$language['ALL_SHOUT']='Todos los mensajes';
$language['ANNOUNCE_URL']='URL del announce del Tracker:';
$language['ANONYMOUS']='Anónimo';
$language['ANSWER']='Respuesta';
$language['AUTHOR']='Autor';
$language['AVATAR_URL']='Avatar (url): ';
$language['AVERAGE']='Promedio';
$language['BACK']='Volver';
$language['BAD_ID']='ID erronea!';
$language['BCK_USERCP']='Volver al panel de control';
$language['BLOCK']='Bloquear';
$language['BODY']='Cuerpo';
$language['BOTTOM']='Pie de página';
$language['BY']='Por';
$language['CANT_DELETE_ADMIN']='No se puede eliminar a un admin!';
$language['CANT_DELETE_NEWS']='No estas autorizado para eliminar noticias!';
$language['CANT_DELETE_TORRENT']='No estas autorizado para eliminar este torrent!...';
$language['CANT_DELETE_USER']='No estas autorizado para eliminar usuarios!';
$language['CANT_DO_QUERY']='No se puede establecer contacto con el servidor SQL - ';
$language['CANT_EDIT_TORR']='No estas autorizado a editar torrents!';
$language['CANT_FIND_TORRENT']='No se encuentra el torrent!';
$language['CANT_READ_LANGUAGE']='No se puede leer el archivo de idioma!';
$language['CANT_SAVE_CONFIG']='No se puede guardar la configuración en el archivo config.php';
$language['CANT_SAVE_LANGUAGE']='No se ha podido guardar el archivo de idioma';
$language['CANT_WRITE_CONFIG']='Atención: no se puede escribir en config.php!';
$language['CATCHUP']='Marcar todos como leidos';
$language['CATEGORY']='Cat.';
$language['CATEGORY_FULL']='Categoria';
$language['CENTER']='centro';
$language['CHANGE_PID']='Cambiar PID';
$language['CHARACTERS']='characters';
$language['CHOOSE']='Elije';
$language['CHOOSE_ONE']='Elije uno';
$language['CLICK_HERE']='click aquí';
$language['CLOSE']='cerrar';
$language['COMMENT']='Com.';
$language['COMMENT_1']='Comentario';
$language['COMMENT_PREVIEW']='Vista preliminar';
$language['COMMENTS']='Comentarios';
$language['CONFIG_SAVED']='Enhorabuena, la nueva configuración se ha guardado correctamente!';
$language['COUNTRY']='País';
$language['CURRENT_DETAILS']='Detalles actuales';
$language['DATABASE_ERROR']='Error en la base de datos.';
$language['DATE']='Fecha';
$language['DB_ERROR_REQUEST']='Error en la base de datos. No se puede completar la petición.';
$language['DB_SETTINGS']='Parametros de la base de datos';
$language['DEAD_ONLY']='Sólo inactivos';
$language['DELETE']='Eliminar';
$language['DELETE_ALL_READED']='Eliminar todos los leidos';
$language['DELETE_CONFIRM']='Estas seguro de querer eliminarlo?';
$language['DELETE_TORRENT']='Eliminar Torrent';
$language['DELFAILED']='No se pudo eliminar';
$language['DESCRIPTION']='Descripción';
$language['DONT_NEED_CHANGE']='No es necesario cambiar estos parametros!';
$language['DOWN']='Dl';
$language['DOWNLOAD']='Descargar';
$language['DOWNLOAD_TORRENT']='Descargar Torrent';
$language['DOWNLOADED']='Descargados';
$language['EDIT']='Editar';
$language['EDIT_LANGUAGE']='Editar Idioma';
$language['EDIT_POST']='Editar Post';
$language['EDIT_TORRENT']='Editar Torrent';
$language['EMAIL']='Email';
$language['EMAIL_SENT']='Se te ha enviado un email
haz click en la url del email para verificar tu cuenta.';
$language['EMAIL_VERIFY']='Email actualizado en '.$SITENAME;
$language['EMAIL_VERIFY_BLOCK']='Email de Verificación enviado';
$language['EMAIL_VERIFY_MSG']='Hola,'."\n\n".'Este email ha sido enviado porque has realizado un cambio de email, cliquea en el link para completar el cambio.'."\n\n".'Un saludo.';
$language['EMAIL_VERIFY_SENT1']='
Un email de verificación se ha enviado a:

';
$language['EMAIL_VERIFY_SENT2']='

Necesitas hacer click en el link del email para
 actualizar tu email. El email te llegará en unos 10 minutos
). Es posible que te llegue a la carpeta de Spam.

';
$language['ERR_500']='HTTP/1.0 500 Acceso no autorizado!';
$language['ERR_AVATAR_EXT']='Solo archivos gif,jpg,bmp or png';
$language['ERR_BAD_LAST_POST']='';
$language['ERR_BAD_NEWS_ID']='ID de noticia erroneo!';
$language['ERR_BODY_EMPTY']='El mensaje no puede quedar vacio!';
$language['ERR_CANT_CONNECT']='No se puede conectar al servidor MySQL';
$language['ERR_CANT_OPEN_DB']='No se puede abrir la base de datos';
$language['ERR_DB_ERR']='Error en la DB. Contacta con un administrador.';
$language['ERR_DELETE_POST']='Eliminar post. Comprobar salud: Estas a punto de eliminar un post. Click';
$language['ERR_DELETE_TOPIC']='Eliminar topic. Comprobar salud: Estas a punto de eliminar un topic. Click';
$language['ERR_EMAIL_ALREADY_EXISTS']='El Email ya existe en la base de datos!';
$language['ERR_EMAIL_NOT_FOUND_1']='Dirección Email';
$language['ERR_EMAIL_NOT_FOUND_2']='no ha sido encontrado en la base de datos.';
$language['ERR_ENTER_NEW_TITLE']='Debes poner un nuevo titulos!';
$language['ERR_FORUM_NOT_FOUND']='El foro no se ha encontrado';
$language['ERR_FORUM_UNKW_ACT']='Error del Foro: Acción desconocida';
$language['ERR_GUEST_EXISTS']='"Guest" es un usuario restringido. No puedes registrarte como "Guest"';
$language['ERR_IMAGE_CODE']='El código de seguridad no coincide';
$language['ERR_INS_TITLE_NEWS']='Debes escribir el títulos y la noticia';
$language['ERR_INV_NUM_FIELD']='Campo numérico invalido';
$language['ERR_INVALID_CLIENT_EVENT']='Evento invalido.';
$language['ERR_INVALID_INFO_BT_CLIENT']='Información del cliente BitTorrent invalida';
$language['ERR_INVALID_IP_NUMB']='Dirección IP invalida. Debe ser en decimal punteado (hostnames no permitidas)';
$language['ERR_LEVEL']='Lo sentimos, tu nivel ';
$language['ERR_LEVEL_CANT_POST']='No se te permite postear en este foro.';
$language['ERR_LEVEL_CANT_VIEW']='No se te permite ver este topic.';
$language['ERR_MISSING_DATA']='Falta información!';
$language['ERR_MUST_BE_LOGGED_SHOUT']='Debes estar logeado para escribir...';
$language['ERR_NO_BODY']='Cuerpo sin texto';
$language['ERR_NO_NEWS_ID']='ID de la noticia no encontrado!';
$language['ERR_NO_POST_WITH_ID']='No puedes postear sin identificarte ';
$language['ERR_NO_SPACE']='Tu usuario no puede contener espacios, corrigelo con _ eg:

';
$language['ERR_NO_TOPIC_ID']='No se ha devuelto el ID del topic';
$language['ERR_NO_TOPIC_POST_ID']='No se ha encontrado topics con el ID del post';
$language['ERR_NOT_AUTH']='No estas autorizado!';
$language['ERR_NOT_FOUND']='No encontrado...';
$language['ERR_NOT_PERMITED']='No permitido';
$language['ERR_PASS_LENGTH']='La contraseña debe tener 4 caracteres como mínimo.';
$language['ERR_PASSWORD_INCORRECT']='Contraseña Incorrecta';
$language['ERR_PERM_DENIED']='Acceso denegado';
$language['ERR_PID_NOT_FOUND']='Vuelve a descargar el torrent. El sistema PID esta activo y no se ha encontrado el PID del torrent';
$language['ERR_RETR_DATA']='Error al intentar recuperar los datos!';
$language['ERR_SEND_EMAIL']='No se ha podido enviar el email. Contacta con la administración.';
$language['ERR_SERVER_LOAD']='El Servidor esta sobrecargado en este momento. Reintentado, espera...';
$language['ERR_SPECIAL_CHAR']='Tu nombre de usuario no puede contener caracteres especiales como:

* ? < > @ $ & % etc.
';
$language['ERR_SQL_ERR']='Error SQL';
$language['ERR_SUBJECT']='Debes poner un asunto.';
$language['ERR_TOPIC_ID_NA']='El ID del topic es N/A';
$language['ERR_TOPIC_LOCKED']='Topic Cerrado';
$language['ERR_TORRENT_IN_BROWSER']='Este archivo es para clientes BitTorrent.';
$language['ERR_UPDATE_USER']='No se ha podido actualizar los datos del usuario. Contacta con un administrador.';
$language['ERR_USER_ALREADY_EXISTS']='Ya existe un usuario con este nick!';
$language['ERR_USER_NOT_FOUND']='Usuario no encontrado';
$language['ERR_USER_NOT_USER']='No estas autorizado a acceder al panel de otro usuario!';
$language['ERR_USERNAME_INCORRECT']='Usuario incorrecto';
$language['ERROR']='Error';
$language['ERROR_ID']='Error ID';
$language['FACOLTATIVE']='opcional';
$language['FILE']='Archivo';
$language['FILE_CONTENTS']='Contenido del torrent';
$language['FILE_NAME']='Nombre de archivo';
$language['FIND_USER']='Buscar usuario';
$language['FINISHED']='Finalizado';
$language['FORUM']='Foro';
$language['FORUM_ERROR']='Error en el foro';
$language['FORUM_INFO']='Información del foro';
$language['FORUM_MIN_CREATE']='Min Class Create';
$language['FORUM_MIN_READ']='Min Class Read';
$language['FORUM_SEARCH']='Buscar';
$language['FORUM_N_TOPICS']='N. Topics';
$language['FORUM_N_POSTS']='N. Posts';
$language['FRM_DELETE']='Eliminar';
$language['FRM_LOGIN']='Logear';
$language['FRM_PREVIEW']='Previsualizar';
$language['FRM_REFRESH']='Actualizar';
$language['FRM_RESET']='Resetear';
$language['FRM_SEND']='Enviar';
$language['FRM_CONFIRM']='Confirmar';
$language['FRM_CANCEL']='Cancelar';
$language['FRM_CLEAN']='Limpiar';
$language['GLOBAL_SERVER_LOAD']='Carga global del servidor (Todas las webs en el servidor)';
$language['GO']='Ir';
$language['GROUP']='Grupo';
$language['GUEST']='Invitado';
$language['GUESTS']='Invitados';
$language['HERE']='aquí';
$language['HISTORY']='Historia';
$language['HOME']='Portada';
$language['IF_YOU_ARE_SURE']='si estas seguro.';
$language['IM_SURE']='Estoy seguro';
$language['IN']='en';
$language['INF_CHANGED']='Información actualizada!';
$language['INFINITE']='Inf.';
$language['INFO_HASH']='Info Hash';
$language['INS_NEW_PWD']='Escribe la nueva contraseña!';
$language['INS_OLD_PWD']='Escribe la contraseña antigua!';
$language['INSERT_DATA']='Escribe toda la información necesaria para subir el archivo.';
$language['INSERT_NEW_FORUM']='Inserta el nuevo foro';
$language['INVALID_ID']='No es una ID valida!';
$language['INVALID_INFO_HASH']='Valor invalido del hash.';
$language['INVALID_PID']='PID Invalido';
$language['INVALID_TORRENT']='Error del Tracker: torrent invalido';
$language['KEYWORDS']='Palabras clave';
$language['LAST_EXTERNAL']='La última actualización externa de torrents se hizo el ';
$language['LAST_NEWS']='Últimas noticias';
$language['LAST_POST_BY']='Último post por';
$language['LAST_SANITY']='El último test de salud se hizo el ';
$language['LAST_TORRENTS']='Últimos Torrents';
$language['LAST_UPDATE']='Última actualización';
$language['LASTPOST']='Último post';
$language['LEECHERS']='leechers';
$language['LEFT']='izquierda';
$language['LOGIN']='Logear';
$language['LOGOUT']='Salir';
$language['MAILBOX']='Buzón';
$language['MANAGE_NEWS']='Administrar noticias';
$language['MEMBER']='Usuario';
$language['MEMBERS']='Usuarios';
$language['MEMBERS_LIST']='Listado de usuarios';
$language['MINIMUM_100_DOWN']='(más de 100 MB descargados)';
$language['MINIMUM_5_LEECH']='con un mínimo de 5 leechers, no incluidos torrents inactivos';
$language['MINIMUM_5_SEED']='con un mínimo de 5 semillas';
$language['MKTOR_INVALID_HASH']='makeTorrent: Recibió un Hash invalido';
$language['MNU_ADMINCP']='Panel de Administración';
$language['MNU_FORUM']='Foro';
$language['MNU_INDEX']='Portada';
$language['MNU_MEMBERS']='Miembros';
$language['MNU_NEWS']='Noticias';
$language['MNU_STATS']='Estadísticas';
$language['MNU_TORRENT']='Torrents';
$language['MNU_UCP_CHANGEPWD']='Cambiar contraseña';
$language['MNU_UCP_HOME']='Panel de control';
$language['MNU_UCP_IN']='Mensajes recibidos';
$language['MNU_UCP_INFO']='Cambiar perfil';
$language['MNU_UCP_NEWPM']='Nuevo mensaje privado';
$language['MNU_UCP_OUT']='Mensajes enviados';
$language['MNU_UCP_PM']='Tus mensajes privados';
$language['MNU_UPLOAD']='Subir';
$language['MORE_SMILES']='Más Emoticonos';
$language['MORE_THAN']='Mas de ';
$language['MORE_THAN_2']='item encontrado, mostrando primero';
$language['NA']='N/A';
$language['NAME']='Nombre';
$language['NEED_COOKIES']='Nota: Necesitas activar las cookies para logearte.';
$language['NEW_COMMENT']='Escribe el comentario...';
$language['NEW_COMMENT_T']='Nuevo comentario';
$language['NEWS']='las noticias';
$language['NEWS_DESCRIPTION']='Noticias:';
$language['NEWS_INSERT']='Escribe la noticia:';
$language['NEWS_PANEL']='Panel de noticias';
$language['NEWS_TITLE']='Título:';
$language['NEXT']='Siguiente';
$language['NO']='No';
$language['NO_BANNED_IPS']='No hay IPs baneadas';
$language['NO_COMMENTS']='Sin comentarios...';
$language['NO_FORUMS']='No se han encontrado foros!';
$language['NO_MAIL']='no tienes nuevos mensajes.';
$language['NO_MESSAGES']='No hay mensajes privados...';
$language['NO_NEWS']='no hay noticias';
$language['NO_PEERS']='No hay peers';
$language['NO_RECORDS']='La lista esta vacia...';
$language['NO_TOPIC']='No se han encontrado topics';
$language['NO_TORR_UP_USER']='El usuario no ha subido torrents';
$language['NO_TORRENTS']='No hay torrents...';
$language['NO_USERS_FOUND']='No se han encontrado usuarios!';
$language['NOBODY_ONLINE']='Nadie online';
$language['NONE']='Ninguno';
$language['NOT_ADMIN_CP_ACCESS']='No estas autorizado a acceder al panel de administración!';
$language['NOT_ALLOW_DOWN']='no se permiten descargas desde';
$language['NOT_AUTH_DOWNLOAD']='No estas autorizado a descargar.';
$language['NOT_AUTH_VIEW_NEWS']='No tienes permiso para leer noticias!';
$language['NOT_AUTHORIZED']='No tienes permiso para ver el';
$language['NOT_AUTHORIZED_UPLOAD']='No tienes permiso para subir!';
$language['NOT_AVAILABLE']='N/A';
$language['NOT_MAIL_IN_URL']='Este no es el email que esta en esta url';
$language['NOT_POSS_RESET_PID']='No se puede resetear tu PID!
Contacta con un admin...';
$language['NOW_LOGIN']='Ahora se te pedira para logearte';
$language['NUMBER_SHORT']='#';
$language['OLD_PWD']='Contraseña antigua';
$language['ONLY_REG_COMMENT']='Solos usuarios registrados pueden enviar comentarios!';
$language['OPT_DB_RES']='Resultado de la optimización de la BD';
$language['OPTION']='Opcion';
$language['PASS_RESET_CONF']='confirmación del reset de la contraseña';
$language['PEER_CLIENT']='Cliente';
$language['PEER_COUNTRY']='País';
$language['PEER_ID']='Peer ID';
$language['PEER_LIST']='Lista de Peers';
$language['PEER_PORT']='Puerto';
$language['PEER_PROGRESS']='Progreso';
$language['PEER_STATUS']='Estado';
$language['PEERS']='peers';
$language['PEERS_DETAILS']='Click aqui para ver los detalles de los peers';
$language['PICTURE']='Imagen';
$language['PID']='PID';
$language['PLEASE_WAIT']='Espere...';
$language['PM']='MP';
$language['POSITION']='Posición';
$language['POST_REPLY']='Contestar';
$language['POSTED_BY']='Enviado por';
$language['POSTED_DATE']='Enviado el';
$language['POSTS']='Posts';
$language['POSTS_PER_DAY']='%s posts por dia';
$language['POSTS_PER_PAGE']='Posts por página';
$language['PREVIOUS']='Anterior.';
$language['PRIVATE_MSG']='Mensaje privado';
$language['PWD_CHANGED']='Contraseña cambiada!';
$language['QUESTION']='Pregunta';
$language['QUICK_JUMP']='Salto rapido';
$language['QUOTE']='Citar';
$language['RANK']='Rank';
$language['RATIO']='Ratio';
$language['REACHED_MAX_USERS']='Número maximo de usuarios';
$language['READED']='Leido';
$language['RECEIVER']='Recibidos';
$language['RECOVER_DESC']='Use the form below to have your password reset and your account details mailed back to you.
(You will have to reply to a confirmation email.)';
$language['RECOVER_PWD']='Recuperar contraseña';
$language['RECOVER_TITLE']='Recuperar usuario/contraseña perdida';
$language['REDIRECT']='si tu explorador no tiene javascript activado haz click aqui';
$language['REDIRECT2']='si tu explorador no tiene javascript activado haz click aqui.';
$language['REDOWNLOAD_TORR_FROM']='volver a descargar el torrent desde';
$language['REGISTERED']='Registrado';
$language['REGISTERED_EMAIL']='Email registrado';
$language['REMOVE']='Eliminar';
$language['REPLIES']='Respuestas';
$language['REPLY']='Responder';
$language['RESULT']='Resultado';
$language['RETRY']='Reintentar';
$language['RETURN_TORRENTS']='Volver al listado de torrents';
$language['REVERIFY_CONGRATS1']='
Tu email se ha verificado y actualizado

Desde: ';
$language['REVERIFY_CONGRATS2']='
a: ';
$language['REVERIFY_CONGRATS3']='

';
$language['REVERIFY_FAILURE']='
Esta url no es valida

Un número es generado cada vez que intentas cambiar tu email
si ves este mensaje, es que has intentado cambiar tu email
mas de una vez y estas usando una url caducada.

Espera hasta que estes seguro de haber recibido el nuevo
email de verificación antes de intentar cambiar tu email de nuevo.

';
$language['REVERIFY_MSG']='Si intentas cambiar tu email se te enviará un link al email para verificar tu nuevo email.

Tu dirección de email no sera actualizada hasta que verifiques la nueva.';
$language['RIGHT']='derecho';
$language['SEARCH']='Buscar';
$language['SEEDERS']='seeds';
$language['SEEN']='Seen';
$language['SELECT']='Seleccionar...';
$language['SENDER']='Remitente';
$language['SENT_ERROR']='Error al enviar';
$language['SHORT_C']='C'; //Shortname for Completed
$language['SHORT_L']='L'; //Shortname for Leechers
$language['SHORT_S']='S'; //Shortname for Seeders
$language['SHOUTBOX']='Mensajero';
$language['SIZE']='Tamaño';
$language['SORRY']='Perdona';
$language['SORTID']='Sortid';
$language['SPEED']='Velocidad';
$language['STICKY']='Sticky';
$language['SUB_CATEGORY']='Sub-Categoria';
$language['SUBJECT']='Asunto';
$language['SUBJECT_MAX_CHAR']='El asunto esta limitado a ';
$language['SUC_POST_SUC_EDIT']='Post editado correctamente.';
$language['SUC_SEND_EMAIL']='Un email de confirmación se ha enviado a';
$language['SUC_SEND_EMAIL_2']='Espera unos segundos a que llegue el email.';
$language['SUCCESS']='Enviado';
$language['SUMADD_BUG']='Tracker bug calling summaryAdd';
$language['TABLE_NAME']='Nombre de tabla';
$language['TIMEZONE']='Zona horaria';
$language['TITLE']='Título';
$language['TOP']='top';
$language['TOP_10_ACTIVE']='10 Torrents más activos';
$language['TOP_10_BEST_SEED']='10 Torrents Mejor sedeados';
$language['TOP_10_BSPEED']='10 Torrents con mejor velocidad';
$language['TOP_10_DOWNLOAD']='Top 10 Downloaders';
$language['TOP_10_SHARE']='Top 10 Mejores Compartidos';
$language['TOP_10_UPLOAD']='Top 10 Uploaders';
$language['TOP_10_WORST']='Top 10 Peores Compartidos';
$language['TOP_10_WORST_SEED']='10 Torrents Peor Sedeados';
$language['TOP_10_WSPEED']='10 Torrents con peor velocidad';
$language['TOP_TORRENTS']='Torrents más populares';
$language['TOPIC']='Topic';
$language['TOPICS']='Topics';
$language['TOPICS_PER_PAGE']='Topics por pagina';
$language['TORR_PEER_DETAILS']='Detalles de los peers';
$language['TORRENT']='Torrent';
$language['TORRENT_ANONYMOUS']='Enviar como anonimo';
$language['TORRENT_CHECK']='Permitir recoger información desde el archivo.';
$language['TORRENT_DETAIL']='Detalles del torrent';
$language['TORRENT_FILE']='Archivo Torrent';
$language['TORRENT_SEARCH']='Buscar torrents';
$language['TORRENT_STATUS']='Estado';
$language['TORRENT_UPDATE']='Actualizando, espere...';
$language['TORRENTS']='torrents';
$language['TORRENTS_PER_PAGE']='Torrents por pagina';
$language['TRACK_DB_ERR']='Tracker/database error. Los detalles estan en el log de errores.';
$language['TRACKER_INFO']=$users.' usuarios, tracking '.$torrents.' torrents ('.$seeds.' seeds, '.$leechers.' leechers, '.$percent.'%)';
$language['TRACKER_LOAD']='Carga del Tracker';
$language['TRACKER_SETTINGS']='Configuración del Tracker';
$language['TRACKER_STATS']='Estadisticas del Tracker';
$language['TRACKING']='tracking';
$language['TRAFFIC']='Trafico';
$language['UCP_NOTE_1']='Aquí puedes ver tus mensajes o enviar mensajes a otros usuarios,';
$language['UCP_NOTE_2']='Modifica tus ajustes.';
$language['UNAUTH_IP']='IP no autorizada.';
$language['UNKNOWN']='desconocido';
$language['UPDATE']='Actualizar';
$language['UPFAILED']='Actualización fallida';
$language['UPLOAD_IMAGE']='Subir imagen';
$language['UPLOAD_LANGUAGE_FILE']='Subir archivo de idioma';
$language['UPLOADED']='Subido';
$language['UPLOADER']='Uploader';
$language['UPLOADS']='Subidos';
$language['URL']='URL';
$language['USER']='Usuario';
$language['USER_CP']='Mi Panel';
$language['USER_CP_1']='Panel de Control de usuarios';
$language['USER_DETAILS']='Detalles de usuario';
$language['USER_EMAIL']='Email valido';
$language['USER_ID']='ID de usuario';
$language['USER_JOINED']='Registrado el';
$language['USER_LASTACCESS']='Último acceso';
$language['USER_LEVEL']='Rank';
$language['USER_LOCAL_TIME']='Horario local del usuario';
$language['USER_NAME']='Usuario';
$language['USER_PASS_RECOVER']='Recuperar usuario/contraseña';
$language['USER_PWD']='Contraseña';
$language['USERS_SEARCH']='Buscar usuarios';
$language['VIEW_DETAILS']='Ver detalles';
$language['VIEW_TOPIC']='Ver topic';
$language['VIEW_UNREAD']='Ver sin leidos';
$language['VIEWS']='Vistas';
$language['VISITOR']='Visitante';
$language['VISITORS']='Visitantes';
$language['WAIT_ADMIN_VALID']='Debes esperar la validación del administrador...';
$language['WARNING']='Atención!';
$language['WELCOME']='Bienvenid@';
$language['WELCOME_ADMINCP']='Bienvenid@ al Panel de Administración';
$language['WELCOME_BACK']='Bienvenid@ de nuevo';
$language['WELCOME_UCP']='Bienvenid@ al Panel de Usuarios';
$language['WORD_AND']='y';
$language['WORD_NEW']='Nuevo';
$language['WROTE']='escribio';
$language['WT']='WT';
$language['X_TIMES']='veces';
$language['YES']='Si';
$language['LAST_IP']='Última IP';
$language['FIRST_UNREAD']='Ir al primer post sin leer';
$language['MODULE_UNACTIVE']='El módulo requerido no esta activo!';
$language['MODULE_NOT_PRESENT']='El módulo requerido no existe!';
$language['MODULE_LOAD_ERROR']='El módulo requerido parece estar corrupto!';
?>


text:
package brooklyn.util.javalang;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.Arrays;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import brooklyn.util.text.Strings;

import com.google.common.collect.ImmutableSet;

/**
 * Utility class for cleaning up stacktraces.
 */
public class StackTraceSimplifier {

    private static final Logger log = LoggerFactory.getLogger(StackTraceSimplifier.class);

    /** comma-separated prefixes (not regexes) */
    public static final String DEFAULT_BLACKLIST_SYSTEM_PROPERTY_NAME = "brooklyn.util.javalang.StackTraceSimplifier.blacklist";

    /** @deprecated since 0.6.0 use {@link #DEFAULT_BLACKLIST_SYSTEM_PROPERTY_NAME} */ @Deprecated
    public static final String LEGACY_DEFAULT_BLACKLIST_SYSTEM_PROPERTY_NAME = "groovy.sanitized.stacktraces";

    private static final Collection<String> DEFAULT_BLACKLIST;

    static {
        ImmutableSet.Builder<String> blacklist = ImmutableSet.builder();
        blacklist.addAll(Arrays.asList(
                System.getProperty(DEFAULT_BLACKLIST_SYSTEM_PROPERTY_NAME,
                        "java.," +
                        "javax.," +
                        "sun.," +
                        "groovy.," +
                        "org.codehaus.groovy.," +
                        "gjdk.groovy.,"
                    ).split("(\\s|,)+")));

        String legacyDefaults = System.getProperty(LEGACY_DEFAULT_BLACKLIST_SYSTEM_PROPERTY_NAME);
        if (Strings.isNonBlank(legacyDefaults)) {
            log.warn("Detected ude of legacy system property "+LEGACY_DEFAULT_BLACKLIST_SYSTEM_PROPERTY_NAME);
            blacklist.addAll(Arrays.asList(legacyDefaults.split("(\\s|,)+")));
        }

        DEFAULT_BLACKLIST = blacklist.build();
    }

    private static final StackTraceSimplifier DEFAULT_INSTACE = newInstance();

    private final Collection<String> blacklist;

    protected StackTraceSimplifier() {
        this(true);
    }

    protected StackTraceSimplifier(boolean includeDefaultBlacklist, String ...packages) {
        ImmutableSet.Builder<String> blacklistB = ImmutableSet.builder();
        if (includeDefaultBlacklist)
            blacklistB.addAll(DEFAULT_BLACKLIST);
        blacklistB.add(packages);
        blacklist = blacklistB.build();
    }

    public static StackTraceSimplifier newInstance() {
        return new StackTraceSimplifier();
    }

    public static StackTraceSimplifier newInstance(String ...additionalBlacklistPackagePrefixes) {
        return new StackTraceSimplifier(true, additionalBlacklistPackagePrefixes);
    }

    public static StackTraceSimplifier newInstanceExcludingOnly(String ...blacklistPackagePrefixes) {
        return new StackTraceSimplifier(false, blacklistPackagePrefixes);
    }

    /** @return whether the given element is useful, that is, not in the blacklist */
    public boolean isUseful(StackTraceElement el) {
        for (String s: blacklist){
            if (el.getClassName().startsWith(s)) return false;;
            // gets underscores in some contexts ?
            if (el.getClassName().replace('_', '.').startsWith(s)) return false;
        }

        return true;
    }

    /** @return new list containing just the {@link #isUseful(StackTraceElement)} stack trace elements */
    public List<StackTraceElement> clean(Iterable<StackTraceElement> st) {
        List<StackTraceElement> result = new LinkedList<StackTraceElement>();
        for (StackTraceElement element: st){
            if (isUseful(element)){
                result.add(element);
            }
        }

        return result;
    }

    /** @return new array containing just the {@link #isUseful(StackTraceElement)} stack trace elements */
    public StackTraceElement[] clean(StackTraceElement[] st) {
        List<StackTraceElement> result = clean(Arrays.asList(st));
        return result.toArray(new StackTraceElement[result.size()]);
    }

    /** @return first {@link #isUseful(StackTraceElement)} stack trace elements, or null */
    public StackTraceElement firstUseful(StackTraceElement[] st) {
        return nthUseful(0, st);
    }

    /** @return (n+1)th {@link #isUseful(StackTraceElement)} stack trace elements (ie 0 is {@link #firstUseful(StackTraceElement[])}), or null */
    public StackTraceElement nthUseful(int n, StackTraceElement[] st) {
        for (StackTraceElement element: st){
            if (isUseful(element)) {
                if (n==0)
                    return element;
                n--;
            }
        }
        return null;
    }

    /** {@link #clean(StackTraceElement[])} the given throwable instance, returning the same instance for convenience */
    public <T extends Throwable> T cleaned(T t) {
        t.setStackTrace(clean(t.getStackTrace()));
        return t;
    }

    // ---- statics

    /** static convenience for {@link #isUseful(StackTraceElement)} */
    public static boolean isStackTraceElementUseful(StackTraceElement el) {
        return DEFAULT_INSTACE.isUseful(el);
    }

    /** static convenience for {@link #clean(Iterable)} */
    public static List<StackTraceElement> cleanStackTrace(Iterable<StackTraceElement> st) {
        return DEFAULT_INSTACE.clean(st);
    }

    /** static convenience for {@link #clean(StackTraceElement[])} */
    public static StackTraceElement[] cleanStackTrace(StackTraceElement[] st) {
        return DEFAULT_INSTACE.clean(st);
    }

    /** static convenience for {@link #cleaned(Throwable)} */
    public static <T extends Throwable> T cleanedStackTrace(T t) {
        return DEFAULT_INSTACE.cleaned(t);
    }

    public static String toString(Throwable t) {
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        t.printStackTrace(pw);
        return sw.getBuffer().toString();
    }

}

redpajama_set_name: RedPajamaGithub


text:
package org.apache.ignite.ml.dataset.primitive.builder.data;

import java.io.Serializable;
import java.util.Iterator;
import org.apache.ignite.ml.dataset.PartitionDataBuilder;
import org.apache.ignite.ml.dataset.UpstreamEntry;
import org.apache.ignite.ml.dataset.primitive.data.SimpleDatasetData;
import org.apache.ignite.ml.environment.LearningEnvironment;
import org.apache.ignite.ml.math.exceptions.preprocessing.NonDoubleVectorException;
import org.apache.ignite.ml.math.primitives.vector.Vector;
import org.apache.ignite.ml.preprocessing.Preprocessor;

/**
 * A partition {@code data} builder that makes {@link SimpleDatasetData}.
 *
 * @param <K> Type of a key in <tt>upstream</tt> data.
 * @param <V> Type of a value in <tt>upstream</tt> data.
 * @param <C> Type of a partition <tt>context</tt>.
 * @param <CO> Type of a coordinate for vectorizer.
 */
public class SimpleDatasetDataBuilder<K, V, C extends Serializable, CO extends Serializable>
    implements PartitionDataBuilder<K, V, C, SimpleDatasetData> {
    /** */
    private static final long serialVersionUID = 756800193212149975L;

    /** Function that extracts features from an {@code upstream} data. */
    private final Preprocessor<K, V> preprocessor;

    /**
     * Construct a new instance of partition {@code data} builder that makes {@link SimpleDatasetData}.
     *
     * @param preprocessor Function that extracts features from an {@code upstream} data.
     */
    public SimpleDatasetDataBuilder(Preprocessor<K, V> preprocessor) {
        this.preprocessor = preprocessor;
    }

    /** {@inheritDoc} */
    @Override public SimpleDatasetData build(
        LearningEnvironment env,
        Iterator<UpstreamEntry<K, V>> upstreamData, long upstreamDataSize, C ctx) {
        // Prepares the matrix of features in flat column-major format.
        int cols = -1;
        double[] features = null;

        int ptr = 0;
        while (upstreamData.hasNext()) {
            UpstreamEntry<K, V> entry = upstreamData.next();
            Vector row = preprocessor.apply(entry.getKey(), entry.getValue()).features();
            if (row.isNumeric()) {
                if (cols < 0) {
                    cols = row.size();
                    features = new double[Math.toIntExact(upstreamDataSize * cols)];
                } else
                    assert row.size() == cols : "Feature extractor must return exactly " + cols + " features";

                for (int i = 0; i < cols; i++)
                    features[Math.toIntExact(i * upstreamDataSize + ptr)] = row.get(i);

                ptr++;
            } else
                throw new NonDoubleVectorException(row);
        }

        return new SimpleDatasetData(features, Math.toIntExact(upstreamDataSize));
    }
}


text:
describe ManageIQ::Providers::Azure::NumberOfVmsVisibilityService do
  context "class information" do
    it "is a subclass of DialogVisibilityService" do
      expect(described_class.new).to be_kind_of(NumberOfVmsVisibilityService)
    end
  end

  context "NumberOfVmsVisibilityService" do
    subject { described_class.new }

    it "has a reader method for number_of_vms" do
      expect(subject).to respond_to(:number_of_vms)
    end

    it "defaults to 1 for the number of vms" do
      expect(described_class.new.number_of_vms).to eql(1)
    end

    it "returns the expected value for determine_visibility" do
      expect(subject.determine_visibility(1, 'azure')).to be_kind_of(Hash)
      expect(subject.determine_visibility(2, 'azure')[:hide]).to_not include(:floating_ip_addresses)
    end
  end
end


text:
package com.socks.greendao;

// THIS CODE IS GENERATED BY greenDAO, DO NOT EDIT. Enable "keep" sections if you want to edit.
/**
 * Entity mapped to table PICTURE_CACHE.
 */
public class PictureCache {

    private Long id;
    private String result;
    private Integer page;
    private Long time;

    public PictureCache() {
    }

    public PictureCache(Long id) {
        this.id = id;
    }

    public PictureCache(Long id, String result, Integer page, Long time) {
        this.id = id;
        this.result = result;
        this.page = page;
        this.time = time;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getResult() {
        return result;
    }

    public void setResult(String result) {
        this.result = result;
    }

    public Integer getPage() {
        return page;
    }

    public void setPage(Integer page) {
        this.page = page;
    }

    public Long getTime() {
        return time;
    }

    public void setTime(Long time) {
        this.time = time;
    }

}


text:
from __future__ import unicode_literals

from django.db import migrations, models
import django.db.models.deletion

class Migration(migrations.Migration):

    initial = True

    dependencies = [
    ]

    operations = [
        migrations.CreateModel(
            name='Device',
            fields=[
                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                ('espID', models.CharField(max_length=200)),
                ('name', models.CharField(max_length=200)),
                ('online', models.BooleanField(default=False)),
            ],
        ),
        migrations.CreateModel(
            name='PWM',
            fields=[
                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                ('room', models.CharField(max_length=200)),
                ('topic', models.CharField(max_length=200)),
                ('name', models.CharField(max_length=200)),
                ('pretty_name', models.CharField(default='', max_length=200)),
                ('setting', models.IntegerField(default=0)),
                ('on', models.BooleanField(default=False)),
                ('channel', models.IntegerField(default=0)),
                ('device', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='esp.Device')),
            ],
        ),
        migrations.CreateModel(
            name='Switch',
            fields=[
                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                ('room', models.CharField(max_length=200)),
                ('topic', models.CharField(max_length=200)),
                ('name', models.CharField(max_length=200)),
                ('pretty_name', models.CharField(default='', max_length=200)),
                ('on', models.BooleanField(default=False)),
                ('channel', models.IntegerField(default=0)),
                ('device', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='esp.Device')),
                ('pwm', models.ManyToManyField(to='esp.PWM')),
            ],
        ),
    ]


text:
package com.azure.monitor.opentelemetry.exporter.implementation.pipeline;

import com.azure.core.http.HttpClient;
import com.azure.core.http.HttpHeaders;
import com.azure.core.http.HttpPipelineBuilder;
import com.azure.core.http.HttpRequest;
import com.azure.core.http.HttpResponse;
import com.azure.core.util.FluxUtil;
import com.azure.monitor.opentelemetry.exporter.implementation.MockHttpResponse;
import com.azure.monitor.opentelemetry.exporter.implementation.localstorage.LocalStorageTelemetryPipelineListener;
import com.azure.monitor.opentelemetry.exporter.implementation.models.TelemetryItem;
import com.azure.monitor.opentelemetry.exporter.implementation.utils.TestUtils;
import io.opentelemetry.sdk.common.CompletableResultCode;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Function;
import java.util.zip.GZIPInputStream;

import static org.assertj.core.api.Assertions.assertThat;

public class TelemetryItemExporterTest {

    private static final String CONNECTION_STRING =
        "InstrumentationKey=00000000-0000-0000-0000-0FEEDDADBEEF;IngestionEndpoint=http://foo.bar";
    private static final String REDIRECT_CONNECTION_STRING =
        "InstrumentationKey=11111111-0000-0000-0000-0FEEDDADBEEF;IngestionEndpoint=http://foo.bar";

    private static final String INSTRUMENTATION_KEY = "00000000-0000-0000-0000-0FEEDDADBEEF";
    private static final String REDIRECT_URL = "http://foo.bar.redirect";

    RecordingHttpClient recordingHttpClient;

    @TempDir
    File tempFolder;

    private TelemetryItemExporter getExporter() {
        HttpPipelineBuilder pipelineBuilder = new HttpPipelineBuilder().httpClient(recordingHttpClient);
        TelemetryPipeline telemetryPipeline = new TelemetryPipeline(pipelineBuilder.build());

        return new TelemetryItemExporter(
            telemetryPipeline,
            new LocalStorageTelemetryPipelineListener(50, tempFolder, telemetryPipeline, null, false));
    }

    private static String getRequestBodyString(Flux<ByteBuffer> requestBody) {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        byte[] compressed = FluxUtil.collectBytesInByteBufferStream(requestBody).block();
        int bufferSize = compressed.length;
        String requestBodyString = null;
        try {
            ByteArrayInputStream bis = new ByteArrayInputStream(compressed);
            GZIPInputStream gis = new GZIPInputStream(bis, bufferSize);
            StringBuilder sb = new StringBuilder();
            byte[] data = new byte[bufferSize];
            int bytesRead;
            while ((bytesRead = gis.read(data)) != -1) {
                sb.append(new String(data, 0, bytesRead, Charset.defaultCharset()));
            }
            bis.close();
            bos.close();
            gis.close();
            requestBodyString = new String(sb);
        } catch (IOException e) {
            // It's ok when this exception is thrown. The tests will fail. Added this comment to satisfy
            // style guide.
        }
        return requestBodyString;
    }

    @BeforeEach
    public void setup() {
        recordingHttpClient =
            new RecordingHttpClient(
                request -> {
                    if (request.getUrl().toString().contains(REDIRECT_URL)) {
                        return Mono.just(new MockHttpResponse(request, 200));
                    }
                    Flux<ByteBuffer> requestBody = request.getBody();
                    String requestBodyString = getRequestBodyString(requestBody);
                    if (requestBodyString != null && requestBodyString.contains(INSTRUMENTATION_KEY)) {
                        return Mono.just(new MockHttpResponse(request, 200));
                    }
                    Map<String, String> headers = new HashMap<>();
                    headers.put("Location", REDIRECT_URL);
                    HttpHeaders httpHeaders = new HttpHeaders(headers);
                    return Mono.just(new MockHttpResponse(request, 307, httpHeaders));
                });
    }

    @Test
    public void singleIkeyTest() {
        // given
        List<TelemetryItem> telemetryItems = new ArrayList<>();
        telemetryItems.add(TestUtils.createMetricTelemetry("metric" + 1, 1, CONNECTION_STRING));
        TelemetryItemExporter exporter = getExporter();

        // when
        CompletableResultCode completableResultCode = exporter.send(telemetryItems);

        // then
        assertThat(completableResultCode.isSuccess()).isEqualTo(true);
        assertThat(recordingHttpClient.getCount()).isEqualTo(1);
    }

    @Test
    public void dualIkeyTest() {
        // given
        List<TelemetryItem> telemetryItems = new ArrayList<>();
        telemetryItems.add(TestUtils.createMetricTelemetry("metric" + 1, 1, CONNECTION_STRING));
        telemetryItems.add(
            TestUtils.createMetricTelemetry("metric" + 2, 2, REDIRECT_CONNECTION_STRING));
        TelemetryItemExporter exporter = getExporter();

        // when
        CompletableResultCode completableResultCode = exporter.send(telemetryItems);

        // then
        assertThat(completableResultCode.isSuccess()).isEqualTo(true);
        assertThat(recordingHttpClient.getCount()).isEqualTo(3);
    }

    @Test
    public void singleIkeyBatchTest() {
        // given
        List<TelemetryItem> telemetryItems = new ArrayList<>();
        telemetryItems.add(TestUtils.createMetricTelemetry("metric" + 1, 1, CONNECTION_STRING));
        telemetryItems.add(TestUtils.createMetricTelemetry("metric" + 2, 2, CONNECTION_STRING));
        TelemetryItemExporter exporter = getExporter();

        // when
        CompletableResultCode completableResultCode = exporter.send(telemetryItems);

        // then
        assertThat(completableResultCode.isSuccess()).isEqualTo(true);
        assertThat(recordingHttpClient.getCount()).isEqualTo(1);
    }

    @Test
    public void dualIkeyBatchTest() {
        // given
        List<TelemetryItem> telemetryItems = new ArrayList<>();
        telemetryItems.add(TestUtils.createMetricTelemetry("metric" + 1, 1, CONNECTION_STRING));
        telemetryItems.add(TestUtils.createMetricTelemetry("metric" + 2, 2, CONNECTION_STRING));
        telemetryItems.add(
            TestUtils.createMetricTelemetry("metric" + 3, 3, REDIRECT_CONNECTION_STRING));
        telemetryItems.add(
            TestUtils.createMetricTelemetry("metric" + 4, 4, REDIRECT_CONNECTION_STRING));
        TelemetryItemExporter exporter = getExporter();

        // when
        CompletableResultCode completableResultCode = exporter.send(telemetryItems);

        // then
        assertThat(completableResultCode.isSuccess()).isEqualTo(true);
        assertThat(recordingHttpClient.getCount()).isEqualTo(3);
    }

    @Test
    public void dualIkeyBatchWithDelayTest() {
        // given
        List<TelemetryItem> telemetryItems = new ArrayList<>();
        telemetryItems.add(TestUtils.createMetricTelemetry("metric" + 1, 1, CONNECTION_STRING));
        telemetryItems.add(TestUtils.createMetricTelemetry("metric" + 2, 2, CONNECTION_STRING));
        telemetryItems.add(
            TestUtils.createMetricTelemetry("metric" + 3, 3, REDIRECT_CONNECTION_STRING));
        telemetryItems.add(
            TestUtils.createMetricTelemetry("metric" + 4, 4, REDIRECT_CONNECTION_STRING));
        TelemetryItemExporter exporter = getExporter();

        // when
        CompletableResultCode completableResultCode = exporter.send(telemetryItems);

        // then
        assertThat(completableResultCode.isSuccess()).isEqualTo(true);
        assertThat(recordingHttpClient.getCount()).isEqualTo(3);

        completableResultCode = exporter.send(telemetryItems);

        // then
        // the redirect url should be cached and should not invoke another redirect.
        assertThat(completableResultCode.isSuccess()).isEqualTo(true);
        assertThat(recordingHttpClient.getCount()).isEqualTo(5);
    }

    @Test
    public void dualIkeyBatchWithDelayAndRedirectFlagFalseTest() {
        // given
        List<TelemetryItem> telemetryItems = new ArrayList<>();
        telemetryItems.add(TestUtils.createMetricTelemetry("metric" + 1, 1, CONNECTION_STRING));
        telemetryItems.add(TestUtils.createMetricTelemetry("metric" + 2, 2, CONNECTION_STRING));
        telemetryItems.add(
            TestUtils.createMetricTelemetry("metric" + 3, 3, REDIRECT_CONNECTION_STRING));
        telemetryItems.add(
            TestUtils.createMetricTelemetry("metric" + 4, 4, REDIRECT_CONNECTION_STRING));
        TelemetryItemExporter exporter = getExporter();

        // when
        CompletableResultCode completableResultCode = exporter.send(telemetryItems);

        // then
        assertThat(completableResultCode.isSuccess()).isEqualTo(true);
        assertThat(recordingHttpClient.getCount()).isEqualTo(3);

        completableResultCode = exporter.send(telemetryItems);

        // then
        // the redirect url should be cached and should not invoke another redirect.
        assertThat(completableResultCode.isSuccess()).isEqualTo(true);
        assertThat(recordingHttpClient.getCount()).isEqualTo(5);
    }

    static class RecordingHttpClient implements HttpClient {

        private final AtomicInteger count = new AtomicInteger();
        private final Function<HttpRequest, Mono<HttpResponse>> handler;

        RecordingHttpClient(Function<HttpRequest, Mono<HttpResponse>> handler) {
            this.handler = handler;
        }

        @Override
        public Mono<HttpResponse> send(HttpRequest httpRequest) {
            count.getAndIncrement();
            return handler.apply(httpRequest);
        }

        int getCount() {
            return count.get();
        }
    }
}


text:
[![Build Status](https://travis-ci.org/wennergr/stensions.svg?branch=master)](https://travis-ci.org/wennergr/stensions)
[![Coverage Status](https://coveralls.io/repos/wennergr/stensions/badge.svg?branch=master)](https://coveralls.io/r/wennergr/stensions?branch=master)

Library with small and usefull extensions to the standard scala library.


text:
var express = require('express'),
    bodyParser = require('body-parser'),
    helpers = require('./helpers'),
    validate = require('../index.js').validate,
    SchemaError = require('jsonschema'),
    addSchemaProperties = require('../index.js').addSchemaProperties,
    app = express();

function clearBody(req, res, next) {
    delete req.body;
    next();
}

app.use(bodyParser.json());

addSchemaProperties({
    contains: function validateContains(instance, schema) {
        if (typeof instance !== 'string') {
            return;
        }
        if (typeof schema.contains !== 'string') {
            throw new SchemaError('"contains" expects a string', schema);
        }
        if (instance.indexOf(schema.contains) < 0) {
            return 'does not contain the string ' + JSON.stringify(schema.contains);
        }
    }
});

/********** Set up test routes  ********/

app.post('/user/', validate({body: helpers.getUserSchema()}), function(req, res) {
    res.json({
        id: '1234'
    });
});

app.post(
    '/api/user/',
    validate({
        body: helpers.getUserSchema(),
        query: helpers.getTokenSchema()
    }),
    function(req, res) {
        res.json({
            id: '1235'
        });
    }
);

app.post(
    '/user/empty_body/',
    clearBody,
    validate({body: helpers.getUserSchema()}),
    function(req, res) {
        res.json({
            id: '1236'
        });
    }
);

app.post(
    '/user/create_default',
    clearBody,
    validate({
        body: helpers.getUserSchema({
            required: false
        })
    }),
    function(req, res) {
        res.json({
            id: '1237'
        });
    }
);

app.post(
    '/user/split_schema/',
    validate({
        body: helpers.getUserSchema({
            properties: {
                address: {'$ref': '/AddressSchema'}
            }
        })
    }, [helpers.getAddressSchema()]),
    function(req, res) {
        res.json({
            id: '1337'
        });
    }
);

/****** Setup validation handler **************/

app.use(function(err, req, res, next) {
    if (err.name === 'JsonSchemaValidation') {
        res.status(400);
        res.json({
            statusText: 'Bad Request',
            validations: err.validations
        });
    } else {
        next(err);
    }
});

module.exports = app;


text:
namespace ServiceStack.Common.Web
{
    public static class HttpHeaders
    {
        public const string XParamOverridePrefix = "X-Param-Override-";

        public const string XHttpMethodOverride = "X-Http-Method-Override";

        public const string XUserAuthId = "X-UAId";

        public const string XForwardedFor = "X-Forwarded-For";

        public const string XRealIp = "X-Real-IP";

        public const string Referer = "Referer";

        public const string CacheControl = "Cache-Control";

        public const string IfModifiedSince = "If-Modified-Since";

        public const string LastModified = "Last-Modified";

        public const string Accept = "Accept";

        public const string AcceptEncoding = "Accept-Encoding";

        public const string ContentType = "Content-Type";

        public const string ContentEncoding = "Content-Encoding";

        public const string ContentLength = "Content-Length";

        public const string ContentDisposition = "Content-Disposition";

        public const string Location = "Location";

        public const string SetCookie = "Set-Cookie";

        public const string ETag = "ETag";

        public const string Authorization = "Authorization";

        public const string WwwAuthenticate = "WWW-Authenticate";

        public const string AllowOrigin = "Access-Control-Allow-Origin";

        public const string AllowMethods = "Access-Control-Allow-Methods";

        public const string AllowHeaders = "Access-Control-Allow-Headers";

        public const string AllowCredentials = "Access-Control-Allow-Credentials";
    }
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<!--
~   Licensed under the Apache License, Version 2.0 (the "License");
~   you may not use this file except in compliance with the License.
~   You may obtain a copy of the License at
~
~   http://www.apache.org/licenses/LICENSE-2.0
~
~   Unless required by applicable law or agreed to in writing, software
~   distributed under the License is distributed on an "AS IS" BASIS,
~   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
~   See the License for the specific language governing permissions and
~   limitations under the License.
-->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <artifactId>jdbi3-parent</artifactId>
        <groupId>org.jdbi</groupId>
        <version>3.20.2-SNAPSHOT</version>
    </parent>

    <artifactId>jdbi3-kotlin-sqlobject</artifactId>
    <name>jdbi3 SqlObject Kotlin plugin</name>

    <developers>
        <developer>
            <name>Matthew Hall</name>
            <url>https://github.com/qualidafial</url>
            <roles>
                <role>Project maintainer</role>
            </roles>
        </developer>
        <developer>
            <name>Jayson Minard</name>
            <url>https://github.com/apatrida</url>
            <roles>
                <role>Original project creator</role>
            </roles>
        </developer>
    </developers>

    <properties>
        <basepom.check.skip-spotbugs>true</basepom.check.skip-spotbugs>
        <moduleName>org.jdbi.v3.sqlobject.kotlin</moduleName>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.jetbrains</groupId>
            <artifactId>annotations</artifactId>
        </dependency>

        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-stdlib</artifactId>
        </dependency>

        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-reflect</artifactId>
        </dependency>

        <dependency>
            <groupId>org.jdbi</groupId>
            <artifactId>jdbi3-core</artifactId>
        </dependency>

        <dependency>
            <groupId>org.jdbi</groupId>
            <artifactId>jdbi3-kotlin</artifactId>
        </dependency>

        <dependency>
            <groupId>org.jdbi</groupId>
            <artifactId>jdbi3-sqlobject</artifactId>
        </dependency>

        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-test-junit</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.jdbi</groupId>
            <artifactId>jdbi3-core</artifactId>
            <classifier>tests</classifier>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <sourceDirectory>${project.basedir}/src/main/kotlin</sourceDirectory>
        <testSourceDirectory>${project.basedir}/src/test/kotlin</testSourceDirectory>
        <plugins>
            <plugin>
                <groupId>org.jetbrains.kotlin</groupId>
                <artifactId>kotlin-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <id>compile</id>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>

                    <execution>
                        <id>test-compile</id>
                        <goals>
                            <goal>test-compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.jetbrains.dokka</groupId>
                <artifactId>dokka-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>javadocJar</goal>
                            <goal>dokka</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>


text:
using FluentNHibernate.Mapping;
using LNF.Impl.Repository.Control;

namespace LNF.Impl.Mappings.Control
{
    internal class ControlAuthorizationMap : ClassMap<ControlAuthorization>
    {
        internal ControlAuthorizationMap()
        {
            Schema("sselControl.dbo");
            Table("[Authorization]");
            CompositeId()
                .KeyProperty(x => x.ActionID)
                .KeyProperty(x => x.ActionInstanceID)
                .KeyProperty(x => x.ClientID)
                .KeyProperty(x => x.Location);
        }
    }
}


text:
'use strict';

// MODULES //

var isFunction = require( '@stdlib/assert/is-function' );
var isString = require( '@stdlib/assert/is-string' ).isPrimitive;
var Buffer = require( '@stdlib/buffer/ctor' );
var string2buffer = require( '@stdlib/buffer/from-string' );
var stream = require( '@stdlib/streams/node/stdin' );
var nextTick = require( '@stdlib/utils/next-tick' );
var format = require( '@stdlib/string/format' );

// MAIN //

/**
* Reads data from `stdin`.
*
* @param {(string|null)} [encoding] - string encoding. If set, data will be returned as an encoded `string`.
* @param {Function} clbk - callback to be invoked upon reading all data from `stdin`
* @throws {TypeError} `encoding` argument must be a string
* @throws {TypeError} callback argument must be a function
* @returns {void}
*
* @example
* function onRead( error, data ) {
*     if ( error ) {
*         throw error;
*     }
*     console.log( data.toString() );
*     // => '...'
* }
*
* stdin( onRead );
*
* @example
* function onRead( error, data ) {
*     if ( error ) {
*         throw error;
*     }
*     console.log( data );
*     // => '...'
* }
*
* stdin( 'utf8', onRead );
*/
function stdin() {
	var clbk;
	var data;
	var enc;
	var len;

	if ( arguments.length === 1 ) {
		clbk = arguments[ 0 ];
	} else {
		enc = arguments[ 0 ];
		if ( !isString( enc ) ) {
			throw new TypeError( format( 'invalid argument. Encoding argument must be a string. Value: `%s`.', enc ) );
		}
		clbk = arguments[ 1 ];
	}
	if ( !isFunction( clbk ) ) {
		throw new TypeError( format( 'invalid argument. Callback argument must be a function. Value: `%s`.', clbk ) );
	}
	if ( enc ) {
		stream.setEncoding( enc );
	}
	// If the calling file is being run as a script and not as part of a pipeline, we should not expect to receive anything on `stdin`.
	if ( stream.isTTY ) {
		return nextTick( onTick );
	}
	data = [];
	len = 0;

	stream.on( 'readable', onReadable );
	stream.on( 'error', onError );
	stream.on( 'end', onEnd );

	/**
	* Callback invoked after the next tick.
	*
	* @private
	* @returns {void}
	*/
	function onTick() {
		if ( enc ) {
			return clbk( null, '' );
		}
		clbk( null, string2buffer( '' ) );
	}

	/**
	* Callback invoked once the stream has data to consume.
	*
	* @private
	*/
	function onReadable() {
		var chunk;
		while ( true ) {
			chunk = stream.read();
			if ( chunk === null ) {
				break;
			}
			if ( typeof chunk === 'string' ) {
				chunk = string2buffer( chunk );
			}
			data.push( chunk );
			len += chunk.length;
		}
	}

	/**
	* Callback invoked upon encountering a stream error.
	*
	* @private
	* @param {Error} error - error object
	*/
	function onError( error ) {
		clbk( error );
	}

	/**
	* Callback invoked after all data has been consumed.
	*
	* @private
	* @returns {void}
	*/
	function onEnd() {
		if ( enc ) {
			// Return a string...
			return clbk( null, data.join( '' ) );
		}
		// Return a buffer...
		clbk( null, Buffer.concat( data, len ) );
	}
}

// EXPORTS //

module.exports = stdin;


text:
"""convert Gettext PO localization files to a Wordfast translation memory file

see: http://translate.sourceforge.net/wiki/toolkit/po2wordfast for examples and
usage instructions
"""

from translate.storage import po
from translate.storage import wordfast
from translate.convert import convert
from translate.misc import wStringIO
import os

class po2wordfast:
    def convertfiles(self, inputfile, wffile, sourcelanguage='en', targetlanguage=None):
        """converts a .po file (possibly many) to a Wordfast TM file"""
        inputstore = po.pofile(inputfile)
        for inunit in inputstore.units:
            if inunit.isheader() or inunit.isblank() or not inunit.istranslated():
                continue
            source = inunit.source
            target = inunit.target
            newunit = wffile.addsourceunit(source)
            newunit.target = target
            newunit.targetlang = targetlanguage

def convertpo(inputfile, outputfile, templatefile, sourcelanguage='en', targetlanguage=None):
    """reads in stdin using fromfileclass, converts using convertorclass, writes to stdout"""
    convertor = po2wordfast()
    outputfile.wffile.header.targetlang = targetlanguage
    convertor.convertfiles(inputfile, outputfile.wffile, sourcelanguage, targetlanguage)
    return 1

class wfmultifile:
    def __init__(self, filename, mode=None):
        """initialises wfmultifile from a seekable inputfile or writable outputfile"""
        self.filename = filename
        if mode is None:
            if os.path.exists(filename):
                mode = 'r'
            else:
                mode = 'w'
        self.mode = mode
        self.multifilename = os.path.splitext(filename)[0]
        self.wffile = wordfast.WordfastTMFile()

    def openoutputfile(self, subfile):
        """returns a pseudo-file object for the given subfile"""
        def onclose(contents):
            pass
        outputfile = wStringIO.CatchStringOutput(onclose)
        outputfile.filename = subfile
        outputfile.wffile = self.wffile
        return outputfile

class WfOptionParser(convert.ArchiveConvertOptionParser):
    def recursiveprocess(self, options):
        if not options.targetlanguage:
            raise ValueError("You must specify the target language")
        super(WfOptionParser, self).recursiveprocess(options)
        self.output = open(options.output, 'w')
        #options.outputarchive.wffile.setsourcelanguage(options.sourcelanguage)
        self.output.write(str(options.outputarchive.wffile))

def main(argv=None):
    formats = {"po": ("txt", convertpo), ("po", "txt"): ("txt", convertpo)}
    archiveformats = {(None, "output"): wfmultifile, (None, "template"): wfmultifile}
    parser = WfOptionParser(formats, usepots=False, usetemplates=False, description=__doc__, archiveformats=archiveformats)
    parser.add_option("-l", "--language", dest="targetlanguage", default=None,
                      help="set target language code (e.g. af-ZA) [required]", metavar="LANG")
    parser.add_option("", "--source-language", dest="sourcelanguage", default='en',
                      help="set source language code (default: en)", metavar="LANG")
    parser.passthrough.append("sourcelanguage")
    parser.passthrough.append("targetlanguage")
    parser.run(argv)

if __name__ == '__main__':
    main()


text:
package fun.lang;

import fun.runtime.Context;
import fun.runtime.Context.Entry;

/**
 * KeepStatement represents a statement with a cache prefix, which provides caching
 * strategy hints to the fun processor.
 *
 * @author Michael St. Hippolyte
 * @version $Revision: 1.27 $
 */
public class KeepStatement extends FunStatement {

    transient private Instantiation[] instances;
    private NameNode[] names;
    private NameNode asName = null;
    private Chunk asNameGenerator = null;
    private NameNode byName = null;
    private boolean asIncluded = false;
    private Instantiation tableInstance;
    private boolean persist = false;
    private boolean inContainer = false;

    public KeepStatement() {
        super();
    }

    public boolean isDynamic() {
        return false;
    }

    protected void setInContainer(boolean inContainer) {
        this.inContainer = inContainer;
    }

    public boolean isInContainer() {
        return inContainer;
    }

    public boolean isInContainer(Context context) {
        if (inContainer) {
            return true;
        }
//        Entry containerEntry = null;
//        // back up to the new frame entry
//        for (Entry entry = context.peek(); entry.getPrevious() != null; entry = entry.getPrevious()) {
//            if (entry.superdef == null) {
//                containerEntry = entry.getPrevious();
//                break;
//            }
//        }
//        if (containerEntry != null && containerEntry.keepMap != null) {
//            String key = context.peek().def.getName();
//            return containerEntry.keepMap.containsKey(key);
//        }
        return false;
    }

    public void setDefName(NameNode name) {
        names = new NameNode[1];
        names[0] = name;
        checkIfAsIncluded();
    }

    protected void setNames(NameNode[] names) {
        this.names = (names == null ? new NameNode[0] : names);
        checkIfAsIncluded();
    }

    protected void setAsName(NameNode name) {
        asName = name;
        checkIfAsIncluded();
    }

    private void checkIfAsIncluded() {
        asIncluded = false;
        if (asName != null && names != null) {
            for (int i = 0; i < names.length; i++) {
                if (asName.equals(names[i])) {
                    asIncluded = true;
                }
            }
        }
    }

    protected void setAsNameGenerator(FunNode node) {
        asNameGenerator = (Chunk) node;
    }

    protected void setByName(NameNode name) {
        byName = name;
    }

    public Name[] getNames() {
        return names;
    }

    public NameNode getDefName() {
        return names[0];
    }

    public NameNode getAsName(Context context) {
        if (asNameGenerator != null) {
            try {
                return new NameNode(asNameGenerator.getText(context));
            } catch (Redirection r) {
                return null;
            }
        } else {
            return asName;
        }
    }

    public boolean getAsIncluded(Context context) {
        if (asNameGenerator != null) {
            try {
                Name as = new NameNode(asNameGenerator.getText(context));
                if (as != null && names != null) {
                    for (int i = 0; i < names.length; i++) {
                        if (as.equals(names[i])) {
                            return true;
                        }
                    }
                }
            } catch (Redirection r) {
                ;
            }
            return false;
        } else {
            return asIncluded;
        }
    }

    public NameNode getByName() {
        return byName;
    }

    public boolean contains(String name) {
        if (names != null) {
            for (int i = 0; i < names.length; i++) {
                if (names[i].getName().equals(name)) {
                    return true;
                }
            }
        }
        return false;
    }

    synchronized public ResolvedInstance[] getResolvedInstances(Context context) throws Redirection {
        int len = names.length;
        NameNode as = getAsName(context);
        boolean included = getAsIncluded(context);
        boolean addAs = (as != null && !included);

        if (addAs) {
            len++;
        }

        ResolvedInstance[] resolvedInstances = new ResolvedInstance[len];
        if (addAs && as.getName() == Name.THIS) {
            len--;
            resolvedInstances[len] = new ResolvedInstance(context.getDefiningDef(), context, null, null);
        }

        if (instances == null) {
            Definition owner = getOwner();
            instances = new Instantiation[len];
            for (int i = 0; i < names.length; i++) {
                instances[i] = new Instantiation(names[i]);
                instances[i].setOwner(owner);
                instances[i].resolve(null);
            }
        }
        for (int i = 0; i < names.length; i++) {
            resolvedInstances[i] = new ResolvedInstance(instances[i], context, false);
        }
        if (addAs && as.getName() != Name.THIS) {
            instances[names.length] = new Instantiation(as);
            instances[names.length].setOwner(owner);
            resolvedInstances[names.length] = new ResolvedInstance(instances[names.length], context, false);
        }
        return resolvedInstances;
    }

    public Definition[] getDefs(Context context) throws Redirection {
        int len = names.length;
        NameNode as = getAsName(context);
        boolean included = getAsIncluded(context);
        boolean addAs = (as != null && !included);

        if (addAs) {
            len++;
        }

        Definition[] defs = new Definition[len];
        if (addAs && as.getName() == Name.THIS) {
            len--;
            defs[len] = context.getDefiningDef();
        }

        if (instances == null) {
            Definition owner = getOwner();
            instances = new Instantiation[len];
            for (int i = 0; i < names.length; i++) {
                instances[i] = new Instantiation(names[i]);
                instances[i].setOwner(owner);
                instances[i].resolve(null);
            }
        }
        for (int i = 0; i < names.length; i++) {
            defs[i] = instances[i].getDefinition(context);
            if (defs[i] == null) {
                throw new Redirection(Redirection.STANDARD_ERROR, "Undefined name in keep statement: " + instances[i].getName());
            }
        }
        if (addAs && as.getName() != Name.THIS) {
            instances[names.length] = new Instantiation(as);
            instances[names.length].setOwner(owner);
            defs[names.length] = instances[names.length].getDefinition(context);
            if (defs[names.length] == null) {
                if (defs[0].hasChildDefinition(as.getName())) {
                    defs[names.length] = defs[0].getChildDefinition(as, context);
                //} else {
                //    throw new Redirection(Redirection.STANDARD_ERROR, "Undefined name in keep statement: " + as.getName());
                }
            }
//        } else if (addBy) {
//            if (defs[0].hasChildDefinition(by.getName())) {
//                defs[names.length] = defs[0].getChildDefinition(by, context);
//            } else {
//                instances[names.length] = new Instantiation(by);
//                instances[names.length].setOwner(owner);
//                defs[names.length] = instances[names.length].getDefinition(context);
//            }
        }
        return defs;
    }

    protected void setTableInstance(Instantiation tableInstance) {
        this.tableInstance = tableInstance;
    }

    public Instantiation getTableInstance() {
        return tableInstance;
    }

    public void setPersist(boolean persist) {
        this.persist = persist;
    }

    public boolean isPersist() {
        return persist;
    }

    public String toString(String prefix) {
        StringBuffer sb = new StringBuffer();
        sb.append(prefix);
        sb.append("keep ");
        for (int i = 0; i < names.length; i++) {
            sb.append(names[i].getName());
            if (i < names.length - 1) {
                sb.append(", ");
            }
        }
        if (asNameGenerator != null) {
            sb.append(" as ");
            sb.append(asNameGenerator.toString());
        } else if (asName != null) {
            sb.append(" as ");
            sb.append(asName.getName());
        } else if (byName != null) {
            sb.append(" by ");
            sb.append(byName.getName());
        }
        if (tableInstance != null) {
            sb.append(" in ");
            sb.append(tableInstance.getDefinitionName());
        }
        sb.append("\n");
        return sb.toString();
    }
}


text:
<?php

// classpath
namespace Mimoto\UserInterface\docs;

// Mimoto classes
use Mimoto\Mimoto;
use Mimoto\Core\CoreConfig;

// Silex classes
use Silex\Application;

// Symfony classes
use Symfony\Component\HttpFoundation\Request;

/**
 * DocsController
 *
 * @author Sebastian Kersten (@supertaboo)
 */
class ChatController
{

    public function viewDocs(Application $app)
    {
        // 1. load data
        $eContentSection = Mimoto::service('data')->select(['type' => CoreConfig::MIMOTO_DATASET, 'values' => ['name' => 'Courses']]);

        // 2. create template
        $page = Mimoto::service('output')->createPage('courseOverview', (!empty($eContentSection)) ? $eContentSection[0] : '');

        // 3. output
        return $page->render();

    }

    public function viewCourse(Application $app, $nCourseId, $nSlideIndex = 0)
    {
        // 1. load course
        $eCourse = Mimoto::service('data')->get('course', $nCourseId);

        // 2. get slides
        $aSlides = $eCourse->getValue('slides');

        // 3. validate
        if (count($aSlides) == 0) die ('Please add a slide to this course');

        // 4. validate
        if (!isset($aSlides[$nSlideIndex])) die ('The slide you are looking for is not here');

        // 5. register
        $eSlide = $aSlides[$nSlideIndex];

        // 6. create template
        $page = Mimoto::service('output')->createPage('slide', $eSlide);

        // 7. setup
        $page->setVar('nCourseId', $nCourseId);
        $page->setVar('sCourseName', $eCourse->getValue('name'));
        $page->setVar('nSlideIndex', $nSlideIndex + 1);
        $page->setVar('nSlideCount', count($aSlides));
        $page->setVar('nPreviousSlide', $nSlideIndex - 1);
        $page->setVar('nNextSlide', $nSlideIndex + 1);

        // 8. output
        return $page->render();
    }

}


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using SiteAccess.Enums;

namespace SiteAccess.Model.Bets
{
    public class PinnacleBet : ICloneable
    {
        /// <summary>
        /// АПИ требует для того, чтобы 2 одинаковых запроса случайно не попали на сервер как 2 разных.
        /// Guid генерируется у себя, главное, чтобы следущий такой же отправился не раньше, чем через 30 мин,
        /// иначе сгенерирует ошибку.
        /// </summary>
        public string Guid;

        /// <summary>
        /// Принять лучшие коеффициенты
        /// </summary>
        public bool AcceptBetterLine;
        public string CustomerReference; // not reqiured
        public OddsFormat OddsFormat;

        /// <summary>
        /// Ставка.
        /// </summary>
        public decimal Stake;
        public WinRiskType WinRiskRate;
        public int SportId;
        public long Eventid;
        public int PeriodNumber;
        public BetType BetType;
        public TeamType TeamType; // for bet type == SPREAD, MONEYLINE and TEAM_TOTAL_POINTS
        public SideType Side; // for bet type == TOTAL_POINTS and TEAM_TOTAL_POINTS
        public long LineId;
        public long? AlternativeLineId; // not required
        public bool? Pitcher1MustStart; //baseballonly (sportid = 3)
        public bool? Pitcher2MustStart; //baseballonly

        public object Clone( )
        {
            return new PinnacleBet {
                    Guid = Guid,
                    AcceptBetterLine = AcceptBetterLine,
                    CustomerReference = CustomerReference,
                    OddsFormat = OddsFormat,
                    Stake = Stake,
                    WinRiskRate = WinRiskRate,
                    SportId = SportId,
                    Eventid = Eventid,
                    PeriodNumber = PeriodNumber,
                    TeamType = TeamType,
                    Side = Side,
                    LineId = LineId,
                    AlternativeLineId = AlternativeLineId,
                    Pitcher1MustStart = Pitcher1MustStart,
                    Pitcher2MustStart = Pitcher2MustStart

            };
        }
    }

}


text:
module RuboCop
  module Cop
    class ProjectPathHelper < RuboCop::Cop::Cop
      MSG = 'Use short project path helpers without explicitly passing the namespace: ' \
        '`foo_project_bar_path(project, bar)` instead of ' \
        '`foo_namespace_project_bar_path(project.namespace, project, bar)`.'.freeze

      METHOD_NAME_PATTERN = /\A([a-z_]+_)?namespace_project(?:_[a-z_]+)?_(?:url|path)\z/.freeze

      def on_send(node)
        return unless method_name(node).to_s =~ METHOD_NAME_PATTERN

        namespace_expr, project_expr = arguments(node)
        return unless namespace_expr && project_expr

        return unless namespace_expr.type == :send
        return unless method_name(namespace_expr) == :namespace
        return unless receiver(namespace_expr) == project_expr

        add_offense(node, location: :selector)
      end

      def autocorrect(node)
        helper_name = method_name(node).to_s.sub('namespace_project', 'project')

        arguments = arguments(node)
        arguments.shift # Remove namespace argument

        replacement = "#{helper_name}(#{arguments.map(&:source).join(', ')})"

        lambda do |corrector|
          corrector.replace(node.source_range, replacement)
        end
      end

      private

      def receiver(node)
        node.children[0]
      end

      def method_name(node)
        node.children[1]
      end

      def arguments(node)
        node.children[2..-1]
      end
    end
  end
end


text:
<?php

namespace PHPExiftool\Driver\Tag\XMPXmpMM;

use JMS\Serializer\Annotation\ExclusionPolicy;
use PHPExiftool\Driver\AbstractTag;

/**
 * @ExclusionPolicy("all")
 */
class HistoryWhen extends AbstractTag
{

    protected $Id = 'HistoryWhen';

    protected $Name = 'HistoryWhen';

    protected $FullName = 'XMP::xmpMM';

    protected $GroupName = 'XMP-xmpMM';

    protected $g0 = 'XMP';

    protected $g1 = 'XMP-xmpMM';

    protected $g2 = 'Other';

    protected $Type = 'date';

    protected $Writable = true;

    protected $Description = 'History When';

    protected $local_g2 = 'Time';

    protected $flag_List = true;
}


text:
package st.redline.core;

import st.redline.compiler.SmalltalkGeneratorOfAdaptorOfAJavaClass;

public class DynamicJavaClassAdaptor {

    private final String className;

    DynamicJavaClassAdaptor(String className) {
        this.className = className;
    }

    PrimObject build() {
        String source = generateSmalltalkFor();
//        System.out.println(source);
        return Evaluator.evaluate(source);
    }

    private String generateSmalltalkFor() {
        return new SmalltalkGeneratorOfAdaptorOfAJavaClass(className).adaptorSource();
    }

    public static String fullyQualifiedClassNameForJavaClassWrapperClassNamed(String fullyQualifiedJavaClassName) { // remove when old code is gone - chad
        return "smalltalkClassesThatAdaptJavaClasses." + fullyQualifiedJavaClassName + "Adaptor";
    }
}


text:
<?php namespace Fisharebest\Localization\Locale;

use Fisharebest\Localization\Territory\TerritoryAt;

class LocaleEnAt extends LocaleEn {
	protected function percentFormat() {
		return '%s' . self::NBSP . self::PERCENT;
	}

	public function territory() {
		return new TerritoryAt;
	}
}


text:
/**
 * 	File contentente la classe CtrlSharedTest
 *
 *	@file		CtrlSharedTest.java
 *	@author		DeSQ
 *	@date		2014-05-14
 *	@version	1.0
 */

package com.sequenziatore.server.controller;

import static org.junit.Assert.*;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringReader;
import java.io.Writer;
import java.lang.reflect.Field;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.hibernate.Query;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.Test;

import com.sequenziatore.server.databaseutil.util.HibernateUtil;
import com.sequenziatore.server.entity.User;

/**
 *	Classe contenente tutti i test di unità dei metodi della classe CtrlShared.
 *
 *	@author 	DeSQ
 */
public class CtrlSharedTest {

	/**
	 * Pulisce il database prima di iniziare ad eseguire i test.
	 * @throws Exception segnala un problema di connessione al database
	 */
	@Before
	public void clean() throws Exception
	{
		//pulizia database
	    HibernateUtil.getSession().beginTransaction();

	    //elimina le data collection
	    Query deleteDataCollection = HibernateUtil.getSession().createQuery("delete DataCollection");
	    deleteDataCollection.executeUpdate();

	    //elimina le iscrizioni ai processi
	    Query unsubscribeToProcess = HibernateUtil.getSession().createQuery("delete Subscription");
	    unsubscribeToProcess.executeUpdate();

	    //elimina i passi di tutti i processi
	    Query deleteTestStep = HibernateUtil.getSession().createQuery("delete Step");
	    deleteTestStep.executeUpdate();

	    //elimina i processi
	    Query deleteTestProcess = HibernateUtil.getSession().createQuery("delete Process");
	    deleteTestProcess.executeUpdate();

	    //elimina gli utenti registrati
	    Query deleteTestUser = HibernateUtil.getSession().createQuery("delete User");
	    deleteTestUser.executeUpdate();

	    HibernateUtil.commitTransaction();
	}

	/**
	 *	Pulisce il database quando sono terminati tutti i test.
	 * @throws Exception segnala un problema di connessione al database
	 */
	@AfterClass
	public static void finalClean() throws Exception
	{
		//pulizia database
	    HibernateUtil.getSession().beginTransaction();

	    //elimina le data collection
	    Query deleteDataCollection = HibernateUtil.getSession().createQuery("delete DataCollection");
	    deleteDataCollection.executeUpdate();

	    //elimina le iscrizioni ai processi
	    Query unsubscribeToProcess = HibernateUtil.getSession().createQuery("delete Subscription");
	    unsubscribeToProcess.executeUpdate();

	    //elimina i passi di tutti i processi
	    Query deleteTestStep = HibernateUtil.getSession().createQuery("delete Step");
	    deleteTestStep.executeUpdate();

	    //elimina i processi
	    Query deleteTestProcess = HibernateUtil.getSession().createQuery("delete Process");
	    deleteTestProcess.executeUpdate();

	    //elimina gli utenti registrati
	    Query deleteTestUser = HibernateUtil.getSession().createQuery("delete User");
	    deleteTestUser.executeUpdate();

	    HibernateUtil.commitTransaction();
	}

	/**
	 *	Test del metodo ctrlUserFacebookLogin() che permette ad un utente di loggarsi tramite Facebook.
	 * @throws Exception segnala un problema di connessione al database
	 */
	@Test
	public void testCtrlUserFacebookLogin() throws Exception{
		HttpServletRequest request = mock(HttpServletRequest.class);
		HttpServletResponse response = mock(HttpServletResponse.class);
		HttpSession session= mock(HttpSession.class);
		CtrlShared ctrlSharedObject = new CtrlShared();

		//creazione ambiente per l'esecuzione della query
		HibernateUtil.getSession().beginTransaction();

     	//creazione utente
        User testUser = new User();
        testUser.setEmail("asd@asd.com");
        testUser.setIsAdmin(false);
        testUser.setPassword("test");
        testUser.setUsername("testUser");
        HibernateUtil.getSession().saveOrUpdate(testUser);
		HibernateUtil.commitTransaction();

	    String stringObject = "{Username: 'testUsername', Password: 'testPassword', "
        		+ "Name: 'testName', Surname: 'testSurname', Email: 'testEmail', "
        		+ "City: 'testCity', District: 'Di', IsAdmin: false}";
    	StringReader stringReaderObject=new StringReader(stringObject);
    	BufferedReader bufferReaderObject = new BufferedReader(stringReaderObject);

    	Writer writerMock = mock(Writer.class);
    	PrintWriter writer = null;
        try {
			when(request.getReader()).thenReturn(bufferReaderObject);
			when(request.getSession()).thenReturn(session);
			when(request.getContentType()).thenReturn("application/json");

			when(session.getAttribute(testUser.getIdUser().toString())).thenReturn(true);
			when(session.getAttribute(testUser.getIdUser().toString()+"Admin")).thenReturn(testUser.getIsAdmin());

			writer = new PrintWriter(writerMock);
			when(response.getWriter()).thenReturn(writer);
		}
        catch (FileNotFoundException e) {}
        catch (IOException e) {}

        Field iParserObject = null;
		Field iServiceObject = null;

		try {
			iParserObject = ctrlSharedObject.getClass().getDeclaredField("iParser");
			iParserObject.setAccessible(true);
			iServiceObject = ctrlSharedObject.getClass().getDeclaredField("iService");
			iServiceObject.setAccessible(true);
		}
		catch (NoSuchFieldException e) {}
		catch (SecurityException e) {}

		ctrlSharedObject.ctrlUserFacebookLogin(request, response);
		assertNotNull(iParserObject);
		assertNotNull(iServiceObject);
	}

	/**
	 *	Test del metodo ctrlModifyAccount() che permette all'utente di modificare i dati del proprio account.
	 * @throws Exception segnala un problema di connessione al database
	 */
    @Test
    public void testCtrlModifyAccount() throws Exception {
    	HttpServletRequest request = mock(HttpServletRequest.class);
        HttpServletResponse response = mock(HttpServletResponse.class);
        HttpSession session= mock(HttpSession.class);
        CtrlShared ctrlSharedObject = new CtrlShared();

        //creazione ambiente per l'esecuzione della query
	    HibernateUtil.getSession().beginTransaction();

        //creazione utente
        User testUser = new User();
        testUser.setEmail("desq@mailinator.com");
        testUser.setIsAdmin(false);
        testUser.setPassword("test");
        testUser.setUsername("test");
        HibernateUtil.getSession().saveOrUpdate(testUser);
	    HibernateUtil.commitTransaction();

	    String stringObject = "{Username: "+testUser.getUsername()+", Email: "+testUser.getEmail()+", Password: "+testUser.getPassword()+", IdUser: "+testUser.getIdUser()+", IsAdmin: "+testUser.getIsAdmin()+", Name: 'test', Surname: 'test', Password2: 'test'}";
    	StringReader stringReaderObject=new StringReader(stringObject);
    	BufferedReader bufferReaderObject = new BufferedReader(stringReaderObject);

    	Writer writerMock = mock(Writer.class);
    	PrintWriter writer = null;
        try {
			when(request.getReader()).thenReturn(bufferReaderObject);
			when(request.getSession()).thenReturn(session);

			when(session.getAttribute(testUser.getIdUser().toString())).thenReturn(true);

			writer = new PrintWriter(writerMock);
			when(response.getWriter()).thenReturn(writer);
		}
        catch (FileNotFoundException e) {}
        catch (IOException e) {}

		ctrlSharedObject.ctrlModifyAccount(request, response);
    }

    /**
	 *	Test del metodo ctrlRecoveryPassword() che permette all'utente di recuperare la password nel caso l'avesse dimenticata.
     * @throws Exception segnala un problema di connessione al database
	 */
    @Test
    public void testCtrlRecoveryPassword() throws Exception {
    	HttpServletRequest request = mock(HttpServletRequest.class);
        HttpServletResponse response = mock(HttpServletResponse.class);
        HttpSession session= mock(HttpSession.class);
        CtrlShared ctrlSharedObject = new CtrlShared();

        //creazione ambiente per l'esecuzione della query
	    HibernateUtil.getSession().beginTransaction();

        //creazione utente
        User testUser = new User();
        testUser.setEmail("desq@mailinator.com");
        testUser.setIsAdmin(false);
        testUser.setPassword("test");
        testUser.setUsername("test");
        HibernateUtil.getSession().saveOrUpdate(testUser);
	    HibernateUtil.commitTransaction();

	    String stringObject = "{Username: "+testUser.getUsername()+"}";
    	StringReader stringReaderObject=new StringReader(stringObject);
    	BufferedReader bufferReaderObject = new BufferedReader(stringReaderObject);

    	Writer writerMock = mock(Writer.class);
    	PrintWriter writer = null;
        try {
			when(request.getReader()).thenReturn(bufferReaderObject);
			when(request.getSession()).thenReturn(session);

			writer = new PrintWriter(writerMock);
			when(response.getWriter()).thenReturn(writer);
		}
        catch (FileNotFoundException e) {}
        catch (IOException e) {}

		ctrlSharedObject.ctrlRecoveryPassword(request, response);
    }

    /**
	 *	Test del metodo ctrlLogout() che permette ad un utente di terminare la sessione.
     * @throws Exception segnala un problema di connessione al database
	 */
    @Test
    public void testCtrlLogout() throws Exception {
    	HttpServletRequest request = mock(HttpServletRequest.class);
        HttpServletResponse response = mock(HttpServletResponse.class);
        HttpSession session= mock(HttpSession.class);
        CtrlShared ctrlSharedObject = new CtrlShared();

        //creazione ambiente per l'esecuzione della query
	    HibernateUtil.getSession().beginTransaction();

        //creazione utente
        User testUser = new User();
        testUser.setEmail("asd@asd.com");
        testUser.setIsAdmin(false);
        testUser.setPassword("test");
        testUser.setUsername("test");
        HibernateUtil.getSession().saveOrUpdate(testUser);
	    HibernateUtil.commitTransaction();

	    String stringObject = "{Username: "+testUser.getUsername()+", Password: "+testUser.getPassword()+", IdUser: "+testUser.getIdUser()+", IsAdmin: "+testUser.getIsAdmin()+"}";
    	StringReader stringReaderObject=new StringReader(stringObject);
    	BufferedReader bufferReaderObject = new BufferedReader(stringReaderObject);

    	Writer writerMock = mock(Writer.class);
    	PrintWriter writer = null;
        try {
			when(request.getReader()).thenReturn(bufferReaderObject);
			when(request.getSession()).thenReturn(session);

			writer = new PrintWriter(writerMock);
			when(response.getWriter()).thenReturn(writer);
		}
        catch (FileNotFoundException e) {}
        catch (IOException e) {}

		ctrlSharedObject.ctrlLogout(request, response);
    }

	/**
	 *	Test del metodo ctrlLogin() che permette ad un utente di autenticarsi.
	 * @throws Exception segnala un problema di connessione al database
	 */
    @Test
    public void testCtrlLogin() throws Exception {
        HttpServletRequest request = mock(HttpServletRequest.class);
        HttpServletResponse response = mock(HttpServletResponse.class);
        HttpSession session= mock(HttpSession.class);
        CtrlShared ctrlSharedObject = new CtrlShared();

        //creazione ambiente per l'esecuzione della query
	    HibernateUtil.getSession().beginTransaction();

        //creazione utente
        User testUser = new User();
        testUser.setEmail("asd@asd.com");
        testUser.setIsAdmin(false);
        testUser.hashAndSetPassword("test");
        testUser.setUsername("test");
        HibernateUtil.getSession().saveOrUpdate(testUser);
	    HibernateUtil.commitTransaction();

        String stringObject = "{Username: "+testUser.getUsername()+", Password: 'test'}";
    	StringReader stringReaderObject=new StringReader(stringObject);
    	BufferedReader bufferReaderObject = new BufferedReader(stringReaderObject);

    	Writer writerMock = mock(Writer.class);
    	PrintWriter writer = null;
        try {
			when(request.getReader()).thenReturn(bufferReaderObject);
			when(request.getSession()).thenReturn(session);

			writer = new PrintWriter(writerMock);
			when(response.getWriter()).thenReturn(writer);
		}
        catch (FileNotFoundException e) {}
        catch (IOException e) {}

        Field iParserObject = null;
		Field iServiceObject = null;

		try {
			iParserObject = ctrlSharedObject.getClass().getDeclaredField("iParser");
			iParserObject.setAccessible(true);
			iServiceObject = ctrlSharedObject.getClass().getDeclaredField("iService");
			iServiceObject.setAccessible(true);
		}
		catch (NoSuchFieldException e) {}
		catch (SecurityException e) {}

		//utente non amministratore e dati corretti
		ctrlSharedObject.ctrlLogin(request, response);

		HibernateUtil.getSession().beginTransaction();
	    testUser.setIsAdmin(true);
	    HibernateUtil.getSession().saveOrUpdate(testUser);
	    HibernateUtil.commitTransaction();

	    stringObject = "{Username: "+testUser.getUsername()+", Password: 'test'}";
    	stringReaderObject=new StringReader(stringObject);
    	bufferReaderObject = new BufferedReader(stringReaderObject);
    	try {
			when(request.getReader()).thenReturn(bufferReaderObject);
		}
    	catch (IOException e) {}

		//utente amministratore e dati corretti
	    ctrlSharedObject.ctrlLogin(request, response);

		stringObject = "{Username: 'username', Password: 'password'}";
    	stringReaderObject=new StringReader(stringObject);
    	bufferReaderObject = new BufferedReader(stringReaderObject);
    	try {
			when(request.getReader()).thenReturn(bufferReaderObject);
		}
    	catch (IOException e) {}

    	//utente amministratore e dati errati
    	ctrlSharedObject.ctrlLogin(request, response);

		assertNotNull(iParserObject);
		assertNotNull(iServiceObject);
    }

    /**
	 *	Test del metodo ctrlViewAccount() che permette all'utente di visualizzare i dati del proprio account.
     * @throws Exception segnala un problema di connessione al database
	 */
    @Test
    public void testCtrlViewAccount() throws Exception {
        HttpServletRequest request = mock(HttpServletRequest.class);
        HttpServletResponse response = mock(HttpServletResponse.class);
        HttpSession session= mock(HttpSession.class);

        //creazione ambiente per l'esecuzione della query
        HibernateUtil.getSession().beginTransaction();

        //creazione utente
        User testUser = new User();
        testUser.setEmail("asd@asd.com");
        testUser.setIsAdmin(false);
        testUser.setPassword("test");
        testUser.setUsername("test");
        HibernateUtil.getSession().saveOrUpdate(testUser);
	    HibernateUtil.commitTransaction();

        CtrlShared ctrlSharedObject = new CtrlShared();

        String stringObject = "{IdUser: "+testUser.getIdUser()+"}";
    	StringReader stringReaderObject=new StringReader(stringObject);
    	BufferedReader bufferReaderObject = new BufferedReader(stringReaderObject);

    	Writer writerMock = mock(Writer.class);
    	PrintWriter writer = null;
        try {
			when(request.getReader()).thenReturn(bufferReaderObject);
			when(request.getSession()).thenReturn(session);

			when(session.getAttribute(testUser.getIdUser().toString())).thenReturn(true);

			writer = new PrintWriter(writerMock);
			when(response.getWriter()).thenReturn(writer);
		}
        catch (FileNotFoundException e) {}
        catch (IOException e) {}

        Field iParserObject = null;
		Field iServiceObject = null;

		try {
			iParserObject = ctrlSharedObject.getClass().getDeclaredField("iParser");
			iParserObject.setAccessible(true);
			iServiceObject = ctrlSharedObject.getClass().getDeclaredField("iService");
			iServiceObject.setAccessible(true);
		}
		catch (NoSuchFieldException e) {}
		catch (SecurityException e) {}

		ctrlSharedObject.ctrlViewAccount(request, response);
		assertNotNull(iParserObject);
		assertNotNull(iServiceObject);
    }

    /**
	 *	Test del metodo ctrlUserRegistration() che permette ad un nuovo utente di registrarsi.
	 */
    @Test
    public void testCtrlUserRegistration() {
        HttpServletRequest request = mock(HttpServletRequest.class);
        HttpServletResponse response = mock(HttpServletResponse.class);
        CtrlShared ctrlSharedObject = new CtrlShared();

        String stringObject = "{Username: 'testUsername', Password: 'testPassword', "
        		+ "Name: 'testName', Surname: 'testSurname', Email: 'testEmail', "
        		+ "City: 'testCity', District: 'Di', IsAdmin: true}";
    	StringReader stringReaderObject=new StringReader(stringObject);
    	BufferedReader bufferReaderObject = new BufferedReader(stringReaderObject);

    	Writer writerMock = mock(Writer.class);
    	PrintWriter writer = null;
        try {
			when(request.getReader()).thenReturn(bufferReaderObject);
			writer = new PrintWriter(writerMock);
			when(response.getWriter()).thenReturn(writer);
		}
        catch (FileNotFoundException e) {}
        catch (IOException e) {}

        Field iParserObject = null;
		Field iServiceObject = null;

		try {
			iParserObject = ctrlSharedObject.getClass().getDeclaredField("iParser");
			iParserObject.setAccessible(true);
			iServiceObject = ctrlSharedObject.getClass().getDeclaredField("iService");
			iServiceObject.setAccessible(true);
		}
		catch (NoSuchFieldException e) {}
		catch (SecurityException e) {}

		ctrlSharedObject.ctrlUserRegistration(request, response);
		assertNotNull(iParserObject);
		assertNotNull(iServiceObject);
    }
}


text:
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Take.Elephant
{
    /// <summary>
    /// Defines a queue with score that allows to await for messages when dequeueing.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface IPriorityBlockingQueue<T> : IPriorityQueue<T>
    {
        /// <summary>
        /// Dequeues an item with the lowest score from the queue, awaiting for a new value if the queue is empty.
        /// </summary>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns></returns>
        Task<T> DequeueMinAsync(CancellationToken cancellationToken);

        /// <summary>
        /// Dequeues an item with the highest score from the queue, awaiting for a new value if the queue is empty.
        /// </summary>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns></returns>
        Task<T> DequeueMaxAsync(CancellationToken cancellationToken);
    }
}


text:
<?php
/* vim: set expandtab sw=4 ts=4 sts=4: */
/**
 * A caching proxy for retrieving version information from phpmyadmin.net
 *
 * @package PhpMyAdmin
 */

// Sets up the session
define('PMA_MINIMUM_COMMON', true);
require_once 'libraries/common.inc.php';

// Get response text from phpmyadmin.net or from the session
// Update cache every 6 hours
if (isset($_SESSION['cache']['version_check'])
    && time() < $_SESSION['cache']['version_check']['timestamp'] + 3600 * 6
) {
    $save = false;
    $response = $_SESSION['cache']['version_check']['response'];
} else {
//    $save = true;
//    $file = 'http://www.phpmyadmin.net/home_page/version.json';
//    if (ini_get('allow_url_fopen')) {
//        $response = file_get_contents($file);
//    } else if (function_exists('curl_init')) {
//        $curl_handle = curl_init($file);
//        curl_setopt($curl_handle, CURLOPT_RETURNTRANSFER, 1);
//        $response = curl_exec($curl_handle);
//    }
}

// Always send the correct headers
header('Content-type: application/json; charset=UTF-8');

// Save and forward the response only if in valid format
$data = json_decode($response);
if (is_object($data) && strlen($data->version) && strlen($data->date)) {
    if ($save) {
        $_SESSION['cache']['version_check'] = array(
            'response' => $response,
            'timestamp' => time()
        );
    }
	echo $response;
/*    echo json_encode(
        array('version' => $data->version, 'date' => $data->date)
    );*/
}

?>