text:
using System;
using System.Globalization;
using System.Collections.Generic;
using System.Linq;

namespace MathNet.Numerics.Tests.StatisticsTests
{

    /// <summary>
    /// Statistics data.
    /// </summary>
    internal class StatTestData
    {
        /// <summary>
        /// Data array.
        /// </summary>
        public readonly double[] Data;

        /// <summary>
        /// Data with nulls.
        /// </summary>
        public readonly double?[] DataWithNulls;

        /// <summary>
        /// Mean value.
        /// </summary>
        public readonly double Mean;

        /// <summary>
        /// Standard Deviation.
        /// </summary>
        public readonly double StandardDeviation;

        /// <summary>
        /// Initializes a new instance of the StatTestData class.
        /// </summary>
        /// <param name="file">Path to the file.</param>
        public StatTestData(string file)
        {
            using (var reader = TestData.Data.ReadText(file))
            {
                var line = reader.ReadLine().Trim();

                while (!line.StartsWith("--"))
                {
                    if (line.StartsWith("Sample Mean"))
                    {
                        Mean = GetValue(line);
                    }
                    else if (line.StartsWith("Sample Standard Deviation"))
                    {
                        StandardDeviation = GetValue(line);
                    }

                    line = reader.ReadLine().Trim();
                }

                line = reader.ReadLine();

                IList<double> list = new List<double>();
                while (line != null)
                {
                    line = line.Trim();
                    if (!line.Equals(string.Empty))
                    {
                        list.Add(double.Parse(line, CultureInfo.InvariantCulture));
                    }

                    line = reader.ReadLine();
                }

                Data = list.ToArray();
            }

            DataWithNulls = new double?[Data.Length + 2];
            for (var i = 0; i < Data.Length; i++)
            {
                DataWithNulls[i + 1] = Data[i];
            }
        }

        /// <summary>
        /// Get value.
        /// </summary>
        /// <param name="str">Parameter name.</param>
        /// <returns>Parameter value.</returns>
        static double GetValue(string str)
        {
            var start = str.IndexOf(":", StringComparison.Ordinal);
            var value = str.Substring(start + 1).Trim();
            if (value.Equals("NaN"))
            {
                return 0;
            }

            return double.Parse(str.Substring(start + 1).Trim(), CultureInfo.InvariantCulture);
        }
    }
}


text:
using namespace bb::cascades;

///////////////////////////////////////////////////////////////////////////////

ApplicationUI::ApplicationUI(bb::cascades::Application *app)
: QObject(app)
, m_model(new FileDataListModel(this))
, m_dev_path("accounts/1000/shared")
, m_def_path(QDir::rootPath () + m_dev_path)
{
    // Register custom type to QML
    qmlRegisterType<ImageData>        ("com.leoz", 1, 0, "ImageData");
    qmlRegisterType<FileDataListModel>("com.leoz", 1, 0, "FileDataListModel");

    // prepare the localization
    m_pTranslator = new QTranslator(this);
    m_pLocaleHandler = new LocaleHandler(this);
    if(!QObject::connect(m_pLocaleHandler, SIGNAL(systemLanguageChanged()), this, SLOT(onSystemLanguageChanged()))) {
        // This is an abnormal situation! Something went wrong!
        // Add own code to recover here
        qWarning() << "Recovering from a failed connect()";
    }
    // initial load
    onSystemLanguageChanged();

    // Create the UI
    QmlDocument *qml = QmlDocument::create("asset:///main.qml").parent(this);
    qml->setContextProperty("_app", this);

    // Create root object for the UI
    AbstractPane *root = qml->createRootObject<AbstractPane>();

    // Set created root object as the application scene
    app->setScene(root);

    // Load file icons
    FileDataIcon::loadIcons();
}

ApplicationUI::~ApplicationUI()
{
    // Free file icons
    FileDataIcon::freeIcons();
}

///////////////////////////////////////////////////////////////////////////////

bool ApplicationUI::showFileList(const QString& path)
{
    qWarning() << "ApplicationUI::showFileList" << path;

    QFileInfo info(path);

    info = normalizeInfo(info);

    bool result(false);

    if (info.isDir()) {
    	if (info.isReadable() && info.isExecutable()) {
    	    result = true;
    	}
    }
    else {
    	if(!FileDataFactory::isSupportedImage(QUrl::fromLocalFile(info.filePath()))) {
        	invokeFile(info);
    	}
    }

    return result;
}

bool ApplicationUI::showImageView(const QString& path)
{
    QFileInfo info(path);

    info = normalizeInfo(info);

    return FileDataFactory::isSupportedImage(QUrl::fromLocalFile(info.filePath()));
}

QString ApplicationUI::getDefPath()
{
	return getPath(m_def_path);
}

QString ApplicationUI::getDefTitle()
{
	return getTitle(m_def_path);
}

QString ApplicationUI::getPath(const QString& path)
{
    QFileInfo info(path);

    if (info.fileName() == QString("..")) {
        info = info.canonicalFilePath();
    }

    return info.filePath();
}

QString ApplicationUI::getTitle(const QString& path)
{
    QFileInfo info(path);

    if (info.fileName() == QString("..")) {
        info = info.canonicalFilePath();
    }

    // Fix the root name
    if (info.isRoot()) {
    	return QString("/");
    }

    return info.fileName();
}

///////////////////////////////////////////////////////////////////////////////

void ApplicationUI::onSystemLanguageChanged()
{
    QCoreApplication::instance()->removeTranslator(m_pTranslator);
    // Initiate, load and install the application translation files.
    QString locale_string = QLocale().name();
    QString file_name = QString("everyfile_%1").arg(locale_string);
    if (m_pTranslator->load(file_name, "app/native/qm")) {
        QCoreApplication::instance()->installTranslator(m_pTranslator);
    }
}

///////////////////////////////////////////////////////////////////////////////

void ApplicationUI::invokeFile(const QFileInfo& info)
{
	navigator_invoke_invocation_t *invoke = NULL;
	navigator_invoke_invocation_create(&invoke);

	QUrl u(QUrl::fromLocalFile(info.filePath()));
	QString url(u.toString());
	QByteArray bytes = url.toUtf8();
	navigator_invoke_invocation_set_uri(invoke, bytes.constData());

	navigator_invoke_invocation_send(invoke);
	navigator_invoke_invocation_destroy(invoke);
}

QFileInfo ApplicationUI::normalizeInfo(QFileInfo& info)
{
    if (info.fileName() == QString("..")) {
        qWarning() << "App::normalizeInfo : shall be normalized!";
        info = info.canonicalFilePath();
        qWarning() << "App::normalizeInfo : normalized path: " << info.filePath();
    }

    return info;
}

///////////////////////////////////////////////////////////////////////////////

redpajama_set_name: RedPajamaGithub


text:
#ifndef _SAM3XA_RTC_INSTANCE_
#define _SAM3XA_RTC_INSTANCE_

/* ========== Register definition for RTC peripheral ========== */
#if (defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__))
#define REG_RTC_CR              (0x400E1A60U) /**< \brief (RTC) Control Register */
#define REG_RTC_MR              (0x400E1A64U) /**< \brief (RTC) Mode Register */
#define REG_RTC_TIMR            (0x400E1A68U) /**< \brief (RTC) Time Register */
#define REG_RTC_CALR            (0x400E1A6CU) /**< \brief (RTC) Calendar Register */
#define REG_RTC_TIMALR          (0x400E1A70U) /**< \brief (RTC) Time Alarm Register */
#define REG_RTC_CALALR          (0x400E1A74U) /**< \brief (RTC) Calendar Alarm Register */
#define REG_RTC_SR              (0x400E1A78U) /**< \brief (RTC) Status Register */
#define REG_RTC_SCCR            (0x400E1A7CU) /**< \brief (RTC) Status Clear Command Register */
#define REG_RTC_IER             (0x400E1A80U) /**< \brief (RTC) Interrupt Enable Register */
#define REG_RTC_IDR             (0x400E1A84U) /**< \brief (RTC) Interrupt Disable Register */
#define REG_RTC_IMR             (0x400E1A88U) /**< \brief (RTC) Interrupt Mask Register */
#define REG_RTC_VER             (0x400E1A8CU) /**< \brief (RTC) Valid Entry Register */
#define REG_RTC_WPMR            (0x400E1B44U) /**< \brief (RTC) Write Protect Mode Register */
#else
#define REG_RTC_CR     (*(RwReg*)0x400E1A60U) /**< \brief (RTC) Control Register */
#define REG_RTC_MR     (*(RwReg*)0x400E1A64U) /**< \brief (RTC) Mode Register */
#define REG_RTC_TIMR   (*(RwReg*)0x400E1A68U) /**< \brief (RTC) Time Register */
#define REG_RTC_CALR   (*(RwReg*)0x400E1A6CU) /**< \brief (RTC) Calendar Register */
#define REG_RTC_TIMALR (*(RwReg*)0x400E1A70U) /**< \brief (RTC) Time Alarm Register */
#define REG_RTC_CALALR (*(RwReg*)0x400E1A74U) /**< \brief (RTC) Calendar Alarm Register */
#define REG_RTC_SR     (*(RoReg*)0x400E1A78U) /**< \brief (RTC) Status Register */
#define REG_RTC_SCCR   (*(WoReg*)0x400E1A7CU) /**< \brief (RTC) Status Clear Command Register */
#define REG_RTC_IER    (*(WoReg*)0x400E1A80U) /**< \brief (RTC) Interrupt Enable Register */
#define REG_RTC_IDR    (*(WoReg*)0x400E1A84U) /**< \brief (RTC) Interrupt Disable Register */
#define REG_RTC_IMR    (*(RoReg*)0x400E1A88U) /**< \brief (RTC) Interrupt Mask Register */
#define REG_RTC_VER    (*(RoReg*)0x400E1A8CU) /**< \brief (RTC) Valid Entry Register */
#define REG_RTC_WPMR   (*(RwReg*)0x400E1B44U) /**< \brief (RTC) Write Protect Mode Register */
#endif /* (defined(__ASSEMBLY__) || defined(__IAR_SYSTEMS_ASM__)) */

