text:
<?php

use Symfony\Component\Routing\Exception\MethodNotAllowedException;
use Symfony\Component\Routing\Exception\ResourceNotFoundException;
use Symfony\Component\Routing\RequestContext;

/**
 * ProjectUrlMatcher.
 *
 * This class has been auto-generated
 * by the Symfony Routing Component.
 */
class ProjectUrlMatcher extends Symfony\Component\Routing\Matcher\UrlMatcher
{
    /**
     * Constructor.
     */
    public function __construct(RequestContext $context)
    {
        $this->context = $context;
    }

    public function match($pathinfo)
    {
        $allow = array();
        $pathinfo = rawurldecode($pathinfo);

        if (0 === strpos($pathinfo, '/rootprefix')) {
            // static
            if ($pathinfo === '/rootprefix/test') {
                return array('_route' => 'static');
            }

            // dynamic
            if (preg_match('#^/rootprefix/(?P<var>[^/]++)$#s', $pathinfo, $matches)) {
                return $this->mergeDefaults(array_replace($matches, array('_route' => 'dynamic')), array ());
            }

        }

        throw 0 < count($allow) ? new MethodNotAllowedException(array_unique($allow)) : new ResourceNotFoundException();
    }
}

redpajama_set_name: RedPajamaGithub


text:
#pragma once
#include <aws/batch/Batch_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <utility>

namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace Batch
{
namespace Model
{

  /**
   *
Details for a Docker volume mount point that's used in a job's container
   * properties. This parameter maps to Volumes in the Create
   * a container section of the Docker Remote API and the
   * --volume option to docker run.

See Also:
   AWS
   * API Reference

   */
  class AWS_BATCH_API MountPoint
  {
  public:
    MountPoint();
    MountPoint(Aws::Utils::Json::JsonView jsonValue);
    MountPoint& operator=(Aws::Utils::Json::JsonView jsonValue);
    Aws::Utils::Json::JsonValue Jsonize() const;

    /**
     *
The path on the container where the host volume is mounted.

     */
    inline const Aws::String& GetContainerPath() const{ return m_containerPath; }

    /**
     *
The path on the container where the host volume is mounted.

     */
    inline bool ContainerPathHasBeenSet() const { return m_containerPathHasBeenSet; }

    /**
     *
The path on the container where the host volume is mounted.

     */
    inline void SetContainerPath(const Aws::String& value) { m_containerPathHasBeenSet = true; m_containerPath = value; }

    /**
     *
The path on the container where the host volume is mounted.

     */
    inline void SetContainerPath(Aws::String&& value) { m_containerPathHasBeenSet = true; m_containerPath = std::move(value); }

    /**
     *
The path on the container where the host volume is mounted.

     */
    inline void SetContainerPath(const char* value) { m_containerPathHasBeenSet = true; m_containerPath.assign(value); }

    /**
     *
The path on the container where the host volume is mounted.

     */
    inline MountPoint& WithContainerPath(const Aws::String& value) { SetContainerPath(value); return *this;}

    /**
     *
The path on the container where the host volume is mounted.

     */
    inline MountPoint& WithContainerPath(Aws::String&& value) { SetContainerPath(std::move(value)); return *this;}

    /**
     *
The path on the container where the host volume is mounted.

     */
    inline MountPoint& WithContainerPath(const char* value) { SetContainerPath(value); return *this;}

    /**
     *
If this value is true, the container has read-only access to the
     * volume. Otherwise, the container can write to the volume. The default value is
     * false.

     */
    inline bool GetReadOnly() const{ return m_readOnly; }

    /**
     *
If this value is true, the container has read-only access to the
     * volume. Otherwise, the container can write to the volume. The default value is
     * false.

     */
    inline bool ReadOnlyHasBeenSet() const { return m_readOnlyHasBeenSet; }

    /**
     *
If this value is true, the container has read-only access to the
     * volume. Otherwise, the container can write to the volume. The default value is
     * false.

     */
    inline void SetReadOnly(bool value) { m_readOnlyHasBeenSet = true; m_readOnly = value; }

    /**
     *
If this value is true, the container has read-only access to the
     * volume. Otherwise, the container can write to the volume. The default value is
     * false.

     */
    inline MountPoint& WithReadOnly(bool value) { SetReadOnly(value); return *this;}

    /**
     *
The name of the volume to mount.

     */
    inline const Aws::String& GetSourceVolume() const{ return m_sourceVolume; }

    /**
     *
The name of the volume to mount.

     */
    inline bool SourceVolumeHasBeenSet() const { return m_sourceVolumeHasBeenSet; }

    /**
     *
The name of the volume to mount.

     */
    inline void SetSourceVolume(const Aws::String& value) { m_sourceVolumeHasBeenSet = true; m_sourceVolume = value; }

    /**
     *
The name of the volume to mount.

     */
    inline void SetSourceVolume(Aws::String&& value) { m_sourceVolumeHasBeenSet = true; m_sourceVolume = std::move(value); }

    /**
     *
The name of the volume to mount.

     */
    inline void SetSourceVolume(const char* value) { m_sourceVolumeHasBeenSet = true; m_sourceVolume.assign(value); }

    /**
     *
The name of the volume to mount.

     */
    inline MountPoint& WithSourceVolume(const Aws::String& value) { SetSourceVolume(value); return *this;}

    /**
     *
The name of the volume to mount.

     */
    inline MountPoint& WithSourceVolume(Aws::String&& value) { SetSourceVolume(std::move(value)); return *this;}

    /**
     *
The name of the volume to mount.

     */
    inline MountPoint& WithSourceVolume(const char* value) { SetSourceVolume(value); return *this;}

  private:

    Aws::String m_containerPath;
    bool m_containerPathHasBeenSet = false;

    bool m_readOnly;
    bool m_readOnlyHasBeenSet = false;

    Aws::String m_sourceVolume;
    bool m_sourceVolumeHasBeenSet = false;
  };

} // namespace Model
} // namespace Batch
} // namespace Aws


