text:
package com.armadialogcreator.application;

/**
 When the {@link Workspace} initializes, place your new implemented instance of {@link WorkspaceData}
 in {@link Workspace#getDataList()}.

 When the workspace is done initializing, the method {@link #loadFromConfigurable(Configurable)} will be invoked.
 This is where you can populate your data with values.

 When the workspace closes, all instances in {@link Workspace#getDataList()} will automatically be saved in the workspace
 save file via {@link ConfigurableManager#exportToConfigurable(Configurable)}.

 The method {@link #getDataID()} will be used to identify in the saved config file which {@link WorkspaceData} instance gets
 what {@link Configurable}.

 @author K
 @see DataLevel#Workspace
 @see ApplicationStateSubscriber
 @since 01/04/2019 */
public interface WorkspaceData extends ADCData {

}


text:
namespace Boxed.AspNetCore.TagHelpers.Twitter
{
    using System;
    using System.Text;
    using Microsoft.AspNetCore.Razor.TagHelpers;

    /// <summary>
    /// The Summary Card with Large Image features a large, full-width prominent image alongside a
    /// tweet. It is designed to give the reader a rich photo experience, and clicking on the image
    /// brings the user to your website. On twitter.com and the mobile clients, the image appears
    /// below the tweet text. See https://dev.twitter.com/cards/types/summary-large-image.
    /// </summary>
    [HtmlTargetElement("twitter-card-summary-large-image", Attributes = SiteUsernameAttributeName + "," + CreatorUsernameAttributeName, TagStructure = TagStructure.WithoutEndTag)]
    public class TwitterCardSummaryLargeImage : TwitterCardSummary
    {
        /// <summary>
        /// Gets the type of the Twitter card.
        /// </summary>
        public override CardType Type => CardType.SummaryLargeImage;