#endif /* _SAM3XA_RTC_INSTANCE_ */


text:
package com.google.cloud.devtools.containeranalysis.v1beta1;

import static com.google.cloud.devtools.containeranalysis.v1beta1.GrafeasV1Beta1Client.ListNoteOccurrencesPagedResponse;
import static com.google.cloud.devtools.containeranalysis.v1beta1.GrafeasV1Beta1Client.ListNotesPagedResponse;
import static com.google.cloud.devtools.containeranalysis.v1beta1.GrafeasV1Beta1Client.ListOccurrencesPagedResponse;

import com.google.api.core.ApiFunction;
import com.google.api.core.BetaApi;
import com.google.api.gax.core.GoogleCredentialsProvider;
import com.google.api.gax.core.InstantiatingExecutorProvider;
import com.google.api.gax.grpc.InstantiatingGrpcChannelProvider;
import com.google.api.gax.rpc.ApiClientHeaderProvider;
import com.google.api.gax.rpc.ClientContext;
import com.google.api.gax.rpc.ClientSettings;
import com.google.api.gax.rpc.PagedCallSettings;
import com.google.api.gax.rpc.TransportChannelProvider;
import com.google.api.gax.rpc.UnaryCallSettings;
import com.google.cloud.devtools.containeranalysis.v1beta1.stub.GrafeasV1Beta1StubSettings;
import com.google.protobuf.Empty;
import io.grafeas.v1beta1.BatchCreateNotesRequest;
import io.grafeas.v1beta1.BatchCreateNotesResponse;
import io.grafeas.v1beta1.BatchCreateOccurrencesRequest;
import io.grafeas.v1beta1.BatchCreateOccurrencesResponse;
import io.grafeas.v1beta1.CreateNoteRequest;
import io.grafeas.v1beta1.CreateOccurrenceRequest;
import io.grafeas.v1beta1.DeleteNoteRequest;
import io.grafeas.v1beta1.DeleteOccurrenceRequest;
import io.grafeas.v1beta1.GetNoteRequest;
import io.grafeas.v1beta1.GetOccurrenceNoteRequest;
import io.grafeas.v1beta1.GetOccurrenceRequest;
import io.grafeas.v1beta1.GetVulnerabilityOccurrencesSummaryRequest;
import io.grafeas.v1beta1.ListNoteOccurrencesRequest;
import io.grafeas.v1beta1.ListNoteOccurrencesResponse;
import io.grafeas.v1beta1.ListNotesRequest;
import io.grafeas.v1beta1.ListNotesResponse;
import io.grafeas.v1beta1.ListOccurrencesRequest;
import io.grafeas.v1beta1.ListOccurrencesResponse;
import io.grafeas.v1beta1.Note;
import io.grafeas.v1beta1.Occurrence;
import io.grafeas.v1beta1.UpdateNoteRequest;
import io.grafeas.v1beta1.UpdateOccurrenceRequest;
import io.grafeas.v1beta1.VulnerabilityOccurrencesSummary;
import java.io.IOException;
import java.util.List;
import javax.annotation.Generated;

// AUTO-GENERATED DOCUMENTATION AND CLASS
/**
 * Settings class to configure an instance of {@link GrafeasV1Beta1Client}.
 *
 *
The default instance has everything set to sensible defaults:
 *
 *

 *
The default service address (containeranalysis.googleapis.com) and default port (443) are
 *       used.
 *
Credentials are acquired automatically through Application Default Credentials.
 *
Retries are configured for idempotent methods but not for non-idempotent methods.
 *

 *
 *
The builder of this class is recursive, so contained classes are themselves builders. When
 * build() is called, the tree of builders is called to create the complete settings object. For
 * example, to set the total timeout of getOccurrence to 30 seconds:
 *
 *

 *
 * GrafeasV1Beta1Settings.Builder grafeasV1Beta1SettingsBuilder =
 *     GrafeasV1Beta1Settings.newBuilder();
 * grafeasV1Beta1SettingsBuilder.getOccurrenceSettings().getRetrySettings().toBuilder()
 *     .setTotalTimeout(Duration.ofSeconds(30));
 * GrafeasV1Beta1Settings grafeasV1Beta1Settings = grafeasV1Beta1SettingsBuilder.build();
 *
 *

 */
@Generated("by gapic-generator")
@BetaApi
public class GrafeasV1Beta1Settings extends ClientSettings<GrafeasV1Beta1Settings> {
  /** Returns the object with the settings used for calls to getOccurrence. */
  public UnaryCallSettings<GetOccurrenceRequest, Occurrence> getOccurrenceSettings() {
    return ((GrafeasV1Beta1StubSettings) getStubSettings()).getOccurrenceSettings();
  }

  /** Returns the object with the settings used for calls to listOccurrences. */
  public PagedCallSettings<
          ListOccurrencesRequest, ListOccurrencesResponse, ListOccurrencesPagedResponse>
      listOccurrencesSettings() {
    return ((GrafeasV1Beta1StubSettings) getStubSettings()).listOccurrencesSettings();
  }

  /** Returns the object with the settings used for calls to deleteOccurrence. */
  public UnaryCallSettings<DeleteOccurrenceRequest, Empty> deleteOccurrenceSettings() {
    return ((GrafeasV1Beta1StubSettings) getStubSettings()).deleteOccurrenceSettings();
  }

  /** Returns the object with the settings used for calls to createOccurrence. */
  public UnaryCallSettings<CreateOccurrenceRequest, Occurrence> createOccurrenceSettings() {
    return ((GrafeasV1Beta1StubSettings) getStubSettings()).createOccurrenceSettings();
  }

  /** Returns the object with the settings used for calls to batchCreateOccurrences. */
  public UnaryCallSettings<BatchCreateOccurrencesRequest, BatchCreateOccurrencesResponse>
      batchCreateOccurrencesSettings() {
    return ((GrafeasV1Beta1StubSettings) getStubSettings()).batchCreateOccurrencesSettings();
  }

  /** Returns the object with the settings used for calls to updateOccurrence. */
  public UnaryCallSettings<UpdateOccurrenceRequest, Occurrence> updateOccurrenceSettings() {
    return ((GrafeasV1Beta1StubSettings) getStubSettings()).updateOccurrenceSettings();
  }

  /** Returns the object with the settings used for calls to getOccurrenceNote. */
  public UnaryCallSettings<GetOccurrenceNoteRequest, Note> getOccurrenceNoteSettings() {
    return ((GrafeasV1Beta1StubSettings) getStubSettings()).getOccurrenceNoteSettings();
  }

  /** Returns the object with the settings used for calls to getNote. */
  public UnaryCallSettings<GetNoteRequest, Note> getNoteSettings() {
    return ((GrafeasV1Beta1StubSettings) getStubSettings()).getNoteSettings();
  }

  /** Returns the object with the settings used for calls to listNotes. */
  public PagedCallSettings<ListNotesRequest, ListNotesResponse, ListNotesPagedResponse>
      listNotesSettings() {
    return ((GrafeasV1Beta1StubSettings) getStubSettings()).listNotesSettings();
  }

  /** Returns the object with the settings used for calls to deleteNote. */
  public UnaryCallSettings<DeleteNoteRequest, Empty> deleteNoteSettings() {
    return ((GrafeasV1Beta1StubSettings) getStubSettings()).deleteNoteSettings();
  }

  /** Returns the object with the settings used for calls to createNote. */
  public UnaryCallSettings<CreateNoteRequest, Note> createNoteSettings() {
    return ((GrafeasV1Beta1StubSettings) getStubSettings()).createNoteSettings();
  }

  /** Returns the object with the settings used for calls to batchCreateNotes. */
  public UnaryCallSettings<BatchCreateNotesRequest, BatchCreateNotesResponse>
      batchCreateNotesSettings() {
    return ((GrafeasV1Beta1StubSettings) getStubSettings()).batchCreateNotesSettings();
  }

  /** Returns the object with the settings used for calls to updateNote. */
  public UnaryCallSettings<UpdateNoteRequest, Note> updateNoteSettings() {
    return ((GrafeasV1Beta1StubSettings) getStubSettings()).updateNoteSettings();
  }

  /** Returns the object with the settings used for calls to listNoteOccurrences. */
  public PagedCallSettings<
          ListNoteOccurrencesRequest, ListNoteOccurrencesResponse, ListNoteOccurrencesPagedResponse>
      listNoteOccurrencesSettings() {
    return ((GrafeasV1Beta1StubSettings) getStubSettings()).listNoteOccurrencesSettings();
  }

  /** Returns the object with the settings used for calls to getVulnerabilityOccurrencesSummary. */
  public UnaryCallSettings<
          GetVulnerabilityOccurrencesSummaryRequest, VulnerabilityOccurrencesSummary>
      getVulnerabilityOccurrencesSummarySettings() {
    return ((GrafeasV1Beta1StubSettings) getStubSettings())
        .getVulnerabilityOccurrencesSummarySettings();
  }

