//! moment.js locale configuration
//! locale : Morocco Central Atlas Tamaziɣt (tzm)
//! author : Abdel Said : https://github.com/abdelsaid

import moment from '../moment';

export default moment.defineLocale('tzm', {
    months : 'ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ'.split('_'),
    monthsShort : 'ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ'.split('_'),
    weekdays : 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
    weekdaysShort : 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
    weekdaysMin : 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
    longDateFormat : {
        LT : 'HH:mm',
        LTS: 'LT:ss',
        L : 'DD/MM/YYYY',
        LL : 'D MMMM YYYY',
        LLL : 'D MMMM YYYY LT',
        LLLL : 'dddd D MMMM YYYY LT'
    },
    calendar : {
        sameDay: '[ⴰⵙⴷⵅ ⴴ] LT',
        nextDay: '[ⴰⵙⴽⴰ ⴴ] LT',
        nextWeek: 'dddd [ⴴ] LT',
        lastDay: '[ⴰⵚⴰⵏⵜ ⴴ] LT',
        lastWeek: 'dddd [ⴴ] LT',
        sameElse: 'L'
    },
    relativeTime : {
        future : 'ⴷⴰⴷⵅ ⵙ ⵢⴰⵏ %s',
        past : 'ⵢⴰⵏ %s',
        s : 'ⵉⵎⵉⴽ',
        m : 'ⵎⵉⵏⵓⴺ',
        mm : '%d ⵎⵉⵏⵓⴺ',
        h : 'ⵙⴰⵄⴰ',
        hh : '%d ⵜⴰⵙⵙⴰⵄⵉⵏ',
        d : 'ⴰⵙⵙ',
        dd : '%d oⵙⵙⴰⵏ',
        M : 'ⴰⵢoⵓⵔ',
        MM : '%d ⵉⵢⵢⵉⵔⵏ',
        y : 'ⴰⵙⴳⴰⵙ',
        yy : '%d ⵉⵙⴳⴰⵙⵏ'
    },
    week : {
        dow : 6, // Saturday is the first day of the week.
        doy : 12  // The week that contains Jan 1st is the first week of the year.
    }
});

{'repo_name': 'getminera/minera', 'stars': '325', 'repo_language': 'PHP', 'file_name': 'index.js', 'mime_type': 'text/plain', 'hash': 3883528486395147016, 'source_dataset': 'data'}


(ns ccw.trace
  (:require [clojure.java.io :as io])
  (:import [java.util Properties]))