text:
require 'rubygems'
require 'test/unit'
require 'mocha'
gem 'celerity'
$:.push 'lib'


text:
package com.neulevel.epp.core.response;

import org.w3c.dom.*;
import com.neulevel.epp.core.*;

/**
 * This EppResponseDataCreateContact class implements EPP
 * Response Data entity for EPP Command Create of EPP Contact objects.
 *
 * @author Ning Zhang ning.zhang@neustar.com
 * @version $Revision: 1.1 $ $Date: 2005/12/06 20:11:35 $
 */
public class EppResponseDataCreateContact extends EppResponseDataCreate
{
	private String id;

	/**
	 * Creates an EppResponseDataCreateContact object,
	 * given the contact id
	 */
	public EppResponseDataCreateContact( String id )
	{
		this.id = id;
	}

	/**
	 * Sets the contact id
	 */
	public void setId( String id )
	{
		this.id = id;
	}

	/**
	 * Gets the contact id
	 */
	public String getId()
	{
		return this.id;
	}

	/**
	 * Converts an XML element into an
	 * EppResponseDataCreateContact object. The caller of this
	 * method must make sure that the root node is the resData element of
	 * EPP responseType for creating an EPP Contact object.
	 *
	 * @param root root node for an
	 *             EppResponseDataCreateContact object
	 *             in XML format
	 *
	 * @return an EppResponseDataCreateContact object, or null
	 *         if the node is invalid
	 */
	public static EppEntity fromXML( Node root )
	{
		NodeList list = root.getChildNodes();
		for( int i = 0; i < list.getLength(); i++ )
		{
			Node node = list.item(i);
			String name = node.getLocalName();
			if( name == null )
			{
				continue;
			}
			if( name.equals("id") )
			{
				String id = EppUtil.getText(node);
				return new EppResponseDataCreateContact(id);
			}
		}

		return null;
	}