  public static final GrafeasV1Beta1Settings create(GrafeasV1Beta1StubSettings stub)
      throws IOException {
    return new GrafeasV1Beta1Settings.Builder(stub.toBuilder()).build();
  }

  /** Returns a builder for the default ExecutorProvider for this service. */
  public static InstantiatingExecutorProvider.Builder defaultExecutorProviderBuilder() {
    return GrafeasV1Beta1StubSettings.defaultExecutorProviderBuilder();
  }

  /** Returns the default service endpoint. */
  public static String getDefaultEndpoint() {
    return GrafeasV1Beta1StubSettings.getDefaultEndpoint();
  }

  /** Returns the default service scopes. */
  public static List<String> getDefaultServiceScopes() {
    return GrafeasV1Beta1StubSettings.getDefaultServiceScopes();
  }

  /** Returns a builder for the default credentials for this service. */
  public static GoogleCredentialsProvider.Builder defaultCredentialsProviderBuilder() {
    return GrafeasV1Beta1StubSettings.defaultCredentialsProviderBuilder();
  }

  /** Returns a builder for the default ChannelProvider for this service. */
  public static InstantiatingGrpcChannelProvider.Builder defaultGrpcTransportProviderBuilder() {
    return GrafeasV1Beta1StubSettings.defaultGrpcTransportProviderBuilder();
  }

  public static TransportChannelProvider defaultTransportChannelProvider() {
    return GrafeasV1Beta1StubSettings.defaultTransportChannelProvider();
  }

  @BetaApi("The surface for customizing headers is not stable yet and may change in the future.")
  public static ApiClientHeaderProvider.Builder defaultApiClientHeaderProviderBuilder() {
    return GrafeasV1Beta1StubSettings.defaultApiClientHeaderProviderBuilder();
  }

  /** Returns a new builder for this class. */
  public static Builder newBuilder() {
    return Builder.createDefault();
  }

  /** Returns a new builder for this class. */
  public static Builder newBuilder(ClientContext clientContext) {
    return new Builder(clientContext);
  }

  /** Returns a builder containing all the values of this settings class. */
  public Builder toBuilder() {
    return new Builder(this);
  }

  protected GrafeasV1Beta1Settings(Builder settingsBuilder) throws IOException {
    super(settingsBuilder);
  }

  /** Builder for GrafeasV1Beta1Settings. */
  public static class Builder extends ClientSettings.Builder<GrafeasV1Beta1Settings, Builder> {
    protected Builder() throws IOException {
      this((ClientContext) null);
    }

    protected Builder(ClientContext clientContext) {
      super(GrafeasV1Beta1StubSettings.newBuilder(clientContext));
    }

    private static Builder createDefault() {
      return new Builder(GrafeasV1Beta1StubSettings.newBuilder());
    }

    protected Builder(GrafeasV1Beta1Settings settings) {
      super(settings.getStubSettings().toBuilder());
    }

    protected Builder(GrafeasV1Beta1StubSettings.Builder stubSettings) {
      super(stubSettings);
    }

    public GrafeasV1Beta1StubSettings.Builder getStubSettingsBuilder() {
      return ((GrafeasV1Beta1StubSettings.Builder) getStubSettings());
    }

    // NEXT_MAJOR_VER: remove 'throws Exception'
    /**
     * Applies the given settings updater function to all of the unary API methods in this service.
     *
     *
Note: This method does not support applying settings to streaming methods.
     */
    public Builder applyToAllUnaryMethods(
        ApiFunction<UnaryCallSettings.Builder<?, ?>, Void> settingsUpdater) throws Exception {
      super.applyToAllUnaryMethods(
          getStubSettingsBuilder().unaryMethodSettingsBuilders(), settingsUpdater);
      return this;
    }

    /** Returns the builder for the settings used for calls to getOccurrence. */
    public UnaryCallSettings.Builder<GetOccurrenceRequest, Occurrence> getOccurrenceSettings() {
      return getStubSettingsBuilder().getOccurrenceSettings();
    }

    /** Returns the builder for the settings used for calls to listOccurrences. */
    public PagedCallSettings.Builder<
            ListOccurrencesRequest, ListOccurrencesResponse, ListOccurrencesPagedResponse>
        listOccurrencesSettings() {
      return getStubSettingsBuilder().listOccurrencesSettings();
    }

    /** Returns the builder for the settings used for calls to deleteOccurrence. */
    public UnaryCallSettings.Builder<DeleteOccurrenceRequest, Empty> deleteOccurrenceSettings() {
      return getStubSettingsBuilder().deleteOccurrenceSettings();
    }

    /** Returns the builder for the settings used for calls to createOccurrence. */
    public UnaryCallSettings.Builder<CreateOccurrenceRequest, Occurrence>
        createOccurrenceSettings() {
      return getStubSettingsBuilder().createOccurrenceSettings();
    }

    /** Returns the builder for the settings used for calls to batchCreateOccurrences. */
    public UnaryCallSettings.Builder<BatchCreateOccurrencesRequest, BatchCreateOccurrencesResponse>
        batchCreateOccurrencesSettings() {
      return getStubSettingsBuilder().batchCreateOccurrencesSettings();
    }

    /** Returns the builder for the settings used for calls to updateOccurrence. */
    public UnaryCallSettings.Builder<UpdateOccurrenceRequest, Occurrence>
        updateOccurrenceSettings() {
      return getStubSettingsBuilder().updateOccurrenceSettings();
    }

    /** Returns the builder for the settings used for calls to getOccurrenceNote. */
    public UnaryCallSettings.Builder<GetOccurrenceNoteRequest, Note> getOccurrenceNoteSettings() {
      return getStubSettingsBuilder().getOccurrenceNoteSettings();
    }

    /** Returns the builder for the settings used for calls to getNote. */
    public UnaryCallSettings.Builder<GetNoteRequest, Note> getNoteSettings() {
      return getStubSettingsBuilder().getNoteSettings();
    }

    /** Returns the builder for the settings used for calls to listNotes. */
    public PagedCallSettings.Builder<ListNotesRequest, ListNotesResponse, ListNotesPagedResponse>
        listNotesSettings() {
      return getStubSettingsBuilder().listNotesSettings();
    }

    /** Returns the builder for the settings used for calls to deleteNote. */
    public UnaryCallSettings.Builder<DeleteNoteRequest, Empty> deleteNoteSettings() {
      return getStubSettingsBuilder().deleteNoteSettings();
    }

    /** Returns the builder for the settings used for calls to createNote. */
    public UnaryCallSettings.Builder<CreateNoteRequest, Note> createNoteSettings() {
      return getStubSettingsBuilder().createNoteSettings();
    }

    /** Returns the builder for the settings used for calls to batchCreateNotes. */
    public UnaryCallSettings.Builder<BatchCreateNotesRequest, BatchCreateNotesResponse>
        batchCreateNotesSettings() {
      return getStubSettingsBuilder().batchCreateNotesSettings();
    }

    /** Returns the builder for the settings used for calls to updateNote. */
    public UnaryCallSettings.Builder<UpdateNoteRequest, Note> updateNoteSettings() {
      return getStubSettingsBuilder().updateNoteSettings();
    }

    /** Returns the builder for the settings used for calls to listNoteOccurrences. */
    public PagedCallSettings.Builder<
            ListNoteOccurrencesRequest,
            ListNoteOccurrencesResponse,
            ListNoteOccurrencesPagedResponse>
        listNoteOccurrencesSettings() {
      return getStubSettingsBuilder().listNoteOccurrencesSettings();
    }

    /**
     * Returns the builder for the settings used for calls to getVulnerabilityOccurrencesSummary.
     */
    public UnaryCallSettings.Builder<
            GetVulnerabilityOccurrencesSummaryRequest, VulnerabilityOccurrencesSummary>
        getVulnerabilityOccurrencesSummarySettings() {
      return getStubSettingsBuilder().getVulnerabilityOccurrencesSummarySettings();
    }

    @Override
    public GrafeasV1Beta1Settings build() throws IOException {
      return new GrafeasV1Beta1Settings(this);
    }
  }
}


text:
source $HOME/.rvm/scripts/rvm

DB_HOST=${DBHOST} rvm jruby-1.7.8 do bundle exec trinidad --config config/trinidad.yml &


text:
/**
 * Created by maomao on 2020/4/23.
 */
Java.perform(function() {
    var cn = "java.security.SecureRandom";
    var target = Java.use(cn);
    if (target) {
        target.setSeed.overloads[0].implementation = function(dest) {
            var myArray=new Array()
            myArray[0] = "INTERESTED"  //INTERESTED & SENSITIVE
            myArray[1] = cn + "." + "setSeed";
            myArray[2] = Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Exception").$new()).split('\n\tat');
            send(myArray);
            return this.setSeed.overloads[0].apply(this, arguments);
        };

        target.setSeed.overloads[1].implementation = function(dest) {
            var myArray=new Array()
            myArray[0] = "INTERESTED"  //INTERESTED & SENSITIVE
            myArray[1] = cn + "." + "setSeed";
            myArray[2] = Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Exception").$new()).split('\n\tat');
            send(myArray);
            return this.setSeed.overloads[1].apply(this, arguments);
        };
    }
});


text:
package org.codehaus.griffon.compile.hessian;