#_(defmacro def-trace-options-keys [bundle-call]
   `(do
      (def ~'symbolic-name (delay (.getSymbolicName ~bundle-call)))
      (def ~'trace-options
        (delay
          (with-open [io# (-> ~bundle-call
                            (.getEntry "/.options")
                            io/input-stream)]
            (into {} (doto (Properties.)
                       (.load io#))))))
      (defn ~'trace-options-keys [] (set (keys ~'trace-options)))))

(defn trace-option-str [trace-option]
  (str "/" (if (keyword? trace-option)
             (.substring (str trace-option) 1)
             trace-option)))

(defmacro mk-trace-macros
  "Install all necessary macros in the calling namespace for leveraging the
  Eclipse Tracing API.
  bundle-call is the code necessary to get the bundle for which tracing support
  must be added.
  get-tracer-call is the code necessary to get an instance of ccw.util.ITracer.
  This means an initialization still needs to be done in the bundle Activator.

  The macros that are installed wrap the org.eclipse.osgi.service.debug.DebugTrace
  utility methods:

  (trace trace-option message)
  (trace trace-option message throwable)
  (trace-dump-stack trace-option)
  (trace-entry trace-option & method-args)
  (trace-exit trace-option & result-value)
  "
  [bundle-call get-tracer-call]
  (let [caller-ns (name (ns-name *ns*))
        caller-tracer (symbol caller-ns "tracer")
        caller-tracer-call (symbol caller-ns "tracer-call")
        caller-trace (symbol caller-ns "trace")]
    `(do
       #_(def-trace-options-keys ~bundle-call)

       (defn ~'^ccw.util.ITracer tracer [] ~get-tracer-call)

       (defmacro ~'tracer-call [trace-option-string# & body#]
         #_(when-not (~'trace-options-keys (str ~'symbolic-name trace-option-string#))
            (throw (RuntimeException.
                    (str "Compilation error: call to ccw.trace/trace"
                         " with non existent trace-option: " trace-option-string#))))
         `(when (.isEnabled (~'~caller-tracer) ~trace-option-string#)
            ~@body#))

       (defmacro ~'trace
         ([trace-option# string#]
          (let [trace-option-string# (trace-option-str trace-option#)]
            `(~'~caller-tracer-call ~trace-option-string#
                                    (.trace (~'~caller-tracer)
                                            ~trace-option-string#
                                            (into-array Object [~string#]))) ))
         ([trace-option# string# throwable#]
          (let [trace-option-string# (trace-option-str trace-option#)]
            `(~'~caller-tracer-call ~trace-option-string#
                                    (.trace (~'~caller-tracer)
                                            ~trace-option-string#
                                            ~throwable#
                                            (into-array Object [~string#]))))))

       (defmacro ~'trace-dump-stack
         ([trace-option#]
          (let [trace-option-string# (trace-option-str trace-option#)]
            `(~'~caller-tracer-call ~trace-option-string#
                                    (.traceDumpStack (~'~caller-tracer)
                                                     ~trace-option-string#)))))

       (defmacro ~'trace-entry
         ([trace-option# & method-args#]
          (let [trace-option-string# (trace-option-str trace-option#)]
            (cond
              (nil? (seq method-args#))
              `(~'~caller-tracer-call ~trace-option-string#
                                      (. (~'~caller-tracer)
                                         ~'~'traceEntry
                                         ~trace-option-string#))
              :else
              `(~'~caller-tracer-call ~trace-option-string#
                                      (. (~'~caller-tracer)
                                         ~'~'traceEntry
                                         ~trace-option-string#
                                         (into-array Object [~@method-args#])))))))
       (defmacro ~'trace-exit
         ([trace-option# & result#]
          (if (seq result#)
            (let [trace-option-string# (trace-option-str trace-option#)]
              `(~'~caller-tracer-call ~trace-option-string#
                                      (. (~'~caller-tracer)
                                         ~'~'traceExit
                                         ~trace-option-string#
                                         ~(first result#)))
              `(~'~caller-tracer-call ~trace-option-string#
                                      (. (~'~caller-tracer)
                                         ~'~'traceExit
                                         ~trace-option-string#))))))

       (defmacro ~'format [trace-option# format-string# & format-args#]
           `(~'~caller-trace ~trace-option# (format ~format-string# ~@format-args#))))))

{'repo_name': 'ccw-ide/ccw', 'stars': '217', 'repo_language': 'Java', 'file_name': 'keyboard-shortcuts.adoc', 'mime_type': 'text/plain', 'hash': -8269612257264044084, 'source_dataset': 'data'}


Participate in the development of the collaborative, free and open food database Open Food Facts

Thank you very much for your interest in the Open Food Facts project and for your support!

A collaborative, free and open database of food products with an increasing impact

Launched in 2012, the Open Food Facts project continues to grow: in 2018, our collaborative, free and open food product database has almost doubled in size, having already quadrupled in 2017! This database is reused for free by over 100 mobile apps and web services and is used by public health research teams.

As mentioned in our last activity report, this very rapid growth in the number of products and reuses opens up new perspectives and opportunities, but also presents new challenges that we now need to address.

Human resources at the service of a citizen project

Since 2012, the Open Food Facts project has been entirely run by volunteer citizens grouped together in a 1901 non-profit association. The project is based on citizen gathering (crowdsourcing) to feed the database (on the model of other citizen projects like OpenStreetMap and Wikipedia), and also on volunteers for management and technical development.

Open Food Facts has a growing impact, but we also have growing difficulties to cope with the extra work this growth entails. To sustain and extend our action, we will put in place human resources dedicated to the project, who can work there full time, being paid.

This will enable a continued growth of the database and will enable addressing the challenges we have identified, and it will also extend the project into new directions (such as extending to new types of products like cosmetics with Open Beauty Facts), or the creation of new services and applications (eg in the field of the fight against waste) etc.

What will your money be used for?

Your donations will allow us to pay a small permanent team that can support volunteer contributors and implement the projects we present in our 2019 roadmap more efficiently and quickly.

Every donation counts!

The establishment of a permanent team requires funding well above our current budget (less than 1000 euros per year until 2017, but already 25000 euros in 2018), even if the team is very small and part time. But your donations will allow us to start building this small team and allow us to search for and claim other sources of funding (such as public grants and foundations not related to the agri-food industry), and thus to continue to build the Open Food Facts project in a sustainable and incremental way.

If you can, so that we can plan and continue its action in a serene and perennial way, please prefer monthly donations.

Thank you very much for your support !

{'repo_name': 'openfoodfacts/openfoodfacts-server', 'stars': '270', 'repo_language': 'HTML', 'file_name': 'madenearme-fr.html', 'mime_type': 'text/html', 'hash': 3251342022872564495, 'source_dataset': 'data'}


name: "layer_norm"
op {
  input: "input"
  output: "result"
  name: ""
  type: "LayerNorm"
  arg {
    name: "axis"
    i: 2
  }
  arg {
    name: "epsilon"
    f: 0.05
  }
}
external_input: "input"
external_output: "result"

{'repo_name': 'pytorch/glow', 'stars': '2190', 'repo_language': 'C++', 'file_name': 'build.sh', 'mime_type': 'text/x-shellscript', 'hash': 1273262266095054631, 'source_dataset': 'data'}


/**
 * Author......: See docs/credits.txt
 * License.....: MIT
 */

//#define NEW_SIMD_CODE

#ifdef KERNEL_STATIC
#include "inc_vendor.h"
#include "inc_types.h"
#include "inc_platform.cl"
#include "inc_common.cl"
#include "inc_scalar.cl"
#include "inc_hash_md5.cl"
#endif

KERNEL_FQ void m09900_mxx (KERN_ATTR_BASIC ())
{
  /**
   * modifier
   */

  const u64 lid = get_local_id (0);
  const u64 gid = get_global_id (0);

  if (gid >= gid_max) return;

  /**
   * base
   */

  md5_ctx_t ctx0;

  md5_init (&ctx0);

  md5_update_global (&ctx0, pws[gid].i, pws[gid].pw_len);

  /**
   * loop
   */

  for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
  {
    md5_ctx_t ctx = ctx0;

    md5_update_global (&ctx, combs_buf[il_pos].i, 100 - pws[gid].pw_len);

    md5_final (&ctx);

    const u32 r0 = ctx.h[DGST_R0];
    const u32 r1 = ctx.h[DGST_R1];
    const u32 r2 = ctx.h[DGST_R2];
    const u32 r3 = ctx.h[DGST_R3];

    COMPARE_M_SCALAR (r0, r1, r2, r3);
  }
}

KERNEL_FQ void m09900_sxx (KERN_ATTR_BASIC ())
{
  /**
   * modifier
   */

  const u64 lid = get_local_id (0);
  const u64 gid = get_global_id (0);

  if (gid >= gid_max) return;

  /**
   * digest
   */

  const u32 search[4] =
  {
    digests_buf[digests_offset].digest_buf[DGST_R0],
    digests_buf[digests_offset].digest_buf[DGST_R1],
    digests_buf[digests_offset].digest_buf[DGST_R2],
    digests_buf[digests_offset].digest_buf[DGST_R3]
  };

  /**
   * base
   */

  md5_ctx_t ctx0;

  md5_init (&ctx0);

  md5_update_global (&ctx0, pws[gid].i, pws[gid].pw_len);

  /**
   * loop
   */

  for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
  {
    md5_ctx_t ctx = ctx0;

    md5_update_global (&ctx, combs_buf[il_pos].i, 100 - pws[gid].pw_len);

    md5_final (&ctx);

    const u32 r0 = ctx.h[DGST_R0];
    const u32 r1 = ctx.h[DGST_R1];
    const u32 r2 = ctx.h[DGST_R2];
    const u32 r3 = ctx.h[DGST_R3];

    COMPARE_S_SCALAR (r0, r1, r2, r3);
  }
}

{'repo_name': 'hashcat/hashcat', 'stars': '8233', 'repo_language': 'C', 'file_name': 'install', 'mime_type': 'text/x-shellscript', 'hash': -7339664591055191501, 'source_dataset': 'data'}


.. _enterprise_agreement_es:

===========================================
Odoo Enterprise Subscription Agreement (ES)
===========================================

.. warning::
    Esta es una traducción al español del "Odoo Enterprise Subscription Agreement".
    Esta traducción se proporciona con la esperanza de que facilite la comprensión, pero no tiene valor legal.
    La única referencia oficial de los términos y condiciones del
    "Odoo Enterprise Subscription Agreement" es :ref:`la versión original en
    inglés <enterprise_agreement>`

.. warning::
    ESTA VERSIÓN NO ESTÁ ACTUALIZADA. PARA LA ÚLTIMA VERSIÓN POR FAVOR VEA
    :ref:`LA VERSIÓN ORIGINAL EN INGLÉS <enterprise_agreement>`

.. note:: Version 8.0 - 2018-05-22

Al suscribirse a los servicios de Odoo Enterprise proporcionados por
Odoo SA y sus afiliados (colectivamente “Odoo SA”) en relación a Odoo Enterprise
Edition u Odoo Community Edition, alojados en las plataformas *Cloud
Hosting* (la nube de Odoo) o en las instalaciones *On Premise*
("Self-Hosting"), usted (el "Cliente") acepta regirse por lo siguientes términos y condiciones:

.. _term_es:

1 Términos de duración del acuerdo
==================================

La duración de este Acuerdo se especifica por escrito en el acuerdo
entre las partes. Odoo acepta contratos mensuales o anuales. Los
contratos de la licencia, llámese uso de Aplicaciones y de Usuarios, se
renueva automáticamente por un término igual al contrato inicial a menos
que cualquiera de las partes proporcione un aviso de terminación por
escrito con un mínimo de 30 días antes de la fecha de finalización del
acuerdo.

.. _definitions_es:

2 Definiciones
==============

Usuario
    Cualquier cuenta de usuario activa con acceso al Software en
    modo de creación y / o edición. Las cuentas de usuario desactivadas y las cuentas utilizadas
    por personas (o sistemas) externos que solo tienen acceso limitado al Software a través del
    portal de usuario no son considerados *Usuarios.*

Aplicación
    Una "Aplicación" es un grupo especializado de funciones
    disponibles para la instalación en el Software, y listados en la sección de precios públicos
    del `sitio web de Odoo SA <https://www.odoo.com/es_ES/>`__

Error/Bug
    Se considera un error cualquier falla del Software que
    resulte en una detención completa, un rastreo de errores o una violación de la seguridad,
    y no es causada directamente por una instalación o configuración defectuosa.
    El incumplimiento de algunas especificaciones o requisitos será considerado como error a
    discreción del Odoo SA (Por ejemplo, cuando el Software no cumple con el comportamiento ni
    los resultados para el cual fue diseñado, o cuando una característica específica del país
    ya no cumple con los requisitos legales de contabilidad).

Versiones Cubiertas
    A menos que se especifique lo contrario, los
    servicios que se ofrecen bajo este acuerdo son aplicables hasta las 3 versiones más recientes,
    inclusive.

    Para estar cubierto por el presente Contrato, el Cliente debe utilizar la versión más reciente
    del software en el momento que se acuerda este contrato. De no ser el caso, se pueden realizar
    cargos adicionales, como se describe en el apartado número :ref:`charges_es`

    .. _enterprise_access_es:

3 Acceso al Software
====================

El cliente puede utilizar el software alojado en la plataforma en la
nube, o elegir la opción de instalarlo en servidores propios. La
plataforma en la nube está alojada y totalmente administrada por Odoo SA y se accede de forma
remota por el cliente. Con la opción de self/hosting o alojado en servidores propios, el cliente
en su lugar aloja el software en sistemas informáticos de su elección, que no están bajo el control
de Odoo SA.

Durante la vigencia de este Acuerdo, Odoo SA otorga al Cliente una
licencia no exclusiva e intransferible para usar (ejecutar, modificar, ejecutar después de la
modificación) las opciones adquiridas del software, según los términos establecidos en el
:ref:`appendix_a_es`.

El Cliente acuerda tomar todas las medidas necesarias para garantizar la ejecución y verificación
de la parte del Software que se encuentra instalada o descargada tanto la verificación del uso de
Odoo Enterprise Edition, incluyendo pero no limitado a la ejecución de su instancia, el número de
usuarios activos/instalados y las aplicaciones instaladas.

Odoo SA se compromete a no divulgar figuras individuales o nombradas a terceros sin el
consentimiento del Cliente, y tratar con todos los datos recopilados de conformidad con su
Política de Privacidad oficial, publicado en `Odoo Privacy <https://www.odoo.com/privacy/>`__

Al vencimiento o terminación de este Acuerdo, esta licencia se revoca
inmediatamente y el cliente acepta dejar de usar el software Odoo
Enterprise Edition y la plataforma en la nube.

En caso de que el Cliente incumpla los términos de esta sección, el
Cliente acepta pagar a Odoo SA una tarifa adicional igual a 300% del
precio de lista aplicable para el número real de Usuarios y Aplicaciones
instaladas.

.. _services_es:

4 Servicios
===========

.. _bugfix_es:

4.1 Servicio de corrección de errores
-------------------------------------

Durante la vigencia de este Acuerdo, Odoo SA se compromete a hacer todos los esfuerzos razonables
para remediar cualquier error del software enviado por el cliente a través del canal apropiado
(dirección de correo electrónico de la mesa de servicio de Odoo SA o el formulario del sitio web
`Odoo Help <https://www.odoo.com/help/>`__ y comenzar a analizar la resolución del error dentro de
un tiempo estimado de 2 días hábiles.

El cliente entiende que los errores causados por una modificación o
extensión que sea parte del software oficial no será cubierto por este servicio de soporte.

Tan pronto como se solucione el error, se comunicará al cliente.

Para los clientes con alojamiento en la nube, si el error se ha
solucionado en una revisión más reciente de la Versión Cubierta del
Software utilizado por el cliente, el cliente acepta actualizar su
sistema a esa revisión para obtener la corrección. No se le pedirá al
cliente que actualice a la versión más reciente como solución.

Cuando se corrige un error en cualquier Versión Cubierta, Odoo SA se
compromete a solucionar el error en todas las Versiones Cubiertas
recientes del software.

Ambas partes reconocen que tal como se especifica en la licencia del
Software y en la sección :ref:`liability_es`,
Odoo SA no se hace responsable de los errores en el Software.

4.2 Servicio de actualizaciones de seguridad
--------------------------------------------

.. _secu_self_hosting_es:

Auto-alojamiento/Self-Hosting
+++++++++++++++++++++++++++++

Durante la vigencia de este Acuerdo, Odoo SA se compromete a enviar un "Aviso de Seguridad" al
cliente para cualquier error de seguridad que se descubra en las Versiones Cubiertas del software,
al menos 2 semanas antes de hacer público el Aviso de seguridad, a menos que el error ya haya sido
divulgado públicamente por un tercero. Los avisos de seguridad incluyen una descripción completa
del error, su causa, sus posibles impactos en los sistemas del cliente, y la solución
correspondiente para cada Cobertura.

El cliente entiende que el error y la información en el aviso de
seguridad deben ser tratados como información confidencial como se
describe en el apartado :ref:`confidentiality_es` durante el período de embargo anterior a la
divulgación pública.

Plataforma en la nube/Cloud Hosting
+++++++++++++++++++++++++++++++++++

Odoo SA se compromete a aplicar las soluciones de seguridad para
cualquier error de seguridad descubierto en una versión del software
alojado en la plataforma de la nube, en todos los sistemas bajo su
control, tan pronto como la solución esté disponible, sin requerir
ninguna acción manual del cliente.

.. _upgrade_es:

4.3 Servicios de actualización
------------------------------

.. _upgrade_odoo_es:

**Servicio de actualización para el software**

Durante la vigencia de este Acuerdo, el Cliente puede enviar solicitudes de actualización a través
del canal apropiado (normalmente, el sitio web del servicio de actualización de Odoo SA), para
convertir una base de datos del software de una Versión Cubierta del software a una Versión
Cubierta más reciente.

Para la Plataforma en la nube, las solicitudes de actualización se
envían directamente desde el panel de control de la Plataforma en la
nube, y no requiere ninguna carga de datos. Para Auto-Hosting, las
solicitudes de actualización deben incluir una copia de respaldo
completa de la base de datos del Cliente y los datos asociados
(generalmente obtenido en el menú de copia de seguridad del software).

Este servicio se proporciona a través de una plataforma automatizada
para permitir que el Cliente realice actualizaciones desatendidas una
vez que una versión anterior de la base de datos del Cliente ha sido
exitosamente actualizada para una Versión Cubierta. El Cliente puede
presentar solicitudes de actualización sucesivas para una base de datos, y acepta enviar al menos
1 solicitud de actualización para fines de prueba antes de enviar la solicitud de actualización final.

El Servicio de actualización se limita a la conversión técnica y la
adaptación de la base de datos para que sea compatible con la versión de destino y la corrección
de cualquier error directamente causado por la operación de actualización y que normalmente no
ocurre en la versión de ndestino.

Es responsabilidad exclusiva del Cliente verificar y validar la base de datos actualizada para
detectar errores, analizar el impacto de los cambios y las nuevas características implementadas
en el versión de destino, y para convertir y adaptar a la versión de destino cualquier extensión
de terceros que se haya instalado en la base de datos antes de la actualización (excepto cuando
sea aplicable según lo previsto en la sección Servicio de actualización para extensiones de
terceros). El cliente puede presentar múltiples solicitudes de actualización para una base de
datos, hasta que se logre un resultado aceptable.

.. _upgrade_extra_es:

Servicio de actualización para extensiones de terceros
++++++++++++++++++++++++++++++++++++++++++++++++++++++

Durante la vigencia de este Acuerdo, el Cliente podrá solicitar
servicios de actualización opcionales para módulos de extensión de
terceros, además de los Servicios de actualización habituales. Esta
servicio es opcional y está sujeto a tarifas adicionales (como se
describe en el apartado :ref:`charges_es`) e incluye la adaptación técnica de módulos de terceros
instalados en la base de datos del Cliente y sus datos correspondientes para ser compatibles con
la versión de destino. El cliente recibirá una versión actualizada de todos los módulos de terceros
instalados junto con la base de datos actualizada.

.. _cloud_hosting_es:

4.4 Servicios de alojamiento en la nube / Cloud Hosting
-------------------------------------------------------

Durante la vigencia de este Acuerdo, cuando el Cliente elija utilizar la
Plataforma en la nube (Cloud Hosting), Odoo SA se compromete a proporcionar los
siguientes servicios:

-  Elección de múltiples regiones de alojamiento (mínimo 3: Europa,
   América, Asia / Pacífico)
-  Alojamiento en centros de datos de nivel III o equivalente, con un
   99,9% de tiempo de actividad óptima de la red
-  Cifrado de comunicación Grado A SSL (HTTPS)
-  Copias de seguridad verificadas, completamente automatizadas,
   replicadas en múltiples regiones
-  Plan de recuperación de desastres, probado regularmente

Los detalles de los servicios de alojamiento en la nube se describen en
la página del Acuerdo de nivel de servicio:
`Cloud SLA <http://www.odoo.com/cloud-sla>`__.

.. _support_service_es:

4.5 Servicios de soporte
------------------------

Alcance
+++++++

Durante la vigencia de este Acuerdo, el Cliente puede abrir un número
ilimitado de tickets de soporte en `Odoo SA <https://www.odoo.com/help>`__,
exclusivamente para preguntas relacionadas con errores (:ref:`bugfix_es`) u orientación con
respecto al uso de las características estándar del Software y los Servicios (funcionalidades,
uso previsto, configuración, solución de problemas).

Se pueden cubrir otras solicitudes de asistencia, como preguntas
relacionadas con desarrollos, personalizaciones, instalación de
Auto-Hosting o servicios que requieren acceso a la base de datos del
Cliente a través de la compra de un Service Pack o Paquete de
Implementación. En caso de que no quede claro si una solicitud está
cubierta por este Acuerdo o un Service Pack, la decisión es a discreción de la disponibilidad de
Odoo SA.

.. _charges_es:

5 Cargos y Cuotas
=================

.. _charges_standard_es:

5.1 Cargos estándares
---------------------

Los cargos estándares para la suscripción de Odoo Enterprise y los
Servicios se basan en el número de Usuarios y las Aplicaciones
instaladas, en la versión de software utilizada por el cliente.

Cuando durante el plazo de uso del sistema, el Cliente tiene más
Usuarios o más Aplicaciones instaladas que las especificadas en el
momento de la celebración de este Acuerdo, el Cliente acepta pagar la
tarifa adicional equivalente al precio de lista aplicable según el
servicio que tenga instalado, para los Usuarios o Aplicaciones
adicionales, para el resto del plazo.

Si en el momento de la conclusión de este Acuerdo, el Cliente utiliza
una Versión Cubierta que no es la más reciente, los cargos estándares
pueden incrementarse en un 50% durante la duración del primer plazo, a discreción exclusiva de
Odoo SA, para cubrir los costos de mantenimiento adicionales.

.. _charges_renewal_es:

5.2 Cargos de renovación
------------------------

En el momento de la renovación, tal como se describe en la sección :ref:`term_es`,
si los cargos aplicados durante los términos
anteriores son más bajos que el precio de lista aplicable más actual,
estos cargos pueden aumentar hasta un 7%.

.. _charges_thirdparty_es:

5.3 Cargos por servicios de actualización de módulos de terceros
----------------------------------------------------------------

El cargo adicional por el Servicio de actualización para módulos de
terceros es de EUR (€) 1000.00 (mil euros) por 1000 líneas de código en los módulos de terceros,
redondeados a las siguientes mil líneas. Las líneas de código incluyen todas las líneas de texto
en el código fuente de esos módulos, independientemente del lenguaje de programación
(Python, Javascript, etc.) o el formato de datos (XML, CSV, etc.), excluyendo líneas en blanco y
líneas de comentarios.

Odoo SA se reserva el derecho de rechazar una solicitud de actualización para módulos de terceros
en virtud de lo anterior si la calidad del código fuente de esos módulos es demasiado baja,
o si estos módulos constituyen una interfaz con software o sistemas de terceros.
La actualización de dichos módulos puede ser sujeta a una oferta por separado, fuera de este Acuerdo.

.. _taxes_es:

5.4 Impuestos
-------------

Todos los aranceles y cargos son exclusivos de todos los impuestos,
aranceles o cargos federales, provinciales, estatales, locales u otros
gubernamentales aplicables (colectivamente, “Impuestos”). El cliente es
responsable de pagar todos los Impuestos asociados con las compras
realizadas por el Cliente en virtud de este Acuerdo, excepto cuando Odoo
SA está legalmente obligado a pagar o cobrar impuestos de los cuales el
cliente es responsable.

.. _conditions_es:

6 Condiciones de los servicios
==============================

6.1 Obligaciones del cliente
----------------------------

El Cliente se compromete a:

- Pagar a Odoo SA cualquier cargo aplicable por los Servicios del
  presente Acuerdo, según las condiciones de pago especificadas en la
  factura correspondiente;

- Notificar inmediatamente a Odoo SA cuando su número real de usarios
  o aplicaciones instaladas exceda el número especificado al final
  del Acuerdo y, en este caso, el pago de la tarifa adicional
  aplicable como se describe en la sección :ref:`charges_standard_es`;

- Tomar todas las medidas necesarias para garantizar la ejecución no
  modificada de la parte del Software que verifica la validez del uso
  de Odoo Enterprise Edition, como se describe en la sección :ref:`enterprise_access_es`;

- Designar a 1 persona de contacto dedicada del Cliente durante toda la duración del Acuerdo;

Cuando el Cliente elige usar la Plataforma en la nube, el Cliente
acuerda además:

- Tomar todas las medidas razonables para mantener sus cuentas de
  Usuario seguras, incluso al elegir una contraseña segura y no
  compartirla con nadie más;

- Hacer uso razonable de los servicios de alojamiento, cone xclusiónde cualquier actividad ilegal
  o actividades abusivas, y observar estrictamente las reglas descritas en la Política de uso
  aceptable publicada en `acceptable use <https://www.odoo.com/acceptable-use>`__.

Cuando el Cliente elige la opción de Auto-alojamiento, el Cliente acepta
además:

Tomar todas las medidas razonables para proteger los archivos y las
bases de datos del Cliente y para garantizar que los datos del Cliente sean seguros y estén
protegidos, reconociendo que Odoo SA no se hace responsable de ninguna pérdida de datos

Otorgar a Odoo SA el acceso necesario para verificar la validez de la Edición Enterprise de Odoo
uso a solicitud (por ejemplo, si la validación automática no es válida para el Cliente);

6.2 No solicitar o contratar
----------------------------
Excepto cuando la otra parte dé su consentimiento por escrito, cada
parte, sus afiliados y sus representantes acuerdan no solicitar u
ofrecer empleo a ningún empleado de la otra parte que esté involucrada en la prestación o el uso
de los Servicios en virtud de este Acuerdo, durante la vigencia del Acuerdo y por un período de
12 meses a partir de la fecha de terminación o vencimiento de este Acuerdo. En caso de cualquier
incumplimiento de las condiciones de esta sección que conduzca a la terminación de dicho empleado,
la parte infractora acuerda pagar a la otra parte un importe de EUR (€) 30000 (treinta mil euros).

.. _publicity_es:

6.3 Publicidad
--------------

Excepto cuando se notifique lo contrario por escrito, cada parte otorga a la otra una licencia
mundial no transferible, no exclusiva, sin regalías para reproducir y mostrar el nombre,
los logotipos de la otra parte y marcas comerciales, con el único fin de referirse a la otra parte
como cliente o proveedor, en sitios web, comunicados de prensa y otros materiales de marketing.

.. _confidentiality_es:

6.4 Confidencialidad
--------------------

Definición de "Información confidencial": Toda la información divulgada
por una parte (la "Parte reveladora") a la otra parte (la "Parte
receptora"), ya sea oralmente o por escrito, es decir, designado como
confidencial o que razonablemente debe entenderse como confidencial dado
la naturaleza de la información y las circunstancias de divulgación.

En particular, cualquier información relacionada con los negocios,
asuntos, productos, desarrollos, secretos comerciales, “know-how”, el
personal, los clientes y los proveedores de cualquiera de las partes
deben considerarse confidenciales.

Para toda la Información confidencial recibida durante el Término de
este Acuerdo, la parte receptora utilizará el mismo grado de atención
que utiliza para proteger la confidencialidad de sus propios servicios
similares.

La parte receptora puede divulgar información confidencial de la parte
reveladora en la medida en que sea obligado por ley, siempre que la
Parte Receptora dé aviso previo a la Parte Divulgadora de la divulgación
obligada, en la medida permitida por la ley.

.. _data_protection_es:

6.5 Protección de datos
-----------------------

Las definiciones de "Datos personales", "Controlador", "Procesamiento"
toman los mismos significados que en el Reglamento (UE) 2016/679 y la
Directiva 2002/58 / CE, y cualquier reglamento o legislación que los
modifica o reemplaza (en lo sucesivo, "Legislación de protección de
datos”)

Procesamiento de datos personales
+++++++++++++++++++++++++++++++++

Las partes reconocen que la base de datos del Cliente puede contener
datos personales, para los cuales el cliente es el controlador. Estos
datos serán procesados por Odoo SA cuando el Cliente así lo indique,
mediante el uso de cualquiera de los Servicios que requieren una base de
datos (por ejemplo, los Servicios de hospedaje en la nube o el Servicio
de actualización de la base de datos), o si el Cliente transfiere su
base de datos o una parte de su base de datos a Odoo SA por cualquier
motivo relacionado con este Acuerdo.

Este procesamiento se realizará de conformidad con la legislación de
protección de datos. En particular, Odoo SA se compromete a:

- (a) Solo procesar los datos personales cuando y como lo indique el Cliente, y para elp ropósito
  de realizar uno de los Servicios en virtud de este Acuerdo, a menos que sea requerido por la
  ley, en cuyo caso, Odoo SA proporcionará un aviso previo al Cliente, a menos que la ley lo prohíba;
- (b) garantizar que todas las personas dentro de Odoo SA” autorizadas para procesar los Datos
  personales estén comprometidos con la confidencialidad;
- (c) implementar y mantener medidas técnicas y organizativas adecuadas para proteger los datos
  personales contra el procesamiento no autorizado o ilegal y contra la pérdida accidental,
  destrucción, daño, robo, alteración o divulgación;
- (d) enviará sin demora al Cliente cualquier solicitud de protección de datos que se haya enviado
  a Odoo SA con respecto a la base de datos del Cliente;
- (e) notificar al Cliente inmediatamente al momento de conocer y confirmar cualquier accidente,
  el procesamiento no autorizado o ilegal de, la divulgación o el acceso a los datos personales;
- (f) notificar al Cliente si las instrucciones de procesamiento infringen la Protección de datos
  aplicables a la legislación, en opinión de Odoo SA;
- (g) poner a disposición del Cliente toda la información necesaria para demostrar el cumplimiento
  con la legislación de protección de datos, permitir y contribuir razonablemente
  a las auditorías, incluidas las inspecciones, realizadas o exigidas por el Cliente;
- (h) eliminar permanentemente todas las copias de la base de datos del Cliente en posesión de
  Odoo SA, o devolver dichos datos, a elección del Cliente, a la terminación de este Acuerdo,
  sujeto a los retrasos especificados en la Política de privacidad
  de Odoo SA (`Privacy <https://www.odoo.com/privacy>`__).

Con respecto a los puntos (d) a (f), el Cliente acepta proporcionar a Odoo SA un contacto preciso
para información en todo momento, según sea necesario para notificar al responsable de Protección
de Datos del Cliente.

Sub procesadores
++++++++++++++++

El Cliente reconoce y acepta que para proporcionar los Servicios, Odoo SA puede utilizar
proveedores de servicios de terceros (sub procesadores) para procesar datos personales.
Odoo SA se compromete a utilizar únicamente sub procesadores de conformidad con la legislación de
protección de datos. Este uso será cubierto por un contrato entre Odoo SA y el Sub procesador
que proporciona garantías al efecto.

La Política de privacidad de Odoo SA, publicada en `Odoo Privacy <https://www.odoo.com/privacy>`_
proporciona información actualizada sobre los nombres y propósitos de los Sub procesadores
actualmente en uso por Odoo SA para la ejecución de los Servicios.

.. _termination_es:

6.6 Terminación
---------------

En el caso de que cualquiera de las Partes incumpla alguna de las
obligaciones que surgen en el presente documento, y si tal el
incumplimiento no ha sido subsanado dentro de los 30 días de calendario posteriores
a la notificación por escrito de dicho incumplimiento, este Acuerdo puede ser rescindido
inmediatamente por la Parte que no incumple.

Además, Odoo SA puede rescindir el Contrato inmediatamente en caso de que el Cliente incumpla
con pagos de las tarifas aplicables a los
Servicios dentro de la fecha de vencimiento especificada en el factura.

Disposiciones supervivientes: Las secciones ":ref:`confidentiality_es`",
“:ref:`disclaimers_es`",“:ref:`liability_es`", y “:ref:`general_provisions_es`” sobrevivirán
cualquier terminación o vencimiento de este Acuerdo.

.. _warranties_disclaimers_es:

7 Garantías, Renuncias, Responsabilidad Civil.
==============================================

.. _warranties_es:

7.1 Garantías
-------------

Durante la vigencia de este Acuerdo, Odoo SA se compromete a utilizar
esfuerzos comercialmente razonables con la finalidad de ejecutar los
Servicios de acuerdo con los estándares de la industria generalmente
aceptados siempre y cuando:

los sistemas informáticos del Cliente están en buen estado de
funcionamiento y, en el caso de Auto-Hosting, el software se instala en
un entorno operativo adecuado;

el Cliente proporciona información adecuada para la resolución de
problemas y, para el Auto alojamiento, cualquier acceso que Odoo SA
puede necesitar para identificar, reproducir y resolver problemas;

Todos los montos adeudados a Odoo SA han sido pagados.

El único y exclusivo remedio del Cliente y la única obligación de Odoo SA por cualquier
incumplimiento de esta garantía es para Odoo SA reanudar la ejecución de los Servicios sin cargo
adicional.

.. _disclaimers_es:

7.2 Renuncias
-------------

Excepto por lo expresamente dispuesto en este documento, ninguna de las
partes ofrece ninguna garantía de ningún tipo, ya sea expresa,
implícita, estatutaria o de otro tipo, y cada parte niega
específicamente todas las garantías implícitas, incluida cualquier
garantía implícita de comercialización, idoneidad para un propósito
particular o no infracción, en la medida máxima permitida por la ley
aplicable.

Odoo SA no garantiza que el Software cumpla con leyes o regulaciones
locales o internacionales.

.. _liability_es:

7.3 Limitación de responsabilidad
---------------------------------

En la medida máxima permitida por la ley, la responsabilidad agregada de cada parte junto con los
afiliados que surjan de o estén relacionados con este Acuerdo no excederán el 50% del monto total
pagado por el Cliente en virtud de este Acuerdo durante los 12 meses inmediatamente anteriores
a la fecha del evento que da lugar a tal reclamo. Las reclamaciones múltiples no ampliarán esta
limitación.

En ningún caso, ninguna de las partes o sus afiliadas serán responsable
por daños indirectos, especiales, ejemplares, incidentales o
consecuentes de cualquier tipo, incluidos, entre otros, la pérdida de
ingresos, ganancias, ahorros, pérdida de negocios u otras pérdidas
financieras, costos de inactividad o demora, datos perdidos o dañados,
que surjan de o en conexión con este Acuerdo independientemente de la
forma de acción, ya sea en contrato, agravio (incluida negligencia
estricta) o cualquier otra teoría legal o equitativa, incluso si una
parte o sus afiliados han sido informados de la posibilidad de tales
daños, o si una parte o sus afiliados no cumpla con su propósito
esencial.

.. _force_majeure_es:

7.4 Fuerza mayor
----------------

Ninguna de las partes será responsable ante la otra parte por la demora
en el cumplimiento o la falta de hacer cualquier desempeño bajo este
Acuerdo cuando tal falla o demora sea causada por regulaciones
gubernamentales, incendios, huelgas, guerras, inundaciones, accidentes,
epidemias, embargos, apropiación de plantas, o producto en su totalidad
o en parte por cualquier gobierno o autoridad pública, o cualquier otra
causa o causas, ya sean de naturaleza similar o diferente, más allá del
control razonable de dicha parte siempre que tal causa o causas existen.

.. _general_provisions_es:

8 Disposiciones generales
=========================

.. _governing_law_es:

8.1 Ley aplicable
-----------------

Ambas partes acuerdan que las leyes de Bélgica se aplicarán, en caso de
que surja cualquier disputa fuera de o en relación con este Acuerdo, sin
tener en cuenta la elección o el conflicto de principios legales. En la
medida en que anteriormente se permita cualquier demanda o procedimiento
judicial, ambas partes acuerdan someterse a la única jurisdicción del
tribunal de Nivelles (Bélgica) con el fin de litigar todas las disputas.

.. _severability_es:

8.2 Divisibilidad
-----------------

En caso de que una o más de las disposiciones de este Acuerdo o
cualquiera de sus aplicaciones sean inválidas, ilegales o no exigibles
en ningún aspecto, la validez, legalidad y exigibilidad de las
disposiciones restantes del presente Acuerdo y su aplicación no serán de
ninguna manera afectados o deteriorados. Ambas partes se comprometen a
reemplazar cualquier inválido, ilegal o inaplicable disposición de este
Acuerdo por una disposición válida que tenga los mismos efectos y
objetivos.

.. _appendix_a_es:

9 Apéndice A: Licencia de Odoo Enterprise Edition
=================================================

.. only:: latex

   Odoo Enterprise Edition tiene licencia de Odoo Enterprise Edition License v1.0, definido como sigue:

    .. highlight:: none

    .. literalinclude:: ../../licenses/enterprise_license.txt

.. only:: html

    Ver :ref:`odoo_enterprise_license`.

{'repo_name': 'odoo/documentation-user', 'stars': '210', 'repo_language': 'CSS', 'file_name': 'test.rst', 'mime_type': 'text/plain', 'hash': -2639608648140140421, 'source_dataset': 'data'}


#include "XModem.h"
#include "Terminal.h"

#define BYTE_NAK        0x15
#define BYTE_SOH        0x01
#define BYTE_ACK        0x06
#define BYTE_CAN        0x18
#define BYTE_EOF        0x1A
#define BYTE_EOT        0x04

#define XMODEM_BLOCK_SIZE   128

#define RECV_INIT_TIMEOUT   5  /* x 100ms */
#define RECV_INIT_COUNT     20 /* 10 secs */
#define SEND_INIT_TIMEOUT   100 /* x 100ms */

#define FIRST_FRAME_NUMBER  1
#define CHECKSUM_INIT_VALUE 0

static enum {
    STATE_OFF,
    STATE_RECEIVE_INIT,
    STATE_RECEIVE_WAIT,
    STATE_RECEIVE_FRAMENUM1,
    STATE_RECEIVE_FRAMENUM2,
    STATE_RECEIVE_DATA,
    STATE_RECEIVE_PROCESS,
    STATE_SEND_INIT,
    STATE_SEND_WAIT,
    STATE_SEND_EOT
} State = STATE_OFF;

static uint8_t CurrentFrameNumber;
static uint8_t ReceivedFrameNumber;
static uint8_t Checksum;
static uint8_t RetryCount;
static uint16_t RetryTimeout;
static uint16_t BufferIdx;
static uint32_t BlockAddress;

static XModemCallbackType CallbackFunc;

static uint8_t CalcChecksum(const void* Buffer, uint16_t ByteCount) {
    uint8_t Checksum = CHECKSUM_INIT_VALUE;
    uint8_t* DataPtr = (uint8_t*) Buffer;

    while(ByteCount--) {
        Checksum += *DataPtr++;
    }

    return Checksum;
}

void XModemReceive(XModemCallbackType TheCallbackFunc)
{
    State = STATE_RECEIVE_INIT;
    CurrentFrameNumber = FIRST_FRAME_NUMBER;
    RetryCount = RECV_INIT_COUNT;
    RetryTimeout = RECV_INIT_TIMEOUT;
    BlockAddress = 0;

    CallbackFunc = TheCallbackFunc;
}

void XModemSend(XModemCallbackType TheCallbackFunc)
{
    State = STATE_SEND_INIT;
    RetryTimeout = SEND_INIT_TIMEOUT;
    BlockAddress = 0;

    CallbackFunc = TheCallbackFunc;
}

bool XModemProcessByte(uint8_t Byte)
{
    switch(State) {
    case STATE_RECEIVE_INIT:
    case STATE_RECEIVE_WAIT:
        if (Byte == BYTE_SOH) {
            /* Next frame incoming */
            BufferIdx = 0;
            Checksum = CHECKSUM_INIT_VALUE;
            State = STATE_RECEIVE_FRAMENUM1;
        } else if (Byte == BYTE_EOT) {
            /* Transmission finished */
            TerminalSendByte(BYTE_ACK);
            State = STATE_OFF;
        } else if (Byte == BYTE_CAN) {
            /* Cancel transmission */
            State = STATE_OFF;
        } else {
            /* Ignore other bytes */
        }

        break;

    case STATE_RECEIVE_FRAMENUM1:
        /* Store frame number */
        ReceivedFrameNumber = Byte;
        State = STATE_RECEIVE_FRAMENUM2;
        break;

    case STATE_RECEIVE_FRAMENUM2:
        if (Byte == (255 - ReceivedFrameNumber)) {
            /* frame-number check passed. */
            State = STATE_RECEIVE_DATA;
        } else {
            /* Something went wrong. Try to recover by sending NAK */
            TerminalSendByte(BYTE_NAK);
            State = STATE_RECEIVE_WAIT;
        }

        break;

    case STATE_RECEIVE_DATA:
        /* Process byte and update checksum */
        TerminalBuffer[BufferIdx++] = Byte;

        if (BufferIdx == XMODEM_BLOCK_SIZE) {
            /* Block full */
            State = STATE_RECEIVE_PROCESS;
        }

        break;

    case STATE_RECEIVE_PROCESS:
        if (ReceivedFrameNumber == CurrentFrameNumber) {
            /* This is the expected frame. Calculate and verify checksum */

            if (CalcChecksum(TerminalBuffer, XMODEM_BLOCK_SIZE) == Byte) {
                /* Checksum is valid. Pass received data to callback function */
                if (CallbackFunc(TerminalBuffer, BlockAddress, XMODEM_BLOCK_SIZE)) {
                    /* Proceed to next frame and send ACK */
                    CurrentFrameNumber++;
                    BlockAddress += XMODEM_BLOCK_SIZE;
                    TerminalSendChar(BYTE_ACK);
                    State = STATE_RECEIVE_WAIT;
                } else {
                    /* Application signals to cancel the transmission */
                    TerminalSendByte(BYTE_CAN);
                    TerminalSendByte(BYTE_CAN);
                    State = STATE_OFF;
                }
            } else {
                /* Data seems to be damaged */
                TerminalSendByte(BYTE_NAK);
                State = STATE_RECEIVE_WAIT;
            }
        } else if (ReceivedFrameNumber == (CurrentFrameNumber - 1)) {
            /* This is a retransmission */
            TerminalSendByte(BYTE_ACK);
            State = STATE_RECEIVE_WAIT;
        } else {
            /* This frame is completely out of order. Just cancel */
            TerminalSendByte(BYTE_CAN);
            State = STATE_OFF;
        }

        break;

    case STATE_SEND_INIT:
        /* Start sending on NAK */
        if (Byte == BYTE_NAK) {
            CurrentFrameNumber = FIRST_FRAME_NUMBER - 1;
            Byte = BYTE_ACK;
        }

        /* Fallthrough */

    case STATE_SEND_WAIT:
        if (Byte == BYTE_CAN) {
            /* Cancel */
            TerminalSendByte(BYTE_ACK);
            State = STATE_OFF;
        } else if (Byte == BYTE_ACK) {
            /* Acknowledge. Proceed to next frame, get data and calc checksum */
            CurrentFrameNumber++;

            if (CallbackFunc(TerminalBuffer, BlockAddress, XMODEM_BLOCK_SIZE)) {
                TerminalSendByte(BYTE_SOH);
                TerminalSendByte(CurrentFrameNumber);
                TerminalSendByte(255 - CurrentFrameNumber);
                TerminalSendBlock(TerminalBuffer, XMODEM_BLOCK_SIZE);
                TerminalSendByte(CalcChecksum(TerminalBuffer, XMODEM_BLOCK_SIZE));

                BlockAddress += XMODEM_BLOCK_SIZE;
            } else {
                TerminalSendByte(BYTE_EOT);
                State = STATE_SEND_EOT;
            }
        } else if (Byte == BYTE_NAK){
            /* Resend frame */
            TerminalSendByte(BYTE_SOH);
            TerminalSendByte(CurrentFrameNumber);
            TerminalSendByte(255 - CurrentFrameNumber);
            TerminalSendBlock(TerminalBuffer, XMODEM_BLOCK_SIZE);
            TerminalSendByte(CalcChecksum(TerminalBuffer, XMODEM_BLOCK_SIZE));
        } else {
            /* Ignore other chars */
        }

        break;

    case STATE_SEND_EOT:
        /* Receive Ack */
        State = STATE_OFF;
        break;

    default:
        return false;
        break;
    }

    return true;
}

void XModemTick(void)
{
    /* Timeouts go here */
    switch(State) {
    case STATE_RECEIVE_INIT:
        if (RetryTimeout-- == 0) {
            if (RetryCount-- > 0) {
                /* Put out communication request */
                TerminalSendChar(BYTE_NAK);
            } else {
                /* Just shut off after some time. */
                State = STATE_OFF;
            }

            RetryTimeout = RECV_INIT_TIMEOUT;
        }
        break;

    case STATE_SEND_INIT:
        if (RetryTimeout-- == 0) {
            /* Abort */
            State = STATE_OFF;
        }
        break;

    default:
        break;
    }
}

{'repo_name': 'iceman1001/ChameleonMini-rebooted', 'stars': '172', 'repo_language': 'C', 'file_name': 'pm3_eml_mfd_test.py', 'mime_type': 'text/x-python', 'hash': 4795243158568331506, 'source_dataset': 'data'}


///////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below.       //
// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,       //
// 2007, 2008, 2009, 2010, 2014, 2015 by Peter Spirtes, Richard Scheines, Joseph   //
// Ramsey, and Clark Glymour.                                                //
//                                                                           //
// This program is free software; you can redistribute it and/or modify      //
// it under the terms of the GNU General Public License as published by      //
// the Free Software Foundation; either version 2 of the License, or         //
// (at your option) any later version.                                       //
//                                                                           //
// This program is distributed in the hope that it will be useful,           //
// but WITHOUT ANY WARRANTY; without even the implied warranty of            //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             //
// GNU General Public License for more details.                              //
//                                                                           //
// You should have received a copy of the GNU General Public License         //
// along with this program; if not, write to the Free Software               //
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA //
///////////////////////////////////////////////////////////////////////////////
package edu.cmu.tetrad.search;

import edu.cmu.tetrad.data.ICovarianceMatrix;
import edu.cmu.tetrad.data.IKnowledge;
import edu.cmu.tetrad.data.Knowledge2;
import edu.cmu.tetrad.data.KnowledgeEdge;
import edu.cmu.tetrad.graph.*;
import edu.cmu.tetrad.util.ChoiceGenerator;
import edu.cmu.tetrad.util.ForkJoinPoolInstance;
import edu.cmu.tetrad.util.TetradLogger;
import java.io.PrintStream;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.RecursiveTask;

/**
 * J.M. Ogarrio and P. Spirtes and J. Ramsey, "A Hybrid Causal Search Algorithm
 * for Latent Variable Models," JMLR 2016.
 *
 * @author Juan Miguel Ogarrio
 * @author ps7z
 * @author jdramsey
 */
public final class GFciMax implements GraphSearch {

    // The PAG being constructed.
    private Graph graph;

    // The background knowledge.
    private IKnowledge knowledge = new Knowledge2();

    // The conditional independence test.
    private IndependenceTest independenceTest;

    // Flag for complete rule set, true if should use complete rule set, false otherwise.
    private boolean completeRuleSetUsed = false;

    // The maximum length for any discriminating path. -1 if unlimited; otherwise, a positive integer.
    private int maxPathLength = -1;

    // Bounds the degree of the graph.
    private int maxDegree = -1;

    // The logger to use.
    private TetradLogger logger = TetradLogger.getInstance();

    // True iff verbose output should be printed.
    private boolean verbose = false;

    // The covariance matrix beign searched over. Assumes continuous data.
    ICovarianceMatrix covarianceMatrix;

    // The sample size.
    int sampleSize;

    // The print stream that output is directed to.
    private PrintStream out = System.out;

    // True iff one-edge faithfulness is assumed. Speed up the algorith for very large searches. By default false.
    private boolean faithfulnessAssumed = true;

    // The score.
    private Score score;

    private SepsetProducer sepsets;
    private long elapsedTime;

    //============================CONSTRUCTORS============================//
    public GFciMax(IndependenceTest test, Score score) {
        if (score == null) {
            throw new NullPointerException();
        }
        this.sampleSize = score.getSampleSize();
        this.score = score;
        this.independenceTest = test;
    }

    //========================PUBLIC METHODS==========================//
    public Graph search() {
        long time1 = System.currentTimeMillis();

        List<Node> nodes = getIndependenceTest().getVariables();

        logger.log("info", "Starting FCI algorithm.");
        logger.log("info", "Independence test = " + getIndependenceTest() + ".");

        this.graph = new EdgeListGraphSingleConnections(nodes);

        Fges fges = new Fges(score);
        fges.setKnowledge(getKnowledge());
        fges.setVerbose(verbose);
        fges.setFaithfulnessAssumed(faithfulnessAssumed);
        fges.setMaxDegree(maxDegree);
        fges.setOut(out);
        graph = fges.search();
        Graph fgesGraph = new EdgeListGraphSingleConnections(graph);
        sepsets = new SepsetsGreedy(fgesGraph, independenceTest, null, maxDegree);

        graph.reorientAllWith(Endpoint.CIRCLE);

        for (Node b : nodes) {
            List<Node> adjacentNodes = fgesGraph.getAdjacentNodes(b);

            if (adjacentNodes.size() < 2) {
                continue;
            }

            ChoiceGenerator cg = new ChoiceGenerator(adjacentNodes.size(), 2);
            int[] combination;

            while ((combination = cg.next()) != null) {
                Node a = adjacentNodes.get(combination[0]);
                Node c = adjacentNodes.get(combination[1]);

                if (graph.isAdjacentTo(a, c) && fgesGraph.isAdjacentTo(a, c)) {
                    if (sepsets.getSepset(a, c) != null) {
                        graph.removeEdge(a, c);
                    }
                }
            }
        }

//        modifiedR0(fgesGraph);
        sepsets = new SepsetsMinScore(fgesGraph, independenceTest, maxDegree);

        addColliders(graph, fgesGraph);

        FciOrient fciOrient = new FciOrient(sepsets);
        fciOrient.setVerbose(verbose);
        fciOrient.setOut(out);
        fciOrient.setKnowledge(getKnowledge());
        fciOrient.setCompleteRuleSetUsed(completeRuleSetUsed);
        fciOrient.setMaxPathLength(maxPathLength);
        fciOrient.doFinalOrientation(graph);

        GraphUtils.replaceNodes(graph, independenceTest.getVariables());

        long time2 = System.currentTimeMillis();

        elapsedTime = time2 - time1;

        return graph;
    }

    @Override
    public long getElapsedTime() {
        return elapsedTime;
    }

    /**
     * The maximum of parents any nodes can have in output pattern.
     *
     * @param maxDegree -1 for unlimited.
     */
    public void setMaxDegree(int maxDegree) {
        if (maxDegree < -1) {
            throw new IllegalArgumentException(
                    "Depth must be -1 (unlimited) or >= 0: " + maxDegree);
        }

        this.maxDegree = maxDegree;
    }

    /**
     * The maximum of parents any nodes can have in output pattern.
     *
     * @return -1 for unlimited.
     */
    public int getMaxDegree() {
        return maxDegree;
    }

    // Due to Spirtes.
    public void modifiedR0(Graph fgesGraph) {
        graph.reorientAllWith(Endpoint.CIRCLE);
        fciOrientbk(knowledge, graph, graph.getNodes());

        List<Node> nodes = graph.getNodes();

        for (Node b : nodes) {
            List<Node> adjacentNodes = graph.getAdjacentNodes(b);

            if (adjacentNodes.size() < 2) {
                continue;
            }

            ChoiceGenerator cg = new ChoiceGenerator(adjacentNodes.size(), 2);
            int[] combination;

            while ((combination = cg.next()) != null) {
                Node a = adjacentNodes.get(combination[0]);
                Node c = adjacentNodes.get(combination[1]);

                if (fgesGraph.isDefCollider(a, b, c)) {
                    graph.setEndpoint(a, b, Endpoint.ARROW);
                    graph.setEndpoint(c, b, Endpoint.ARROW);
                } else if (fgesGraph.isAdjacentTo(a, c) && !graph.isAdjacentTo(a, c)) {
                    List<Node> sepset = sepsets.getSepset(a, c);

                    if (sepset != null && !sepset.contains(b)) {
                        graph.setEndpoint(a, b, Endpoint.ARROW);
                        graph.setEndpoint(c, b, Endpoint.ARROW);
                    }
                }
            }
        }
    }

    public IKnowledge getKnowledge() {
        return knowledge;
    }

    public void setKnowledge(IKnowledge knowledge) {
        if (knowledge == null) {
            throw new NullPointerException();
        }

        this.knowledge = knowledge;
    }

    /**
     * @return true if Zhang's complete rule set should be used, false if only
     * R1-R4 (the rule set of the original FCI) should be used. False by
     * default.
     */
    public boolean isCompleteRuleSetUsed() {
        return completeRuleSetUsed;
    }

    /**
     * @param completeRuleSetUsed set to true if Zhang's complete rule set
     * should be used, false if only R1-R4 (the rule set of the original FCI)
     * should be used. False by default.
     */
    public void setCompleteRuleSetUsed(boolean completeRuleSetUsed) {
        this.completeRuleSetUsed = completeRuleSetUsed;
    }

    /**
     * @return the maximum length of any discriminating path, or -1 of
     * unlimited.
     */
    public int getMaxPathLength() {
        return maxPathLength;
    }

    /**
     * @param maxPathLength the maximum length of any discriminating path, or -1
     * if unlimited.
     */
    public void setMaxPathLength(int maxPathLength) {
        if (maxPathLength < -1) {
            throw new IllegalArgumentException("Max path length must be -1 (unlimited) or >= 0: " + maxPathLength);
        }

        this.maxPathLength = maxPathLength;
    }

    /**
     * True iff verbose output should be printed.
     */
    public boolean isVerbose() {
        return verbose;
    }

    public void setVerbose(boolean verbose) {
        this.verbose = verbose;
    }

    /**
     * The independence test.
     */
    public IndependenceTest getIndependenceTest() {
        return independenceTest;
    }

    public ICovarianceMatrix getCovMatrix() {
        return covarianceMatrix;
    }

    public ICovarianceMatrix getCovarianceMatrix() {
        return covarianceMatrix;
    }

    public void setCovarianceMatrix(ICovarianceMatrix covarianceMatrix) {
        this.covarianceMatrix = covarianceMatrix;
    }

    public PrintStream getOut() {
        return out;
    }

    public void setOut(PrintStream out) {
        this.out = out;
    }

    public void setIndependenceTest(IndependenceTest independenceTest) {
        this.independenceTest = independenceTest;
    }

    public void setFaithfulnessAssumed(boolean faithfulnessAssumed) {
        this.faithfulnessAssumed = faithfulnessAssumed;
    }

    //===========================================PRIVATE METHODS=======================================//
    /**
     * Orients according to background knowledge
     */
    private void fciOrientbk(IKnowledge knowledge, Graph graph, List<Node> variables) {
        logger.log("info", "Starting BK Orientation.");

        for (Iterator<KnowledgeEdge> it = knowledge.forbiddenEdgesIterator(); it.hasNext();) {
            KnowledgeEdge edge = it.next();

            //match strings to variables in the graph.
            Node from = SearchGraphUtils.translate(edge.getFrom(), variables);
            Node to = SearchGraphUtils.translate(edge.getTo(), variables);

            if (from == null || to == null) {
                continue;
            }

            if (graph.getEdge(from, to) == null) {
                continue;
            }

            // Orient to*->from
            graph.setEndpoint(to, from, Endpoint.ARROW);
            graph.setEndpoint(from, to, Endpoint.CIRCLE);
            logger.log("knowledgeOrientation", SearchLogUtils.edgeOrientedMsg("Knowledge", graph.getEdge(from, to)));
        }

        for (Iterator<KnowledgeEdge> it = knowledge.requiredEdgesIterator(); it.hasNext();) {
            KnowledgeEdge edge = it.next();

            //match strings to variables in this graph
            Node from = SearchGraphUtils.translate(edge.getFrom(), variables);
            Node to = SearchGraphUtils.translate(edge.getTo(), variables);

            if (from == null || to == null) {
                continue;
            }

            if (graph.getEdge(from, to) == null) {
                continue;
            }

            graph.setEndpoint(to, from, Endpoint.TAIL);
            graph.setEndpoint(from, to, Endpoint.ARROW);
            logger.log("knowledgeOrientation", SearchLogUtils.edgeOrientedMsg("Knowledge", graph.getEdge(from, to)));
        }

        logger.log("info", "Finishing BK Orientation.");
    }

    private void addColliders(Graph graph, final Graph fgesGraph) {
        List<Node> nodes = graph.getNodes();

        class Task extends RecursiveTask<Boolean> {

            int from;
            int to;
            int chunk = 20;
            List<Node> nodes;
            Graph graph;

            public Task(List<Node> nodes, Graph graph, int from, int to) {
                this.nodes = nodes;
                this.graph = graph;
                this.from = from;
                this.to = to;
            }

            @Override
            protected Boolean compute() {
                if (to - from <= chunk) {
                    for (int i = from; i < to; i++) {
                        doNode(graph, fgesGraph, nodes.get(i));
                    }

                    return true;
                } else {
                    int mid = (to + from) / 2;

                    Task left = new Task(nodes, graph, from, mid);
                    Task right = new Task(nodes, graph, mid, to);

                    left.fork();
                    right.compute();
                    left.join();

                    return true;
                }
            }
        }

        Task task = new Task(nodes, graph, 0, nodes.size());

        ForkJoinPoolInstance.getInstance().getPool().invoke(task);
    }

    private void doNode(Graph graph, Graph fgesGraph, Node b) {
        List<Node> adjacentNodes = graph.getAdjacentNodes(b);

        if (adjacentNodes.size() < 2) {
            return;
        }

        ChoiceGenerator cg = new ChoiceGenerator(adjacentNodes.size(), 2);
        int[] combination;

        while ((combination = cg.next()) != null) {
            Node a = adjacentNodes.get(combination[0]);
            Node c = adjacentNodes.get(combination[1]);

//            if (fgesGraph.isAdjacentTo(a, c) && !graph.isAdjacentTo(a, c)) {
            // S actually has to be non-null here, but the compiler doesn't know that.
            List<Node> S = sepsets.getSepset(a, c);
            if (S != null && !S.contains(b)) {
                graph.setEndpoint(a, b, Endpoint.ARROW);
                graph.setEndpoint(c, b, Endpoint.ARROW);
            }
        }
//        }
    }
}

{'repo_name': 'cmu-phil/tetrad', 'stars': '187', 'repo_language': 'Java', 'file_name': 'TimeoutComparisonTest.java', 'mime_type': 'text/x-java', 'hash': 6040309372987912235, 'source_dataset': 'data'}


#ifndef QMEMORYBUFFER_H
#define QMEMORYBUFFER_H

#include "qhexbuffer.h"

class QMemoryBuffer : public QHexBuffer
{
    Q_OBJECT

    public:
        explicit QMemoryBuffer(QObject *parent = nullptr);
        uchar at(qint64 idx) override;
        qint64 length() const override;
        void insert(qint64 offset, const QByteArray& data) override;
        void remove(qint64 offset, int length) override;
        QByteArray read(qint64 offset, int length) override;
        bool read(QIODevice* device) override;
        void write(QIODevice* device) override;

        qint64 indexOf(const QByteArray& ba, qint64 from) override;
        qint64 lastIndexOf(const QByteArray& ba, qint64 from) override;
    private:
        QByteArray m_buffer;
};

#endif // QMEMORYBUFFER_H

{'repo_name': 'Dax89/QHexView', 'stars': '144', 'repo_language': 'C++', 'file_name': 'replacecommand.cpp', 'mime_type': 'text/x-c', 'hash': -2983153214790999899, 'source_dataset': 'data'}


#ifndef BOOST_MPL_SET_SET0_HPP_INCLUDED
#define BOOST_MPL_SET_SET0_HPP_INCLUDED

// Copyright Aleksey Gurtovoy 2003-2004
// Copyright David Abrahams 2003-2004
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/mpl for documentation.

// $Id$
// $Date$
// $Revision$

#include <boost/mpl/set/aux_/at_impl.hpp>
#include <boost/mpl/set/aux_/clear_impl.hpp>
//#include <boost/mpl/set/aux_/O1_size.hpp>
#include <boost/mpl/set/aux_/size_impl.hpp>
#include <boost/mpl/set/aux_/empty_impl.hpp>
#include <boost/mpl/set/aux_/insert_impl.hpp>
#include <boost/mpl/set/aux_/erase_impl.hpp>
#include <boost/mpl/set/aux_/erase_key_impl.hpp>
#include <boost/mpl/set/aux_/has_key_impl.hpp>
#include <boost/mpl/set/aux_/key_type_impl.hpp>
#include <boost/mpl/set/aux_/value_type_impl.hpp>
#include <boost/mpl/set/aux_/begin_end_impl.hpp>
#include <boost/mpl/set/aux_/iterator.hpp>
#include <boost/mpl/set/aux_/item.hpp>
#include <boost/mpl/set/aux_/set0.hpp>
#include <boost/mpl/set/aux_/tag.hpp>

#endif // BOOST_MPL_SET_SET0_HPP_INCLUDED

{'repo_name': 'zhaoyongke/Caffe21Days', 'stars': '119', 'repo_language': 'C++', 'file_name': 'stack.hpp', 'mime_type': 'text/x-c', 'hash': -8681388561171352245, 'source_dataset': 'data'}


#! /bin/sh
# make directories for CWP/SU codes installation

B=$CWPROOT/bin
I=$CWPROOT/include
L=$CWPROOT/lib

mkdir $CWPROOT
mkdir $B $L $I
mkdir $I/Xtcwp $L/X11 $L/X11/app-defaults $I/Xmcwp
mkdir $I/Triangles
mkdir $I/Wpc
mkdir $I/MGL
mkdir $I/Reflect

exit 0

{'repo_name': 'JohnWStockwellJr/SeisUnix', 'stars': '153', 'repo_language': 'C', 'file_name': 'tetramod', 'mime_type': 'text/plain', 'hash': -4285116596256349801, 'source_dataset': 'data'}


%%

%unicode 4.0
%public
%class UnicodePropList_Extender_4_0

%type int
%standalone

%include ../../resources/common-unicode-all-binary-property-java

%%

\p{Extender} { setCurCharPropertyValue(); }
[^] { }

<<EOF>> { printOutput(); return 1; }

{'repo_name': 'jflex-de/jflex', 'stars': '328', 'repo_language': 'Java', 'file_name': 'BUILD.bazel', 'mime_type': 'text/plain', 'hash': 2046933437983393804, 'source_dataset': 'data'}


<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
    <Filter Include="Source Files">
      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
    </Filter>
    <Filter Include="Header Files">
      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
    </Filter>
    <Filter Include="Resource Files">
      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav</Extensions>
    </Filter>
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="getopt.c">
      <Filter>Source Files</Filter>
    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="getopt.h">
      <Filter>Header Files</Filter>
    </ClInclude>
  </ItemGroup>
</Project>

{'repo_name': 'losnoco/vgmstream', 'stars': '407', 'repo_language': 'C', 'file_name': 'foo_input_vgmstream.rc', 'mime_type': 'text/x-c', 'hash': -2565668645139060055, 'source_dataset': 'data'}


// SPDX-License-Identifier: GPL-2.0
// Copyright (c) 2018 Facebook

#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>

struct {
	__uint(type, BPF_MAP_TYPE_ARRAY);
	__uint(max_entries, 1);
	__type(key, __u32);
	__type(value, __u64);
} cg_ids SEC(".maps");

struct {
	__uint(type, BPF_MAP_TYPE_ARRAY);
	__uint(max_entries, 1);
	__type(key, __u32);
	__type(value, __u32);
} pidmap SEC(".maps");

SEC("tracepoint/syscalls/sys_enter_nanosleep")
int trace(void *ctx)
{
	__u32 pid = bpf_get_current_pid_tgid();
	__u32 key = 0, *expected_pid;
	__u64 *val;

	expected_pid = bpf_map_lookup_elem(&pidmap, &key);
	if (!expected_pid || *expected_pid != pid)
		return 0;

	val = bpf_map_lookup_elem(&cg_ids, &key);
	if (val)
		*val = bpf_get_current_cgroup_id();

	return 0;
}

char _license[] SEC("license") = "GPL";
__u32 _version SEC("version") = 1; /* ignored by tracepoints, required by libbpf.a */

{'repo_name': 'intel/gvt-linux', 'stars': '276', 'repo_language': 'C', 'file_name': 'u_os_desc.h', 'mime_type': 'text/x-c', 'hash': -3703525318852645594, 'source_dataset': 'data'}


<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>mall-admin-ums</artifactId>
        <groupId>com.mtcarpenter</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>ums-common</artifactId>

</project>

{'repo_name': 'mtcarpenter/mall-cloud-alibaba', 'stars': '101', 'repo_language': 'Java', 'file_name': 'CmsPrefrenceAreaProductRelationClient.java', 'mime_type': 'text/x-java', 'hash': -7379774572310346369, 'source_dataset': 'data'}


namespace ClassLib054
{
    public class Class083
    {
        public static string Property => "ClassLib054";
    }
}

{'repo_name': 'dotnet/performance', 'stars': '329', 'repo_language': 'C#', 'file_name': 'Class067.cs', 'mime_type': 'text/plain', 'hash': -1598809210320027468, 'source_dataset': 'data'}


{#
This file is part of EC-CUBE

Copyright(c) EC-CUBE CO.,LTD. All Rights Reserved.

http://www.ec-cube.co.jp/

For the full copyright and license information, please view the LICENSE
file that was distributed with this source code.
#}

{% extends '@admin/default_frame.twig' %}

{% set menus = ['setting', 'system', 'masterdata'] %}

{% block title %}{{ 'admin.setting.system.master_data_management'|trans }}{% endblock %}
{% block sub_title %}{{ 'admin.setting.system'|trans }}{% endblock %}

{% block main %}

                <form id="form1" name="form1" method="post" action="{{ url('admin_setting_system_masterdata') }}">
                    {{ form_widget(form._token) }}

                                {{ 'admin.setting.system.master_data_management'|trans }}

                                    {{ form_widget(form.masterdata) }}
                                    {{ form_errors(form.masterdata) }}

                                    <button class="btn btn-primary" type="submit">{{ 'admin.setting.system.master_data.select'|trans }}</button>

                </form>

                {% if form2.data is not empty %}
                    <form id="form2" name="form2" method="post" action="{{ url('admin_setting_system_masterdata_edit') }}">
                        {{ form_widget(form2.masterdata_name) }}
                        {{ form_widget(form2._token) }}

                                    {{ 'admin.setting.system.master_data.description'|trans|nl2br }}

                                            {{ 'admin.setting.system.master_data.id'|trans }}

                                            {{ 'admin.setting.system.master_data.name'|trans }}

                                    {% for data in form2.data %}

                                                {{ form_widget(data.id) }}
                                                {{ form_errors(data.id) }}

                                                {{ form_widget(data.name) }}
                                                {{ form_errors(data.name) }}

                                    {% endfor %}

                                                <button class="btn btn-ec-conversion px-5" type="submit">{{ 'admin.common.save'|trans }}</button>

                    </form>
                {% endif %}

{% endblock %}

{'repo_name': 'EC-CUBE/ec-cube', 'stars': '536', 'repo_language': 'PHP', 'file_name': 'devcontainer.json', 'mime_type': 'text/plain', 'hash': 2152419274277431473, 'source_dataset': 'data'}


// 2001-10-03 From: Dimitris Vyzovitis <vyzo@media.mit.edu>

// Copyright (C) 2001-2019 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3.  If not see
// <http://www.gnu.org/licenses/>.

// rope (SGI extension)

#include <ext/rope>
#include <iostream>

void test01()
{
  __gnu_cxx::crope foo;
  foo += "bar";
  const char* data = foo.c_str();
  std::cout << data << std::endl;
}

int main()
{
  test01();
  return 0;
}

{'repo_name': 'riscv/riscv-gcc', 'stars': '155', 'repo_language': 'C', 'file_name': 'visium-protos.h', 'mime_type': 'text/x-c', 'hash': -7355822218161855358, 'source_dataset': 'data'}


/**
 * Copyright Camunda Services GmbH and/or licensed to Camunda Services GmbH
 * under one or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information regarding copyright
 * ownership.
 *
 * Camunda licenses this file to you under the MIT; you may not use this file
 * except in compliance with the MIT License.
 */

'use strict';

var electron = require('electron'),
    ipcMain = electron.ipcMain,
    app = electron.app;

const {
  assign,
  pick
} = require('min-dash');

function on(event, callback, that) {

  ipcMain.on(event, function(evt, id, args) {

    function done(...doneArgs) {
      var actualArgs = doneArgs.map(function(e) {

        // error.message and error.code are not enumerable
        if (e instanceof Error) {
          return assign({}, pick(e, [ 'message', 'code' ]), e);
        }

        return e;
      });

      var responseEvent = event + ':response:' + id;

      evt.sender.send(responseEvent, actualArgs);
    }

    callback.apply(that || null, [ ...args, done ]);
  });
}

module.exports.on = on;

function send() {
  var args = Array.prototype.slice.call(arguments);

  app.mainWindow.webContents.send.apply(app.mainWindow.webContents, args);
}

module.exports.send = send;

{'repo_name': 'camunda/camunda-modeler', 'stars': '603', 'repo_language': 'JavaScript', 'file_name': 'index.html', 'mime_type': 'text/html', 'hash': -2553736310033836071, 'source_dataset': 'data'}


# 什么是 CSRF 攻击

::: tip Issue
 欢迎在 Issue 中交流与讨论: [Issue 160](https://github.com/shfshanyue/Daily-Question/issues/160)
:::

::: tip Author
回答者: [DoubleRayWang](https://github.com/DoubleRayWang)
:::

跨站请求伪造（英语：Cross-site request forgery），也被称为 one-click attack 或者 session riding，通常缩写为 CSRF 或者 XSRF， 是一种挟制用户在当前已登录的Web应用程序上执行非本意的操作的攻击方法。跟跨网站脚本（XSS）相比，XSS 利用的是用户对指定网站的信任，CSRF 利用的是网站对用户网页浏览器的信任。

来源：[维基百科](https://zh.wikipedia.org/wiki/%E8%B7%A8%E7%AB%99%E8%AF%B7%E6%B1%82%E4%BC%AA%E9%80%A0)

{'repo_name': 'shfshanyue/Daily-Question', 'stars': '938', 'repo_language': 'Vue', 'file_name': 'Readme.md', 'mime_type': 'text/plain', 'hash': -2892496633208886220, 'source_dataset': 'data'}


// Signature format: 3.0
package androidx.work.testing {

  public class SynchronousExecutor implements java.util.concurrent.Executor {
    ctor public SynchronousExecutor();
    method public void execute(Runnable);
  }

  public interface TestDriver {
    method public void setAllConstraintsMet(java.util.UUID);
    method public void setInitialDelayMet(java.util.UUID);
    method public void setPeriodDelayMet(java.util.UUID);
  }

  public class TestListenableWorkerBuilder<W extends androidx.work.ListenableWorker> {
    method public W build();
    method public static androidx.work.testing.TestListenableWorkerBuilder from(android.content.Context, androidx.work.WorkRequest);
    method public static <W extends androidx.work.ListenableWorker> androidx.work.testing.TestListenableWorkerBuilder<W!> from(android.content.Context, Class<W!>);
    method public androidx.work.testing.TestListenableWorkerBuilder setId(java.util.UUID);
    method public androidx.work.testing.TestListenableWorkerBuilder setInputData(androidx.work.Data);
    method @RequiresApi(28) public androidx.work.testing.TestListenableWorkerBuilder setNetwork(android.net.Network);
    method public androidx.work.testing.TestListenableWorkerBuilder setRunAttemptCount(int);
    method public androidx.work.testing.TestListenableWorkerBuilder setTags(java.util.List<java.lang.String!>);
    method @RequiresApi(24) public androidx.work.testing.TestListenableWorkerBuilder setTriggeredContentAuthorities(java.util.List<java.lang.String!>);
    method @RequiresApi(24) public androidx.work.testing.TestListenableWorkerBuilder setTriggeredContentUris(java.util.List<android.net.Uri!>);
    method public androidx.work.testing.TestListenableWorkerBuilder setWorkerFactory(androidx.work.WorkerFactory);
  }

  public final class TestListenableWorkerBuilderKt {
    ctor public TestListenableWorkerBuilderKt();
    method public static inline <reified W extends androidx.work.ListenableWorker> androidx.work.testing.TestListenableWorkerBuilder<W> TestListenableWorkerBuilder(android.content.Context context, androidx.work.Data inputData = androidx.work.Data.EMPTY, java.util.List<java.lang.String> tags = emptyList(), int runAttemptCount = 1, java.util.List<? extends android.net.Uri> triggeredContentUris = emptyList(), java.util.List<java.lang.String> triggeredContentAuthorities = emptyList());
  }

  public class TestWorkerBuilder<W extends androidx.work.Worker> extends androidx.work.testing.TestListenableWorkerBuilder<W> {
    method public static androidx.work.testing.TestWorkerBuilder<? extends androidx.work.Worker> from(android.content.Context, androidx.work.WorkRequest, java.util.concurrent.Executor);
    method public static <W extends androidx.work.Worker> androidx.work.testing.TestWorkerBuilder<W!> from(android.content.Context, Class<W!>, java.util.concurrent.Executor);
  }

  public final class TestWorkerBuilderKt {
    ctor public TestWorkerBuilderKt();
    method public static inline <reified W extends androidx.work.Worker> androidx.work.testing.TestWorkerBuilder<W> TestWorkerBuilder(android.content.Context context, java.util.concurrent.Executor executor, androidx.work.Data inputData = androidx.work.Data.EMPTY, java.util.List<java.lang.String> tags = emptyList(), int runAttemptCount = 1, java.util.List<? extends android.net.Uri> triggeredContentUris = emptyList(), java.util.List<java.lang.String> triggeredContentAuthorities = emptyList());
  }

  public final class WorkManagerTestInitHelper {
    method @Deprecated public static androidx.work.testing.TestDriver? getTestDriver();
    method public static androidx.work.testing.TestDriver? getTestDriver(android.content.Context);
    method public static void initializeTestWorkManager(android.content.Context);
    method public static void initializeTestWorkManager(android.content.Context, androidx.work.Configuration);
  }

}

{'repo_name': 'aosp-mirror/platform_frameworks_support', 'stars': '1569', 'repo_language': 'Java', 'file_name': 'Nullable.java', 'mime_type': 'text/x-java', 'hash': -4341837346816013206, 'source_dataset': 'data'}


// RUN: %libomp-compile-and-run
#include <stdio.h>
#include "omp_testsuite.h"

int test_omp_section_private()
{
  int sum;
  int sum0;
  int i;
  int known_sum;

  sum = 7;
  sum0 = 0;

  #pragma omp parallel
  {
    #pragma omp sections private(sum0,i)
    {
      #pragma omp section
      {
        sum0 = 0;
        for (i = 1; i < 400; i++)
          sum0 = sum0 + i;
        #pragma omp critical
        {
          sum = sum + sum0;
        }
      }
      #pragma omp section
      {
        sum0 = 0;
        for (i = 400; i < 700; i++)
          sum0 = sum0 + i;
        #pragma omp critical
        {
          sum = sum + sum0;
        }
      }
      #pragma omp section
      {
        sum0 = 0;
        for (i = 700; i < 1000; i++)
          sum0 = sum0 + i;
        #pragma omp critical
        {
          sum = sum + sum0;
        }
      }
    } /*end of sections*/
  } /* end of parallel */
  known_sum = (999 * 1000) / 2 + 7;
  return (known_sum == sum);
} /* end of check_section_private*/

int main()
{
  int i;
  int num_failed=0;

  for(i = 0; i < REPETITIONS; i++) {
    if(!test_omp_section_private()) {
      num_failed++;
    }
  }
  return num_failed;
}

{'repo_name': 'researchmm/tasn', 'stars': '133', 'repo_language': 'Python', 'file_name': 'DESCRIPTION', 'mime_type': 'text/plain', 'hash': -1952115334337006473, 'source_dataset': 'data'}


#pragma once

#include <stdint.h>
#include "il2cpp-config.h"

struct Il2CppArray;
struct Il2CppException;

namespace il2cpp
{
namespace icalls
{
namespace mscorlib
{
namespace System
{
namespace Diagnostics
{
    class LIBIL2CPP_CODEGEN_API StackTrace
    {
    public:
        static Il2CppArray* get_trace(Il2CppException *exc, int32_t skip, bool need_file_info);
    };
} /* namespace Diagnostics */
} /* namespace System */
} /* namespace mscorlib */
} /* namespace icalls */
} /* namespace il2cpp */

{'repo_name': 'andrewnakas/ARKit-Cardboard-VR', 'stars': '130', 'repo_language': 'C++', 'file_name': 'AudioManager.asset', 'mime_type': 'text/plain', 'hash': -5933806478166208182, 'source_dataset': 'data'}


/*
 * Knowage, Open Source Business Intelligence suite
 * Copyright (C) 2016 Engineering Ingegneria Informatica S.p.A.
 *
 * Knowage is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Knowage is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package it.eng.spagobi.georeport.dao;

import it.eng.spagobi.commons.dao.ISpagoBIDao;

import java.util.Map;

import org.geotools.feature.FeatureCollection;
import org.opengis.feature.simple.SimpleFeature;

/**
 * @authors Andrea Gioia (andrea.gioia@eng.it), Fabio D'Ovidio (f.dovidio@inovaos.it)
 */
public interface IFeaturesProviderWFSDAO extends ISpagoBIDao {

	SimpleFeature getFeatureById(Object fetureProviderEndPoint, String layerName, Map parameters);

	FeatureCollection getAllFeatures(String srcFile);

	FeatureCollection getAllFeaturesOLD(Object fetureProviderEndPoint, String layerName);

}

{'repo_name': 'KnowageLabs/Knowage-Server', 'stars': '244', 'repo_language': 'Java', 'file_name': 'AbstractModelEditingTest.java', 'mime_type': 'text/x-java', 'hash': -4603540841332791809, 'source_dataset': 'data'}


<!--
  ~ Geopaparazzi - Digital field mapping on Android based devices
  ~ Copyright (C) 2016  HydroloGIS (www.hydrologis.com)
  ~
  ~ This program is free software: you can redistribute it and/or modify
  ~ it under the terms of the GNU General Public License as published by
  ~ the Free Software Foundation, either version 3 of the License, or
  ~ (at your option) any later version.
  ~
  ~ This program is distributed in the hope that it will be useful,
  ~ but WITHOUT ANY WARRANTY; without even the implied warranty of
  ~ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  ~ GNU General Public License for more details.
  ~
  ~ You should have received a copy of the GNU General Public License
  ~ along with this program.  If not, see <http://www.gnu.org/licenses/>.
  -->

<vector xmlns:android="http://schemas.android.com/apk/res/android"
    android:width="24dp"
    android:height="24dp"
    android:viewportWidth="24.0"
    android:viewportHeight="24.0">
    <path
        android:fillColor="@color/main_background"
        android:pathData="M1,21h22L12,2 1,21zm12,-3h-2v-2h2v2zm0,-4h-2v-4h2v4z" />
</vector>

{'repo_name': 'geopaparazzi/geopaparazzi', 'stars': '128', 'repo_language': 'Java', 'file_name': 'ImportDefaultDatabaseMenuEntry.java', 'mime_type': 'text/x-java', 'hash': -3846851720560914149, 'source_dataset': 'data'}


#!/bin/python
import sys
import unittest

from evaluate import *

class eval_tester(unittest.TestCase):
    def test_eval(self):
        evaler = Evaler()

{'repo_name': 'algorithmdog/Reinforcement_Learning_Blog', 'stars': '268', 'repo_language': 'Python', 'file_name': 'policy.py', 'mime_type': 'text/x-python', 'hash': -2899728115969894099, 'source_dataset': 'data'}


<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>CFBundleDevelopmentRegion</key>
	<string>en</string>
	<key>CFBundleExecutable</key>
	<string>$(EXECUTABLE_NAME)</string>
	<key>CFBundleIdentifier</key>
	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
	<key>CFBundleInfoDictionaryVersion</key>
	<string>6.0</string>
	<key>CFBundleName</key>
	<string>$(PRODUCT_NAME)</string>
	<key>CFBundlePackageType</key>
	<string>BNDL</string>
	<key>CFBundleShortVersionString</key>
	<string>3.1.0</string>
	<key>CFBundleSignature</key>
	<string>????</string>
	<key>CFBundleVersion</key>
	<string>$(CURRENT_PROJECT_VERSION)</string>
	<key>LSApplicationCategoryType</key>
	<string></string>
</dict>
</plist>

{'repo_name': 'leancloud/objc-sdk', 'stars': '185', 'repo_language': 'Objective-C', 'file_name': 'LCTestBase.swift', 'mime_type': 'text/x-c++', 'hash': 3439227954036285484, 'source_dataset': 'data'}


// Copyright 2016 Circonus, Inc. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package checkmgr

import (
	"fmt"
	"math/rand"
	"net"
	"net/url"
	"reflect"
	"strconv"
	"strings"
	"time"

	"github.com/circonus-labs/circonus-gometrics/api"
)

func init() {
	rand.Seed(time.Now().UnixNano())
}

// Get Broker to use when creating a check
func (cm *CheckManager) getBroker() (*api.Broker, error) {
	if cm.brokerID != 0 {
		cid := fmt.Sprintf("/broker/%d", cm.brokerID)
		broker, err := cm.apih.FetchBroker(api.CIDType(&cid))
		if err != nil {
			return nil, err
		}
		if !cm.isValidBroker(broker) {
			return nil, fmt.Errorf(
				"[ERROR] designated broker %d [%s] is invalid (not active, does not support required check type, or connectivity issue)",
				cm.brokerID,
				broker.Name)
		}
		return broker, nil
	}
	broker, err := cm.selectBroker()
	if err != nil {
		return nil, fmt.Errorf("[ERROR] Unable to fetch suitable broker %s", err)
	}
	return broker, nil
}

// Get CN of Broker associated with submission_url to satisfy no IP SANS in certs
func (cm *CheckManager) getBrokerCN(broker *api.Broker, submissionURL api.URLType) (string, error) {
	u, err := url.Parse(string(submissionURL))
	if err != nil {
		return "", err
	}

	hostParts := strings.Split(u.Host, ":")
	host := hostParts[0]

	if net.ParseIP(host) == nil { // it's a non-ip string
		return u.Host, nil
	}

	cn := ""

	for _, detail := range broker.Details {
		if *detail.IP == host {
			cn = detail.CN
			break
		}
	}

	if cn == "" {
		return "", fmt.Errorf("[ERROR] Unable to match URL host (%s) to Broker", u.Host)
	}

	return cn, nil

}

// Select a broker for use when creating a check, if a specific broker
// was not specified.
func (cm *CheckManager) selectBroker() (*api.Broker, error) {
	var brokerList *[]api.Broker
	var err error
	enterpriseType := "enterprise"

	if len(cm.brokerSelectTag) > 0 {
		filter := api.SearchFilterType{
			"f__tags_has": cm.brokerSelectTag,
		}
		brokerList, err = cm.apih.SearchBrokers(nil, &filter)
		if err != nil {
			return nil, err
		}
	} else {
		brokerList, err = cm.apih.FetchBrokers()
		if err != nil {
			return nil, err
		}
	}

	if len(*brokerList) == 0 {
		return nil, fmt.Errorf("zero brokers found")
	}

	validBrokers := make(map[string]api.Broker)
	haveEnterprise := false

	for _, broker := range *brokerList {
		broker := broker
		if cm.isValidBroker(&broker) {
			validBrokers[broker.CID] = broker
			if broker.Type == enterpriseType {
				haveEnterprise = true
			}
		}
	}

	if haveEnterprise { // eliminate non-enterprise brokers from valid brokers
		for k, v := range validBrokers {
			if v.Type != enterpriseType {
				delete(validBrokers, k)
			}
		}
	}

	if len(validBrokers) == 0 {
		return nil, fmt.Errorf("found %d broker(s), zero are valid", len(*brokerList))
	}

	validBrokerKeys := reflect.ValueOf(validBrokers).MapKeys()
	selectedBroker := validBrokers[validBrokerKeys[rand.Intn(len(validBrokerKeys))].String()]

	if cm.Debug {
		cm.Log.Printf("[DEBUG] Selected broker '%s'\n", selectedBroker.Name)
	}

	return &selectedBroker, nil

}

// Verify broker supports the check type to be used
func (cm *CheckManager) brokerSupportsCheckType(checkType CheckTypeType, details *api.BrokerDetail) bool {

	baseType := string(checkType)

	for _, module := range details.Modules {
		if module == baseType {
			return true
		}
	}

	if idx := strings.Index(baseType, ":"); idx > 0 {
		baseType = baseType[0:idx]
	}

	for _, module := range details.Modules {
		if module == baseType {
			return true
		}
	}

	return false

}

// Is the broker valid (active, supports check type, and reachable)
func (cm *CheckManager) isValidBroker(broker *api.Broker) bool {
	var brokerHost string
	var brokerPort string

	if broker.Type != "circonus" && broker.Type != "enterprise" {
		return false
	}

	valid := false

	for _, detail := range broker.Details {
		detail := detail

		// broker must be active
		if detail.Status != statusActive {
			if cm.Debug {
				cm.Log.Printf("[DEBUG] Broker '%s' is not active.\n", broker.Name)
			}
			continue
		}

		// broker must have module loaded for the check type to be used
		if !cm.brokerSupportsCheckType(cm.checkType, &detail) {
			if cm.Debug {
				cm.Log.Printf("[DEBUG] Broker '%s' does not support '%s' checks.\n", broker.Name, cm.checkType)
			}
			continue
		}

		if detail.ExternalPort != 0 {
			brokerPort = strconv.Itoa(int(detail.ExternalPort))
		} else {
			if detail.Port != nil && *detail.Port != 0 {
				brokerPort = strconv.Itoa(int(*detail.Port))
			} else {
				brokerPort = "43191"
			}
		}

		if detail.ExternalHost != nil && *detail.ExternalHost != "" {
			brokerHost = *detail.ExternalHost
		} else if detail.IP != nil && *detail.IP != "" {
			brokerHost = *detail.IP
		}

		if brokerHost == "" {
			cm.Log.Printf("[WARN] Broker '%s' instance %s has no IP or external host set", broker.Name, detail.CN)
			continue
		}

		if brokerHost == "trap.noit.circonus.net" && brokerPort != "443" {
			brokerPort = "443"
		}

		retries := 5
		for attempt := 1; attempt <= retries; attempt++ {
			// broker must be reachable and respond within designated time
			conn, err := net.DialTimeout("tcp", fmt.Sprintf("%s:%s", brokerHost, brokerPort), cm.brokerMaxResponseTime)
			if err == nil {
				conn.Close()
				valid = true
				break
			}

			cm.Log.Printf("[WARN] Broker '%s' unable to connect, %v. Retrying in 2 seconds, attempt %d of %d.", broker.Name, err, attempt, retries)
			time.Sleep(2 * time.Second)
		}

		if valid {
			if cm.Debug {
				cm.Log.Printf("[DEBUG] Broker '%s' is valid\n", broker.Name)
			}
			break
		}
	}
	return valid
}

{'repo_name': 'hashicorp/vault', 'stars': '16436', 'repo_language': 'Go', 'file_name': 'NOTICE.md', 'mime_type': 'text/plain', 'hash': 586187490862037518, 'source_dataset': 'data'}


{'repo_name': 'rfordatascience/tidytuesday', 'stars': '2401', 'repo_language': 'HTML', 'file_name': 'readme.md', 'mime_type': 'text/plain', 'hash': 5600412924797093092, 'source_dataset': 'data'}


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<meta name="generator" content="Doxygen 1.8.3"/>
<title>xilmailbox: xilmailbox_ipips.h File Reference</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>

<link href="navtree.css" rel="stylesheet" type="text/css"/>

<link href="doxygen.css" rel="stylesheet" type="text/css" />
<link href="HTML_custom.css" rel="stylesheet" type="text/css"/>

xilmailbox

Xilinx Vitis Drivers API Documentation

Overview

Data Structures

APIs

File List

xilmailbox_ipips.h File Reference

Copyright © 2015 Xilinx Inc. All rights reserved.

{'repo_name': 'Xilinx/embeddedsw', 'stars': '311', 'repo_language': 'HTML', 'file_name': 'openamp.mld', 'mime_type': 'text/plain', 'hash': -1469573235430904002, 'source_dataset': 'data'}