	/**
	 * Converts an EppResponseDataCreateContact object into
	 * an XML element.
	 *
	 * @param doc the XML Document object
	 * @param tag the tag/element name for the
	 *            EppResponseDataCreateContact object
	 *
	 * @return an Element object
	 */
	public Element toXML( Document doc, String tag )
	{
		Element elm;
		Element body = doc.createElement(tag);
		Element data = EppUtil.createElementNS(doc, "contact", "creData");
		body.appendChild(data);
		if( id != null )
		{
			elm = doc.createElement("id");
			elm.appendChild(doc.createTextNode(id));
			data.appendChild(elm);
		}

		return body;
	}
}


text:
from utils import *

class SimpleCNN(object):
    # Define network hyper-parameters
    def __init__(self, n_out=10, last_act=tf.identity, **kwargs):
        self.name = 'simplecnn'        # default name
        self.n_out = n_out
        self.k = 5
        self.last_act = last_act
        self.kwargs = kwargs

    # Network is divided into two different parts
    def former(self, x, name=None, reuse=False):
        if not name:
            name = self.name
        kwargs = dict(self.kwargs)  # Clone

        with tf.variable_scope(name) as vs:
            if reuse:
                vs.reuse_variables()

            # TODO: Check the shape of x0

            conv1 = conv2d('conv1_1', x, [self.k, self.k, 01, 32], stride=2, **kwargs)        # 28 x 28 => 14
            conv2 = conv2d('conv2_1', conv1, [self.k, self.k, 32, 64], stride=2, **kwargs)    # 14 x 14 => 7

        return conv2

    def latter(self, conv3, name=None, reuse=False):
        if not name:
            name = self.name
        kwargs = dict(self.kwargs)  # Clone

        with tf.variable_scope(name) as vs:
            if reuse:
                vs.reuse_variables()

            kwargs['bn'] = False
            out = fc('fc1',
                   tf.reshape(conv3, [-1, 7 * 7 * 64]), [7 * 7 * 64, self.n_out],
                   self.last_act, **kwargs)                                         # No BN at the last layer

        return out

    # Instantiate the network
    def __call__(self, x, name=None, reuse=False, **kwargs):
        feat = self.former(x, name, reuse, **kwargs)
        out = self.latter(feat, name, reuse, **kwargs)

        return out

class SimpleGEN(object):
    # Define network hyper-parameters
    def __init__(self, n_in=128, last_act=tf.identity, **kwargs):
        self.name = 'simplegen'        # default name
        self.n_in = n_in
        self.k = 5
        self.last_act = last_act
        self.kwargs = kwargs

    # Network is divided into two different parts (so that we can experiment networks with *shared* former layers)
    def former(self, z, name=None, reuse=False):
        if not name:
            name = self.name
        kwargs = dict(self.kwargs)      # Clone

        with tf.variable_scope(name) as vs:
            if reuse:
                vs.reuse_variables()

            h = fc('fc1', z, [self.n_in, 7 * 7 * 64], act=tf.nn.elu, **kwargs)
            h = tf.reshape(h, [-1, 7, 7, 64])  # 7 x 7
            h = deconv2d('deconv1', h, [-1, 14, 14, 32], [self.k, self.k, 32, 64], stride=2, act=tf.nn.elu, **kwargs)

        return h

    def latter(self, h, name=None, reuse=False):
        if not name:
            name = self.name
        kwargs = dict(self.kwargs)  # Clone

        with tf.variable_scope(name) as vs:
            if reuse:
                vs.reuse_variables()

            kwargs['bn'] = False  # Last layer only
            kwargs['act'] = tf.identity
            h = deconv2d('deconv2', h, [-1, 28, 28, 01], [self.k, self.k, 01, 32], stride=2, **kwargs)
            h = self.last_act(h, 'out')

        return h

    # Instantiate the network
    def __call__(self, x, name=None, reuse=False, **kwargs):
        feat = self.former(x, name, reuse, **kwargs)
        out = self.latter(feat, name, reuse, **kwargs)

        return out