        /// <summary>
        /// Appends a HTML-encoded string representing this instance to the
        /// <paramref name="stringBuilder"/> containing the Twitter card meta tags.
        /// </summary>
        /// <param name="stringBuilder">The string builder.</param>
        public override void ToString(StringBuilder stringBuilder)
        {
            if (stringBuilder == null)
            {
                throw new ArgumentNullException(nameof(stringBuilder));
            }

            base.ToString(stringBuilder);

            stringBuilder.AppendMetaNameContentIfNotNull("twitter:site:Id", this.SiteId);
            stringBuilder.AppendMetaNameContentIfNotNull("twitter:title", this.Title);
            stringBuilder.AppendMetaNameContentIfNotNull("twitter:description", this.Description);
            stringBuilder.AppendMetaNameContentIfNotNull("twitter:creator", this.CreatorUsername);
            stringBuilder.AppendMetaNameContentIfNotNull("twitter:creator:id", this.CreatorId);

            if (this.Image != null)
            {
                stringBuilder.AppendMetaNameContent("twitter:image", this.Image.ImageUrl);
                stringBuilder.AppendMetaNameContentIfNotNull("twitter:image:height", this.Image.Height);
                stringBuilder.AppendMetaNameContentIfNotNull("twitter:image:width", this.Image.Width);
            }
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
.class public abstract Lcom/google/android/gms/dynamic/b$a;
.super Landroid/os/Binder;

# interfaces
.implements Lcom/google/android/gms/dynamic/b;

# annotations
.annotation system Ldalvik/annotation/EnclosingClass;
    value = Lcom/google/android/gms/dynamic/b;
.end annotation

.annotation system Ldalvik/annotation/InnerClass;
    accessFlags = 0x409
    name = "a"
.end annotation

.annotation system Ldalvik/annotation/MemberClasses;
    value = {
        Lcom/google/android/gms/dynamic/b$a$a;
    }
.end annotation

# direct methods
.method public constructor <init>()V
    .locals 1

    invoke-direct {p0}, Landroid/os/Binder;-><init>()V

    const-string v0, "com.google.android.gms.dynamic.IObjectWrapper"

    invoke-virtual {p0, p0, v0}, Lcom/google/android/gms/dynamic/b$a;->attachInterface(Landroid/os/IInterface;Ljava/lang/String;)V

    return-void
.end method

.method public static E(Landroid/os/IBinder;)Lcom/google/android/gms/dynamic/b;
    .locals 2

    if-nez p0, :cond_0

    const/4 v0, 0x0

    return-object v0

    :cond_0
    const-string v0, "com.google.android.gms.dynamic.IObjectWrapper"

    invoke-interface {p0, v0}, Landroid/os/IBinder;->queryLocalInterface(Ljava/lang/String;)Landroid/os/IInterface;

    move-result-object v0

    move-object v1, v0

    if-eqz v0, :cond_1

    instance-of v0, v1, Lcom/google/android/gms/dynamic/b;

    if-eqz v0, :cond_1

    move-object v0, v1

    check-cast v0, Lcom/google/android/gms/dynamic/b;

    return-object v0

    :cond_1
    new-instance v0, Lcom/google/android/gms/dynamic/b$a$a;

    invoke-direct {v0, p0}, Lcom/google/android/gms/dynamic/b$a$a;-><init>(Landroid/os/IBinder;)V

    return-object v0
.end method

# virtual methods
.method public asBinder()Landroid/os/IBinder;
    .locals 0

    return-object p0
.end method

.method public onTransact(ILandroid/os/Parcel;Landroid/os/Parcel;I)Z
    .locals 1

    sparse-switch p1, :sswitch_data_0

    goto :goto_0

    :sswitch_data_0
    .sparse-switch
        0x5f4e5446 -> :sswitch_0
    .end sparse-switch

    :sswitch_0
    const-string v0, "com.google.android.gms.dynamic.IObjectWrapper"

    invoke-virtual {p3, v0}, Landroid/os/Parcel;->writeString(Ljava/lang/String;)V

    const/4 v0, 0x1

    return v0

    :goto_0
    invoke-super {p0, p1, p2, p3, p4}, Landroid/os/Binder;->onTransact(ILandroid/os/Parcel;Landroid/os/Parcel;I)Z

    move-result v0

    return v0
.end method


text:
#ifndef _VKTSHADEREXECUTOR_HPP
#define _VKTSHADEREXECUTOR_HPP
/*!
 * \file
 * \brief Vulkan ShaderExecutor
 *//*--------------------------------------------------------------------*/

#include "tcuDefs.hpp"
#include "vktTestCase.hpp"
#include "gluVarType.hpp"
#include "vkShaderProgram.hpp"

#include <vector>
#include <string>

namespace vkt
{
namespace shaderexecutor
{

//! Shader input / output variable declaration.
struct Symbol
{
	std::string				name;		//!< Symbol name.
	glu::VarType			varType;	//!< Symbol type.

	Symbol (void) {}
	Symbol (const std::string& name_, const glu::VarType& varType_) : name(name_), varType(varType_) {}
};

enum SpirVCaseT
{
	SPIRV_CASETYPE_NONE = 0,
	SPIRV_CASETYPE_COMPARE,
	SPIRV_CASETYPE_FREM,
	SPIRV_CASETYPE_MODFSTRUCT,
	SPIRV_CASETYPE_FREXPSTRUCT,
	SPIRV_CASETYPE_MAX_ENUM,
};

//! Complete shader specification.
struct ShaderSpec
{
	glu::GLSLVersion		glslVersion;
	std::vector<Symbol>		inputs;
	std::vector<Symbol>		outputs;
	std::string				globalDeclarations;	//!< These are placed into global scope. Can contain uniform declarations for example.
	std::string				source;				//!< Source snippet to be executed.
	vk::ShaderBuildOptions	buildOptions;
	bool					packFloat16Bit;
	SpirVCaseT				spirvCase;
	int						localSizeX;			// May be used for compute shaders.

	ShaderSpec (void)
		: glslVersion		(glu::GLSL_VERSION_450)
		, packFloat16Bit	(false)
		, spirvCase			(SPIRV_CASETYPE_NONE)
		, localSizeX		(1)
	{}
};

enum
{
	//!< Descriptor set index for additional resources
	EXTRA_RESOURCES_DESCRIPTOR_SET_INDEX		= 1,
};

//! Base class for shader executor.
class ShaderExecutor
{
public:
	virtual					~ShaderExecutor		(void);

	//! Execute
	virtual void			execute				(int numValues, const void* const* inputs, void* const* outputs, vk::VkDescriptorSet extraResources = (vk::VkDescriptorSet)0) = 0;
	bool					areInputs16Bit		(void) const;
	bool					areOutputs16Bit		(void) const;
	bool					isOutput16Bit		(const size_t ndx) const;
	bool					areInputs64Bit		(void) const;
	bool					areOutputs64Bit		(void) const;
	bool					isOutput64Bit		(const size_t ndx) const;
	bool					isSpirVShader		(void) { return (m_shaderSpec.spirvCase != SPIRV_CASETYPE_NONE); }
	SpirVCaseT				spirvCase			(void) { return m_shaderSpec.spirvCase; }

protected:
							ShaderExecutor		(Context& context, const ShaderSpec& shaderSpec)
								: m_context		(context)
								, m_shaderSpec	(shaderSpec)
							{}

	Context&				m_context;
	const ShaderSpec		m_shaderSpec;

private:
							ShaderExecutor		(const ShaderExecutor&);
	ShaderExecutor&			operator=			(const ShaderExecutor&);
};

bool				executorSupported	(glu::ShaderType shaderType);
void				generateSources		(glu::ShaderType shaderType, const ShaderSpec& shaderSpec, vk::SourceCollections& dst);
ShaderExecutor*		createExecutor		(Context& context, glu::ShaderType shaderType, const ShaderSpec& shaderSpec, vk::VkDescriptorSetLayout extraResourcesLayout = (vk::VkDescriptorSetLayout)0);
void				checkSupportShader	(Context& context, const glu::ShaderType shaderType);

} // shaderexecutor
} // vkt

#endif // _VKTSHADEREXECUTOR_HPP


text:
package com.todo.models;

import org.hibernate.validator.constraints.NotEmpty;

import javax.persistence.*;
import java.util.Date;

/**
 * Created by masud on 2/18/17.
 */

@Entity
@Table(name = "tasks")
public class Task {

    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.AUTO)
    private long id;

    @NotEmpty
    @Column(name = "summary")
    private String summary;

    @NotEmpty
    @Column(name = "description", length = 1000)
    private String description;

    @Column(name = "status")
    private String status;

    @Column(name = "date_of_work")
    private Date dateOfWork;

    @Column(name = "time_spent")
    private String timeSpent;

    @Column(name = "created_at")
    private Date createdAt;

    @Column(name = "updated_at")
    private Date updatedAt;

    @ManyToOne()
    @JoinColumn(name = "user_id")
    private User user;

    @ManyToOne()
    @JoinColumn(name = "project_id")
    private Project project;

    public Task() {}

    public Task(String summary, String description, String status, Date dateOfWork, String timeSpent, User user, Project project) {
        this.summary = summary;
        this.description = description;
        this.status = status;
        this.dateOfWork = dateOfWork;
        this.timeSpent = timeSpent;
        this.user = user;
        this.project = project;
        this.createdAt = new Date();
        this.updatedAt = new Date();
    }

    @Override
    public String toString() {
        return "Task{" +
                "id=" + id +
                ", summary='" + summary + '\'' +
                ", description='" + description + '\'' +
                ", status='" + status + '\'' +
                ", dateOfWork=" + dateOfWork +
                ", timeSpent='" + timeSpent + '\'' +
                '}';
    }

    public long getId() {
        return id;
    }

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

    public String getSummary() {
        return summary;
    }

    public void setSummary(String summary) {
        this.summary = summary;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    public Date getDateOfWork() {
        return dateOfWork;
    }

    public void setDateOfWork(Date dateOfWork) {
        this.dateOfWork = dateOfWork;
    }

    public String getTimeSpent() {
        return timeSpent;
    }

    public void setTimeSpent(String timeSpent) {
        this.timeSpent = timeSpent;
    }

    public Date getCreatedAt() {
        return createdAt;
    }

    public void setCreatedAt(Date createdAt) {
        this.createdAt = createdAt;
    }

    public Date getUpdatedAt() {
        return updatedAt;
    }

    public void setUpdatedAt(Date updatedAt) {
        this.updatedAt = updatedAt;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public Project getProject() {
        return project;
    }

    public void setProject(Project project) {
        this.project = project;
    }
}


text:
<?xml version="1.0" encoding="utf-8"?>
<Traductions>
  <Parametre Separateur="\">
    <Proprietes>
      <Propriete>Caption</Propriete>
      <Propriete>Text</Propriete>
      <Propriete>Hint</Propriete>
      <Propriete>Items</Propriete>
    </Proprietes>
  </Parametre>
  <Langues>
    <Langue index="FR" name="FrenchLang" default="1" />
    <Langue index="EN" name="EnglishLang" default="0" />
	<Langue index="ES" name="SpanishLang" default="0" />
  </Langues>
  <Labels>
    <Popup type="TComboBox">
      <Items>
        <FR>Le fichier scratch2.bat n'existe pas.\Le fichier scratch2.bat n'existe pas.\Le fichier xi_portable_Win.bat n'existe pas.\Le numéro du port COM doit être un entier.\Le numéro du port d'écoute doit être un entier compris entre 0~65535.\Interface réalisée par Sébastien Canet, décembre 2014 - v2.2.2 - mai 2015\Afficher l'adresse IP du poste\Cacher l'adresse IP du poste</FR>
        <EN>The file 'scratch2.bat' does not exist.\The file 'scratch2.bat' does not exist.\The file 'xi_portable_Win.bat' does not exist.\#COM port must be an integer.\The listening port number must be in range [0~65535].\Software created by Sébastien Canet, december 2014 - v2.2.2 - mai 2015\Show computer IP adress\Hide computer IP adress</EN>
		<ES>El fichero 'scratch2.bat' no existe.\El fichero 'scratch2.bat' no existe.\El fichero 'xi_portable_Win.bat' no existe.\El numero de puerto #COM debe ser un numero entero.\El numero de puerto debe encntrarse en el rango [0~65535].\Software creado por Sébastien Canet, diciembre 2014 - v2.2.2 - mayo 2015\Mostrar la IP del computador\Ocultar la IP del computador</ES>
      </Items>
    </Popup>
	<InterfaceXi type="TInterfaceXi">
      <Caption>
        <FR>XiDuino : connexion Scratch2 - Arduino</FR>
        <EN>XiDuino : connecting Scratch2Arduino</EN>
		<ES>XiDuino : conectando Scratch2Arduino</ES>
      </Caption>
    </InterfaceXi>
    <Label1 type="TLabel">
      <Caption>
        <FR>Une carte Arduino est connectée sur</FR>
        <EN>An Arduino card is connected on</EN>
		<ES>Esta conectada una tarjeta Arduino en</ES>
      </Caption>
    </Label1>
    <Label2 type="TLabel">
      <Caption>
        <FR>le port COM</FR>
        <EN>COM port #</EN>
		<ES>el puerto COM</ES>
      </Caption>
    </Label2>
    <Label3 type="TLabel">
      <Caption>
        <FR>au port d'écoute</FR>
        <EN>XiServer is on #</EN>
		<ES>el puerto XiServer esta activado</ES>
      </Caption>
    </Label3>
    <Label4 type="TLabel">
      <Caption>
        <FR>La fenêtre se fermera s'il y a un</FR>
        <EN>The pop-up window will close if</EN>
		<ES>La ventana emergente se cerrara si</ES>
      </Caption>
    </Label4>
    <Label5 type="TLabel">
      <Caption>
        <FR>problème de port ou bien si la</FR>
        <EN>there's a COM problem or if the Arduino card</EN>
		<ES>hay un problema en el COM o en la tarjeta Arduino</ES>
      </Caption>
    </Label5>
    <Label6 type="TLabel">
      <Caption>
        <FR>carte Arduino est mal programmée.</FR>
        <EN>is not uploaded correctly.</EN>
		<ES>no se carga correctamente.</ES>
      </Caption>
    </Label6>
    <Label7 type="TLabel">
      <Caption>
        <FR>Adresse(s) IP du poste :</FR>
        <EN>Computer IP adress:</EN>
		<ES>Direccion IP:</ES>
      </Caption>
    </Label7>
    <Button1 type="TButton">
      <Caption>
        <FR>Lancer XiDuino</FR>
        <EN>Launch XiDuino</EN>
		<ES>Lanzar XiDuino</ES>
      </Caption>
    </Button1>
    <Button2 type="TButton">
      <Caption>
        <FR>Lancer Scratch2</FR>
        <EN>Launch Scratch2</EN>
		<ES>Lanzar Scratch2</ES>
      </Caption>
    </Button2>
    <Button3 type="TButton">
      <Caption>
        <FR>Scratch2 en ligne</FR>
        <EN>Scratch2 online</EN>
		<ES>Scratch2 en linea</ES>
      </Caption>
    </Button3>
    <Langues type="TMenuItem">
      <Caption>
        <FR>&Langues</FR>
        <EN>&Languages</EN>
		<ES>&Lenguajes</ES>
      </Caption>
    </Langues>
    <FrenchLang type="TMenuItem">
      <Caption>
        <FR>Français</FR>
        <EN>French</EN>
		<ES>Frances</ES>
      </Caption>
    </FrenchLang>
    <EnglishLang type="TMenuItem">
      <Caption>
        <FR>Anglais</FR>
        <EN>English</EN>
		<ES>Ingles</ES>
      </Caption>
    </EnglishLang>
	<SpanishLang type="TMenuItem">
      <Caption>
        <FR>Espagnol</FR>
        <EN>Spanish</EN>
        <ES>Espanol</ES>
      </Caption>
    </SpanishLang>
    <Fichier type="TMenuItem">
      <Caption>
        <FR>&Fichier</FR>
        <EN>&File</EN>
		<ES>&Archivo</ES>
      </Caption>
    </Fichier>
			<Bibliothque type="TMenuItem">
			  <Caption>
				<FR>B&ibliothèque</FR>
				<EN>L&ibrairie</EN>
				<ES>L&ibrerias</ES>
			  </Caption>
			</Bibliothque>
			<ExemplesScratch2 type="TMenuItem">
			  <Caption>
				<FR>&Projets Scratch2</FR>
				<EN>&Project Scratch2</EN>
				<ES>&Proyectos Scratch2</ES>
			  </Caption>
			</ExemplesScratch2>
			<Quitter1 type="TMenuItem">
			  <Caption>
				<FR>&Quitter</FR>
				<EN>&Quit</EN>
				<ES>&Salir</ES>
			  </Caption>
			</Quitter1>
    <Outils1 type="TMenuItem">
      <Caption>
        <FR>&Outils</FR>
        <EN>T&ools</EN>
		<ES>H&erramientas</ES>
      </Caption>
    </Outils1>
			<Gestionnairedepriphriques1 type="TMenuItem">
			  <Caption>
				<FR>Gestio&nnaire de périphériques</FR>
				<EN>Device ma&nagement</EN>
				<ES>Gestion de p&eriférico</ES>
			  </Caption>
			</Gestionnairedepriphriques1>
			<InstallDrivers type="TMenuItem">
			  <Caption>
				<FR>&Installer les pilotes</FR>
				<EN>&Install drivers</EN>
				<ES>&Instalar drivers</ES>
			  </Caption>
			</InstallDrivers>
					<w32 type="TMenuItem">
					  <Caption>
						<FR>Windows 32bits x86</FR>
						<EN>Windows 32bits x86</EN>
						<ES>Windows 32bits x86</ES>
					  </Caption>
					</w32>
					<w64 type="TMenuItem">
					  <Caption>
						<FR>Windows 64bits x64</FR>
						<EN>Windows 64bits x64</EN>
						<ES>Windows 64bits x64</ES>
					  </Caption>
					</w64>
			<Upload type="TMenuItem">
			  <Caption>
				<FR>Téléverser 'Firmata' dans une &carte</FR>
				<EN>Upload 'Firmata' in a &card</EN>
				<ES>Descargar 'Firmata' en una &card</ES>
			  </Caption>
			</Upload>
					<Firmata_Uno type="TMenuItem">
					  <Caption>
						<FR>Arduino Uno</FR>
						<EN>Arduino Uno</EN>
						<ES>Arduino Uno</ES>
					  </Caption>
					</Firmata_Uno>
					<Firmata_Mega type="TMenuItem">
					  <Caption>
						<FR>Arduino Mega</FR>
						<EN>Arduino Mega</EN>
						<ES>Arduino Mega</ES>
					  </Caption>
					</Firmata_Mega>
			<nodejs type="TMenuItem">
			  <Caption>
				<FR>Installer &node.js sur ce poste</FR>
				<EN>Install &node.js in this directory</EN>
				<ES>Instalar &node.js en este directorio</ES>
			  </Caption>
			</nodejs>
			<Locate type="TMenuItem">
			  <Caption>
				<FR>&Localiser les dossiers</FR>
				<EN>&Locate folders</EN>
				<ES>&Localizar carpetas</ES>
			  </Caption>
			</Locate>
					<Ouvrir type="TMenuItem">
					  <Caption>
						<FR>Localiser Scratch 2</FR>
						<EN>Locate Scratch2</EN>
						<ES>Localizar Scratch 2</ES>
					  </Caption>
					</Ouvrir>
					<Localiserledossierbibliothque1 type="TMenuItem">
					  <Caption>
						<FR>Localiser le dossier 'bibliothèque'</FR>
						<EN>Locate folder 'librairie'</EN>
						<ES>Localizar la carpeta de 'libreria'</ES>
					  </Caption>
					</Localiserledossierbibliothque1>
					<Localiserledossierprojets1 type="TMenuItem">
					  <Caption>
						<FR>Localiser le dossier 'projets'</FR>
						<EN>Locate folder 'project'</EN>
						<ES>Localizar la carpeta de 'proyectos'</ES>
					  </Caption>
					</Localiserledossierprojets1>
					<Localiserledossierdocumentation1 type="TMenuItem">
					  <Caption>
						<FR>Localiser le dossier 'documentation'</FR>
						<EN>Locate folder 'documentation'</EN>
						<ES>Localizar la carpeta de 'documentacion'</ES>
					  </Caption>
					</Localiserledossierdocumentation1>
					<Drivers type="TMenuItem">
					  <Caption>
						<FR>Ouvrir le dossier 'pilotes'</FR>
						<EN>Open 'drivers' folder</EN>
						<ES>Abrir carpeta de 'drivers'</ES>
					  </Caption>
					</Drivers>
			<Init type="TMenuItem">
			  <Caption>
				<FR>Réinitialiser les p&aramètres</FR>
				<EN>Initialise p&arameters</EN>
				<ES>Inicializar los p&arametros</ES>
			  </Caption>
			</Init>
			<AfficherladresseIPduposte1 type="TMenuItem">
			  <Caption>
				<FR>Afficher l'adresse &IP du poste</FR>
				<EN>Show computer &IP adress</EN>
				<ES>Mostrar la direccion &IP</ES>
			  </Caption>
			</AfficherladresseIPduposte1>
	<Documentation1 type="TMenuItem">
      <Caption>
        <FR>&Documentation</FR>
        <EN>&Documentation</EN>
		<ES>&Documentacion</ES>
      </Caption>
    </Documentation1>
    <BlocklyArduino type="TMenuItem">
      <Caption>
        <FR>Aller plus loin avec &Blockly@rduino</FR>
        <EN>Go furthermore with &Blockly@rduino</EN>
		<ES>Ademas con &Blockly@rduino</ES>
      </Caption>
    </BlocklyArduino>
    <Aide1 type="TMenuItem">
      <Caption>
        <FR>&Aide</FR>
        <EN>&Help</EN>
		<ES>&Ayuda</ES>
      </Caption>
    </Aide1>
			<Diaporamadeprsenation1 type="TMenuItem">
			  <Caption>
				<FR>&0. Diaporama de présentation</FR>
				<EN>&0. slideshow introduction</EN>
				<ES>&0. Presentacion</ES>
			  </Caption>
			</Diaporamadeprsenation1>
			<PrparerArduino1 type="TMenuItem">
			  <Caption>
				<FR>&1. Préparer la carte Arduino</FR>
				<EN>&1. prepare Arduino card</EN>
				<ES>&1. Preparar la tarjeta Arduino</ES>
			  </Caption>
			</PrparerArduino1>
			<Utilisation1 type="TMenuItem">
			  <Caption>
				<FR>&2. Utilisation de Xi</FR>
				<EN>&2. how to use Xi</EN>
				<ES>&2. Utilizacion de Xi</ES>
			  </Caption>
			</Utilisation1>
			<N4Principesdeprogrammation1 type="TMenuItem">
			  <Caption>
				<FR>&3. Principes de programmation</FR>
				<EN>&3. the best way to code</EN>
				<ES>&3. Principios de programacion</ES>
			  </Caption>
			</N4Principesdeprogrammation1>
			<N3Mmentodescommandes1 type="TMenuItem">
			  <Caption>
				<FR>&4. Mémento des commandes</FR>
				<EN>&4. Xi command summary</EN>
				<ES>&4. Aviso de comandos de Xi</ES>
			  </Caption>
			</N3Mmentodescommandes1>
			<Links type="TMenuItem">
			  <Caption>
				<FR>&Liens</FR>
				<EN>&Links</EN>
				<ES>&Enlaces</ES>
			  </Caption>
			</Links>
					<Wiki1 type="TMenuItem">
					  <Caption>
						<FR>Wiki</FR>
						<EN>Wiki</EN>
						<ES>Wiki</ES>
					  </Caption>
					</Wiki1>
					<A_propos type="TMenuItem">
					  <Caption>
						<FR>Fichiers source</FR>
						<EN>Github file</EN>
						<ES>Ficheros fuente Github</ES>
					  </Caption>
					</A_propos>
					<SiteofficieldeXi type="TMenuItem">
					  <Caption>
						<FR>Site officiel de Xi</FR>
						<EN>Xi official site</EN>
						<ES>Sitio Oficial de Xi</ES>
					  </Caption>
					</SiteofficieldeXi>
					<SiteofficielArduino1 type="TMenuItem">
					  <Caption>
						<FR>Site officiel Arduino</FR>
						<EN>Arduino official site</EN>
						<ES>Sitio Oficial de Arduino</ES>
					  </Caption>
					</SiteofficielArduino1>
					<lchargerlesdrivers1 type="TMenuItem">
					  <Caption>
						<FR>Télécharger les drivers</FR>
						<EN>Download Arduino drivers</EN>
						<ES>Cargar Drivers de Arduino</ES>
					  </Caption>
					</lchargerlesdrivers1>
			<Apropos1 type="TMenuItem">
			  <Caption>
				<FR>A propos</FR>
				<EN>About</EN>
				<ES>Acerca de</ES>
			  </Caption>
			</Apropos1>
  </Labels>
</Traductions>


text:
<?xml version="1.0" encoding="utf-8"?>
<android.support.v7.widget.CardView xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/cardView_android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_marginBottom="8dp"
    android:layout_marginEnd="16dp"
    android:layout_marginStart="16dp"
    android:layout_marginTop="8dp"
    android:foreground="@drawable/ripple_with_color_mask"
    >

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_margin="8dp"
        android:orientation="vertical">

        <TextView
            android:id="@+id/title_android"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_marginStart="8dp"
            android:textAppearance="@style/Base.TextAppearance.AppCompat.Small" />

        <ImageView
            android:id="@+id/imageView_android_image"
            android:layout_width="match_parent"
            android:layout_height="200dp"
            android:layout_margin="8dp"
            android:visibility="gone" />
    </LinearLayout>
</android.support.v7.widget.CardView>


text:
  * Jobs detail modal
  * Jobs table improvements - dataset linkable

# 0.1.3
 * [Bugfix] Typos

# 0.1.2
 * Bugfixes
 * Tables list - badges
 * Accordion with clickabled header

# 0.1.1
 * Empty output tables screen

# 0.1.0
 * First production release with all required features

# 0.0.0
 * Initial version


text:
package is.hail.expr.ir

case class ScopedDepth(eval: Int, agg: Int, scan: Int) {
  def incrementEval: ScopedDepth = ScopedDepth(eval + 1, agg, scan)

  def incrementAgg: ScopedDepth = ScopedDepth(eval, agg + 1, scan)

  def promoteAgg: ScopedDepth = ScopedDepth(agg, 0, 0)

  def incrementScan: ScopedDepth = ScopedDepth(eval, agg, scan + 1)

  def promoteScan: ScopedDepth = ScopedDepth(scan, 0, 0)

  def incrementScanOrAgg(isScan: Boolean): ScopedDepth = if (isScan) incrementScan else incrementAgg

  def promoteScanOrAgg(isScan: Boolean): ScopedDepth = if (isScan) promoteScan else promoteAgg
}

object NestingDepth {
  def apply(ir0: BaseIR): Memo[Int] = {

    val memo = Memo.empty[Int]

    def computeChildren(ir: BaseIR): Unit = {
      ir.children
        .iterator
        .zipWithIndex
        .foreach {
          case (child: IR, i) => computeIR(child, ScopedDepth(0, 0, 0))
          case (tir: TableIR, i) => computeTable(tir)
          case (mir: MatrixIR, i) => computeMatrix(mir)
          case (bmir: BlockMatrixIR, i) => computeBlockMatrix(bmir)
        }
    }

    def computeTable(tir: TableIR): Unit = computeChildren(tir)

    def computeMatrix(mir: MatrixIR): Unit = computeChildren(mir)

    def computeBlockMatrix(bmir: BlockMatrixIR): Unit = computeChildren(bmir)

    def computeIR(ir: IR, depth: ScopedDepth): Unit = {
      memo.bind(ir, depth.eval)
      ir match {
        case StreamMap(a, name, body) =>
          computeIR(a, depth)
          computeIR(body, depth.incrementEval)
        case StreamZip(as, _, body, _, _) =>
          as.foreach(computeIR(_, depth))
          computeIR(body, depth.incrementEval)
        case StreamFor(a, valueName, body) =>
          computeIR(a, depth)
          computeIR(body, depth.incrementEval)
        case StreamFlatMap(a, name, body) =>
          computeIR(a, depth)
          computeIR(body, depth.incrementEval)
        case StreamFilter(a, name, cond) =>
          computeIR(a, depth)
          computeIR(cond, depth.incrementEval)
        case StreamTakeWhile(a, name, cond) =>
          computeIR(a, depth)
          computeIR(cond, depth.incrementEval)
        case StreamDropWhile(a, name, cond) =>
          computeIR(a, depth)
          computeIR(cond, depth.incrementEval)
        case StreamFold(a, zero, accumName, valueName, body) =>
          computeIR(a, depth)
          computeIR(zero, depth)
          computeIR(body, depth.incrementEval)
        case StreamFold2(a, accum, _, seq, result) =>
          computeIR(a, depth)
          accum.foreach { case (_, value) => computeIR(value, depth) }
          seq.foreach(computeIR(_, depth.incrementEval))
          computeIR(result, depth)
        case StreamScan(a, zero, accumName, valueName, body) =>
          computeIR(a, depth)
          computeIR(zero, depth)
          computeIR(body, depth.incrementEval)
        case StreamJoinRightDistinct(left, right, lKey, rKey, l, r, joinF, joinType) =>
          computeIR(left, depth)
          computeIR(right, depth)
          computeIR(joinF, depth.incrementEval)
        case TailLoop(_, params, body) =>
          params.foreach { case (_, p) => computeIR(p, depth) }
          computeIR(body, depth.incrementEval)
        case NDArrayMap(nd, _, body) =>
          computeIR(nd, depth)
          computeIR(body, depth.incrementEval)
        case NDArrayMap2(nd1, nd2, _, _, body, _) =>
          computeIR(nd1, depth)
          computeIR(nd2, depth)
          computeIR(body, depth.incrementEval)
        case AggExplode(array, _, aggBody, isScan) =>
          computeIR(array, depth.promoteScanOrAgg(isScan))
          computeIR(aggBody, depth.incrementScanOrAgg(isScan))
        case AggArrayPerElement(a, _, _, aggBody, knownLength, isScan) =>
          computeIR(a, depth.promoteScanOrAgg(isScan))
          computeIR(aggBody, depth.incrementScanOrAgg(isScan))
          knownLength.foreach(computeIR(_, depth))
        case TableAggregate(child, query) =>
          computeTable(child)
          computeIR(query, ScopedDepth(0, 0, 0))
        case MatrixAggregate(child, query) =>
          computeMatrix(child)
          computeIR(query, ScopedDepth(0, 0, 0))
        case _ =>
          ir.children.iterator
            .zipWithIndex
            .foreach {
              case (child: IR, i) => if (UsesAggEnv(ir, i))
                computeIR(child, depth.promoteAgg)
              else if (UsesScanEnv(ir, i))
                computeIR(child, depth.promoteScan)
              else
                computeIR(child, depth)
              case (child: TableIR, _) => computeTable(child)
              case (child: MatrixIR, _) => computeMatrix(child)
              case (child: BlockMatrixIR, _) => computeBlockMatrix(child)
            }
      }
    }

    ir0 match {
      case ir: IR => computeIR(ir, ScopedDepth(0, 0, 0))
      case tir: TableIR => computeTable(tir)
      case mir: MatrixIR => computeMatrix(mir)
      case bmir: BlockMatrixIR => computeBlockMatrix(bmir)
    }

    memo
  }
}


text:
package k8s

import (
	"fmt"

	"github.com/rook/rook/pkg/cephmgr/mon"
	"github.com/rook/rook/pkg/cephmgr/rgw"
	"github.com/rook/rook/pkg/clusterd"
	"github.com/rook/rook/pkg/model"
	"github.com/rook/rook/pkg/operator/k8sutil"
	k8smds "github.com/rook/rook/pkg/operator/mds"
	k8srgw "github.com/rook/rook/pkg/operator/rgw"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

type clusterHandler struct {
	k8sContext  *k8sutil.Context
	dcontext    *clusterd.DaemonContext
	clusterInfo *mon.ClusterInfo
	namespace   string
	versionTag  string
}

func New(k8sContext *k8sutil.Context, dcontext *clusterd.DaemonContext, clusterInfo *mon.ClusterInfo, namespace, versionTag string) *clusterHandler {
	return &clusterHandler{k8sContext: k8sContext, dcontext: dcontext, clusterInfo: clusterInfo, namespace: namespace, versionTag: versionTag}
}

func (s *clusterHandler) GetClusterInfo() (*mon.ClusterInfo, error) {
	return s.clusterInfo, nil
}

func (s *clusterHandler) EnableObjectStore() error {
	logger.Infof("Starting the Object store")
	r := k8srgw.New(s.k8sContext, s.clusterInfo.Name, s.namespace, s.versionTag)
	err := r.Start(s.clusterInfo)
	if err != nil {
		return fmt.Errorf("failed to start rgw. %+v", err)
	}
	return nil
}

func (s *clusterHandler) RemoveObjectStore() error {
	logger.Infof("TODO: Remove the object store")
	return nil
}

func (s *clusterHandler) GetObjectStoreConnectionInfo() (*model.ObjectStoreConnectInfo, bool, error) {
	logger.Infof("Getting the object store connection info")
	service, err := s.k8sContext.Clientset.CoreV1().Services(s.namespace).Get("rgw", metav1.GetOptions{})
	if err != nil {
		return nil, false, fmt.Errorf("failed to get rgw service. %+v", err)
	}

	info := &model.ObjectStoreConnectInfo{
		Host:       "rook-rgw",
		IPEndpoint: rgw.GetRGWEndpoint(service.Spec.ClusterIP),
	}
	logger.Infof("Object store connection: %+v", info)
	return info, true, nil
}

func (s *clusterHandler) StartFileSystem(fs *model.FilesystemRequest) error {
	logger.Infof("Starting the MDS")
	c := k8smds.New(s.k8sContext, s.clusterInfo.Name, s.namespace, s.versionTag)
	return c.Start(s.k8sContext.Clientset, s.clusterInfo)
}

func (s *clusterHandler) RemoveFileSystem(fs *model.FilesystemRequest) error {
	logger.Infof("TODO: Remove file system")
	return nil
}

func (s *clusterHandler) GetMonitors() (map[string]*mon.CephMonitorConfig, error) {
	logger.Infof("TODO: Get monitors")
	mons := map[string]*mon.CephMonitorConfig{}

	return mons, nil
}

func (s *clusterHandler) GetNodes() ([]model.Node, error) {
	logger.Infof("Getting nodes")
	return getNodes(s.k8sContext.Clientset)
}


text:
@interface AppDelegate ()

@property (strong, nonatomic) id eventHandler;

@end

@implementation AppDelegate

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification
{
    // Go into system prefs > Accessibility and grant access to Xcode. Otherwise key downs won't register.
    NSDictionary *options = @{(__bridge_transfer NSString *)kAXTrustedCheckOptionPrompt: @YES};
    AXIsProcessTrustedWithOptions((__bridge CFDictionaryRef)options);

    self.eventHandler = [NSEvent addGlobalMonitorForEventsMatchingMask:NSKeyDownMask handler:^(NSEvent *event) {
        NSLog(@"Event: %@", event);
    }];
}

- (void)applicationWillTerminate:(NSNotification *)aNotification
{
    [NSEvent removeMonitor:self.eventHandler];
}

@end


text:
    <title>Contact us</title>

Contact Justin For Problem Solving

    {% if form.errors %}

            Please correct the error{{ form.errors|pluralize }} below

    {% endif %}

    <form action="" method="post">

            {{ form.as_table }}

        <input type="submit" value="Submit">
    </form>


text:
layout: sgpm-default-display
title:
author:
tags: ["1950s", "1960s", "1970s", "1980s", "1990s", "bhairahawa", "dharan", "gurkhas", "kathmandu", "nepal", "pokhara", "singapore", "singapore gurkha archive", "singapore gurkha old photographs", "singapore gurkha photography museum", "singapore gurkhas"]
credit:
source: -singapore-gurkhas-050116-gcspf-gurkha-contingent-archives-cbg-42
description: "Chandra wife put's a tika on the sister-in-law."
copyright: ChandraBahadurGurung-SingaporeGurkhaPhotographyMuseum
slug: -singapore-gurkhas-050116-gcspf-gurkha-contingent-archives-cbg-42
date: 2014-10-09
img_path: singapore-gurkhas-050116-gcspf-gurkha-contingent-archives-CBG-42.jpg
category: singapore-gurkha-photography-museum
---

	 		{{ site.tags }}


text:
var pastas = Array("Alfabeto",
"Anelli",
"Barbina",
"Bavette",
"Bavettine",
"Bigoli",
"Bucatini",
"Calamarata",
"Calamaretti",
"Campanelle",
"Cannelloni",
"Capellini",
"Capunti",
"Casarecce",
"Cavatappi",
"Cavatelli",
"Cellentani",
"Cencioni",
"Chifferi",
"Ciriole",
"Conchiglie",
"Conchigliette",
"Corallini",
"Corzetti",
"Croxetti",
"Ditali",
"Ditalini",
"Elicoidali",
"Fagioloni",
"Farfalle",
"Farfalline",
"Fedelini",
"Fettuce",
"Fettucelle",
"Fideos",
"Fideua",
"Fiori",
"Fregula",
"Funghini",
"Fusilli",
"Garganelli",
"Gemelli",
"Gigli",
"Gramigna",
"Grattini",
"Grattoni",
"Lagane",
"Lanterne",
"Linguine",
"Lumache",
"Lumaconi",
"Mafalde",
"Maltagliati",
"Mandala",
"Manicotti",
"Marille",
"Marziani",
"Matriciani",
"Midolline",
"Mostaccioli",
"Orecchiette",
"Orzo",
"Paccheri",
"Pappardelle",
"Pastina",
"Pellizzoni",
"Perciatelli",
"Pici",
"Pillus",
"Pipe",
"Pizzoccheri",
"Puntine",
"Quadrefiore",
"Radiatori",
"Ricciolini",
"Ricciutelle",
"Rotelle",
"Rotini",
"Rotini",
"Sagnarelli",
"Scialatelli",
"Sorprese",
"Spirali",
"Stelle",
"Stortini",
"Stringozzi",
"Strozzapreti",
"Tagliatelle",
"Talierini",
"Torchio",
"Tortiglioni",
"Trenette",
"Trenne",
"Tripoline",
"Tripolini",
"Trofie",
"Tuffoli",
"Ziti",
"Zitoni");

// array of composers
var composers = Array("Albertini",
"Albinoni",
"Alfano ",
"Allapana ",
"Allegri",
"Anfossi ",
"Bedetti ",
"Bellini ",
"Bertali ",
"Boccherini ",
"Bononcini  ",
"Brunetti ",
"Busoni",
"Campagnoli ",
"Carissimi",
"Casella ",
"Tedesco ",
"Catalani ",
"Cavalieri ",
"Cavalli ",
"Cherubini ",
"Cimarosa ",
"Clementi ",
"Corelli ",
"Carulli",
"Vittorio ",
"Donatoni ",
"Donaudy ",
"Donizetti",
"Ferrero",
"Finzi ",
"Franchetti",
"Francesconi ",
"Frescobaldi ",
"Gabrieli ",
"Galuppi ",
"Gariboldi ",
"Ghedini ",
"Giordano",
"Giuliani ",
"Jommelli ",
"Landini",
"Legrenzi ",
"Locatelli ",
"Luchesi ",
"Luzzaschi ",
"Mainerio",
"Malipiero ",
"Marcello ",
"Marenzio ",
"Marini ",
"Martucci ",
"Mascagni  ",
"Mazzocchi ",
"Mazzazzoli ",
"Menotti ",
"Mercadante ",
"Monteverdi",
"Ortolani",
"Ortolano ",
"Pacini ",
"Paganini ",
"Paisiello ",
"Petrassi",
"Palestrina ",
"Pasquini ",
"Pergolesi ",
"Piccinni ",
"Pizzetti ",
"Ponchielli ",
"Puccini ",
"Pugnani ",
"Rampollini",
"Respighi ",
"Rieti ",
"Rossini ",
"Sacchini ",
"Salieri ",
"Sammartini ",
"Scarlatti ",
"Schittino ",
"Scelsi ",
"Sciarrino ",
"Sgambati ",
"Simonetti ",
"Spontini ",
"Steffani ",
"Strozzi ",
"Tartini ",
"Torelli ",
"Tozzi ",
"Traetta ",
"Uccellini ",
"Valentini ",
"Veracini ",
"Venturi ",
"Viotti ",
"Vittorio ",
"Zipoli"
);

// keeping track of score
var right=0;
var wrong=0;

$(document).ready(function(){
    // function that picks either a pasta or composer to be displayed
    function generate(){
        var rand = Math.random();
        if(rand < .5) { // choose a pasta to display
            var random = pastas[Math.floor(Math.random()*pastas.length)];
        }
        else { // choose a composer to display
            var random = composers[Math.floor(Math.random()*composers.length)];
        }
    // set the text of "random word" to whatever random pasta/composer chosen
    $("#randomword").html(random);
    } // close generate function
    generate(); // when the page is loaded, run the generate function
    // button stuffs
    $("#composer").hover(function(){ // when you hover over "composer", it becomes a darker red
        $("#composerh2").css("color", "#AF2B36");
        $("#composerh2").css("cursor", "pointer");
        }, function(){ // but goes back to the original red when your cursor is lifed
        $("#composerh2").css("color", "#CF2B36");
        $("#composerh2").css("cursor", "pointer");
        }
        )
    $("#pasta").hover(function(){ // repeat for pasta
        $("#pastah2").css("color", "#AF2B36");
        $("#pastah2").css("cursor", "pointer");
        }, function(){
        $("#pastah2").css("color", "#CF2B36");
        $("#pastah2").css("cursor", "pointer");
        }
        );
    $("#composer").click(function(){
            var curr = $("#randomword").html(); // set the variable "curr" to the text that is displayed
            if(composers.indexOf(curr) > -1){ // if the current one is in the composers array
            // display text with green background
            $("#answer").html(curr +" is indeed a composer!");
            $("#answer").css("visibility", "visible");
            $('#answer').css("background-color", "#019243");
            right += 1;
            // display the current score
            $('#score').html("So far you have gotten " + right + " of " + (right+wrong) + " correct.");
            $("#score").css("visibility", "visible");
            }
            else{
            // display the text with red background
            $("#answer").html("Wrong! " + curr + " is a pasta");
            $("#answer").css("visibility", "visible");
            $('#answer').css("background-color", "#CF2B36");
            wrong += 1;
            // display the current score
            $('#score').html("So far you have gotten " + right + " of " + (right+wrong) + " correct.");
            $("#score").css("visibility", "visible");
            }
            generate(); // pick a new italian word to be displayed
    })
    $("#pasta").click(function(){ // repeat for pasta
            var curr = $("#randomword").html();
            if(pastas.indexOf(curr) > -1){
            $("#answer").html(curr +" is indeed a pasta!");
            $("#answer").css("visibility", "visible");
            $('#answer').css("background-color", "#019243");
            $('#answer').css("background-color", "#019243");
            right += 1;
            $('#score').html("So far you have gotten " + right + " of " + (right+wrong) + " correct.");
            $("#score").css("visibility", "visible");
            }
            else{
            $("#answer").html("Wrong! " + curr + " is a composer");
            $("#answer").css("visibility", "visible");
            $('#answer').css("background-color", "#CF2B36");
            wrong += 1;
            $('#score').html("So far you have gotten " + right + " of " + (right+wrong) + " correct.");
            $("#score").css("visibility", "visible");
            }
            generate();
    })
});


text:
/*	$NetBSD: ds1286reg.h,v 1.2 2002/02/25 17:37:47 kleink Exp $ 	*/

/*
 * Copyright (c) 2001 Rafal K. Boni
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * Originally based on mc146818reg.h, with the following license:
 *
 * Copyright (c) 1995 Carnegie-Mellon University.
 * All rights reserved.
 *
 * Permission to use, copy, modify and distribute this software and
 * its documentation is hereby granted, provided that both the copyright
 * notice and this permission notice appear in all copies of the
 * software, derivative works or modified versions, and any portions
 * thereof, and that both notices appear in supporting documentation.
 *
 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
 * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
 *
 * Carnegie Mellon requests users of this software to return to
 *
 *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
 *  School of Computer Science
 *  Carnegie Mellon University
 *  Pittsburgh PA 15213-3890
 *
 * any improvements or extensions that they make and grant Carnegie the
 * rights to redistribute these changes.
 */

/*
 * Definitions for the Dallas Semiconductor DS1286/DS1386 Real Time Clock.
 *
 * Plucked right from the Dallas Semicomductor specs available at
 * http://pdfserv.maxim-ic.com/arpdf/DS1286.pdf and
 * http://pdfserv.maxim-ic.com/arpdf/DS1386-DS1386P.pdf
 *
 * The DS1286 and 1386 have 14 clock-related registers and some amount
 * of user registers (50 for the 1286, 8K or 32K for the 1386).  The
 * first eleven registers contain time-of-day and alarm data, the rest
 * contain various control bits and the watchdog timer functionality.
 *
 * Since the locations of these ports and the method used to access
 * them can be machine-dependent, the low-level details of reading
 * and writing the RTC's registers are handled by machine-specific
 * functions.
 *
 * The Dalla chip always stored time-of-day and alarm data in BCD.
 * The "hour" time-of-year and alarm fields can either be expressed in
 * AM/PM format, or in 24-hour format.  If AM/PM format is chosen, the
 * hour fields can have the values: 1-12 and 21-32 (the latter being
 * PM).  If the 24-hour format is chosen, they can have the values
 * 0-23.  The hour format is selectable separately for the time and
 * alarm fields, and is controller by bit 6 of the respective register.
 */

/*
 * The registers, and the bits within each register.
 */

#define	DS_SUBSEC	0x0	/* Time of year: hundredths of seconds (0-99) */
#define	DS_SEC		0x1	/* Time of year: seconds (0-59) */
#define	DS_MIN		0x2	/* Time of year: minutes (0-59) */
#define	DS_AMIN		0x3	/* Alarm: minutes */
#define	DS_HOUR		0x4	/* Time of year: hour (see above) */

#define  DS_HOUR_12MODE		0x40	/* Hour mode: 12-hour (on), 24 (off) */
#define  DS_HOUR_12HR_PM	0x20	/* AM/PM in 12-hour mode: on = PM */
#define  DS_HOUR_12HR_MASK	0x1f	/* Mask for hours in 12hour mode */
#define  DS_HOUR_24HR_MASK	0x3f	/* Mask for hours in 24hour mode */

#define	DS_AHOUR	0x5	/* Alarm: hour */
#define	DS_DOW		0x6	/* Time of year: day of week (1-7) */
#define	DS_ADOW		0x7	/* Alarm: day of week (1-7) */
#define	DS_DOM		0x8	/* Time of year: day of month (1-31) */
#define	DS_MONTH	0x9	/* Time of year: month (1-12), wave generator */

#define	 DS_MONTH_MASK		0x3f	/* Mask to extract month */
#define	 DS_WAVEGEN_MASK	0xc0	/* Mask to extract wave bits */

#define	DS_YEAR		0xA	/* Time of year: year in century (0-99) */

#define	DS_CONTROL	0xB	/* Control register A */

#define	 DS_TE		0x80	/* Update in progress (on == disable update) */
#define	 DS_INTSWAP	0x40	/* Swap INTA, INTB outputs */
#define	 DS_INTBSRC	0x20	/* INTB source (on) or sink (off) current */
#define	 DS_INTAPLS	0x10	/* INTA pulse (on) or level (off) mode */
#define  DS_WAM		0x08	/* Watchdog alarm mask */
#define  DS_TDM		0x04	/* Time-of-day alarm mask */
#define  DS_WAF		0x02	/* Watchdog alarm flag */
#define  DS_TDF		0x01	/* Time-of-day alarm flag */

#define	DS_NREGS	0xd	/* 14 registers; CMOS follows */
#define	DS_NTODREGS	0xb	/* 10 of those regs are for TOD and alarm */

#define	DS_NVRAM_START	0xe	/* start of NVRAM: offset 14 */

/* NVRAM size depends on the chip -- the 1286 only has 50 bytes, whereas
 * the 1386 can have 8K or 32K
 */
#define	DS_NVRAM_SIZE	50		/* 50 bytes of NVRAM */

/*
 * RTC register/NVRAM read and write functions -- machine-dependent.
 * Appropriately manipulate RTC registers to get/put data values.
 */
u_int ds1286_read __P((void *sc, u_int reg));
void ds1286_write __P((void *sc, u_int reg, u_int datum));

/*
 * A collection of TOD/Alarm registers.
 */
typedef u_int ds_todregs[DS_NTODREGS];

/*
 * Get all of the TOD/Alarm registers
 * Must be called at splhigh(), and with the RTC properly set up.
 */
#define DS1286_GETTOD(sc, regs)						\
	do {								\
		int i;							\
		u_int ctl;						\
									\
		/* turn off update for now */				\
		ctl = ds1286_read(sc, DS_CONTROL);			\
		ds1286_write(sc, DS_CONTROL, ctl | DS_TE);		\
									\
		/* read all of the tod/alarm regs */			\
		for (i = 0; i < DS_NTODREGS; i++) 			\
			(*regs)[i] = ds1286_read(sc, i);		\
									\
		/* turn update back on */				\
		ds1286_write(sc, DS_CONTROL, ctl);			\
	} while (0);

/*
 * Set all of the TOD/Alarm registers
 * Must be called at splhigh(), and with the RTC properly set up.
 */
#define DS1286_PUTTOD(sc, regs)						\
	do {								\
		int i;							\
		u_int ctl;						\
									\
		/* turn off update for now */				\
		ctl = ds1286_read(sc, DS_CONTROL);			\
		ds1286_write(sc, DS_CONTROL, ctl | DS_TE);		\
									\
		/* write all of the tod/alarm regs */			\
		for (i = 0; i < DS_NTODREGS; i++) 			\
			ds1286_write(sc, i, (*regs)[i]);		\
									\
		/* turn update back on */				\
		ds1286_write(sc, DS_CONTROL, ctl);			\
	} while (0);


text:
package main

import (
	"fmt"
	"os"

	vc "github.com/kata-containers/runtime/virtcontainers"
	"github.com/kata-containers/runtime/virtcontainers/pkg/oci"
	"github.com/urfave/cli"
)

var deleteCLICommand = cli.Command{
	Name:  "delete",
	Usage: "Delete any resources held by one or more containers",
	ArgsUsage: `<container-id> [container-id...]

   <container-id> is the name for the instance of the container.

EXAMPLE:
   If the container id is "ubuntu01" and ` + name + ` list currently shows the
   status of "ubuntu01" as "stopped" the following will delete resources held
   for "ubuntu01" removing "ubuntu01" from the ` + name + ` list of containers:

       # ` + name + ` delete ubuntu01`,
	Flags: []cli.Flag{
		cli.BoolFlag{
			Name:  "force, f",
			Usage: "Forcibly deletes the container if it is still running (uses SIGKILL)",
		},
	},
	Action: func(context *cli.Context) error {
		args := context.Args()
		if args.Present() == false {
			return fmt.Errorf("Missing container ID, should at least provide one")
		}

		force := context.Bool("force")
		for _, cID := range []string(args) {
			if err := delete(cID, force); err != nil {
				return err
			}
		}

		return nil
	},
}

func delete(containerID string, force bool) error {
	// Checks the MUST and MUST NOT from OCI runtime specification
	status, podID, err := getExistingContainerInfo(containerID)
	if err != nil {
		return err
	}

	containerID = status.ID

	containerType, err := oci.GetContainerType(status.Annotations)
	if err != nil {
		return err
	}

	// Retrieve OCI spec configuration.
	ociSpec, err := oci.GetOCIConfig(status)
	if err != nil {
		return err
	}

	forceStop := false
	if oci.StateToOCIState(status.State) == oci.StateRunning {
		if !force {
			return fmt.Errorf("Container still running, should be stopped")
		}

		forceStop = true
	}

	switch containerType {
	case vc.PodSandbox:
		if err := deletePod(podID); err != nil {
			return err
		}
	case vc.PodContainer:
		if err := deleteContainer(podID, containerID, forceStop); err != nil {
			return err
		}
	default:
		return fmt.Errorf("Invalid container type found")
	}

	// In order to prevent any file descriptor leak related to cgroups files
	// that have been previously created, we have to remove them before this
	// function returns.
	cgroupsPathList, err := processCgroupsPath(ociSpec, containerType.IsPod())
	if err != nil {
		return err
	}

	return removeCgroupsPath(containerID, cgroupsPathList)
}

func deletePod(podID string) error {
	if _, err := vci.StopPod(podID); err != nil {
		return err
	}

	if _, err := vci.DeletePod(podID); err != nil {
		return err
	}

	return nil
}

func deleteContainer(podID, containerID string, forceStop bool) error {
	if forceStop {
		if _, err := vci.StopContainer(podID, containerID); err != nil {
			return err
		}
	}

	if _, err := vci.DeleteContainer(podID, containerID); err != nil {
		return err
	}

	return nil
}

func removeCgroupsPath(containerID string, cgroupsPathList []string) error {
	if len(cgroupsPathList) == 0 {
		ccLog.WithField("container", containerID).Info("Cgroups files not removed because cgroupsPath was empty")
		return nil
	}

	for _, cgroupsPath := range cgroupsPathList {
		if err := os.RemoveAll(cgroupsPath); err != nil {
			return err
		}
	}

	return nil
}


text:
package CQS::CQSPileup;

use strict;
use warnings;
use File::Basename;
use CQS::PBS;
use CQS::ConfigUtils;
use CQS::SystemUtils;
use CQS::FileUtils;
use CQS::Task;
use CQS::NGSCommon;
use CQS::StringUtils;

our @ISA = qw(CQS::Task);

sub new {
  my ($class) = @_;
  my $self = $class->SUPER::new();
  $self->{_name}   = "CQSPileup";
  $self->{_suffix} = "_pl";
  bless $self, $class;
  return $self;
}

sub perform {
  my ( $self, $config, $section ) = @_;

  my ( $task_name, $path_file, $pbsDesc, $target_dir, $logDir, $pbsDir, $resultDir, $option, $sh_direct, $cluster ) = get_parameter( $config, $section );

  my $cqsFile = get_cqstools( $config, $section, 1 );
  my $samtools = get_param_file( $config->{$section}{samtools},  "samtools",  1 );
  my $gffFile  = get_param_file( $config->{$section}{gff_file},  "gff_file",  1 );

  my %rawFiles = %{ get_raw_files( $config, $section ) };

  my %seqCountFiles = ();
  if ( has_raw_files( $config, $section, "seqcount" ) ) {
    %seqCountFiles = %{ get_raw_files( $config, $section, "seqcount" ) };
  }

  my $shfile = $self->taskfile( $pbsDir, $task_name );
  open( SH, ">$shfile" ) or die "Cannot create $shfile";
  print SH get_run_command($sh_direct) . "\n";

  for my $sampleName ( sort keys %rawFiles ) {
    my @bamFiles  = @{ $rawFiles{$sampleName} };
    my $bamFile   = $bamFiles[0];
    my $fileName  = basename($bamFile);
    my $countFile = $fileName . ".tsv";

    my $seqcountFile = "";
    if ( defined $seqCountFiles{$sampleName} ) {
      my @seqcounts = @{ $seqCountFiles{$sampleName} };
      my $seqcount  = $seqcounts[0];
      $seqcountFile = " -c $seqcount";
    }

    my $curDir = create_directory_or_die( $resultDir . "/$sampleName" );

    my $pbsFile = $self->pbsfile( $pbsDir, $sampleName );
    my $pbsName = basename($pbsFile);
    my $log     = $self->logfile( $logDir, $sampleName );
    print SH "\$MYCMD ./$pbsName \n";

    my $log_desc = $cluster->get_log_desc($log);

    open( OUT, ">$pbsFile" ) or die $!;
    print OUT "$pbsDesc
$log_desc

$path_file

cd $curDir

if [ -s $countFile ]; then
  echo job has already been done. if you want to do again, delete $countFile and submit job again.
  exit 0
fi

echo CQSPileup=`date`

mono-sgen $cqsFile cqs_pileup $option --samtools $samtools -i $bamFile -g $gffFile -o $countFile $seqcountFile

echo finished=`date`

exit 0
";

    close OUT;

    print "$pbsFile created \n";
  }
  close(SH);

  if ( is_linux() ) {
    chmod 0755, $shfile;
  }

  print "!!!shell file $shfile created, you can run this shell file to submit all cqs_pileup tasks.\n";

  #`qsub $pbsFile`;
}

sub result {
  my ( $self, $config, $section, $pattern ) = @_;

  my ( $task_name, $path_file, $pbsDesc, $target_dir, $logDir, $pbsDir, $resultDir, $option, $sh_direct ) = get_parameter( $config, $section );

  my %rawFiles = %{ get_raw_files( $config, $section ) };

  my $result = {};
  for my $sampleName ( keys %rawFiles ) {
    my $curDir = $resultDir . "/$sampleName";

    my @bamFiles = @{ $rawFiles{$sampleName} };
    my $bamFile  = $bamFiles[0];
    my $fileName = basename($bamFile);

    my @resultFiles = ();
    my $countFile   = $curDir . "/" . $fileName . ".tsv";
    push( @resultFiles, $countFile );

    $result->{$sampleName} = filter_array( \@resultFiles, $pattern );
  }
  return $result;
}

1;


text:
#include <errno.h>
#include <device.h>
#include <gpio.h>
#include <soc.h>
#include <fsl_common.h>
#include <fsl_port.h>

#include "gpio_utils.h"

struct gpio_mcux_config {
	GPIO_Type *gpio_base;
	PORT_Type *port_base;
	unsigned int flags;
};

struct gpio_mcux_data {
	/* port ISR callback routine address */
	sys_slist_t callbacks;
	/* pin callback routine enable flags, by pin number */
	u32_t pin_callback_enables;
};

static int gpio_mcux_configure(struct device *dev,
			       int access_op, u32_t pin, int flags)
{
	const struct gpio_mcux_config *config = dev->config->config_info;
	GPIO_Type *gpio_base = config->gpio_base;
	PORT_Type *port_base = config->port_base;
	port_interrupt_t port_interrupt = 0;
	u32_t mask = 0U;
	u32_t pcr = 0U;
	u8_t i;

	/* Check for an invalid pin number */
	if (pin >= ARRAY_SIZE(port_base->PCR)) {
		return -EINVAL;
	}

	/* Check for an invalid pin configuration */
	if ((flags & GPIO_INT) && (flags & GPIO_DIR_OUT)) {
		return -EINVAL;
	}

	/* Check if GPIO port supports interrupts */
	if ((flags & GPIO_INT) && ((config->flags & GPIO_INT) == 0U)) {
		return -ENOTSUP;
	}

	/* The flags contain options that require touching registers in the
	 * GPIO module and the corresponding PORT module.
	 *
	 * Start with the GPIO module and set up the pin direction register.
	 * 0 - pin is input, 1 - pin is output
	 */

	if (access_op == GPIO_ACCESS_BY_PIN) {
		if ((flags & GPIO_DIR_MASK) == GPIO_DIR_IN) {
			gpio_base->PDDR &= ~BIT(pin);
		} else {  /* GPIO_DIR_OUT */
			gpio_base->PDDR |= BIT(pin);
		}
	} else {	/* GPIO_ACCESS_BY_PORT */
		if ((flags & GPIO_DIR_MASK) == GPIO_DIR_IN) {
			gpio_base->PDDR = 0x0;
		} else {  /* GPIO_DIR_OUT */
			gpio_base->PDDR = 0xFFFFFFFF;
		}
	}

	/* Now do the PORT module. Figure out the pullup/pulldown
	 * configuration, but don't write it to the PCR register yet.
	 */
	mask |= PORT_PCR_PE_MASK | PORT_PCR_PS_MASK;

	if ((flags & GPIO_PUD_MASK) == GPIO_PUD_PULL_UP) {
		/* Enable the pull and select the pullup resistor. */
		pcr |= PORT_PCR_PE_MASK | PORT_PCR_PS_MASK;

	} else if ((flags & GPIO_PUD_MASK) == GPIO_PUD_PULL_DOWN) {
		/* Enable the pull and select the pulldown resistor (deselect
		 * the pullup resistor.
		 */
		pcr |= PORT_PCR_PE_MASK;
	}

	/* Still in the PORT module. Figure out the interrupt configuration,
	 * but don't write it to the PCR register yet.
	 */
	mask |= PORT_PCR_IRQC_MASK;

	if (flags & GPIO_INT) {
		if (flags & GPIO_INT_EDGE) {
			if (flags & GPIO_INT_ACTIVE_HIGH) {
				port_interrupt = kPORT_InterruptRisingEdge;
			} else if (flags & GPIO_INT_DOUBLE_EDGE) {
				port_interrupt = kPORT_InterruptEitherEdge;
			} else {
				port_interrupt = kPORT_InterruptFallingEdge;
			}
		} else { /* GPIO_INT_LEVEL */
			if (flags & GPIO_INT_ACTIVE_HIGH) {
				port_interrupt = kPORT_InterruptLogicOne;
			} else {
				port_interrupt = kPORT_InterruptLogicZero;
			}
		}
		pcr |= PORT_PCR_IRQC(port_interrupt);
	}

	/* Now we can write the PORT PCR register(s). If accessing by pin, we
	 * only need to write one PCR register. Otherwise, write all the PCR
	 * registers in the PORT module (one for each pin).
	 */
	if (access_op == GPIO_ACCESS_BY_PIN) {
		port_base->PCR[pin] = (port_base->PCR[pin] & ~mask) | pcr;
	} else {  /* GPIO_ACCESS_BY_PORT */
		for (i = 0U; i < ARRAY_SIZE(port_base->PCR); i++) {
			port_base->PCR[i] = (port_base->PCR[pin] & ~mask) | pcr;
		}
	}

	return 0;
}

static int gpio_mcux_write(struct device *dev,
			   int access_op, u32_t pin, u32_t value)
{
	const struct gpio_mcux_config *config = dev->config->config_info;
	GPIO_Type *gpio_base = config->gpio_base;

	if (access_op == GPIO_ACCESS_BY_PIN) {
		if (value) {
			/* Set the data output for the corresponding pin.
			 * Writing zeros to the other bits leaves the data
			 * output unchanged for the other pins.
			 */
			gpio_base->PSOR = BIT(pin);
		} else {
			/* Clear the data output for the corresponding pin.
			 * Writing zeros to the other bits leaves the data
			 * output unchanged for the other pins.
			 */
			gpio_base->PCOR = BIT(pin);
		}
	} else { /* GPIO_ACCESS_BY_PORT */
		/* Write the data output for all the pins */
		gpio_base->PDOR = value;
	}

	return 0;
}

static int gpio_mcux_read(struct device *dev,
			  int access_op, u32_t pin, u32_t *value)
{
	const struct gpio_mcux_config *config = dev->config->config_info;
	GPIO_Type *gpio_base = config->gpio_base;

	*value = gpio_base->PDIR;

	if (access_op == GPIO_ACCESS_BY_PIN) {
		*value = (*value & BIT(pin)) >> pin;
	}

	/* nothing more to do for GPIO_ACCESS_BY_PORT */

	return 0;
}

static int gpio_mcux_manage_callback(struct device *dev,
				     struct gpio_callback *callback, bool set)
{
	struct gpio_mcux_data *data = dev->driver_data;

	return gpio_manage_callback(&data->callbacks, callback, set);
}

static int gpio_mcux_enable_callback(struct device *dev,
				     int access_op, u32_t pin)
{
	struct gpio_mcux_data *data = dev->driver_data;

	if (access_op == GPIO_ACCESS_BY_PIN) {
		data->pin_callback_enables |= BIT(pin);
	} else {
		data->pin_callback_enables = 0xFFFFFFFF;
	}

	return 0;
}

static int gpio_mcux_disable_callback(struct device *dev,
				      int access_op, u32_t pin)
{
	struct gpio_mcux_data *data = dev->driver_data;

	if (access_op == GPIO_ACCESS_BY_PIN) {
		data->pin_callback_enables &= ~BIT(pin);
	} else {
		data->pin_callback_enables = 0U;
	}

	return 0;
}

static void gpio_mcux_port_isr(void *arg)
{
	struct device *dev = (struct device *)arg;
	const struct gpio_mcux_config *config = dev->config->config_info;
	struct gpio_mcux_data *data = dev->driver_data;
	u32_t enabled_int, int_status;

	int_status = config->port_base->ISFR;
	enabled_int = int_status & data->pin_callback_enables;

	gpio_fire_callbacks(&data->callbacks, dev, enabled_int);

	/* Clear the port interrupts */
	config->port_base->ISFR = 0xFFFFFFFF;
}

static const struct gpio_driver_api gpio_mcux_driver_api = {
	.config = gpio_mcux_configure,
	.write = gpio_mcux_write,
	.read = gpio_mcux_read,
	.manage_callback = gpio_mcux_manage_callback,
	.enable_callback = gpio_mcux_enable_callback,
	.disable_callback = gpio_mcux_disable_callback,
};

#ifdef CONFIG_GPIO_MCUX_PORTA
static int gpio_mcux_porta_init(struct device *dev);

static const struct gpio_mcux_config gpio_mcux_porta_config = {
	.gpio_base = (GPIO_Type *) DT_NXP_KINETIS_GPIO_GPIO_A_BASE_ADDRESS,
	.port_base = PORTA,
#ifdef DT_NXP_KINETIS_GPIO_GPIO_A_IRQ_0
	.flags = GPIO_INT,
#else
	.flags = 0,
#endif
};

static struct gpio_mcux_data gpio_mcux_porta_data;

DEVICE_AND_API_INIT(gpio_mcux_porta, DT_NXP_KINETIS_GPIO_GPIO_A_LABEL,
		    gpio_mcux_porta_init,
		    &gpio_mcux_porta_data, &gpio_mcux_porta_config,
		    POST_KERNEL, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,
		    &gpio_mcux_driver_api);

static int gpio_mcux_porta_init(struct device *dev)
{
#ifdef DT_NXP_KINETIS_GPIO_GPIO_A_IRQ_0
	IRQ_CONNECT(DT_NXP_KINETIS_GPIO_GPIO_A_IRQ_0, DT_NXP_KINETIS_GPIO_GPIO_A_IRQ_0_PRIORITY,
		    gpio_mcux_port_isr, DEVICE_GET(gpio_mcux_porta), 0);

	irq_enable(DT_NXP_KINETIS_GPIO_GPIO_A_IRQ_0);
#endif
	return 0;
}
#endif /* CONFIG_GPIO_MCUX_PORTA */

#ifdef CONFIG_GPIO_MCUX_PORTB
static int gpio_mcux_portb_init(struct device *dev);

static const struct gpio_mcux_config gpio_mcux_portb_config = {
	.gpio_base = (GPIO_Type *) DT_NXP_KINETIS_GPIO_GPIO_B_BASE_ADDRESS,
	.port_base = PORTB,
#ifdef DT_NXP_KINETIS_GPIO_GPIO_B_IRQ_0
	.flags = GPIO_INT,
#else
	.flags = 0,
#endif
};

static struct gpio_mcux_data gpio_mcux_portb_data;

DEVICE_AND_API_INIT(gpio_mcux_portb, DT_NXP_KINETIS_GPIO_GPIO_B_LABEL,
		    gpio_mcux_portb_init,
		    &gpio_mcux_portb_data, &gpio_mcux_portb_config,
		    POST_KERNEL, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,
		    &gpio_mcux_driver_api);

static int gpio_mcux_portb_init(struct device *dev)
{
#ifdef DT_NXP_KINETIS_GPIO_GPIO_B_IRQ_0
	IRQ_CONNECT(DT_NXP_KINETIS_GPIO_GPIO_B_IRQ_0, DT_NXP_KINETIS_GPIO_GPIO_B_IRQ_0_PRIORITY,
		    gpio_mcux_port_isr, DEVICE_GET(gpio_mcux_portb), 0);

	irq_enable(DT_NXP_KINETIS_GPIO_GPIO_B_IRQ_0);
#endif
	return 0;
}
#endif /* CONFIG_GPIO_MCUX_PORTB */

#ifdef CONFIG_GPIO_MCUX_PORTC
static int gpio_mcux_portc_init(struct device *dev);

static const struct gpio_mcux_config gpio_mcux_portc_config = {
	.gpio_base = (GPIO_Type *) DT_NXP_KINETIS_GPIO_GPIO_C_BASE_ADDRESS,
	.port_base = PORTC,
#ifdef DT_NXP_KINETIS_GPIO_GPIO_C_IRQ_0
	.flags = GPIO_INT,
#else
	.flags = 0,
#endif
};

static struct gpio_mcux_data gpio_mcux_portc_data;

DEVICE_AND_API_INIT(gpio_mcux_portc, DT_NXP_KINETIS_GPIO_GPIO_C_LABEL,
		    gpio_mcux_portc_init,
		    &gpio_mcux_portc_data, &gpio_mcux_portc_config,
		    POST_KERNEL, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,
		    &gpio_mcux_driver_api);

static int gpio_mcux_portc_init(struct device *dev)
{
#ifdef DT_NXP_KINETIS_GPIO_GPIO_C_IRQ_0
	IRQ_CONNECT(DT_NXP_KINETIS_GPIO_GPIO_C_IRQ_0, DT_NXP_KINETIS_GPIO_GPIO_C_IRQ_0_PRIORITY,
		    gpio_mcux_port_isr, DEVICE_GET(gpio_mcux_portc), 0);

	irq_enable(DT_NXP_KINETIS_GPIO_GPIO_C_IRQ_0);
#endif
	return 0;
}
#endif /* CONFIG_GPIO_MCUX_PORTC */

#ifdef CONFIG_GPIO_MCUX_PORTD
static int gpio_mcux_portd_init(struct device *dev);

static const struct gpio_mcux_config gpio_mcux_portd_config = {
	.gpio_base = (GPIO_Type *) DT_NXP_KINETIS_GPIO_GPIO_D_BASE_ADDRESS,
	.port_base = PORTD,
#ifdef DT_NXP_KINETIS_GPIO_GPIO_D_IRQ_0
	.flags = GPIO_INT,
#else
	.flags = 0,
#endif
};

static struct gpio_mcux_data gpio_mcux_portd_data;

DEVICE_AND_API_INIT(gpio_mcux_portd, DT_NXP_KINETIS_GPIO_GPIO_D_LABEL,
		    gpio_mcux_portd_init,
		    &gpio_mcux_portd_data, &gpio_mcux_portd_config,
		    POST_KERNEL, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,
		    &gpio_mcux_driver_api);

static int gpio_mcux_portd_init(struct device *dev)
{
#ifdef DT_NXP_KINETIS_GPIO_GPIO_D_IRQ_0
	IRQ_CONNECT(DT_NXP_KINETIS_GPIO_GPIO_D_IRQ_0, DT_NXP_KINETIS_GPIO_GPIO_D_IRQ_0_PRIORITY,
		    gpio_mcux_port_isr, DEVICE_GET(gpio_mcux_portd), 0);

	irq_enable(DT_NXP_KINETIS_GPIO_GPIO_D_IRQ_0);
#endif
	return 0;
}
#endif /* CONFIG_GPIO_MCUX_PORTD */

#ifdef CONFIG_GPIO_MCUX_PORTE
static int gpio_mcux_porte_init(struct device *dev);

static const struct gpio_mcux_config gpio_mcux_porte_config = {
	.gpio_base = (GPIO_Type *) DT_NXP_KINETIS_GPIO_GPIO_E_BASE_ADDRESS,
	.port_base = PORTE,
#ifdef DT_NXP_KINETIS_GPIO_GPIO_E_IRQ_0
	.flags = GPIO_INT,
#else
	.flags = 0,
#endif
};

static struct gpio_mcux_data gpio_mcux_porte_data;

DEVICE_AND_API_INIT(gpio_mcux_porte, DT_NXP_KINETIS_GPIO_GPIO_E_LABEL,
		    gpio_mcux_porte_init,
		    &gpio_mcux_porte_data, &gpio_mcux_porte_config,
		    POST_KERNEL, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,
		    &gpio_mcux_driver_api);

static int gpio_mcux_porte_init(struct device *dev)
{
#ifdef DT_NXP_KINETIS_GPIO_GPIO_E_IRQ_0
	IRQ_CONNECT(DT_NXP_KINETIS_GPIO_GPIO_E_IRQ_0, DT_NXP_KINETIS_GPIO_GPIO_E_IRQ_0_PRIORITY,
		    gpio_mcux_port_isr, DEVICE_GET(gpio_mcux_porte), 0);

	irq_enable(DT_NXP_KINETIS_GPIO_GPIO_E_IRQ_0);
#endif
	return 0;
}
#endif /* CONFIG_GPIO_MCUX_PORTE */


text:
package io.github.marcelovca90.common;

public class DataSetMetadata
{
    private int emptyHamCount;
    private int emptySpamCount;
    private String folder;

    public DataSetMetadata(String folder, int emptyHamCount, int emptySpamCount)
    {
        super();
        this.folder = folder;
        this.emptyHamCount = emptyHamCount;
        this.emptySpamCount = emptySpamCount;
    }

    public int getEmptyHamCount()
    {
        return emptyHamCount;
    }

    public int getEmptySpamCount()
    {
        return emptySpamCount;
    }

    public String getFolder()
    {
        return folder;
    }

    @Override
    public String toString()
    {
        return "DataSetMetadata [folder=" + folder + ", emptyHamCount=" + emptyHamCount + ", emptySpamCount=" + emptySpamCount + "]";
    }
}


text:
package org.qipki.crypto.mac;

import java.io.InputStream;
import java.io.UnsupportedEncodingException;

/**
 * Hash and Block Cipher based Message Authentication Code.
 */
public interface MAC
{

    byte[] mac( InputStream data, HMACParameters params );

    String hexMac( InputStream data, HMACParameters params );

    String base64Mac( InputStream data, HMACParameters params );

    byte[] mac( byte[] data, HMACParameters params );

    String hexMac( byte[] data, HMACParameters params );

    String base64Mac( byte[] data, HMACParameters params );

    byte[] mac( String data, HMACParameters params );

    String hexMac( String data, HMACParameters params );

    String base64Mac( String data, HMACParameters params );

    byte[] mac( String data, String encoding, HMACParameters params )
        throws UnsupportedEncodingException;

    String hexMac( String data, String encoding, HMACParameters params )
        throws UnsupportedEncodingException;

    String base64Mac( String data, String encoding, HMACParameters params )
        throws UnsupportedEncodingException;

    byte[] mac( InputStream data, BCMACParameters params );

    String hexMac( InputStream data, BCMACParameters params );

    String base64Mac( InputStream data, BCMACParameters params );

    byte[] mac( byte[] data, BCMACParameters params );

    String hexMac( byte[] data, BCMACParameters params );

    String base64Mac( byte[] data, BCMACParameters params );

    byte[] mac( String data, BCMACParameters params );

    String hexMac( String data, BCMACParameters params );

    String base64Mac( String data, BCMACParameters params );

    byte[] mac( String data, String encoding, BCMACParameters params )
        throws UnsupportedEncodingException;

    String hexMac( String data, String encoding, BCMACParameters params )
        throws UnsupportedEncodingException;

    String base64Mac( String data, String encoding, BCMACParameters params )
        throws UnsupportedEncodingException;

}


text:
package io.sarl.eclipse.launching.config;

/**
 * Type of the root context identifier in the multiagent system.
 *
 * @author $Author: sgalland$
 * @version $FullVersion$
 * @mavengroupid $GroupId$
 * @mavenartifactid $ArtifactId$
 */
public enum RootContextIdentifierType {

	/** The identifier of the root context is the one
	 * given by the SRE.
	 */
	DEFAULT_CONTEXT_ID,

	/** The identifier of the root context is randomly
	 * computed at each start of the SRE.
	 */
	RANDOM_CONTEXT_ID,

	/** The identifier of the root context is computed
	 * from the name of the type of the bott agent.
	 */
	BOOT_AGENT_CONTEXT_ID;

}


text:
[Bioconda](https://bioconda.github.io/) is a bioinformatics resource that extends the *Conda* package manager with bioinformatics software packages.
*ngs-bits* binaries can be easily built using *Bioconda*.

## Setting up Bioconda (if not done yet)

To install *ngs-bits* binaries, follow these instructions:

1. Install [Miniconda](https://conda.io/miniconda.html), which installs a minimal version of the *conda* package manager.

2. Add the *Bioconda* channels using the *conda* command:

		> conda config --add channels defaults
		> conda config --add channels conda-forge
		> conda config --add channels bioconda

## Installing ngs-bits

Install the *ngs-bits* package using *conda*:

	> conda install ngs-bits

## Executing

Now the *ngs-bits* executables are installed into the *conda* `bin` folder.
For example, try this:

	> bin/ReadQC --help

### Adding reference genome to the settings

Some of the *ngs-bits* tools need a reference genome in FASTA format.
You can set the reference genome on the command line, e.g. the `-ref` parameter of the `VcfLeftNormalize` tool.

To avoid having to set the reference genome for each call, you can set up a settings file.
Copy the template:

	> cp bin/settings.ini.example bin/settings.ini

and then set the `reference_genome` parameter in the `bin/settings.ini` file.


text:
package proguard.optimize.peephole;

import proguard.classfile.*;
import proguard.classfile.attribute.*;
import proguard.classfile.attribute.visitor.*;
import proguard.classfile.instruction.*;
import proguard.classfile.util.SimplifiedVisitor;
import proguard.optimize.info.ExceptionInstructionChecker;

/**
 * This AttributeVisitor removes exception handlers that are unreachable in the
 * code attributes that it visits.
 *
 * @author Eric Lafortune
 */
public class UnreachableExceptionRemover
extends      SimplifiedVisitor
implements   AttributeVisitor,
             ExceptionInfoVisitor
{
    private final ExceptionInfoVisitor extraExceptionInfoVisitor;

    /**
     * Creates a new UnreachableExceptionRemover.
     */
    public UnreachableExceptionRemover()
    {
        this(null);
    }

    /**
     * Creates a new UnreachableExceptionRemover.
     * @param extraExceptionInfoVisitor an optional extra visitor for all
     *                                  removed exceptions.
     */
    public UnreachableExceptionRemover(ExceptionInfoVisitor extraExceptionInfoVisitor)
    {
        this.extraExceptionInfoVisitor = extraExceptionInfoVisitor;
    }

    // Implementations for AttributeVisitor.

    public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}

    public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute)
    {
        // Go over the exception table.
        codeAttribute.exceptionsAccept(clazz, method, this);

        // Remove exceptions with empty code blocks.
        codeAttribute.u2exceptionTableLength =
            removeEmptyExceptions(codeAttribute.exceptionTable,
                                  codeAttribute.u2exceptionTableLength);
    }

    // Implementations for ExceptionInfoVisitor.

    public void visitExceptionInfo(Clazz clazz, Method method, CodeAttribute codeAttribute, ExceptionInfo exceptionInfo)
    {
        if (!mayThrowExceptions(clazz,
                                method,
                                codeAttribute,
                                exceptionInfo.u2startPC,
                                exceptionInfo.u2endPC))
        {
            // Make the code block empty.
            exceptionInfo.u2endPC = exceptionInfo.u2startPC;

            if (extraExceptionInfoVisitor != null)
            {
                extraExceptionInfoVisitor.visitExceptionInfo(clazz, method, codeAttribute, exceptionInfo);
            }
        }
    }

    // Small utility methods.

    /**
     * Returns whether the specified block of code may throw exceptions.
     */
    private boolean mayThrowExceptions(Clazz         clazz,
                                       Method        method,
                                       CodeAttribute codeAttribute,
                                       int           startOffset,
                                       int           endOffset)
    {
        byte[] code = codeAttribute.code;

        // Go over all instructions.
        int offset = startOffset;
        while (offset < endOffset)
        {
            // Get the current instruction.
            Instruction instruction = InstructionFactory.create(code, offset);

            // Check if it may be throwing exceptions.
            if (instruction.mayThrowExceptions())
            {
                return true;
            }

            // Go to the next instruction.
            offset += instruction.length(offset);
        }

        return false;
    }

    /**
     * Returns the given list of exceptions, without the ones that have empty
     * code blocks.
     */
    private int removeEmptyExceptions(ExceptionInfo[] exceptionInfos,
                                      int             exceptionInfoCount)
    {
        // Overwrite all empty exceptions.
        int newIndex = 0;
        for (int index = 0; index < exceptionInfoCount; index++)
        {
            ExceptionInfo exceptionInfo = exceptionInfos[index];
            if (exceptionInfo.u2startPC < exceptionInfo.u2endPC)
            {
                exceptionInfos[newIndex++] = exceptionInfo;
            }
        }

        return newIndex;
    }
}


text:
package nl.hsac.fitnesse.fixture.util.selenium.by;

import org.apache.commons.lang3.StringUtils;
import org.openqa.selenium.By;

/**
 * By to work using 'technical selectors.
 */
public class TechnicalSelectorBy {

    /**
     * Whether supplied place is a technical selector.
     * @param place place that might be technical selector
     * @return true if place starts with one of the technical selector prefixes.
     */
    public static boolean isTechnicalSelector(String place) {
        return StringUtils.startsWithAny(place,
                "id=", "xpath=", "css=", "name=", "link=", "partialLink=");
    }

    /**
     * @param place place that might be technical selector
     * @return By if place was a technical selector, null otherwise.
     */
    public static By forPlace(String place) {
        By result = null;
        if (place.startsWith("id=")) {
            result = By.id(place.substring(3));
        } else if (place.startsWith("css=")) {
            result = By.cssSelector(place.substring(4));
        } else if (place.startsWith("name=")) {
            result = By.name(place.substring(5));
        } else if (place.startsWith("link=")) {
            result = By.linkText(place.substring(5));
        } else if (place.startsWith("partialLink=")) {
            result = By.partialLinkText(place.substring(12));
        } else if (place.startsWith("xpath=")) {
            result = new XPathBy(place.substring(6));
        }
        return result;
    }
}


text:
package com.arpnetworking;

import com.arpnetworking.logback.widgets.WidgetWithJsonValue;
import com.arpnetworking.logback.widgets.WidgetWithLogValue;
import com.arpnetworking.logback.widgets.WidgetWithLogValueProvidingReference;
import org.junit.Test;

/**
 * Integration test of bean identity injection.
 *
 * @author Ville Koskela (vkoskela at groupon dot com)
 */
public class BeanIdentifierInjectionIntegrationTest extends BaseStenoIntegrationTest {

    @Test
    public void test() {
        // LogValue or JsonValue without reference
        getStenoLogger().info(
                "test",
                "WidgetWithJsonValue.class",
                "widget",
                new WidgetWithJsonValue("w1"));
        getStenoLogger().info(
                "test",
                "WidgetWithLogValue.class",
                "widget",
                new WidgetWithLogValue("w2"));

        // LogValue with reference
        getStenoLogger().info(
                "test",
                "WidgetWithLogValueProvidingReference.class",
                "widget",
                new WidgetWithLogValueProvidingReference("w3"));

        assertOutput();
    }
}


text:
require "abstract_unit"
require "active_support/security_utils"

class SecurityUtilsTest < ActiveSupport::TestCase
  def test_secure_compare_should_perform_string_comparison
    assert ActiveSupport::SecurityUtils.secure_compare("a", "a")
    assert_not ActiveSupport::SecurityUtils.secure_compare("a", "b")
  end

  def test_variable_size_secure_compare_should_perform_string_comparison
    assert ActiveSupport::SecurityUtils.variable_size_secure_compare("a", "a")
    assert_not ActiveSupport::SecurityUtils.variable_size_secure_compare("a", "b")
  end
end


text:
battle = {};
battle.atk = {};
battle.skl = {};
battle.action = {};
battle.effect = {};

battle.setup = function(){

    battle.maxlevel = 99;
    battle.herotoshowstatus = false;
    battle.order = new Array();
    battle.heroes = clone(resources.hms.Heroes)

    for (var hero in battle.heroes) {
        battle.initHero(battle.heroes[hero])
    }
}

battle.initHero = function(hero){
    hero["side"] = "hero"
    hero["xp"] = 0
    hero["level"] = 0
    hero["xpnextlevel"] = hero["ExpToLevel"][0]*hero["level"]+hero["ExpToLevel"][1]
    hero["skill"]=[]
    hero["hp"] = 0
    hero["hpmax"] = 0
    hero["mod"] = {"st": 0, "dx":0,"iq":0}
    hero["equiped"] = {"weapon": false, "armor" : false}
    battle.uplevel(hero,1,true)
}

battle.initMonster = function(monster){
    monster["side"] = "monster"
    monster["level"] = 0
    monster["skill"]=[]
    monster["hp"] = 0
    monster["hpmax"] = 0
    battle.setMonsterLevel(monster)
    if(!("prob" in monster)) {
        var prob = {}
        var totalprob = 0
        var atks = clone(monster["skill"])
        atks.push("atk")
        for(var i = 0; i < atks.length; i++){
            if(i==atks.length -1){
                prob[atks[i]]=1-totalprob
            } else {
                totalprob+= 1.0/atks.length
                prob[atks[i]]=1.0/atks.length
            }
        }
        monster["prob"] = prob
    }
    monster["xpreward"] = monster["ExpToLevel"][0]*monster["level"]+monster["ExpToLevel"][1]
    monster["dead"]=false
}

battle.uplevel = function(hero, leveltoup, silent){
    var silent = (typeof silent === "undefined") ? false : silent;

    var currlvl = hero["level"]
    if(leveltoup > currlvl) {
        hero["st"] =Math.floor(leveltoup*hero["baseStats"]["st"]/battle.maxlevel)
        hero["dx"] =Math.floor(leveltoup*hero["baseStats"]["dx"]/battle.maxlevel)
        hero["iq"] =Math.floor(leveltoup*hero["baseStats"]["iq"]/battle.maxlevel)
        hero["hp"] =Math.floor(leveltoup*hero["baseStats"]["hp"]/battle.maxlevel)
        hero["hpmax"] =Math.floor(leveltoup*hero["baseStats"]["hp"]/battle.maxlevel)

        for(var i = currlvl+1; i < leveltoup+1; i++) {
            var lvl = i.toString()
            var text=hero["name"]+" reached level "+lvl+"!"
            hero["level"] = i
            hero["xpnextlevel"] += hero["ExpToLevel"][0]*hero["level"]+hero["ExpToLevel"][1]
            if (lvl in hero["Pathway"]) {
                if ("learn" in hero["Pathway"][lvl]) {
                    var tolearn = hero["Pathway"][lvl]["learn"]
                    for (var stuff in tolearn){
                        hero[stuff].push(tolearn[stuff])
                        text += "\n"+hero["name"]+" learned "+tolearn[stuff]+"!"
                    }
                }
                if ("forget" in hero["Pathway"][lvl]){
                    var toforget = hero["Pathway"][lvl]["forget"]
                    for (var stuff in toforget){
                        removeA(hero[stuff],toforget[stuff])
                        text += "\n"+hero["name"]+" forgot "+toforget[stuff]+"!"
                    }
                }
            }
            if(!silent){
                actions.showText(text)
            }
        }
    }
}

battle.setMonsterLevel = function(mon){
    var mlevel = 0
    for (var i = 0; i < player.party.length; i++) {
        mlevel += battle.hero[i].level
    }

    mlevel = Math.floor(mlevel/player.party.length)
    mlevel += battle.diceroll(1) + player.party.length
    mlevel = Math.max(mlevel-3,1)

    battle.uplevel(mon,mlevel,true)
}

battle.selectFromProb = function(probdict){
    var random = Math.random();
    var range = 0.0;
    for (atsk in probdict) {
        if(range <= random && random <= range+probdict[atsk])
            return atsk
        range+=probdict[atsk]
    }
}

battle.diceroll = function(n){
    var i = n;
    var result = 0;
    while (i > 0){
        i--
        result+=Math.floor(Math.random()*3+1)
    }
    return result
}

battle.action.atk = function(){
    actions.showText("attack!")
}

battle.action.skill = function(skill){
    actions.showText(skill)
}

battle.start = function(monsterlist){
    battle.holdAtomStack = engine.atomStack
    engine.atomStack=new Array();
    battle.monster = [];
    battle.hero = [];
    battle.waitherodecision = false
    battle.bchToAttack = []
    battle.ended = false
    battle.xpreward = 0;

    if(monsterlist.length>1){
        dist.efnumb[0]=31
    }

    for (var i = 0; i < player.party.length; i++) {
        battle.hero[i] = battle.heroes[player.party[i]]
    }

    for (var i = 0; i < monsterlist.length; i++) {
        battle.monster[i] = clone(resources.hms.Monsters[monsterlist[i]])
        battle.initMonster(battle.monster[i])
    }

    battle.skills = resources.hms.Skills

    battle.setOrderStack();
    actions.fadeIn('blackFadeIn;doNotKeep')

}

battle.resolveOrder = function() {
    if(battle.ended) {
        return
    }

    if(!battle.waitherodecision) {
        if(battle.order.length > 0){
            battle.bchToAttack = battle.order.shift();
            if(battle.bchToAttack[1]=="hero") {
                console.log("hero attack")
                if(battle.resolveIfSideDead()) {
                    return
                }
                battle.herodecision = "action"
                actions.questionBox("attack;skill")
                battle.waitherodecision = true
                if(battle.resolveIfSideDead()) {
                    return
                }
            } else {
                console.log("monster attack")
                if(battle.resolveIfSideDead()) {
                    return
                }
                if(!(battle.bchToAttack[0].dead)){
                    battle.mAttack(battle.bchToAttack[0])
                }
                if(battle.resolveIfSideDead()) {
                    return
                }
            }
        } else {
            if(battle.isPartyAlive()) {
                battle.setOrderStack()
            }

        }
    } else {
        battle.hAttack(battle.bchToAttack[0])
    }
}

battle.resolveIfSideDead = function(){
    if(!(battle.isPartyAlive())){
        while(battle.order.length > 0) {
            battle.order.pop();
        }
        battle.ended = true
        actions.showText("You died!")
        battle.end("died")
        return true
    }
    if(!(battle.isMonstersAlive())){
        while(battle.order.length > 0) {
            battle.order.pop();
        }
        battle.ended = true
        actions.showText("You win!")
        battle.end("win")
        return true
    }
    return false
}

battle.setOrderStack = function(){
    while(battle.order.length > 0) {
        battle.order.pop();
    }
    for (var i = 0; i < player.party.length; i++) {
        battle.order.push([battle.hero[i],"hero"]);
    }
    for (var i = 0; i < battle.monster.length; i++) {
        battle.order.push([battle.monster[i],"monster"]);
    }
    battle.order.sort( function(a,b) {
        if (a[0]["dx"] > b[0]["dx"])
            return -1;
        if (a[0]["dx"] < b[0]["dx"])
            return 1;
        return 0;
    } );
}

battle.hAct = {}
battle.hAct.askTarget = function(){
    engine.questionBoxAnswer = engine.questionBoxUndef
    battle.hAct.targetting = true
    battle.herodecision = "target"
    var selmon = []
    for(var i=0; i<battle.monster.length;i++){
        if(!(battle.monster[i].dead)){
            selmon.push(battle.monster[i])
        }
    }

    if(selmon.length == 1){
        selmon[0].selected = false
        battle.hAct.targetting = false
        battle.hAct.__target = [selmon[0]]
        engine.questionBoxAnswer = 0
        HID.inputs["accept"].active = false
        return
    }

   //the selectable monsters
    for(var i=0; i<selmon.length;i++){
        selmon[i].selected = false
        selmon[i].flash = 0

        if ( i == 0) {
            selmon[i].previous = selmon[0]
            selmon[i].next = selmon[i+1]
        } else if (i == selmon.length-1) {
            selmon[i].previous = selmon[i-1]
            selmon[i].next = selmon[i]
        } else {
            selmon[i].previous = selmon[i-1]
            selmon[i].next = selmon[i+1]
        }

    }
    selmon[0].selected = true
    battle.hAct.selectedMonster = selmon[0]
}

battle.hAct.changeSelection = function(next){
    battle.hAct.selectedMonster.selected = false
    battle.hAct.selectedMonster = battle.hAct.selectedMonster[next]
    battle.hAct.selectedMonster.selected = true
}

battle.hAct.targetUpdate= function(){
    if(typeof this.keyPressed === "undefined" ){
        this.keyPressed = 0
    }

    if(this.keyPressed==0) {
        if(HID.inputs["up"].active){
            battle.hAct.changeSelection('previous')
            HID.inputs["up"].active = false
            this.keyPressed=32
        }else if(HID.inputs["left"].active){
            battle.hAct.changeSelection('previous')
            HID.inputs["left"].active = false
            this.keyPressed=32
        }else if(HID.inputs["right"].active){
            battle.hAct.changeSelection('next')
            HID.inputs["right"].active = false
            this.keyPressed=32
        }else if(HID.inputs["down"].active){
            battle.hAct.changeSelection('next')
            HID.inputs["down"].active = false
            this.keyPressed=32
        }else if(HID.inputs["accept"].active){
            this.selectedMonster.selected = false
            battle.hAct.targetting = false
            battle.hAct.__target = [battle.hAct.selectedMonster]
            engine.questionBoxAnswer = 0
            HID.inputs["accept"].active = false
            this.keyPressed=32
        }else if(HID.inputs["cancel"].active){

        }
    } else {
        this.keyPressed-=4
    }
}

battle.hAttack = function(hero){
    //select action
    //if attack or skill select target
    //resolve
    if(engine.questionBoxAnswer != engine.questionBoxUndef && battle.herodecision == "action"){
        if(engine.questionBoxAnswer == 0 ) {
            battle.hAct.__damage = battle.atk.pts(hero)
            battle.hAct.__actionType = ["hpdown"]
            battle.hAct.__skill = "atk"
            if(battle.monster.length <= 1){
                battle.hAct.__target = [battle.monster[0]]
                var __proceed = true
            } else {
                battle.hAct.askTarget()
            }
        } else if(engine.questionBoxAnswer == 1){
            battle.herodecision = "skill"
            var options = hero["skill"].join(";")
            options="back;"+options
            actions.questionBox(options)
        }
    }
    if(engine.questionBoxAnswer != engine.questionBoxUndef && battle.herodecision == "skill"){
        if(engine.questionBoxAnswer==0) {
            battle.herodecision = "action"
            actions.questionBox("attack;skill")
        } else {
            actions.showText(engine.questionBoxAnswerStr)
            battle.hAct.__damage = battle.skl.pts(hero,engine.questionBoxAnswerStr)
            battle.hAct.__actionType = battle.skills[engine.questionBoxAnswerStr].effect
            battle.hAct.__target = [battle.monster[0]]
            battle.hAct.__skill = engine.questionBoxAnswerStr
            var __proceed = true
        }

    }
    if(engine.questionBoxAnswer != engine.questionBoxUndef && battle.herodecision == "target"){
        var __proceed = true
    }
    if(typeof __proceed !== "undefined" ){
        if(__proceed != false){
            console.log("attacked")
            battle.resolveAtk(hero, battle.hAct.__target, battle.hAct.__damage,
                battle.hAct.__actionType, battle.hAct.__skill)
            actions.proceedBattleTurn()
        }
    }
}

battle.mAttack = function(mn){
    var mon = mn
    var attack = battle.selectFromProb(mon["prob"])
    var damage = 0
    var actionType = []
    var target = [battle.mTarget(mon)]

    if(attack=="atk") {
        damage = battle.atk.pts(mon)
        actionType = ["hpdown"]
    } else {
        damage = battle.skl.pts(mon,attack)
        actionType = battle.skills[attack].effect
        if(battle.skills[attack].affect=="all")
            target = battle.hero
    }

    if(damage>0){
        screen.flashMonster(mon,'#eeeeee')
    } else {
        screen.shakeMonster(mon)
    }

    battle.resolveAtk(mon, target, damage, actionType, attack)
}

battle.resolveAtk = function(bchSrc, bchVct, dmg, act, skill){
    //for each victim, do the effect applying damage
    for (var j = 0; j < bchVct.length; j++) {
        for (var i = 0; i < act.length; i++) {
            battle.effect[act[i]](bchSrc,bchVct[j],dmg, skill)
        }
    }
}

battle.effect.hpdown = function(bchsrc,bch,dmg, skill){
    bch.hp = Math.max(bch["hp"]-dmg, 0)
    if(skill == "atk") {
        actions.showText(bchsrc.name+" attacked "+ bch.name+" and dealt "+dmg+" damage!")
    } else {
        actions.showText(bchsrc.name+" used "+skill+" on "+ bch.name+" and dealt "+dmg+" damage!")
    }
    if(bch.side == "monster"){
        screen.flashMonster(bch, '#bf0010')
    }
}

battle.effect.hpup = function(bchsrc, bch,dmg){
    bch.hp = Math.min(bch["hp"]+dmg, bch["hpmax"])
}

battle.mTarget = function(monster){
    var dead = true
    if(monster.target=="splash"){

    } else if(monster.target=="hero"){
        var options = battle.hero.length

        for (var i = 0; i < options; i++) {
            if(battle.hero[i].Leader && battle.isAlive(battle.hero[i])) {
                return battle.hero[i]
            }
        }

    } else if(monster.target=="weakest") {
        var minhp = 999999999
        var index = 0
        for (var i = 0; i < options; i++) {
            if(battle.hero[i].hp < minhp && battle.hero[i].hp > 0) {
                minhp = battle.hero[i]["hp"]
                index = i
            }
        }
        return battle.hero[index]
    }

    var target = 0
    var options = battle.hero.length
    var targetProb = {}
    for (var i = 0; i < options; i++) {
        targetProb[i] = 1/options
    }

    var tries = 0

    while(dead){
        tries++
        target = battle.selectFromProb(targetProb)
        dead = !battle.isAlive(battle.hero[target])
        if(tries > 20) {
            break
        }
    }

    return battle.hero[target]
}

battle.end = function(battleresult) {
    battle.lastresult = battleresult
    for (var i = 0; i < battle.hero.length; i++){
        if(battle.isAlive(battle.hero[i])){
            var thishero = battle.hero[i]
            thishero.xp+=Math.floor(battle.xpreward/battle.hero.length)

            while(thishero.xp > thishero.xpnextlevel){
                var newlevel = thishero.level + 1
                battle.uplevel(thishero,newlevel)
            }
        }
    }
    actions.changeState("map")
    engine.atomStack.push([function(){engine.atomStack = battle.holdAtomStack },''])
}

battle.isPartyAlive = function() {
    var test = 0
    for (var i = 0; i < battle.hero.length; i++){
        test += battle.isAlive(battle.hero[i])
    }
    return (test > 0)
}

battle.monsterDies = function(monster){
    battle.xpreward += monster.xpreward
}

battle.isMonstersAlive = function() {
    var test = 0
    for (var i = 0; i < battle.monster.length; i++){
        test += battle.isAlive(battle.monster[i])
        if(!(battle.isAlive(battle.monster[i]))){
            if(!(battle.monster[i].dead)){
                battle.monster[i].dead = true
                battle.monsterDies(battle.monster[i])
            }
        }
    }
    return (test > 0)
}

battle.isAlive = function(bch){
    return (bch["hp"] > 0)
}

battle.atk.pts = function(bch){
    return battle.diceroll(bch["st"])
}

battle.skl.pts = function(bch,skill){
    var baseplus = getkey0(battle.skills[skill],"basep")
    var plus = getkey0(battle.skills[skill],"plus")
    var attribut = 0
    if("atr" in battle.skills[skill])
        attribut = bch[battle.skills[skill]["atr"]]

    return Math.max(battle.diceroll(baseplus+attribut)+plus,0)
}

battle.mApplyState = function(mon,st) {
    for(var k in mon.state[st]){
        mon[k] = mon.state[st][k]
    }
}

battle.update = function(){
    battle.resolveOrder();
    if(battle.hAct.targetting){
        battle.hAct.targetUpdate();
    }

}


text:
export default {
  isDefined(node) {
    return typeof node !== 'undefined';
  },
  isBinaryExpression(node) {
    return this.isDefined(node) && /BinaryExpression/.test(node.type);
  },
  isLiteral(node) {
    return this.isDefined(node) && /Literal/.test(node.type);
  },
  isString(node) {
    return this.isLiteral(node) && typeof node.value === 'string';
  }
};


text:
<!-- This issue tracker is only for technical issues related to Myriadcoin Core.

General myriadcoin questions and/or support requests are best directed to the Myriadcoin Reddit at https://www.reddit.com/r/myriadcoin.

For reporting security issues, please email (preferably all of the following):
    8bitcoder: info@myriadcoin.org
    cryptapus: info@cryptapus.org, various other contact methods are available at https://cryptapus.org.

If the node is "stuck" during sync or giving "block checksum mismatch" errors, please ensure your hardware is stable by running memtest and observe CPU temperature with a load-test tool such as linpack before creating an issue! -->

<!-- Describe the issue -->
<!--- What behavior did you expect? -->

<!--- What was the actual behavior (provide screenshots if the issue is GUI-related)? -->

<!--- How reliably can you reproduce the issue, what are the steps to do so? -->

<!-- What version of Myriadcoin Core are you using, where did you get it (website, self-compiled, etc)? -->

<!-- What type of machine are you observing the error on (OS/CPU and disk type)? -->

<!-- For the GUI-related issue on Linux provide names and versions of a distro, a desktop environment and a graphical shell (if relevant). -->

<!-- Any extra information that might be useful in the debugging process. -->
<!--- This is normally the contents of a `debug.log` or `config.log` file. Raw text or a link to a pastebin type site are preferred. -->


text:
xssPackage
==========

A PHP toolkit for doing XSS, includes db creator, cookie collector and example XSS code.

Install
==========

1. Make sure you have LAMP or XAMP installed
2. Next drop the files into the web folder
3. Run install.html and modify the settings as needed

Use
==========
1. Visit http://WEBSERVER/xssPackage/xss.php (provided you dropped all the files in a folder named xssPackage)
2. Browse to http://WEBSERVER/xssPackage this will let you see the captured cookie
3. View source of xss.php, xss1.php and xss2.php to get ideas on how to embed code on vulnerable sites

Disclaimer
==========
If you use this tool, use it for good. It is meant to be something to show to clients, in iCTFs, or for your own learning.
I am not responsible if you use it for evil. Enjoy!