import org.codehaus.griffon.compile.core.BaseConstants;
import org.codehaus.griffon.compile.core.MethodDescriptor;

import static org.codehaus.griffon.compile.core.MethodDescriptor.annotatedMethod;
import static org.codehaus.griffon.compile.core.MethodDescriptor.annotatedType;
import static org.codehaus.griffon.compile.core.MethodDescriptor.annotations;
import static org.codehaus.griffon.compile.core.MethodDescriptor.args;
import static org.codehaus.griffon.compile.core.MethodDescriptor.method;
import static org.codehaus.griffon.compile.core.MethodDescriptor.throwing;
import static org.codehaus.griffon.compile.core.MethodDescriptor.type;
import static org.codehaus.griffon.compile.core.MethodDescriptor.typeParams;
import static org.codehaus.griffon.compile.core.MethodDescriptor.types;

/**
 * @author Andres Almiray
 */
public interface BurlapAwareConstants extends BaseConstants {
    String BURLAP_HANDLER_TYPE = "griffon.plugins.hessian.BurlapHandler";
    String BURLAP_HANDLER_PROPERTY = "hessianHandler";
    String BURLAP__HANDLER_FIELD_NAME = "this$" + BURLAP_HANDLER_PROPERTY;
    String BURLAP_CLIENT_CALLBACK_TYPE = "griffon.plugins.hessian.BurlapClientCallback";
    String BURLAP_EXCEPTION_TYPE = "griffon.plugins.hessian.exceptions.BurlapException";

    String METHOD_WITH_BURLAP = "withBurlap";
    String METHOD_DESTROY_BURLAP_CLIENT = "destroyBurlapClient";

    String CALLBACK = "callback";
    String PARAMS = "params";

    MethodDescriptor[] METHODS = new MethodDescriptor[]{
        annotatedMethod(
            types(type(ANNOTATION_NULLABLE)),
            type(R),
            typeParams(R),
            METHOD_WITH_BURLAP,
            args(
                annotatedType(annotations(ANNOTATION_NONNULL), JAVA_UTIL_MAP, JAVA_LANG_STRING, JAVA_LANG_OBJECT),
                annotatedType(annotations(ANNOTATION_NONNULL), BURLAP_CLIENT_CALLBACK_TYPE, R)),
            throwing(type(BURLAP_EXCEPTION_TYPE))
        ),

        method(
            type(VOID),
            METHOD_DESTROY_BURLAP_CLIENT,
            args(annotatedType(types(type(ANNOTATION_NONNULL)), JAVA_LANG_STRING))
        )
    };
}


text:
/**
 * This file contains the functions needed to handle S2C throughput
 * test (client part).
 *
 * Jakub S³awiñski 2006-08-02
 * jeremian@poczta.fm
 */

#include <unistd.h>
#include <stdlib.h>
#include <string.h>

#include "clt_tests.h"
#include "logging.h"
#include "network.h"
#include "protocol.h"
#include "utils.h"
#include "strlutils.h"

int ssndqueue, sbytes;
double spdin, s2cspd;

/**
 * S2C throughput test to measure network bandwidth
 * from server to client.
 * @param ctlSocket 	Socket on which messages are received from the server
 * @param tests     	Character indicator for test to be run
 * @param host          Server name string
 * @param conn_options 	Options to use while connecting to server(for ex, IPV4)
 * @param buf_size  	TCP send/receive buffer size
 * @param result_srv		result obtained from server (containing values of web100 variables)
 * @return integer > 0 if successful, < 0 in case of error
 * 		Return codes:
 * 		1: Error receiving protocol message
 *		2: Unexpected protocol message (type) received
 *		3: Improper message payload
 *		4: Incorrect message data received
 *		-3: Unable to resolve server address
 *		-15: Cannot connect to server
 */

int test_s2c_clt(int ctlSocket, char tests, char* host, int conn_options,
                 int buf_size, char* result_srv) {
  char buff[BUFFSIZE + 1];
  int msgLen, msgType;
  int s2cport = atoi(PORT3);
  I2Addr sec_addr = NULL;
  int inlth, retcode, one = 1, set_size;
  int inSocket;
  socklen_t optlen;
  uint64_t bytes;
  double t;
  struct timeval sel_tv;
  fd_set rfd;
  char* ptr;

  // variables used for protocol validation logs
  enum TEST_STATUS_INT teststatuses = TEST_NOT_STARTED;
  enum TEST_ID testids = S2C;

  if (tests & TEST_S2C) {
    setCurrentTest(TEST_S2C);
    // protocol logs
    teststatuses = TEST_STARTED;
    protolog_status(getpid(), testids, teststatuses, ctlSocket);

    // First message expected from the server is a TEST_PREPARE. Any other
    // message type is unexpected at this point.
    log_println(1, " <-- S2C throughput test -->");
    msgLen = sizeof(buff);
    if (recv_msg(ctlSocket, &msgType, buff, &msgLen)) {
      log_println(0, "Protocol error - missed prepare message!");
      return 1;
    }
    if (check_msg_type(S2C_TEST_LOG, TEST_PREPARE, msgType, buff, msgLen)) {
      return 2;
    }
    // This TEST_PREPARE message is expected to have the port number as message
    // body. Check if this is a valid integral port.
    if (msgLen <= 0) {
      log_println(0, "Improper message");
      return 3;
    }
    buff[msgLen] = 0;
    if (check_int(buff, &s2cport)) {
      log_println(0, "Invalid port number");
      return 4;
    }
    log_println(1, "  -- port: %d", s2cport);

    /* Cygwin seems to want/need this extra getsockopt() function
     * call.  It certainly doesn't do anything, but the S2C test fails
     * at the connect() call if it's not there.  4/14/05 RAC
     */
    optlen = sizeof(set_size);
    getsockopt(ctlSocket, SOL_SOCKET, SO_SNDBUF, &set_size, &optlen);

    // get "address details" of the server using the host name
    if ((sec_addr = I2AddrByNode(get_errhandle(), host)) == NULL) {
      log_println(0, "Unable to resolve server address: %s", strerror(errno));
      return -3;
    }
    I2AddrSetPort(sec_addr, s2cport);  // set port to value obtained from server

    // Connect to the server; set socket options
    if ((retcode = CreateConnectSocket(&inSocket, NULL, sec_addr, conn_options,
                                       buf_size))) {
      log_println(0, "Connect() for Server to Client failed", strerror(errno));
      return -15;
    }

    setsockopt(inSocket, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));

    /* Linux updates the sel_tv time values everytime select returns.  This
     * means that eventually the timer will reach 0 seconds and select will
     * exit with a timeout signal.  Other OS's don't do that so they need
     * another method for detecting a long-running process.  The check below
     * will cause the loop to terminate if select says there is something
     * to read and the loop has been active for over 14 seconds.  This usually
     * happens when there is a problem (duplex mismatch) and there is data
     * queued up on the server.
     */

    // Expect a TEST_START message from server now. Any other message
    // type is an error
    msgLen = sizeof(buff);
    if (recv_msg(ctlSocket, &msgType, buff, &msgLen)) {
      log_println(0, "Protocol error - missed start message!");
      return 1;
    }
    if (check_msg_type(S2C_TEST_LOG, TEST_START, msgType, buff, msgLen)) {
      return 2;
    }

    // server performs the S->C throughput test now. Get data sent by server.

    printf("running 10s inbound test (server to client) . . . . . . ");
    fflush(stdout);

    // Set socket timeout to 15 seconds
    bytes = 0;
    t = secs() + 15.0;
    sel_tv.tv_sec = 15;
    sel_tv.tv_usec = 5;
    FD_ZERO(&rfd);
    FD_SET(inSocket, &rfd);
    // Read data sent by server as soon as it is available. Stop listening if
    // ...timeout has been exceeded.
    for (;;) {
      retcode = select(inSocket+1, &rfd, NULL, NULL, &sel_tv);
      if (secs() > t) {
        log_println(5, "Receive test running long, break out of read loop");
        break;
      }
      if (retcode > 0) {
        inlth = read(inSocket, buff, sizeof(buff));
        if (inlth == 0)
          break;
        bytes += inlth;
        continue;
      }
      if (get_debuglvl() > 5) {
        log_println(0, "s2c read loop exiting:", strerror(errno));
      }
      break;
    }

    // get actual time for which data was received, and calculate throughput
    // based on it.
    t = secs() - t + 15.0;
    spdin = ((BITS_8_FLOAT * bytes) / KILO) / t;  // kbps

    // log_println(0,"S->C: Received %d bytes in %0.2f secs: Spdin= %f", bytes,
    //             t, spdin);

    // Server sends calculated throughput value, unsent data amount in the
    // socket queue and overall number of sent bytes in a TEST_MSG
    msgLen = sizeof(buff);
    if (recv_msg(ctlSocket, &msgType, buff, &msgLen)) {
      log_println(0, "Protocol error - missed text message!");
      return 1;
    }
    if (check_msg_type(S2C_TEST_LOG, TEST_MSG, msgType, buff, msgLen)) {
      return 2;  // no other message type expected
    }
    // Is message of valid length, and does it have all the data expected?
    if (msgLen <= 0) {
      log_println(0, "Improper message");
      return 3;
    }
    buff[msgLen] = 0;
    ptr = strtok(buff, " ");
    if (ptr == NULL) {
      log_println(0, "S2C: Improper message");
      return 4;
    }
    s2cspd = atoi(ptr);  // get S->C throughput first
    ptr = strtok(NULL, " ");
    if (ptr == NULL) {
      log_println(0, "S2C: Improper message");
      return 4;
    }
    ssndqueue = atoi(ptr);  // get amount of unsent data in queue
    ptr = strtok(NULL, " ");
    if (ptr == NULL) {
      log_println(0, "S2C: Improper message");
      return 4;
    }
    sbytes = atoi(ptr);  // finally get total-sent-byte-count
    // log_println(0,"S->C received throughput: %f",s2cspd);
    // log results in a convenient units format
    if (spdin < 1000)
      printf("%0.2f kb/s\n", spdin);
    else
      printf("%0.2f Mb/s\n", spdin/1000);

    I2AddrFree(sec_addr);

    // send TEST_MSG to server with the client-calculated throughput
    snprintf(buff, sizeof(buff), "%0.0f", spdin);
    send_msg(ctlSocket, TEST_MSG, buff, strlen(buff));

    // client now expected to receive web100 variables collected by server

    result_srv[0] = '\0';
    for (;;) {
      msgLen = sizeof(buff);
      memset(buff, 0, msgLen);  // reset buff and msgLen

      // get web100 variables
      if (recv_msg(ctlSocket, &msgType, buff, &msgLen)) {
        log_println(0, "Protocol error - missed text/finalize message!");
        return 1;
      }

      // TEST_FINALIZE msg from server indicates end of web100 var transmission
      if (msgType == TEST_FINALIZE) {
        break;
      }

      // if neither TEST_FINALIZE, nor TEST_MSG, signal error!
      if (check_msg_type(S2C_TEST_LOG, TEST_MSG, msgType, buff, msgLen)) {
        return 2;
      }

      // hardcoded size of array from main tests
      strlcat(result_srv, buff, 2 * BUFFSIZE);
    }
    log_println(6, "result_srv = '%s', of len %d", result_srv, msgLen);
    log_println(1, " <------------------------->");

    // log protocol validation logs
    teststatuses = TEST_ENDED;
    protolog_status(getpid(), testids, teststatuses, ctlSocket);
    setCurrentTest(TEST_NONE);
  }

  return 0;
}