text:
SplashScene::SplashScene()
{
    m_szTagName = "splash";
    m_isAllLoaded = false;
}

SplashScene::~SplashScene()
{
}

void SplashScene::Start()
{
    m_isAllLoaded = false;
    g_pImgManager->AddImageList();
    while (g_pImgManager->AddImageByJson(m_szTagName));
    m_isAllLoaded = true;

    UnitPos cPos = GLOBAL_CENTER_POS;

    m_sprNewGame = new SpritesObject;
    m_sprNewGame->SetBodyImg(g_pImgManager->FindImage("new-game"));
    m_sprNewGame->SetupForSprites(1, 1);
    m_sprNewGame->SetBodyPos({ cPos.x, cPos.y - 200.0f });
    m_sprNewGame->SetBodySize({ 800, 100 });

    m_sprCustomGame = new SpritesObject;
    m_sprCustomGame->SetBodyImg(g_pImgManager->FindImage("custom-game"));
    m_sprCustomGame->SetupForSprites(1, 1);
    m_sprCustomGame->SetBodyPos({ cPos.x, cPos.y });
    m_sprCustomGame->SetBodySize({ 800, 100 });

    m_sprExitGame = new SpritesObject;
    m_sprExitGame->SetBodyImg(g_pImgManager->FindImage("exit-game"));
    m_sprExitGame->SetupForSprites(1, 1);
    m_sprExitGame->SetBodyPos({ cPos.x, cPos.y + 200.0f });
    m_sprExitGame->SetBodySize({ 800, 100 });
}

void SplashScene::Update()
{
    m_sprNewGame->Update();
    m_sprCustomGame->Update();
    m_sprExitGame->Update();

    if (m_isAllLoaded)
    {
        UserController();
    }
}

void SplashScene::Render()
{
    m_sprNewGame->Render(g_hDC);
    m_sprCustomGame->Render(g_hDC);
    m_sprExitGame->Render(g_hDC);
}

void SplashScene::Release()
{
    SAFE_DELETE(m_sprNewGame);
    SAFE_DELETE(m_sprCustomGame);
    SAFE_DELETE(m_sprExitGame);
}

void SplashScene::UserController()
{
    if (g_pKeyManager->isOnceKeyDown(VK_LBUTTON))
    {
        if (PtInRect(&m_sprNewGame->GetBodyRect(), g_ptMouse))
        {
            g_pScnManager->ChangeScene("game");
        }
        else if (PtInRect(&m_sprCustomGame->GetBodyRect(), g_ptMouse))
        {
            g_pScnManager->ChangeScene("custom-game");
        }
        else if (PtInRect(&m_sprExitGame->GetBodyRect(), g_ptMouse))
        {
            g_pScnManager->ChangeScene("exit");
        }
    }
}


text:
<?php
// define variables and set to empty values
$email = $name = $capresponse = $comment = "";

$error="";

if ($_SERVER["REQUEST_METHOD"] == "POST") {
  //collect data from post html post request.
  $email = test_input($_POST["email"]);
  $name = test_input($_POST["name"]);
  $capresponse = test_input($_POST["g-recaptcha-response"]);
  $comment = test_input($_POST["comment"]);
}