text:
*pdfmarks* is a simple utility for modifying page markings of PDF documents.

Page markings are the logical page numberings that conventional PDF viewers show when reading a document.

## Dependencies

* *Bash* >= v3.2
* *Ghostscript* >= v9.0


text:
<?xml version="1.0" encoding="UTF-8"?>
<!-- Reviewed: no -->
<sect2 id="zend.validate.set.hostname">
    <title>Hostname</title>

    <para>
        <classname>Zend_Validate_Hostname</classname> allows you to validate a hostname against a
        set of known specifications. It is possible to check for three different types of hostnames:
        a <acronym>DNS</acronym> Hostname (i.e. <filename>domain.com</filename>), IP address (i.e.
        1.2.3.4), and Local hostnames (i.e. localhost). By default only <acronym>DNS</acronym>
        hostnames are matched.
    </para>

    <sect3 id="zend.validate.set.hostname.options">
        <title>Supported options for Zend_Validate_Hostname</title>

        <para>
            The following options are supported for <classname>Zend_Validate_Hostname</classname>:
        </para>

        <itemizedlist>
            <listitem>
                <para>
                    <emphasis><property>allow</property></emphasis>: Defines the sort of hostname
                    which is allowed to be used. See <link
                        linkend="zend.validate.set.hostname.types">Hostname types</link> for
                    details.
                </para>
            </listitem>

            <listitem>
                <para>
                    <emphasis><property>idn</property></emphasis>: Defines if <acronym>IDN</acronym>
                    domains are allowed or not. This option defaults to <constant>TRUE</constant>.
                </para>
            </listitem>

            <listitem>
                <para>
                    <emphasis><property>ip</property></emphasis>: Allows to define a own IP
                    validator. This option defaults to a new instance of
                    <classname>Zend_Validate_Ip</classname>.
                </para>
            </listitem>

            <listitem>
                <para>
                    <emphasis><property>tld</property></emphasis>: Defines if
                    <acronym>TLD</acronym>s are validated. This option defaults to
                    <constant>TRUE</constant>.
                </para>
            </listitem>
        </itemizedlist>
    </sect3>

    <sect3 id="zend.validate.set.hostname.basic">
        <title>Basic usage</title>

        <para>
            A basic example of usage is below:
        </para>

        <programlisting language="php"><![CDATA[
$validator = new Zend_Validate_Hostname();
if ($validator->isValid($hostname)) {
    // hostname appears to be valid
} else {
    // hostname is invalid; print the reasons
    foreach ($validator->getMessages() as $message) {
        echo "$message\n";
    }
}
]]></programlisting>

        <para>
            This will match the hostname <varname>$hostname</varname> and on failure populate
            <methodname>getMessages()</methodname> with useful error messages.
        </para>
    </sect3>

    <sect3 id="zend.validate.set.hostname.types">
        <title>Validating different types of hostnames</title>

        <para>
            You may find you also want to match IP addresses, Local hostnames, or a combination of
            all allowed types. This can be done by passing a parameter to
            <classname>Zend_Validate_Hostname</classname> when you instantiate it. The parameter
            should be an integer which determines what types of hostnames are allowed. You are
            encouraged to use the <classname>Zend_Validate_Hostname</classname> constants to do
            this.
        </para>

        <para>
            The <classname>Zend_Validate_Hostname</classname> constants are:
            <constant>ALLOW_DNS</constant> to allow only
            <acronym>DNS</acronym> hostnames, <constant>ALLOW_IP</constant> to allow IP addresses,
            <constant>ALLOW_LOCAL</constant> to allow local network names,
            <constant>ALLOW_URI</constant> to allow
            <ulink url="http://tools.ietf.org/html/rfc3986">RFC3986</ulink>-compliant addresses,
            and <constant>ALLOW_ALL</constant> to allow all four above types.
        </para>

        <note>
            <title>Additional Information on ALLOW_URI</title>
            <para>
                <constant>ALLOW_URI</constant> allows to check hostnames
                according to <ulink url="http://tools.ietf.org/html/rfc3986">RFC3986</ulink>. These
                are registered names which are used by <acronym>WINS</acronym>, NetInfo and also local
                hostnames like those defined within your <filename>.hosts</filename> file.
            </para>
        </note>

        <para>
            To just check for IP addresses you can use the example below:
        </para>

        <programlisting language="php"><![CDATA[
$validator = new Zend_Validate_Hostname(Zend_Validate_Hostname::ALLOW_IP);
if ($validator->isValid($hostname)) {
    // hostname appears to be valid
} else {
    // hostname is invalid; print the reasons
    foreach ($validator->getMessages() as $message) {
        echo "$message\n";
    }
}
]]></programlisting>

        <para>
            As well as using <constant>ALLOW_ALL</constant> to accept all common hostnames types
            you can combine these types to allow for combinations. For example, to accept
            <acronym>DNS</acronym> and Local hostnames instantiate your
            <classname>Zend_Validate_Hostname</classname> object as so:
        </para>

        <programlisting language="php"><![CDATA[
$validator = new Zend_Validate_Hostname(Zend_Validate_Hostname::ALLOW_DNS |
                                        Zend_Validate_Hostname::ALLOW_IP);
]]></programlisting>
    </sect3>

    <sect3 id="zend.validate.set.hostname.idn">
        <title>Validating International Domains Names</title>

        <para>
            Some Country Code Top Level Domains (ccTLDs), such as 'de' (Germany), support
            international characters in domain names. These are known as International Domain Names
            (<acronym>IDN</acronym>). These domains can be matched by
            <classname>Zend_Validate_Hostname</classname> via extended characters that are used in
            the validation process.
        </para>

        <note>
            <title>IDN domains</title>

            <para>
                Until now more than 50 ccTLDs support <acronym>IDN</acronym> domains.
            </para>
        </note>

        <para>
            To match an <acronym>IDN</acronym> domain it's as simple as just using the standard
            Hostname validator since <acronym>IDN</acronym> matching is enabled by default. If you
            wish to disable <acronym>IDN</acronym> validation this can be done by either passing a
            parameter to the <classname>Zend_Validate_Hostname</classname> constructor or via the
            <methodname>setValidateIdn()</methodname> method.
        </para>

        <para>
            You can disable <acronym>IDN</acronym> validation by passing a second parameter to the
            <classname>Zend_Validate_Hostname</classname> constructor in the following way.
        </para>

        <programlisting language="php"><![CDATA[
$validator =
    new Zend_Validate_Hostname(
        array(
            'allow' => Zend_Validate_Hostname::ALLOW_DNS,
            'idn'   => false
        )
    );
]]></programlisting>

        <para>
            Alternatively you can either pass <constant>TRUE</constant> or
            <constant>FALSE</constant> to <methodname>setValidateIdn()</methodname> to enable or
            disable <acronym>IDN</acronym> validation. If you are trying to match an
            <acronym>IDN</acronym> hostname which isn't currently supported it is likely it will
            fail validation if it has any international characters in it. Where a ccTLD file doesn't
            exist in <filename>Zend/Validate/Hostname</filename> specifying the additional
            characters a normal hostname validation is performed.
        </para>

        <note>
            <title>IDN validation</title>

            <para>
                Please note that <acronym>IDN</acronym>s are only validated if you allow
                <acronym>DNS</acronym> hostnames to be validated.
            </para>
        </note>
    </sect3>

    <sect3 id="zend.validate.set.hostname.tld">
        <title>Validating Top Level Domains</title>

        <para>
            By default a hostname will be checked against a list of known <acronym>TLD</acronym>s.
            If this functionality is not required it can be disabled in much the same way as
            disabling <acronym>IDN</acronym> support. You can disable <acronym>TLD</acronym>
            validation by passing a third parameter to the
            <classname>Zend_Validate_Hostname</classname> constructor. In the example below we are
            supporting <acronym>IDN</acronym> validation via the second parameter.
        </para>

        <programlisting language="php"><![CDATA[
$validator =
    new Zend_Validate_Hostname(
        array(
            'allow' => Zend_Validate_Hostname::ALLOW_DNS,
            'idn'   => true,
            'tld'   => false
        )
    );
]]></programlisting>

        <para>
            Alternatively you can either pass <constant>TRUE</constant> or
            <constant>FALSE</constant> to <methodname>setValidateTld()</methodname> to enable or
            disable <acronym>TLD</acronym> validation.
        </para>

        <note>
            <title>TLD validation</title>

            <para>
                Please note <acronym>TLD</acronym>s are only validated if you allow
                <acronym>DNS</acronym> hostnames to be validated.
            </para>
        </note>
    </sect3>