if ($email!="" && $name!="" && $comment!="" && $capresponse!="")
  {
  if(isset($_POST['g-recaptcha-response']) && !empty($_POST['g-recaptcha-response'])){
      //your site secret key
      $secret = 'Your secret code goes here';
      //get verify response data
      $verifyResponse = file_get_contents('https://www.google.com/recaptcha/api/siteverify?secret='.$secret.'&response='.$_POST['g-recaptcha-response']);
      $responseData = json_decode($verifyResponse);
      if($responseData->success)
      {
          //contact form submission code
          //destination email
          $to = 'youremail@youremail.com';
          //subject line will look like this
          $subject = 'New comment from '.$name.' via the website!';
          //this is what the email will look like.
          $htmlContent = "

Message:

Contactor details

Name: ".$name."

email: ".$email."

Content:

Comment: ".$comment."

          ";
          // Always set content-type when sending HTML email
          $headers = "MIME-Version: 1.0" . "\n";
          $headers .= "Content-type:text/html;charset=UTF-8" . "\n";
          // More headers
          $headers .= 'From:'.$name.' <donotreply@yoursite.com>' . "\n";
          //send email
          if (mail($to,$subject,$htmlContent,$headers))
          {
             $error="Success! Your message is on its way. Our team will respond when they can.";
          }
          else
          {
              $error="Something went wrong while sending the message on our end. We'll sort it out. Try again in a few hours.";
          }

      }
      else
      {
        $error="Google error code! Code type: ".($responsedata->error-codes);
      }
    }
    else
    {$error="Sorry! We couldn't verify if you were a bot or not. Please go back and make sure you entered the CAPTCHA.";}
  }
else
{
  $error="Please ensure all form inputs are filled. Press back and make sure to do so.";
}

function test_input($data) {
  $data = trim($data);
  $data = stripslashes($data);
  $data = htmlspecialchars($data);
  return $data;
}

$ech=$error;
echo $error;
?>


text:
$(document).ready(function() {
    $('#btnDoIt').click(function() {
        $("#theForm").ajaxSubmit({
            dataType: null,
            success: function(data) {
                var imageData = new Uint8Array(data.length);
                for(var i=0, j=data.length; i<j; ++i){
                    imageData[i]=data.charCodeAt(i);
                }
                var blob = new Blob([imageData], {type: "image/jpeg"});
                var url = URL.createObjectURL(blob);

                var img = new Image();
                var context = document.getElementById('myCanvas').getContext("2d");
                img.onload = function() {
                    /// draw image to canvas
                    context.drawImage(url, 1,1);
                };
                img.onerror = function(error) {
                    console.error(error);
                };
                img.src = url;
            }
        });
    });
});


text:
package org.jabref.gui.externalfiletype;

import java.util.Objects;

import javax.swing.JLabel;

import org.jabref.gui.icon.IconTheme;
import org.jabref.gui.icon.JabRefIcon;

/**
 * This class defines a type of external files that can be linked to from JabRef.
 * The class contains enough information to provide an icon, a standard extension
 * and a link to which application handles files of this type.
 */
public class CustomExternalFileType implements ExternalFileType {

    private final JLabel label = new JLabel();
    private String name;
    private String extension;
    private String openWith;
    private String iconName;
    private String mimeType;
    private JabRefIcon icon;

    public CustomExternalFileType(String name, String extension, String mimeType,
                                  String openWith, String iconName, JabRefIcon icon) {
        label.setText(null);
        this.name = name;
        label.setToolTipText(this.name);
        this.extension = extension;
        this.mimeType = mimeType;
        this.openWith = openWith;

        setIconName(iconName);
        setIcon(icon);
    }

    public CustomExternalFileType(ExternalFileType type) {
        this(type.getName(), type.getExtension(), type.getMimeType(), type.getOpenWithApplication(), "", type.getIcon());
    }

    /**
     * Construct an ExternalFileType from a String array. This is used when
     * reading file type definitions from Preferences, where the available data types are
     * limited. We assume that the array contains the same values as the main constructor,
     * in the same order.
     *
     * @param val arguments.
     */
    public static ExternalFileType buildFromArgs(String[] val) {
        if ((val == null) || (val.length < 4) || (val.length > 5)) {
            throw new IllegalArgumentException("Cannot construct ExternalFileType without four elements in String[] argument.");
        }
        String name = val[0];
        String extension = val[1];
        String openWith;
        String mimeType;
        String iconName;

        if (val.length == 4) {
            // Up to version 2.4b the mime type is not included:
            mimeType = "";
            openWith = val[2];
            iconName = val[3];
        } else {
            // When mime type is included, the array length should be 5:
            mimeType = val[2];
            openWith = val[3];
            iconName = val[4];
        }

        // set icon to default first
        JabRefIcon icon = IconTheme.JabRefIcons.FILE;

        // check whether there is another icon defined for this file type
        for (ExternalFileType fileType : ExternalFileTypes.getDefaultExternalFileTypes()) {
            if (fileType.getName().equals(name)) {
                icon = fileType.getIcon();
                break;
            }
        }

        return new CustomExternalFileType(name, extension, mimeType, openWith, iconName, icon);
    }

    @Override
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
        label.setToolTipText(this.name);
    }

    @Override
    public String getExtension() {
        if (extension == null) {
            return "";
        }
        return extension;
    }

    public void setExtension(String extension) {
        this.extension = extension;
    }

    @Override
    public String getMimeType() {
        if (mimeType == null) {
            return "";
        }
        return mimeType;
    }

    public void setMimeType(String mimeType) {
        this.mimeType = mimeType;
    }

    @Override
    public String getOpenWithApplication() {
        if (openWith == null) {
            return "";
        }
        return openWith;
    }

    public void setOpenWith(String openWith) {
        this.openWith = openWith;
    }

    /**
     * Obtain a JLabel instance set with this file type's icon. The same JLabel
     * is returned from each call of this method.
     *
     * @return the label.
     */
    public JLabel getIconLabel() {
        return label;
    }

    /**
     * Get the string associated with this file type's icon.
     *
     * @return The icon name.
     */
    public String getIconName() {
        return iconName;
    }

    /**
     * Set the string associated with this file type's icon.
     *
     * @param name The icon name to use.
     */
    public void setIconName(String name) {
        this.iconName = name;
    }

    @Override
    public JabRefIcon getIcon() {
        return icon;
    }

    public void setIcon(JabRefIcon icon) {
        Objects.requireNonNull(icon);
        this.icon = icon;
        label.setIcon(this.icon.getSmallIcon());
    }

    @Override
    public String toString() {
        return getName();
    }

    public ExternalFileType copy() {
        return new CustomExternalFileType(name, extension, mimeType, openWith, iconName, icon);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, extension, mimeType, openWith, iconName);
    }

    /**
     * We define two file type objects as equal if their name, extension, openWith and
     * iconName are equal.
     *
     * @param object The file type to compare with.
     * @return true if the file types are equal.
     */
    @Override
    public boolean equals(Object object) {
        if (this == object) {
            return true;
        }

        if (object instanceof CustomExternalFileType) {
            CustomExternalFileType other = (CustomExternalFileType) object;
            return Objects.equals(name, other.name) && Objects.equals(extension, other.extension) &&
                    Objects.equals(mimeType, other.mimeType) && Objects.equals(openWith, other.openWith) && Objects.equals(iconName, other.iconName);
        }
        return false;
    }
}


text:
module CodewarsApi
  class ResponseChecker
    def self.check_errors(response)
      unless response.code.to_i == 200
        raise "Response code is '#{response.code}'\n#{response.message}"
      end
    end
  end
end


text:
module Main where

-- The Grempa library has to be built with the test flag to be able to use this.
import Data.Parser.Grempa.Test
import Test.QuickCheck

-- Import the different parsers and grammars
import Ex1SimpleExpr(expr)
import Ex1SimpleExprParser(parseExprStatic)

import Ex2Calculator(calc)
import Ex2CalculatorParser(parseCalcStatic)

import Ex3Fun(fun)
import Ex3FunParser(parseFunStatic)