</sect2>
<!--
vim:se ts=4 sw=4 et:
-->


text:
package nz.co.gregs.dbvolution.internal.properties;

import nz.co.gregs.dbvolution.internal.properties.SafeOneWaySimpleTypeAdaptor;
import static org.hamcrest.Matchers.*;
import static org.junit.Assert.*;
import nz.co.gregs.dbvolution.datatypes.DBTypeAdaptor;
import nz.co.gregs.dbvolution.internal.properties.SafeOneWaySimpleTypeAdaptor.Direction;

import org.junit.Test;

public class SafeOneWayTypeAdaptorTest {

	@Test
	public void sourceTypeCorrectGivenIntegerToStringAdaptorToExternal() {
		SafeOneWaySimpleTypeAdaptor oneWay = new SafeOneWaySimpleTypeAdaptor("myField",
				new IntegerToStringAdaptor(), Direction.TO_EXTERNAL, null, null);
		assertThat(oneWay.getSourceType(), is((Object) String.class));
	}

	@Test
	public void targetTypeCorrectGivenIntegerToStringAdaptorToExternal() {
		SafeOneWaySimpleTypeAdaptor oneWay = new SafeOneWaySimpleTypeAdaptor("myField",
				new IntegerToStringAdaptor(), Direction.TO_EXTERNAL, null, null);
		assertThat(oneWay.getTargetType(), is((Object) Integer.class));
	}

	@Test
	public void sourceTypeCorrectGivenIntegerToStringAdaptorToInternal() {
		SafeOneWaySimpleTypeAdaptor oneWay = new SafeOneWaySimpleTypeAdaptor("myField",
				new IntegerToStringAdaptor(), Direction.TO_INTERNAL, null, null);
		assertThat(oneWay.getSourceType(), is((Object) Integer.class));
	}

	@Test
	public void targetTypeCorrectGivenIntegerToStringAdaptorToInternal() {
		SafeOneWaySimpleTypeAdaptor oneWay = new SafeOneWaySimpleTypeAdaptor("myField",
				new IntegerToStringAdaptor(), Direction.TO_INTERNAL, null, null);
		assertThat(oneWay.getTargetType(), is((Object) String.class));
	}

	@Test
	public void targetTypeCorrectGivenIntegerToStringAdaptorToExternalAndExplicitLongTarget() {
		SafeOneWaySimpleTypeAdaptor oneWay = new SafeOneWaySimpleTypeAdaptor("myField",
				new IntegerToStringAdaptor(), Direction.TO_EXTERNAL, null, Long.class);
		assertThat(oneWay.getTargetType(), is((Object) Long.class));
	}

	@Test
	public void targetTypeCorrectGivenIntegerToStringAdaptorToExternalAndExplicitShortTarget() {
		SafeOneWaySimpleTypeAdaptor oneWay = new SafeOneWaySimpleTypeAdaptor("myField",
				new IntegerToStringAdaptor(), Direction.TO_EXTERNAL, null, Short.class);
		assertThat(oneWay.getTargetType(), is((Object) Short.class));
	}

	@Test
	public void sourceTypeCorrectGivenIntegerToStringAdaptorToInternalAndExplicitLongSource() {
		SafeOneWaySimpleTypeAdaptor oneWay = new SafeOneWaySimpleTypeAdaptor("myField",
				new IntegerToStringAdaptor(), Direction.TO_INTERNAL, Long.class, null);
		assertThat(oneWay.getSourceType(), is((Object) Long.class));
	}

	@Test
	public void sourceTypeCorrectGivenIntegerToStringAdaptorToInternalAndExplicitShortSource() {
		SafeOneWaySimpleTypeAdaptor oneWay = new SafeOneWaySimpleTypeAdaptor("myField",
				new IntegerToStringAdaptor(), Direction.TO_INTERNAL, Short.class, null);
		assertThat(oneWay.getSourceType(), is((Object) Short.class));
	}

	@Test
	public void convertsGivenIntegerTypeAdaptorToExternal() {
		SafeOneWaySimpleTypeAdaptor oneWay = new SafeOneWaySimpleTypeAdaptor("myField",
				new IntegerToStringAdaptor(), Direction.TO_EXTERNAL, null, null);
		Object result = oneWay.convert("23");
		assertThat(result, is(instanceOf(Integer.class)));
		assertThat((Integer) result, is(23));
	}

	@Test
	public void convertsGivenIntegerTypeAdaptorToInternal() {
		SafeOneWaySimpleTypeAdaptor oneWay = new SafeOneWaySimpleTypeAdaptor("myField",
				new IntegerToStringAdaptor(), Direction.TO_INTERNAL, null, null);
		Integer value = 23;
		Object result = oneWay.convert(value);
		assertThat(result, is(instanceOf(String.class)));
		assertThat((String) result, is("23"));
	}

	@Test
	public void castsIntegerToLongGivenIntegerTypeAdaptorToExternalAndExplicitLongTarget() {
		SafeOneWaySimpleTypeAdaptor oneWay = new SafeOneWaySimpleTypeAdaptor("myField",
				new IntegerToStringAdaptor(), Direction.TO_EXTERNAL, null, Long.class);
		Object result = oneWay.convert("23");
		assertThat(result, is(instanceOf(Long.class)));
		assertThat((Long) result, is(23L));
	}

	@Test
	public void castsLongToIntegerGivenIntegerTypeAdaptorToInternalAndExplicitLongSource() {
		SafeOneWaySimpleTypeAdaptor oneWay = new SafeOneWaySimpleTypeAdaptor("myField",
				new IntegerToStringAdaptor(), Direction.TO_INTERNAL, Long.class, null);
		Long value = 23L;
		Object result = oneWay.convert(value);
		assertThat(result, is(instanceOf(String.class)));
		assertThat((String) result, is("23"));
	}

	static class IntegerToStringAdaptor implements DBTypeAdaptor<Integer, String> {

		@Override
		public Integer fromDatabaseValue(String dbvValue) {
			return (dbvValue == null) ? null : Integer.parseInt(dbvValue);
		}

		@Override
		public String toDatabaseValue(Integer objectValue) {
			return (objectValue == null) ? null : objectValue.toString();
		}
	}
}