-- | Running 'quickCheck' on these different tests will generate random
--   inputs from the grammars and the expected output, and compare the parser's
--   output with that. This is useful to see that the parser covers all of the
--   defined language (you should get conflicts if it does not, but it feels
--   good to get an assurance).
testEx1 = prop_parser parseExprStatic  expr
testEx2 = prop_parser parseCalcStatic  calc
testEx3 = prop_parser parseFunStatic   fun

main = do
  quickCheck testEx1
  quickCheck testEx2
  quickCheck testEx3


text:
/* ----------------------------------------------------------------------- */
/*                                 so1h_0.h                                */
/* ----------------------------------------------------------------------- */
/*                                                                         */
/* ----------------------------------------------------------------------- */

/* SO1H_0 toma el control tras la carga de SO1HIMG (EXE o SYS) y tras      */
/* reubicarse en la direccion 0x90000 localiza la tabla dirf que esta tras */
/* el codigo de SO1H_0 en SO1HIMG. La entradas de esa tabla se copian a    */
/* una tabla reubicacion salvo las entradas 0 (de SO1H_0) y 1 (de dirf), y */
/* añadiendose para cada entrada los campos origen y destino que indican   */
/* la ubicación actual del fichero en memoria y el destino donde deben     */
/* ubicarse para crear con ellos los procesos que van a ejecutarse en un   */
/* primer momento. Una vez completada la tabla reubicacion SO1H lleva a    */
/* cabo la reubicacion dejando los espacios necesario para las pilas de    */
/* los procesos que se van a crear.                                        */

#ifndef SO1H_0_H
#define SO1H_0_H

#include <so1hpub.h\tipos.h>                                    /* dword_t */
#include <so1h_0.h\dirf.h>                                  /* entradaDF_t */

extern dword_t dirInicial ; /* direccion correspondiente a CS:0000 de SO1H */

extern dword_t dirCargaFichero ;          /* direccion de carga de SO1HIMG */

extern dword_t dirFinal ;                       /* primera direccion libre */

/* tipo correspondiente a la tabla reubicacion */

typedef struct {
    entradaDF_t entradaDF ;
	dword_t origen ;
	dword_t destino ;
} reubicacion_t ;	       /* extension de entradaDF_t para la reubicacion */

extern reubicacion_t * reubicacion ;                  /* tabla reubicacion */

extern dword_t numER ;       /* numero de entradas de la tabla reubicacion */

/* reubicacion[0] corresponde a SO1H_K.BIN
/* reubicacion[1] corresponde a un primer programa de usuario (driver)     */
/* ...                                                                     */
/* reubicacion[numER-2] corresponde al ultimo programa de usuario (driver) */
/* reubicacion[numER-1] corresponde al disco RAM.                          */

#endif /* SO1H_0_H */


text:
import React, {createClass} from 'react';

const Nav = createClass({
  render() {
    return (

        Subtle Avenue

    );
  }
});

export default Nav;


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

namespace _04__Merge_Files
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] firstNumb = File.ReadAllText("FileOne.txt")
                .Split(new char[] { ' ', ',', '.', '!', '?', '-', '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries)
                .Select(int.Parse)
                .ToArray();
            int[] secondNumb = File.ReadAllText("FileTwo.txt")
                .Split(new char[] { ' ', ',', '.', '!', '?', '-', '\n', '\r' },StringSplitOptions.RemoveEmptyEntries)
                .Select(int.Parse)
                .ToArray();

            List<int> merge = new List<int>();

            for (int i = 0; i < firstNumb.Length; i++)
            {
                merge.Add(firstNumb[i]);
            }
            for (int i = 0; i < secondNumb.Length; i++)
            {
                merge.Add(secondNumb[i]);
            }

            foreach (var elem in merge.OrderBy(x => x))
            {
                File.AppendAllText("Merge.txt", elem  + Environment.NewLine);
            }

        }
    }
}