text:
{-# LANGUAGE CPP, DisambiguateRecordFields #-}
-- | A switch has some number of flow tables. Each flow table is a
-- prioritized list of entries containing a @Match@, a list of
-- @Action@s, and other options affecting the behavior of the switch.
-- This module represents the OpenFlow messages that can be used
-- to modify flow tables.
module Nettle.OpenFlow.FlowTable (
  FlowTableID
  , FlowMod (..)
  , Cookie
  , Priority
  , TimeOut (..)
  , FlowRemoved (..)
  , FlowRemovalReason (..)
  ) where

import Nettle.OpenFlow.Switch
import Nettle.OpenFlow.Action
import Nettle.OpenFlow.Match
import Nettle.OpenFlow.Packet
import Data.Word
import Data.List as List

type FlowTableID = Word8

data FlowMod = AddFlow { match             :: Match
                       , priority          :: Priority
                       , actions           :: ActionSequence
                       , cookie            :: Cookie
                       , idleTimeOut       :: TimeOut
                       , hardTimeOut       :: TimeOut
                       , notifyWhenRemoved :: Bool
                       , applyToPacket     :: Maybe BufferID
                       , overlapAllowed    :: Bool
                       }
             | AddEmergencyFlow { match          :: Match
                                , priority       :: Priority
                                , actions        :: ActionSequence
                                , cookie         :: Cookie
                                , overlapAllowed :: Bool
                                }

             | ModifyFlows { match                      :: Match
                           , newActions                 :: ActionSequence
                           , ifMissingPriority          :: Priority
                           , ifMissingCookie            :: Cookie
                           , ifMissingIdleTimeOut       :: TimeOut
                           , ifMissingHardTimeOut       :: TimeOut
                           , ifMissingNotifyWhenRemoved :: Bool
                           , ifMissingOverlapAllowed    :: Bool
                           }
             | ModifyExactFlow { match                      :: Match
                               , priority                   :: Priority
                               , newActions                 :: ActionSequence
                               , ifMissingCookie            :: Cookie
                               , ifMissingIdleTimeOut       :: TimeOut
                               , ifMissingHardTimeOut       :: TimeOut
                               , ifMissingNotifyWhenRemoved :: Bool
                               , ifMissingOverlapAllowed    :: Bool
                               }
             | DeleteFlows { match   :: Match,
                             outPort :: Maybe PseudoPort
                           }
             | DeleteExactFlow { match    :: Match,
                                 outPort  :: Maybe PseudoPort,
                                 priority :: Priority
                               }

                     deriving (Show, Eq)

type Cookie = Word64

-- |The priority of a flow entry is a 16-bit integer. Flow entries with higher numeric priorities match before lower ones.
type Priority = Word16

-- | Each flow entry has idle and hard timeout values
-- associated with it.
data TimeOut  = Permanent
              | ExpireAfter Word16
                deriving (Show,Eq)

-- | When a switch removes a flow, it may send a message containing the information
-- in @FlowRemovedRecord@ to the controller.
data FlowRemoved = FlowRemovedRecord { flowRemovedMatch         :: Match,
                                       flowRemovedCookie        :: Word64,
                                       flowRemovedPriority      :: Priority,
                                       flowRemovedReason        :: FlowRemovalReason,
                                       flowRemovedDuration      :: Integer,
                                       flowRemovedDurationNSecs :: Integer,
                                       flowRemovedIdleTimeout   :: Integer,
                                       flowRemovedPacketCount   :: Integer,
                                       flowRemovedByteCount     :: Integer }
                 deriving (Show,Eq)

data FlowRemovalReason = IdleTimerExpired
                       | HardTimerExpired
                       | DeletedByController
                         deriving (Show,Eq,Ord,Enum)


text:
<?php

namespace Google\Service\Apigee;

class GoogleCloudApigeeV1Operation extends \Google\Collection
{
  protected $collection_key = 'methods';
  /**
   * @var string[]
   */
  public $methods;
  /**
   * @var string
   */
  public $resource;

  /**
   * @param string[]
   */
  public function setMethods($methods)
  {
    $this->methods = $methods;
  }
  /**
   * @return string[]
   */
  public function getMethods()
  {
    return $this->methods;
  }
  /**
   * @param string
   */
  public function setResource($resource)
  {
    $this->resource = $resource;
  }
  /**
   * @return string
   */
  public function getResource()
  {
    return $this->resource;
  }
}

// Adding a class alias for backwards compatibility with the previous class name.
class_alias(GoogleCloudApigeeV1Operation::class, 'Google_Service_Apigee_GoogleCloudApigeeV1Operation');


text:
package org.semanticweb.elk.reasoner.query;

import org.junit.Assert;
import org.semanticweb.elk.reasoner.incremental.IncrementalReasoningCorrectnessTestWithInterrupts;
import org.semanticweb.elk.reasoner.incremental.IncrementalReasoningTestWithInterruptsDelegate;
import org.semanticweb.elk.testing.DiffableOutput;
import org.semanticweb.elk.testing.TestManifest;

public abstract class BaseIncrementalQueryTest<Q, A, O extends DiffableOutput<?, O>>
		extends
		IncrementalReasoningCorrectnessTestWithInterrupts<QueryTestInput<Q>, A, O, IncrementalReasoningTestWithInterruptsDelegate<A, O>> {

	public BaseIncrementalQueryTest(
			final TestManifest<QueryTestInput<Q>> testManifest,
			final IncrementalReasoningTestWithInterruptsDelegate<A, O> testDelegate) {
		super(testManifest, testDelegate);
	}

	@Override
	protected void correctnessCheck(final O actualOutput,
			final O expectedOutput) throws Exception {

		boolean actualContainsAllExpected = actualOutput
				.containsAllElementsOf(expectedOutput);
		boolean expectedContainsAllActual = expectedOutput
				.containsAllElementsOf(actualOutput);
		if (actualContainsAllExpected && expectedContainsAllActual) {
			return;
		}
		// else
		final StringBuilder message = new StringBuilder(
				"Actual output is not equal to the expected output:");
		if (!actualContainsAllExpected) {
			actualOutput.reportMissingElementsOf(expectedOutput,
					getOutputListener("< ", message));
		}
		if (!expectedContainsAllActual) {
			expectedOutput.reportMissingElementsOf(actualOutput,
					getOutputListener("<>", message));
		}
		Assert.fail(message.toString());
	}

	private static <E> DiffableOutput.Listener<E> getOutputListener(
			final String prefix, final StringBuilder message) {
		return new DiffableOutput.Listener<E>() {

			@Override
			public void missing(E element) {
				message.append('\n');
				message.append(prefix);
				message.append(element);
			}
		};
	}

}


text:
<?xml version="1.0" encoding="utf-8"?>
<resources>

    <array name="names_players_list">

        <!-- En A -->
        <item>Anormal guy</item>
        <item>Average guy</item>
        <item>Armageddon</item>
        <item>Almost smart</item>
        <item>America forever</item>
        <item>Animal</item>
        <item>Apple lover</item>
        <item>Australia forever</item>
        <item>Adele Adkins</item>

        <!-- EN B -->
        <item>Baby justin</item>
        <item>Blue star</item>
        <item>Bachelor</item>
        <item>Bacon and shrimp</item>
        <item>Banker so kill me</item>
        <item>Beauty</item>
        <item>Betrayal habit</item>
        <item>Benjamin Castaldi</item>
        <item>Boxing is a must</item>

        <!-- EN C -->
        <item>Canada forever</item>
        <item>Chairman so listen</item>
        <item>China forever or not</item>
        <item>Climatologist</item>
        <item>Clues is a must</item>
        <item>Conspirator</item>
        <item>Contributor to the kill</item>
        <item>Cooperator if i want</item>
        <item>Cornelius Nyungura or Corneille</item>

        <!-- EN D -->
        <item>Denmark forever</item>
        <item>Dealer so call me</item>
        <item>Dexterity is useless here</item>
        <item>Difficult guy</item>
        <item>Dwarf</item>
        <item>Dolphin lover</item>
        <item>Discipline is everything</item>
        <item>Dieudonné M bala M bala</item>
        <item>Daniel Michael Blake Day-Lewise</item>

        <!-- EN E -->
        <item>Egyptian in town</item>
        <item>Elephant lover</item>
        <item>Enthusiasm guy</item>
        <item>Ethiopia forever</item>
        <item>Exchange with me</item>
        <item>Executive so kill me</item>
        <item>Espionage pro</item>
        <item>Europe will make it</item>
        <item>Eminem in town</item>

        <!-- EN F -->
        <item>Farmer</item>
        <item>Felony is my name</item>
        <item>Fencing lover</item>
        <item>Fisherman in week-end</item>
        <item>Football adept</item>
        <item>Foresight ability care</item>
        <item>France forever</item>
        <item>Funeral held soon</item>
        <item>Fantasy reader</item>

        <!-- EN G -->
        <item>Gangster</item>
        <item>Geek and what</item>
        <item>Germany forever</item>
        <item>Girlfriend you dream of</item>
        <item>Gambling addict</item>
        <item>Geometry professor</item>
        <item>God father from the mafia</item>
        <item>Gaga stephani</item>
        <item>Garou</item>

        <!-- EN H -->
        <item>Human or not</item>
        <item>Hairdresser</item>
        <item>Hunter waiting to kill</item>
        <item>Horse-riding lover</item>
        <item>Honorable guy</item>
        <item>High school student</item>
        <item>Hammering everyone</item>
        <item>Hallyday Johnny</item>
        <item>Doctor save me</item>

        <!-- EN I -->
        <item>Idiot of the town</item>
        <item>Idealist peace-maker</item>
        <item>Idol in game</item>
        <item>Immunity for me</item>
        <item>Ironic guy</item>
        <item>Insect lover</item>
        <item>Information is a must</item>
        <item>Immortal guy</item>
        <item>Indochine singer</item>

        <!-- EN J -->
        <item>Japan forever</item>
        <item>Jovial person</item>
        <item>Justice seeker</item>
        <item>Jealous girlfriend</item>
        <item>Jeweller</item>
        <item>Journalist cover me</item>
        <item>January is coming</item>
        <item>Jordan i love you</item>
        <item>Jesse Eisenber the survivor</item>

        <!-- EN K -->
        <item>Korea forever</item>
        <item>Killer in cover</item>
        <item>King in is kingdom</item>
        <item>Kitten keeper</item>
        <item>Kiss me or die</item>
        <item>Keyboard where are you</item>
        <item>Kleptomaniac</item>
        <item>Kilo go away go</item>
        <item>Kaka go Milan forever</item>

        <!-- EN L -->
        <item>Lantern jax in game</item>
        <item>Lawyer so care</item>
        <item>Lemonade is so good</item>
        <item>Leopard lover</item>
        <item>Levelling so easy</item>
        <item>Lizard hater</item>
        <item>Loyalty to the team</item>
        <item>Lion lover</item>
        <item>Lagaf</item>

        <!-- EN M -->
        <item>Martyr as always</item>
        <item>Maths professor</item>
        <item>Merry christmas guys</item>
        <item>Misfit lover</item>
        <item>Monkey lover</item>
        <item>Monarch in town</item>
        <item>Moral person</item>
        <item>Mimi mouse</item>
        <item>Murderer in cover</item>

        <!-- EN N -->
        <item>Nabilla non mais allo</item>
        <item>Negociator</item>
        <item>Night-club lover</item>
        <item>Nightmare it is me</item>
        <item>Novice in game</item>
        <item>Nonsense person</item>
        <item>Nymphomaniac</item>
        <item>Never say never</item>
        <item>Normal guy</item>

        <!-- EN O -->
        <item>Oath to the team</item>
        <item>Observer</item>
        <item>Old man</item>
        <item>Online games forever</item>
        <item>Opportunist person</item>
        <item>Oceanographist</item>
        <item>On duty</item>
        <item>Optimistic person</item>
        <item>Orelsan in town</item>

        <!-- EN P -->
        <item>Panties lover</item>
        <item>Paradox is a paradox</item>
        <item>Patriot</item>
        <item>Peer to peer system</item>
        <item>Perspicacity is a must</item>
        <item>Pharmacist</item>
        <item>Pianist</item>
        <item>Pillow lover</item>
        <item>Pitbull just for you</item>

        <!-- EN Q -->
        <item>Quantity over quality</item>
        <item>Question yourself</item>
        <item>Queen of the game</item>
        <item>Queen is in town</item>
        <item>Quality over quantity</item>
        <item>Quarrel maker</item>
        <item>QSDFGHJKLM</item>
        <item>Quartz collector</item>
        <item>Quentin</item>

        <!-- EN R -->
        <item>Rabbit lover</item>
        <item>Refrigerator is too far</item>
        <item>Resident of New york</item>
        <item>Retailer</item>
        <item>Revenge seeker</item>
        <item>Rhapsody listener</item>
        <item>Ruby m.... Ruby m....</item>
        <item>Rage guy</item>
        <item>Rihanna sing for you</item>

        <!-- EN S -->
        <item>Saturn is beautiful</item>
        <item>Saturday night</item>
        <item>Singer in pause</item>
        <item>School lover</item>
        <item>Shark hunter</item>
        <item>Sister-in-law</item>
        <item>Sleeping actually</item>
        <item>Software never end</item>
        <item>Shakira move for you</item>

        <!-- EN T -->
        <item>Today is the day</item>
        <item>Taiwan forever</item>
        <item>Teacher</item>
        <item>Tennis lover</item>
        <item>Thief in cover</item>
        <item>Thursday just one more</item>
        <item>Trader</item>
        <item>Transformers hell yeah</item>

        <!-- EN U -->
        <item>Utimate player</item>
        <item>Unemployed person</item>
        <item>Unconscious player</item>
        <item>United States forever</item>
        <item>University student</item>
        <item>University teacher</item>
        <item>User for the first time</item>
        <item>Utopiste</item>
        <item>Ugly guy</item>

        <!-- EN V -->
        <item>Vengeance will follow</item>
        <item>Verdict guilty</item>
        <item>Veteran player </item>
        <item>Vigil on duty</item>
        <item>Violence prohibited plz</item>
        <item>Visitor testing</item>
        <item>Valuable player</item>
        <item>Virtuosity in person</item>
        <item>Volunteer to kill</item>

        <!-- EN W -->
        <item>Weapon in human form</item>
        <item>Wine adept</item>
        <item>Witch</item>
        <item>Winner all the time</item>
        <item>Winner or hope so</item>
        <item>Warrior</item>
        <item>Whiskey is a must</item>
        <item>Women in crazy state</item>
        <item>Wolf lover</item>

        <!-- EN X -->
        <item>Xenotime collector</item>
        <item>Xanthamides searcher</item>
        <item>Xylophonist</item>
        <item>Xerography user</item>
        <item>Xylophone adept</item>
        <item>Xenogenetic suspicious person</item>
        <item>Xenocryst collector</item>
        <item>Xebec conductor</item>
        <item>Xylopyrographist</item>

        <!-- EN Y -->
        <item>Young girl</item>
        <item>Yacht conductor</item>
        <item>Youngster</item>
        <item>Yolk lover</item>
        <item>Yaourt lover</item>
        <item>Yarn seller</item>
        <item>Yes i am an idiot</item>
        <item>Youngster in dangerous state</item>
        <item>Young crazy girl</item>

        <!-- EN Z -->
        <item>Zoologist</item>
        <item>Zero time losing</item>
        <item>Zoo adept</item>
        <item>Zachary Quinto</item>

    </array>

</resources>


text:
<head>
  <meta charset="utf-8">
  <meta name="apple-mobile-web-app-capable" content="yes">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">

  {% assign page_title = '' %}
  {% if page.title == "Home" %}
      {% capture page_title %}
        {{ site.title }}{{ site.title2 }} | {{ site.description }}
        {%if paginator and paginator.page != 1 %} - Página {{ paginator.page }}{% endif %}
      {% endcapture %}
  {% else %}
      {% capture page_title %}
          {%if page.slug == 'category' %}Categoria: {% endif %}
          {%if page.slug == 'tag' %}Tag: {% endif %} {{ page.title }} | {{ site.title }}{{ site.title2}}
      {% endcapture %}
  {% endif %}
  {% capture page_title %}
      {{ page_title | strip | rstrip | lstrip | escape | strip_newlines }}
  {% endcapture %}

  <title>{{ page_title }}</title>

  {% assign page_description = '' %}
  {% capture page_description %}
      {% if page.description %}
          {{ page.description | strip_html | strip | rstrip | strip_newlines | truncate: 160 }}
      {% else %}
          {{ site.description }}
      {% endif %}
      {%if paginator and paginator.page != 1 %} - Página {{ paginator.page }} {% endif %}
      {%if page.slug == 'category' %} Categoria: {{ page.title }}{% endif %}
      {%if page.slug == 'tag' %} Tag: {{ page.title }}{% endif %}
  {% endcapture %}

  {% capture page_description %}
      {{ page_description | strip | rstrip | lstrip | escape | strip_newlines }}
  {% endcapture %}

  <meta name="description" content="{{ page_description }}">
  <meta name="keywords" content="{% if page.keywords %}{{ page.keywords }}{% else %}{{ site.keywords }}{% endif %}">

  <meta name="HandheldFriendly" content="True">
  <meta name="MobileOptimized" content="320">

  {% assign page_image = '' %}
  {% capture page_image %}
      {% if page.cover %}
          {{ page.cover | prepend: site.baseurl | prepend: site.url }}
      {% else %}
          {{ site.cover | prepend: site.baseurl | prepend: site.url }}
      {% endif %}
  {% endcapture %}
  {% capture page_image %}{{ page_image | strip | rstrip | lstrip | escape | strip_newlines }}{% endcapture %}

  <!-- Social: Facebook / Open Graph -->
{% if page.id %}
  <meta property="og:type" content="article">
  <meta property="article:author" content="{{ site.author.name }}">
  <meta property="article:section" content="{{ page.categories | join: ', ' }}">
  <meta property="article:tag" content="{{ page.keywords }}">
  <meta property="article:published_time" content="{{ page.date }}">
{% else%}
  <meta property="og:type" content="website">
{% endif %}
  <meta property="og:url" content="{{ page.url | replace:'index.html','' | prepend: site.baseurl | prepend: site.url }}">
  <meta property="og:title" content="{{ page_title }}">
  <meta property="og:image" content="{{ page_image }}">
  <meta property="og:description" content="{{ page_description }}">
  <meta property="og:site_name" content="{{ site.author.name }}">
  <meta property="og:locale" content="{{ site.og_locale }}">

  <!-- Social: Twitter -->
  <meta name="twitter:card" content="{{ site.twitter_card }}">
  <meta name="twitter:site" content="{{ site.twitter_site }}">
  <meta name="twitter:title" content="{{ page_title }}">
  <meta name="twitter:description" content="{{ page_description }}">
  <meta name="twitter:image:src" content="{{ page_image }}">

  <!-- Social: Google+ / Schema.org  -->
  <meta itemprop="name" content="{{ page_title }}">
  <meta itemprop="description" content="{{ page_description }}">
  <meta itemprop="image" content="{{ page_image }}">

  <!-- rel prev and next -->
  {% if paginator.previous_page %}
    <link rel="prev" href="{{ paginator.previous_page_path | prepend: site.baseurl | prepend: site.url }}">
  {% endif %}
  {% if paginator.next_page %}
    <link rel="next" href="{{ paginator.next_page_path | prepend: site.baseurl | prepend: site.url }}">
  {% endif %}

  <link rel="stylesheet" href="{{ "/assets/css/main.css" | prepend: site.baseurl }}">
  <link rel="stylesheet" href="{{ "/assets/css/font-awesome.min.css" | prepend: site.baseurl }}">

  <!-- Canonical link tag -->
  <link rel="canonical" href="{{ page.url | replace:'index.html','' | prepend: site.baseurl | prepend: site.url }}">
  <link rel="alternate" type="application/rss+xml" title="{{ site.title }}{{ site.title2 }}" href="{{ "/feed.xml" | prepend: site.baseurl | prepend: site.url }}">

  <script type="text/javascript">
  var disqus_shortname = '{{ site.disqus_shortname }}';
  var _gaq = _gaq || [];
  _gaq.push(['_setAccount', '{{ site.google_analytics }}']);
  _gaq.push(['_trackPageview']);

  (function() {
    var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
    ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
    var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
  })();

  <title>Highlight.js</title>
  <link rel="stylesheet" href="http://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.1.0/styles/default.min.css">
  <script src="http://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.1.0/highlight.min.js"></script>
  <script type="text/javascript">
  hljs.initHighlightingOnLoad();
  </script>
</head>