text:
package gov.samhsa.consent2share.domain.account;

import java.io.Serializable;
import java.util.Calendar;
import java.util.Set;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.SpringSecurityCoreVersion;

public class Users implements Serializable,
org.springframework.security.core.userdetails.UserDetails{

	private static final long serialVersionUID = SpringSecurityCoreVersion.SERIAL_VERSION_UID;
	private int failedLoginAttempts;
    private String password;
    private Calendar lockoutTime;
    final Logger logger = LoggerFactory.getLogger(this.getClass());

    private final String username;
    private final Set<GrantedAuthority> authorities;
    private final boolean accountNonExpired;
    private boolean accountNonLocked;
    private final boolean credentialsNonExpired;
    private final boolean enabled;

	public Users(String username, String password, boolean enabled, boolean accountNonExpired,
            boolean credentialsNonExpired, Set<GrantedAuthority> authorities) {
    	this(0,username, password, enabled, enabled, true, credentialsNonExpired, authorities,null);
    }

	public Users(String username, String password, Set<GrantedAuthority> authorities) {
        this(0,username, password, true, true, true, true, authorities,null);
    }

	public Users(int failedLoginAttempts,String username, String password, boolean enabled, boolean accountNonExpired,
            boolean credentialsNonExpired, Set<GrantedAuthority> authorities) {
		this(failedLoginAttempts,username, password, enabled, accountNonExpired, true, credentialsNonExpired, authorities,null);
    }

	public Users(int failedLoginAttempts,String username, String password, boolean enabled, boolean accountNonExpired,
            boolean credentialsNonExpired, Set<GrantedAuthority> authorities,Calendar cal) {
		this(failedLoginAttempts,username, password, enabled, accountNonExpired, true, credentialsNonExpired, authorities, cal);
	}

	public Users(int failedLoginAttempts,String username, String password, boolean enabled, boolean accountNonExpired, boolean accountNonLocked,
            boolean credentialsNonExpired, Set<GrantedAuthority> authorities,Calendar cal) {
		if (((username == null) || "".equals(username)) || (password == null)) {
            throw new IllegalArgumentException("Cannot pass null or empty values to constructor");
        }
		this.failedLoginAttempts=failedLoginAttempts;
        this.username = username;
        this.password = password;
        this.enabled = enabled;
        this.accountNonExpired = accountNonExpired;
        this.accountNonLocked = accountNonLocked;
        this.credentialsNonExpired = credentialsNonExpired;
        this.authorities = authorities;
        this.lockoutTime=cal;
    }

	public void increaseFailedLoginAttempts(){
		failedLoginAttempts++;
	}

	public void setFailedLoginAttemptsToZero(){
		failedLoginAttempts=0;
	}

	public int getFailedLoginAttempts() {
		return failedLoginAttempts;
	}

	public void setFailedLoginAttempts(int failedLoginAttempts) {
		this.failedLoginAttempts = failedLoginAttempts;
	}

	@Override
	public Set<GrantedAuthority> getAuthorities() {
		return this.authorities;
	}

	@Override
	public String getPassword() {
		return this.password;
	}

	@Override
	public String getUsername() {
		return this.username;
	}

	@Override
	public boolean isAccountNonExpired() {
		return this.accountNonExpired;
	}

	@Override
	public boolean isCredentialsNonExpired() {
		return this.credentialsNonExpired;
	}

	@Override
	public boolean isEnabled() {
		return this.enabled;
	}

	public Calendar getLockoutTime() {
		return lockoutTime;
	}

	public void setLockoutTime(Calendar lockoutTime) {
		this.lockoutTime = lockoutTime;
	}

	public void setAccountNonLocked(boolean isAccountNonLocked){
		this.accountNonLocked = isAccountNonLocked;
	}

	@Override
	public boolean isAccountNonLocked() {
		return accountNonLocked;
	}

	@Override
	public int hashCode() {
		return username.hashCode();
	}

	@Override
	public boolean equals(Object obj) {
		if (obj instanceof Users) {
            return username.equals(((Users) obj).username);
        }
        return false;
	}

	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append(super.toString()).append(": ");
		sb.append("Username: ").append(this.username).append("; ");
		sb.append("Password: [PROTECTED]; ");
		sb.append("Enabled: ").append(this.enabled).append("; ");
        sb.append("AccountNonExpired: ").append(this.accountNonExpired).append("; ");
        sb.append("credentialsNonExpired: ").append(this.credentialsNonExpired).append("; ");
		return sb.toString();
	}

}


text:
package org.wso2.carbon.event.processor.template.deployer;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.event.processor.core.exception.ExecutionPlanConfigurationException;
import org.wso2.carbon.event.processor.core.exception.ExecutionPlanDependencyValidationException;
import org.wso2.carbon.event.processor.core.internal.util.EventProcessorConstants;
import org.wso2.carbon.event.processor.template.deployer.internal.ExecutionPlanDeployerConstants;
import org.wso2.carbon.event.processor.template.deployer.internal.ExecutionPlanDeployerValueHolder;
import org.wso2.carbon.event.template.manager.core.DeployableTemplate;
import org.wso2.carbon.event.template.manager.core.TemplateDeployer;
import org.wso2.carbon.event.template.manager.core.TemplateDeploymentException;
import org.wso2.siddhi.query.api.util.AnnotationHelper;
import org.wso2.siddhi.query.compiler.SiddhiCompiler;
import org.wso2.siddhi.query.compiler.exception.SiddhiParserException;

public class ExecutionPlanTemplateDeployer implements TemplateDeployer {

    private static final Log log = LogFactory.getLog(ExecutionPlanTemplateDeployer.class);

    @Override
    public String getType() {
        return "realtime";
    }

    @Override
    public void deployArtifact(DeployableTemplate template) throws TemplateDeploymentException {
        String planName;
        try {
            if (template == null) {
                throw new TemplateDeploymentException("No artifact received to be deployed.");
            }
            planName = template.getArtifactId();
            planName = planName.replaceAll(" ", "_");
            undeployArtifact(planName);

            // configuring plan name etc
            String updatedExecutionPlan = template.getArtifact();
            String executionPlanNameDefinition = ExecutionPlanDeployerConstants.EXECUTION_PLAN_NAME_ANNOTATION + "('"
                    + planName + "')";

            if (AnnotationHelper.getAnnotationElement(
                    EventProcessorConstants.ANNOTATION_NAME_NAME, null,
                    SiddhiCompiler.parse(updatedExecutionPlan).getAnnotations()) == null
                    || !updatedExecutionPlan.contains(ExecutionPlanDeployerConstants.EXECUTION_PLAN_NAME_ANNOTATION)) {
                updatedExecutionPlan = executionPlanNameDefinition + updatedExecutionPlan;
            } else {
                //@Plan:name will be updated with given configuration name and uncomment in case if it is commented
                updatedExecutionPlan = updatedExecutionPlan.replaceAll(
                        ExecutionPlanDeployerConstants.EXECUTION_PLAN_NAME_ANNOTATION
                                + ExecutionPlanDeployerConstants.REGEX_NAME_COMMENTED_VALUE,
                        executionPlanNameDefinition);
            }

            //Get Template Execution plan, Tenant Id and deploy Execution Plan
            ExecutionPlanDeployerValueHolder.getEventProcessorService()
                    .deployExecutionPlan(updatedExecutionPlan);

        } catch (SiddhiParserException e) {
            throw new TemplateDeploymentException(
                    "Validation exception occurred when parsing Execution Plan of Template "
                            + template.getConfiguration().getName() + " of Domain " + template.getConfiguration().getDomain(), e);
        } catch (ExecutionPlanConfigurationException e) {
            throw new TemplateDeploymentException(
                    "Configuration exception occurred when adding Execution Plan of Template "
                    + template.getConfiguration().getName() + " of Domain " + template.getConfiguration().getDomain(), e);

        } catch (ExecutionPlanDependencyValidationException e) {
            throw new TemplateDeploymentException(
                    "Validation exception occurred when adding Execution Plan of Template "
                    + template.getConfiguration().getName() + " of Domain " + template.getConfiguration().getDomain(), e);
        }
    }

    @Override
    public void deployIfNotDoneAlready(DeployableTemplate template) throws TemplateDeploymentException{
        if (template == null) {
            throw new TemplateDeploymentException("No artifact received to be deployed.");
        }
        String planName = template.getArtifactId();
        planName = planName.replaceAll(" ", "_");
        if (ExecutionPlanDeployerValueHolder.getEventProcessorService().
                getAllActiveExecutionConfigurations().get(planName) == null) {
            deployArtifact(template);
        } else {
            if(log.isDebugEnabled()) {
                log.debug("Common Artifact: " + planName + " of Domain " + template.getConfiguration().getDomain()
                          + " was not deployed as it is already being deployed.");
            }
        }
    }

    @Override
    public void undeployArtifact(String artifactId) throws TemplateDeploymentException {
        artifactId = artifactId.replaceAll(" ", "_");
        try {
            if (ExecutionPlanDeployerValueHolder.getEventProcessorService().getAllActiveExecutionConfigurations().keySet().contains(artifactId)) {
                ExecutionPlanDeployerValueHolder.getEventProcessorService().undeployActiveExecutionPlan(artifactId);
            } else {
                ExecutionPlanDeployerValueHolder.getEventProcessorService().undeployInactiveExecutionPlan(artifactId + EventProcessorConstants.EP_CONFIG_FILE_EXTENSION_WITH_DOT);
            }
        } catch (ExecutionPlanConfigurationException e) {
            throw new TemplateDeploymentException("Could not undeploy exceution plan: " + artifactId, e);
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
package org.keycloak.models.map.storage.jpa.role.entity;

import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.UUID;
import java.util.stream.Collectors;
import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.persistence.UniqueConstraint;
import javax.persistence.Version;
import org.hibernate.annotations.Type;
import org.hibernate.annotations.TypeDef;
import org.hibernate.annotations.TypeDefs;
import org.keycloak.models.map.common.DeepCloner;
import org.keycloak.models.map.common.UuidValidator;
import org.keycloak.models.map.role.MapRoleEntity.AbstractRoleEntity;
import static org.keycloak.models.map.storage.jpa.Constants.CURRENT_SCHEMA_VERSION_ROLE;
import org.keycloak.models.map.storage.jpa.JpaRootVersionedEntity;
import org.keycloak.models.map.storage.jpa.hibernate.jsonb.JsonbType;

/**
 * There are some fields marked by {@code @Column(insertable = false, updatable = false)}.
 * Those fields are automatically generated by database from json field,
 * therefore marked as non-insertable and non-updatable to instruct hibernate.
 */
@Entity
@Table(name = "kc_role", uniqueConstraints = {@UniqueConstraint(columnNames = {"realmId", "clientId", "name"})})
@TypeDefs({@TypeDef(name = "jsonb", typeClass = JsonbType.class)})
public class JpaRoleEntity extends AbstractRoleEntity implements JpaRootVersionedEntity {

    @Id
    @Column
    private UUID id;

    //used for implicit optimistic locking
    @Version
    @Column
    private int version;

    @Type(type = "jsonb")
    @Column(columnDefinition = "jsonb")
    private final JpaRoleMetadata metadata;

    @Column(insertable = false, updatable = false)
    @Basic(fetch = FetchType.LAZY)
    private Integer entityVersion;

    @Column(insertable = false, updatable = false)
    @Basic(fetch = FetchType.LAZY)
    private String realmId;

    @Column(insertable = false, updatable = false)
    @Basic(fetch = FetchType.LAZY)
    private String clientId;

    @Column(insertable = false, updatable = false)
    @Basic(fetch = FetchType.LAZY)
    private String name;

    @Column(insertable = false, updatable = false)
    @Basic(fetch = FetchType.LAZY)
    private String description;

    @OneToMany(mappedBy = "root", cascade = CascadeType.PERSIST, orphanRemoval = true)
    private final Set<JpaRoleAttributeEntity> attributes = new HashSet<>();

    /**
     * No-argument constructor, used by hibernate to instantiate entities.
     */
    public JpaRoleEntity() {
        this.metadata = new JpaRoleMetadata();
    }

    public JpaRoleEntity(DeepCloner cloner) {
        this.metadata = new JpaRoleMetadata(cloner);
    }

    /**
     * Used by hibernate when calling cb.construct from read(QueryParameters) method.
     * It is used to select role without metadata(json) field.
     */
    public JpaRoleEntity(UUID id, int version, Integer entityVersion, String realmId, String clientId, String name, String description) {
        this.id = id;
        this.version = version;
        this.entityVersion = entityVersion;
        this.realmId = realmId;
        this.clientId = clientId;
        this.name = name;
        this.description = description;
        this.metadata = null;
    }

    public boolean isMetadataInitialized() {
        return metadata != null;
    }

    @Override
    public Integer getCurrentSchemaVersion() {
        return CURRENT_SCHEMA_VERSION_ROLE;
    }

    @Override
    public Integer getEntityVersion() {
        if (isMetadataInitialized()) return metadata.getEntityVersion();
        return entityVersion;
    }

    @Override
    public void setEntityVersion(Integer entityVersion) {
        metadata.setEntityVersion(entityVersion);
    }

    @Override
    public int getVersion() {
        return version;
    }

    @Override
    public String getId() {
        return id == null ? null : id.toString();
    }

    @Override
    public void setId(String id) {
        String validatedId = UuidValidator.validateAndConvert(id);
        this.id = UUID.fromString(validatedId);
    }

    @Override
    public String getRealmId() {
        if (isMetadataInitialized()) return metadata.getRealmId();
        return realmId;
    }

    @Override
    public String getClientId() {
        if (isMetadataInitialized()) return metadata.getClientId();
        return clientId;
    }

    @Override
    public String getName() {
        if (isMetadataInitialized()) return metadata.getName();
        return name;
    }

    @Override
    public String getDescription() {
        if (isMetadataInitialized()) return metadata.getDescription();
        return description;
    }

    @Override
    public void setClientRole(Boolean clientRole) {
        // intentionally do nothing, assuming the role is client-role when this.getClientId() != null;
    }

    @Override
    public void setRealmId(String realmId) {
        metadata.setRealmId(realmId);
    }

    @Override
    public void setClientId(String clientId) {
        metadata.setClientId(clientId);
    }

    @Override
    public void setName(String name) {
        metadata.setName(name);
    }

    @Override
    public void setDescription(String description) {
        metadata.setDescription(description);
    }

    @Override
    public Set<String> getCompositeRoles() {
        throw new UnsupportedOperationException("this is implemented in JpaMapRoleEntityDelegate, should never be called");
    }

    @Override
    public void setCompositeRoles(Set<String> compositeRoles) {
        if (compositeRoles == null) {
            // this is called when cloning an entity during creation, can't be avoided with the current implementation
            return;
        }
        throw new UnsupportedOperationException("this is implemented in JpaMapRoleEntityDelegate, should never be called");

    }

    @Override
    public void addCompositeRole(String roleId) {
        throw new UnsupportedOperationException("this is implemented in JpaMapRoleEntityDelegate, should never be called");

    }

    @Override
    public void removeCompositeRole(String roleId) {
        throw new UnsupportedOperationException("this is implemented in JpaMapRoleEntityDelegate, should never be called");
    }

    @Override
    public Map<String, List<String>> getAttributes() {
        Map<String, List<String>> result = new HashMap<>();
        for (JpaRoleAttributeEntity attribute : attributes) {
            List<String> values = result.getOrDefault(attribute.getName(), new LinkedList<>());
            values.add(attribute.getValue());
            result.put(attribute.getName(), values);
        }
        return result;
    }

    @Override
    public List<String> getAttribute(String name) {
        return attributes.stream()
                .filter(a -> Objects.equals(a.getName(), name))
                .map(JpaRoleAttributeEntity::getValue)
                .collect(Collectors.toList());
    }

    @Override
    public void setAttributes(Map<String, List<String>> attributes) {
        this.attributes.clear();
        if (attributes != null) {
            for (Map.Entry<String, List<String>> entry : attributes.entrySet()) {
                setAttribute(entry.getKey(), entry.getValue());
            }
        }
    }

    @Override
    public void setAttribute(String name, List<String> values) {
        removeAttribute(name);
        for (String value : values) {
            JpaRoleAttributeEntity attribute = new JpaRoleAttributeEntity(this, name, value);
            attributes.add(attribute);
        }
    }

    @Override
    public void removeAttribute(String name) {
        attributes.removeIf(attr -> Objects.equals(attr.getName(), name));
    }

    @Override
    public int hashCode() {
        return getClass().hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof JpaRoleEntity)) return false;
        return Objects.equals(getId(), ((JpaRoleEntity) obj).getId());
    }

}


text:
package test;

import com.jcraft.jsch.*;
import java.io.*;

public class SSHexample
{
public static void Console(OutputStream outputStream)
{
    String user = "root";
    String password = "lo0ldcigigcsrq4kkvvb6o9nhe";
    String host = "h2261183.stratoserver.net";
    int port=22;

    String remoteFile="ty.txt";

    try
    {
        JSch jsch = new JSch();
        Session session = jsch.getSession(user, host, port);
        session.setPassword(password);
        session.setConfig("StrictHostKeyChecking", "no");
        System.out.println("Establishing Connection...");
        session.connect();
        System.out.println("Connection established.");
        System.out.println("Crating SFTP Channel.");
        ChannelSftp sftpChannel = (ChannelSftp) session.openChannel("sftp");
        sftpChannel.connect();
        System.out.println("SFTP Channel created.");
        InputStream out= null;
    out= sftpChannel.get(remoteFile);
        BufferedReader br = new BufferedReader(new InputStreamReader(out));
        String line;
        while ((line = br.readLine()) != null)
    {
            System.out.println(line);
        }
    br.close();
        sftpChannel.disconnect();
        session.disconnect();
    }
    catch(JSchException | SftpException | IOException e)
{
    System.out.println(e);
}
}
}


text:
<?php

// this allows players to edit their profile. the menu entry will appear if the player is logged in
// as defined in /menu.php, if nobody is logged in a link to the signup page (join.php) is displayed instead.

   header("Cache-Control: no-cache");
   header("Pragma: no-cache");

   $page = 'players';
   $subpage = 'editprofile';

   require('./variables.php');
   require('./variablesdb.php');
   require('./functions.php');
   require('./top.php');

   require_once('log/KLogger.php');
   $logEdit = new KLogger('/var/www/yoursite/http/log/editprofile/', KLogger::INFO);

if (! empty($_GET['name'])) {
    $name = mysql_real_escape_string($_GET['name']);
}

$back = "
go back
";
$checked = "checked='checked'";

?>

<?= getOuterBoxTop($subNavText.getRaquo().getSubNavigation($subpage, $name), "") ?>

<?php

   if(empty($cookie_name)) {
     echo "
You are not logged in.
";
   }
	else {
		if (! empty($_POST['submit'])) {
         $submit = mysql_real_escape_string($_POST['submit']);
      }
      else {
         $submit = '';
      }

      if (! empty($_POST['passworddb'])) {
         $passworddb = mysql_real_escape_string($_POST['passworddb']);
      }
      else {
         $passworddb = '';
      }

      if (! empty($_POST['passwordrepeat'])) {
         $passwordrepeat = mysql_real_escape_string($_POST['passwordrepeat']);
      }
      else {
         $passwordrepeat = '';
      }

      $pwd = password_hash($passworddb, PASSWORD_DEFAULT);

      if (! empty($_POST['serial5'])) {
      	 $serial5 = mysql_real_escape_string($_POST['serial5']);
         $serial5 = strtoupper(str_replace("-","", $serial5));
      }
      else {
         $serial5 = '';
      }

      if (! empty($_POST['serial6'])) {
      	 $serial6 = mysql_real_escape_string($_POST['serial6']);
         $serial6 = strtoupper(str_replace("-","", $serial6));
      }
      else {
         $serial6 = '';
      }
		if ($submit == 'Submit') {

       $na = "n/a";
       $alias1 = mysql_real_escape_string($_POST['alias1']);
       $alias1 = trim(strip_tags($alias1));
       $platform1 = mysql_real_escape_string($_POST['platform1']);
       $game1 = mysql_real_escape_string($_POST['game1']);
       $msn1 = mysql_real_escape_string($_POST['msn1']);
       $msn1 = strip_tags($msn1);
       $msn1 = trim($msn1);
       $icq1 = mysql_real_escape_string($_POST['icq1']);
       $icq1 = strip_tags($icq1);
       $icq1 = trim($icq1);
       $aim1 = mysql_real_escape_string($_POST['aim1']);
       $aim1 = strip_tags($aim1);
       $aim1 = trim($aim1);
       $mail1 = mysql_real_escape_string($_POST['mail1']);
       $mail1 = strip_tags($mail1);
       $mail1 = trim($mail1);
       $forum1 = mysql_real_escape_string($_POST['forum1']);
       $forum1 = strip_tags($forum1);
       $forum1 = trim($forum1);
       $country1 = mysql_real_escape_string($_POST['country1']);
       if (empty($country1)) {
          $country1 = "No country";
       }
     $favteam11 = mysql_real_escape_string($_POST['favteam11']);
     $favteam21 = mysql_real_escape_string($_POST['favteam21']);

     $nationality1 = mysql_real_escape_string($_POST['nationality1']);

      if (empty($nationality1) || $nationality1 == "") {
          $nationality1 = $country1;
      }

      $message1 = mysql_real_escape_string($_POST['message1']);
      $message1 = strip_tags($message1);
      $message1 = trim($message1);

       if (isset($_POST["gamesMail1"])) {
        $gamesMail1 = "yes";
       } else {
        $gamesMail1 = "no";
       }

       if (isset($_POST["deductMail1"])) {
        $deductMail1 = "yes";
       } else {
        $deductMail1 = "no";
       }

       if (isset($_POST["newsletter1"])) {
        $newsletter1 = "yes";
       } else {
        $newsletter1 = "no";
       }

       $uploadSpeed1 = mysql_real_escape_string($_POST["uploadSpeed1"]);
       $downloadSpeed1 = mysql_real_escape_string($_POST["downloadSpeed1"]);

        if (empty($msn1)) { $msn1 = $na; }

        if (empty($icq1)) { $icq1 = $na; }
        if (empty($aim1)) { $aim1 = $na; }
        if (empty($mail1)) { $mail1 = $na; }

       if (strcmp($cookie_name, $alias1) == 0) {
        $alias1 = "";
      }
      $hash5 = mysql_real_escape_string($_POST["hash5"]);
      if (!empty($serial5)) {
      $result = array();
      $res5 = exec("/opt/sixserver/sixserver-env/bin/python2.6 /opt/sixserver/lib/fiveserver/gethash.py ".$hash5, $result);
        $hash5 = $result[0];
      }

      $hash6 = mysql_real_escape_string($_POST["hash6"]);
      if (!empty($serial6)) {
        $result = array();
        $res6 = exec("/opt/sixserver/sixserver-env/bin/python2.6 /opt/sixserver/lib/fiveserver/gethash.py ".$hash6, $result);
        $hash6 = $result[0];
      }
			$defaultversion1 = mysql_real_escape_string($_POST['defaultversion']);

			$sql = "SELECT version from $versionstable";
			$result = mysql_query($sql);
			$count = 0;
			$versions1 = "";
			while ($row = mysql_fetch_array($result)) {
				$count++;
				$version = $row['version'];
				if (isset($_POST['version_'.$version])) {
				    $versions1 .= $version;
				}
			}

			if (empty ($passworddb)) {
        echo "
Please supply a password.
".$back;
      }
      else if ($passworddb != $passwordrepeat) {
        echo "
Password and repetition do not match.
".$back;
      }
   			else if ($passworddb == $name || $passworddb == $name) {
			  echo "
Please choose a better password.
".$back;
		 	}
			 else if ($versions1 == "") {
		 	  echo "
Please select at least one game.
".$back;
		   }
			else if (!stristr($versions1, $defaultversion1)) {
		 	   echo "
The default game you selected is not one of the games you have.
".$back;
		    }
        else if (strlen($serial5) > 0 && strlen($serial5) != 20) {
          echo "
The PES 5 serial you entered is not valid.
".$back;
        }
        else if (strlen($serial6) > 0 && strlen($serial6) != 20) {
          echo "
The PES 6 serial you entered is not valid.
".$back;
        }
		    else {
                 $sql="SELECT * FROM $playerstable WHERE name='$cookie_name' AND pwd = '$cookieSessionId'";
	               $result = mysql_query($sql);
	               $num = mysql_num_rows($result);

	               if ($num > 0) {
                  $row = mysql_fetch_array($result);
                  $player_id = $row['player_id'];

                  $maildb = $row['mail'];
                  $numEmail = 0;
                  if ($mail1 != $maildb) {
                    $sqlEmail = "SELECT * FROM $playerstable WHERE player_id<>".$player_id." AND mail='".$mail1."'";
                    $resultEmail = mysql_query($sqlEmail);
                    $numEmail = mysql_num_rows($resultEmail);
                  }

                  If ($numEmail == 0) {
                          $signup = $row['signup'];
                          $invalidEmail = $row['invalidEmail'];
                          $rejected = $row['rejected'];
                          $approved = $row['approved'];
                          $signupSent = $row['signupSent'];

                            if (!empty($_FILES['picture']['size'])) {
                               $f1_size = $_FILES['picture']['size'];
                               $f1_name = $_FILES['picture']['name'];
                               $f1_tmpname = $_FILES['picture']['tmp_name'];

                               $ext = strtolower(substr($f1_name,strrpos($f1_name, ".")+1));

                               $valides = array($valid_picture_extension1,$valid_picture_extension2,$valid_picture_extension3);
                               $w = 0;
                               $h = 0;
                               list($w, $h) = getimagesize($f1_tmpname);
                               if ($w > 500 || $h > 500) {
                              echo '
Your picture is too big ('.$w.'x'.$h.'). Maximum size: 500x500
'.$back;
                            }
                               elseif ($f1_size > $maxsize_picture_upload) {
                                  echo '
Your picture is too big. '.$f1_size.'KB, Maximum: '.$maxsize_picture_upload.'KB
';
                               }
                               else {
                                  if (!in_array($ext,$valides)) {
                                     echo '
Invalid image extension \''.$ext.'\'. Valid extensions are: '.$valid_picture_extension1." ".$valid_picture_extension2." ".$valid_picture_extension3."
";
                                  }
                                  else {
                                     $picturename = $player_id.'.'.$ext;
                                     // will only work on unix sytems, add unlink() for windows!
                         $copywork = rename($f1_tmpname, "./pictures/$picturename");
                         chmod("./pictures/$picturename", 0644);
                                     if ($copywork) echo '
Picture '.$picturename.' saved.
';
                                  }
                               }
                            }

                            if (!empty($_FILES['picture']['size']) && !$copywork) {
                               // echo "
Upload failed.
";
                            }
                            else {

                       $sql = "UPDATE $playerstable SET alias = '$alias1',  ".
                        "mail = '$mail1', icq = '$icq1', " .
                        "aim = '$aim1', msn = '$msn1', country = '$country1', nationality = '$nationality1', " .
                        "passworddb = '', pwd='$pwd', forum='$forum1', sendGamesMail = '$gamesMail1', " .
                        "uploadSpeed = '$uploadSpeed1', downloadSpeed = '$downloadSpeed1', " .
                        "sendDeductMail = '$deductMail1', " .
                        "sendNewsletter = '$newsletter1', " .
                        "message = '$message1', versions = '$versions1', ".
                        "defaultversion='$defaultversion1', favteam1='$favteam11', favteam2 = '$favteam21', " .
                        "serial5='$serial5', hash5='$hash5', serial6='$serial6', hash6='$hash6', invalidEmail=0 WHERE name='$cookie_name'";
                         $result = mysql_query($sql);

                         $logEdit->logInfo('Profile saved, name='.$cookie_name.' pwd='.$passworddb);
                         $logEdit->logInfo('sql='.$sql);

                         echo "
Your changes have been saved.
";
                         echo "
You may need to log in again for changes to take effect.
";

                         if (($mail1 != $maildb) && ($rejected == 0) && ($approved == 'no') && ($signupSent == 1) && !$inactiveAndBanned) {
                           $link = "http://www.yoursite/activate.php?id=".$signup;
                           $res = sendActivationLinkMail($mail1, $name, $link);
                           echo "
An account activation link has been sent to ".$mail1.".
";
                         }
                      }
                    } else {
                      echo "
The email address you entered is already in use by another account. Please note that only one account per player is allowed.
".$back;
                    }
	               } // end if num > 0
	               else {
	                  echo "
We couldn't find you in the database. Please try again or contact the admin if the problem persists.
".$back;
	               }
	            } // end if submit

            }
            else {
           $sql="SELECT * FROM $playerstable WHERE name = '$cookie_name'";
					 $result=mysql_query($sql,$db);
           $row = mysql_fetch_array($result);
           $player_id = $row['player_id'];
           $mail = $row["mail"];
           $name = $cookie_name;
           $icq = $row["icq"];
           $aim = $row["aim"];
           $msn = $row["msn"];
           $country = $row["country"];
					 $nationality = $row["nationality"];
           $forum = $row["forum"];
           $alias = $row["alias"];
           $gamesMail = $row["sendGamesMail"];
           $deductMail = $row["sendDeductMail"];
           $newsletter = $row["sendNewsletter"];

           $uploadSpeed = $row["uploadSpeed"];
           $downloadSpeed = $row["downloadSpeed"];
					 $message = $row["message"];
					 $versions = $row["versions"];
					 $defaultversion = $row["defaultversion"];
           $approved = $row["approved"];
					 $favteam1 = $row["favteam1"];
 					 $favteam2 = $row["favteam2"];
 					 $serial5 = $row["serial5"];
 					 $serial6 = $row["serial6"];
 					 if ($approved == "no") {
              $nameDisplay = "".$name."";
				   } else {
              $nameDisplay = $name;
           }
                ?>

				 	 <?= getBoxTop("Edit Profile", "", false, null); ?>
                     <form method="post" action="editprofile.php<?
                     	if ($name != null) {
                     		echo "?name=".$name;
                     	}
                     ?>" onsubmit="return validateProfile();" enctype="multipart/form-data">

                        Name
                        <?= $nameDisplay ?>

		            Alias
		            <input class="width150" type="Text" name="alias1" maxlength="15" value="<? echo $alias ?>">
		            An alias, eg. a forum or messenger name

                        Location*
                        <select class="width150" name="country1">
                           	 <option></option>
	 <option value="No country">No country</option>
	<?php
    $sql = "SELECT country FROM $countriestable ORDER BY COUNTRY ASC";
    $result = mysql_query($sql);
    while ($row = mysql_fetch_array($result)) {
    	$row_country = $row['country'];
    	if ($row_country == $country) {
    		$selected = "selected='selected'";
    	} else {
    		$selected = "";
    	}
        echo "<option value=\"$row_country\" $selected>$row_country</option>";
    }
    ?>

                        </select>
                     Your Location

            Nationality
            <select class="width150" name="nationality1">
	 <option></option>
	 <option value="No country">No country</option>
	<?php
    $sql = "SELECT country FROM $countriestable ORDER BY COUNTRY ASC";
    $result = mysql_query($sql);
    while ($row = mysql_fetch_array($result)) {
    	$row_country = $row['country'];
    	if ($row_country == $nationality) {
    		$selected = "selected='selected'";
    	} else {
    		$selected = "";
    	}
        echo "<option  value=\"$row_country\" $selected>$row_country</option>";
    }
    ?>

            </select>
            Your nationality (only if different from location)

                        Picture
                        <input size="10" type="File" name="picture">
                        A picture of yourself (max. size: 500x500)

    				  <?= getCheckboxesForSupportedVersions($versions); ?>

			            Default Game
			            <?= getSelectboxForAllVersions($defaultversion) ?>
			            The game you play online the most often

                        Email address*
                        <input class="width150" type="Text" name="mail1" value="<? echo $mail ?>">
                        Must be valid!

                        PES 6 serial
                        <input class="width150" maxlength="24" type="Text" name="serial6"  id="serial6" value="<? echo $serial6 ?>"><input class="width150" maxlength="24" type="hidden" name="serial5" id="serial5" value="<? echo $serial5 ?>">
                        For <?= $leaguename ?> Sixserver (no dashes)

            Group

               <input class="width150" type="Text" name="forum1" maxlength="30" value="<?= $forum ?>">

            Displayed in Sixserver

                        ICQ
                        <input class="width150" type="Text" name="icq1" value="<? echo $icq ?>">

                        MSN
                        <input class="width150" type="Text" name="msn1" value="<? echo $msn ?>">

                        AIM
                        <input class="width150" type="Text" name="aim1" value="<? echo $aim ?>">

                        Upload speed
                        <input class="width150" type="Text" maxlength="5" name="uploadSpeed1" value="<? echo $uploadSpeed ?>">
                        Bandwidth in kbps (eg. 128, 256, 512)

                        Download speed
                        <input class="width150" type="Text" maxlength="5" name="downloadSpeed1" value="<? echo $downloadSpeed ?>">
                        No idea? Use this.

						Message
						<input class="width150" type="Text" maxlength="40" name="message1" value="<? echo $message ?>">
						A short message that will appear on your profile page

              Favorite team 1

							<select class="width150" name="favteam11">
							<?= getTeamsOptionsNone(false) ?>
							<?= getTeamsAllOptions($favteam1) ?>
							</select>

			            Favorite team 2

							<select class="width150" name="favteam21">
							<?= getTeamsOptionsNone(false) ?>
							<?= getTeamsAllOptions($favteam2) ?>
							</select>

						<input name="gamesMail1" type="checkbox" class="checkbox"
						<? if ($gamesMail == 'yes') { echo $checked; } ?>/>  Daily game summary
						by email
						If you have played games, highly recommended!

						<input name="newsletter1" type="checkbox" class="checkbox"
						<?
						if ($newsletter == 'yes') {
							echo $checked;
						}
						?>/>  Occasional info mail
						Only once or twice a year

    Enter current or new password to save your changes.

  Password*
  <input type="password" id="password" class="width150" name="passworddb" maxlength="10">
  (10 characters max.)

  Repeat password*
  <input type="password" class="width150" name="passwordrepeat" maxlength="10">

							<input type="hidden" name="hash5" id="hash5" size="32" value=""/>
							<input type="hidden" name="hash6" id="hash6" size="32" value=""/>
							<input type="hidden" name="name" id="name" size="32" value="<?= $name ?>"/>
					 		<input type="Submit" name="submit" value="Submit" class="width150">

					 </form>

				<?= getBoxBottom() ?>

                    <?
                       $imgpathGif = './pictures/'.$player_id.'.gif';
					   $imgpathJpg = './pictures/'.$player_id.'.jpg';
					   $imgpath = "";
					   if (is_readable($imgpathGif) && is_readable($imgpathJpg)) {
					   		$timeGif = filemtime($imgpathGif);
					   		$timeJpg = filemtime($imgpathJpg);
							if ($timeGif > $timeJpg) {
								$imgpath = $imgpathGif;
							} else {
								$imgpath = $imgpathJpg;
							}
					   } else if (is_readable($imgpathGif)) {
					   	$imgpath = $imgpathGif;
					   } else if (is_readable($imgpathJpg)) {
					   	$imgpath = $imgpathJpg;
					   }

					   if (!empty($imgpath)) {
						?>
						<?= getBoxTop("User Image", "", false, null); ?>
					      <img src="<? echo $imgpath ?>" />
						<?= getBoxBottom() ?>
					   <? } ?>

      <?php
      }
   }
?>
<?= getOuterBoxBottom() ?>
<?
require('./bottom.php');
?>


text:
require 'base64'
require 'json'
require 'openssl'
require 'securerandom'

require 'jwe/base64'
require 'jwe/serialization/compact'
require 'jwe/alg'
require 'jwe/enc'
require 'jwe/zip'

# A ruby implementation of the RFC 7516 JSON Web Encryption (JWE) standard.
module JWE
  class DecodeError < RuntimeError; end
  class NotImplementedError < RuntimeError; end
  class BadCEK < RuntimeError; end
  class InvalidData < RuntimeError; end

  VALID_ALG = ['RSA1_5', 'RSA-OAEP', 'RSA-OAEP-256', 'A128KW', 'A192KW', 'A256KW', 'dir', 'ECDH-ES', 'ECDH-ES+A128KW', 'ECDH-ES+A192KW', 'ECDH-ES+A256KW', 'A128GCMKW', 'A192GCMKW', 'A256GCMKW', 'PBES2-HS256+A128KW', 'PBES2-HS384+A192KW', 'PBES2-HS512+A256KW'].freeze
  VALID_ENC = ['A128CBC-HS256', 'A192CBC-HS384', 'A256CBC-HS512', 'A128GCM', 'A192GCM', 'A256GCM'].freeze
  VALID_ZIP = ['DEF'].freeze

  class << self
    def encrypt(payload, key, alg: 'RSA-OAEP', enc: 'A128GCM', **more_headers)
      header = generate_header(alg, enc, more_headers)
      check_params(header, key)

      payload = apply_zip(header, payload, :compress)

      cipher = Enc.for(enc)
      cipher.cek = key if alg == 'dir'

      json_hdr = header.to_json
      ciphertext = cipher.encrypt(payload, Base64.jwe_encode(json_hdr))

      generate_serialization(json_hdr, Alg.encrypt_cek(alg, key, cipher.cek), ciphertext, cipher)
    end

    def decrypt(payload, key)
      header, enc_key, iv, ciphertext, tag = Serialization::Compact.decode(payload)
      header = JSON.parse(header)
      check_params(header, key)

      cek = Alg.decrypt_cek(header['alg'], key, enc_key)
      cipher = Enc.for(header['enc'], cek, iv, tag)

      plaintext = cipher.decrypt(ciphertext, payload.split('.').first)

      apply_zip(header, plaintext, :decompress)
    end

    def check_params(header, key)
      check_alg(header[:alg] || header['alg'])
      check_enc(header[:enc] || header['enc'])
      check_zip(header[:zip] || header['zip'])
      check_key(key)
    end

    def check_alg(alg)
      raise ArgumentError.new("\"#{alg}\" is not a valid alg method") unless VALID_ALG.include?(alg)
    end

    def check_enc(enc)
      raise ArgumentError.new("\"#{enc}\" is not a valid enc method") unless VALID_ENC.include?(enc)
    end

    def check_zip(zip)
      raise ArgumentError.new("\"#{zip}\" is not a valid zip method") unless zip.nil? || zip == '' || VALID_ZIP.include?(zip)
    end

    def check_key(key)
      raise ArgumentError.new('The key must not be nil or blank') if key.nil? || (key.is_a?(String) && key.strip == '')
    end

    def param_to_class_name(param)
      klass = param.gsub(/[-\+]/, '_').downcase.sub(/^[a-z\d]*/) { $&.capitalize }
      klass.gsub(/_([a-z\d]*)/i) { Regexp.last_match(1).capitalize }
    end

    def apply_zip(header, data, direction)
      zip = header[:zip] || header['zip']
      if zip
        Zip.for(zip).new.send(direction, data)
      else
        data
      end
    end

    def generate_header(alg, enc, more)
      header = { alg: alg, enc: enc }.merge(more)
      header.delete(:zip) if header[:zip] == ''
      header
    end

    def generate_serialization(hdr, cek, content, cipher)
      Serialization::Compact.encode(hdr, cek, cipher.iv, content, cipher.tag)
    end
  end
end


text:
/**
 * Created by lerayne on 09.05.17.
 */

export const defaultUserState = {
    id: -1
}

export default function userReducer(state=defaultUserState, action){
    const {type, payload} = action

    switch (type) {
        case 'SET_USER':
            console.log('set_user payload', payload)
            return {
                ...state,
                ...payload
            }

        default:
            return state
    }
}


text:
package org.apache.spark.sql.execution.datasources.orc

import org.apache.hadoop.fs.Path
import org.apache.hadoop.io.NullWritable
import org.apache.hadoop.mapreduce.TaskAttemptContext
import org.apache.orc.mapred.OrcStruct
import org.apache.orc.mapreduce.OrcOutputFormat

import org.apache.spark.sql.catalyst.InternalRow
import org.apache.spark.sql.execution.datasources.OutputWriter
import org.apache.spark.sql.types._

private[orc] class OrcOutputWriter(
    path: String,
    dataSchema: StructType,
    context: TaskAttemptContext)
  extends OutputWriter {

  private[this] val serializer = new OrcSerializer(dataSchema)

  private val recordWriter = {
    new OrcOutputFormat[OrcStruct]() {
      override def getDefaultWorkFile(context: TaskAttemptContext, extension: String): Path = {
        new Path(path)
      }
    }.getRecordWriter(context)
  }

  override def write(row: InternalRow): Unit = {
    recordWriter.write(NullWritable.get(), serializer.serialize(row))
  }

  override def close(): Unit = {
    recordWriter.close(context)
  }
}


text:
"""_version.py: track package version information"""
from os import path
import warnings

INSTALLED = True
try:    #pragma: no cover
    import prosper.common.prosper_version as p_version
except ImportError:
    INSTALLED = False

HERE = path.abspath(path.dirname(__file__))

def get_version():
    """find current version information

    Returns:
        (str): version information

    """
    if not INSTALLED:
        try:
            with open('version.txt', 'r') as v_fh:
                return v_fh.read()
        except Exception:
            warnings.warn(
                'Unable to resolve package version until installed',
                UserWarning
            )
            return '0.0.0'  #can't parse version without stuff installed

    return p_version.get_version(HERE)

__version__ = get_version()


text:
package com.zegoggles.smssync;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.util.Log;

public class SmsBroadcastReceiver extends BroadcastReceiver {
    public static final String SMS_RECEIVED = "android.provider.Telephony.SMS_RECEIVED";

    @Override
    public void onReceive(Context ctx, Intent intent) {
        if (intent.getAction().equals(Intent.ACTION_BOOT_COMPLETED)) {
          bootup(ctx);
        } else if (intent.getAction().equals(SMS_RECEIVED)) {
          incomingSMS(ctx);
        }
    }

    private void bootup(Context ctx) {
        Log.d(Consts.TAG, "SMSBackup+ bootup");
        incomingSMS(ctx);
    }

    private void incomingSMS(Context ctx) {
        if (PrefStore.isEnableAutoSync(ctx) &&
            PrefStore.isLoginInformationSet(ctx) &&
            !PrefStore.isFirstSync(ctx)) {

            Alarms.scheduleIncomingSync(ctx);
        } else {
            Log.i(Consts.TAG, "Received SMS / bootup but not set up to sync.");
        }
    }
}


text:
//package model;
//
//import java.util.ArrayList;
//import java.util.List;
//import java.util.Map;
//
//public class Document {
//
//    private int id;
//
//    private String body;//原文
//
//    private int totalWords;//总词数
//
//    private List<Sentence> sentences;//原文所有的句子
//
//    private Map<String, Integer> termsFrequencyMap;//词频信息
//
//    private List<Paragraph> paragraphs;
//
//    /**
//     * 返回该文档的句子总数
//     *
//     * @return
//     */
//    public int getSentenceCount() {
//        if (sentences != null) {
//            return sentences.size();
//        } else {
//            return 0;
//        }
//    }
//
//    public void putParagraph(Paragraph paragraph) {
//        if (paragraphs == null) {
//            paragraphs = new ArrayList<Paragraph>();
//        }
//        paragraphs.add(paragraph);
//        if (this.sentences == null) {
//            this.sentences = new ArrayList<Sentence>();
//        }
//        this.sentences.addAll(paragraph.getSentences());
//    }
//
//    //	public void putSentences(List<Sentence> sentences){
//    //		if(this.sentences==null){
//    //			this.sentences = new ArrayList<Sentence>();
//    //		}
//    //		this.sentences.addAll(sentences);
//    //	}
//    public int getId() {
//        return id;
//    }
//
//    public void setId(int id) {
//        this.id = id;
//    }
//
//    public List<Sentence> getSentences() {
//        return sentences;
//    }
//
//    public void setSentences(List<Sentence> sentences) {
//        this.sentences = sentences;
//    }
//
//    public int getTotalWords() {
//        return totalWords;
//    }
//
//    public void setTotalWords(int totalWords) {
//        this.totalWords = totalWords;
//    }
//
//    public Map<String, Integer> getTermsFrequencyMap() {
//        return termsFrequencyMap;
//    }
//
//    public void setTermsFrequencyMap(Map<String, Integer> termsFrequencyMap) {
//        this.termsFrequencyMap = termsFrequencyMap;
//    }
//
//    public String getBody() {
//        return body;
//    }
//
//    public void setBody(String body) {
//        this.body = body;
//    }
//
//}


text:
<!DOCTYPE html>

  <link rel="stylesheet" type="text/css" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css" />
  <link href='https://fonts.googleapis.com/css?family=Lato:400,100,700,400italic' rel='stylesheet' type='text/css'>
  <meta charset="UTF-8">
  <title>Transcend</title>


text:
""" Tokenization classes for PhoBERT"""

import os
import re
from shutil import copyfile
from typing import List, Optional, Tuple

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging

logger = logging.get_logger(__name__)

VOCAB_FILES_NAMES = {
    "vocab_file": "vocab.txt",
    "merges_file": "bpe.codes",
}

PRETRAINED_VOCAB_FILES_MAP = {
    "vocab_file": {
        "vinai/phobert-base": "https://huggingface.co/vinai/phobert-base/resolve/main/vocab.txt",
        "vinai/phobert-large": "https://huggingface.co/vinai/phobert-large/resolve/main/vocab.txt",
    },
    "merges_file": {
        "vinai/phobert-base": "https://huggingface.co/vinai/phobert-base/resolve/main/bpe.codes",
        "vinai/phobert-large": "https://huggingface.co/vinai/phobert-large/resolve/main/bpe.codes",
    },
}

PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES = {
    "vinai/phobert-base": 256,
    "vinai/phobert-large": 256,
}

def get_pairs(word):
    """
    Return set of symbol pairs in a word.

    Word is represented as tuple of symbols (symbols being variable-length strings).
    """
    pairs = set()
    prev_char = word[0]
    for char in word[1:]:
        pairs.add((prev_char, char))
        prev_char = char

    pairs = set(pairs)
    return pairs

class PhobertTokenizer(PreTrainedTokenizer):
    """
    Construct a PhoBERT tokenizer. Based on Byte-Pair-Encoding.

    This tokenizer inherits from [`PreTrainedTokenizer`] which contains most of the main methods. Users should refer to
    this superclass for more information regarding those methods.

    Args:
        vocab_file (`str`):
            Path to the vocabulary file.
        merges_file (`str`):
            Path to the merges file.
        bos_token (`st`, *optional*, defaults to `"<s>"`):
            The beginning of sequence token that was used during pretraining. Can be used a sequence classifier token.

            <Tip>

            When building a sequence using special tokens, this is not the token that is used for the beginning of
            sequence. The token used is the `cls_token`.

            </Tip>

        eos_token (`str`, *optional*, defaults to `"</s>"`):
            The end of sequence token.

            <Tip>

            When building a sequence using special tokens, this is not the token that is used for the end of sequence.
            The token used is the `sep_token`.

            </Tip>

        sep_token (`str`, *optional*, defaults to `"</s>"`):
            The separator token, which is used when building a sequence from multiple sequences, e.g. two sequences for
            sequence classification or for a text and a question for question answering. It is also used as the last
            token of a sequence built with special tokens.
        cls_token (`str`, *optional*, defaults to `"<s>"`):
            The classifier token which is used when doing sequence classification (classification of the whole sequence
            instead of per-token classification). It is the first token of the sequence when built with special tokens.
        unk_token (`str`, *optional*, defaults to `"<unk>"`):
            The unknown token. A token that is not in the vocabulary cannot be converted to an ID and is set to be this
            token instead.
        pad_token (`str`, *optional*, defaults to `"<pad>"`):
            The token used for padding, for example when batching sequences of different lengths.
        mask_token (`str`, *optional*, defaults to `"<mask>"`):
            The token used for masking values. This is the token used when training this model with masked language
            modeling. This is the token which the model will try to predict.
    """

    vocab_files_names = VOCAB_FILES_NAMES
    pretrained_vocab_files_map = PRETRAINED_VOCAB_FILES_MAP
    max_model_input_sizes = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES

    def __init__(
        self,
        vocab_file,
        merges_file,
        bos_token="<s>",
        eos_token="</s>",
        sep_token="</s>",
        cls_token="<s>",
        unk_token="<unk>",
        pad_token="<pad>",
        mask_token="<mask>",
        **kwargs
    ):
        super().__init__(
            bos_token=bos_token,
            eos_token=eos_token,
            unk_token=unk_token,
            sep_token=sep_token,
            cls_token=cls_token,
            pad_token=pad_token,
            mask_token=mask_token,
            **kwargs,
        )

        self.vocab_file = vocab_file
        self.merges_file = merges_file

        self.encoder = {}
        self.encoder[self.bos_token] = 0
        self.encoder[self.pad_token] = 1
        self.encoder[self.eos_token] = 2
        self.encoder[self.unk_token] = 3

        self.add_from_file(vocab_file)

        self.decoder = {v: k for k, v in self.encoder.items()}

        with open(merges_file, encoding="utf-8") as merges_handle:
            merges = merges_handle.read().split("\n")[:-1]
        merges = [tuple(merge.split()[:-1]) for merge in merges]
        self.bpe_ranks = dict(zip(merges, range(len(merges))))
        self.cache = {}

    def build_inputs_with_special_tokens(
        self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None
    ) -> List[int]:
        """
        Build model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and
        adding special tokens. A PhoBERT sequence has the following format:

        - single sequence: `<s> X </s>`
        - pair of sequences: `<s> A </s></s> B </s>`

        Args:
            token_ids_0 (`List[int]`):
                List of IDs to which the special tokens will be added.
            token_ids_1 (`List[int]`, *optional*):
                Optional second list of IDs for sequence pairs.

        Returns:
            `List[int]`: List of [input IDs](../glossary#input-ids) with the appropriate special tokens.
        """

        if token_ids_1 is None:
            return [self.cls_token_id] + token_ids_0 + [self.sep_token_id]
        cls = [self.cls_token_id]
        sep = [self.sep_token_id]
        return cls + token_ids_0 + sep + sep + token_ids_1 + sep

    def get_special_tokens_mask(
        self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None, already_has_special_tokens: bool = False
    ) -> List[int]:
        """
        Retrieve sequence ids from a token list that has no special tokens added. This method is called when adding
        special tokens using the tokenizer `prepare_for_model` method.

        Args:
            token_ids_0 (`List[int]`):
                List of IDs.
            token_ids_1 (`List[int]`, *optional*):
                Optional second list of IDs for sequence pairs.
            already_has_special_tokens (`bool`, *optional*, defaults to `False`):
                Whether or not the token list is already formatted with special tokens for the model.

        Returns:
            `List[int]`: A list of integers in the range [0, 1]: 1 for a special token, 0 for a sequence token.
        """

        if already_has_special_tokens:
            return super().get_special_tokens_mask(
                token_ids_0=token_ids_0, token_ids_1=token_ids_1, already_has_special_tokens=True
            )

        if token_ids_1 is None:
            return [1] + ([0] * len(token_ids_0)) + [1]
        return [1] + ([0] * len(token_ids_0)) + [1, 1] + ([0] * len(token_ids_1)) + [1]

    def create_token_type_ids_from_sequences(
        self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None
    ) -> List[int]:
        """
        Create a mask from the two sequences passed to be used in a sequence-pair classification task. PhoBERT does not
        make use of token type ids, therefore a list of zeros is returned.

        Args:
            token_ids_0 (`List[int]`):
                List of IDs.
            token_ids_1 (`List[int]`, *optional*):
                Optional second list of IDs for sequence pairs.

        Returns:
            `List[int]`: List of zeros.
        """

        sep = [self.sep_token_id]
        cls = [self.cls_token_id]

        if token_ids_1 is None:
            return len(cls + token_ids_0 + sep) * [0]
        return len(cls + token_ids_0 + sep + sep + token_ids_1 + sep) * [0]

    @property
    def vocab_size(self):
        return len(self.encoder)

    def get_vocab(self):
        return dict(self.encoder, **self.added_tokens_encoder)

    def bpe(self, token):
        if token in self.cache:
            return self.cache[token]
        word = tuple(token)
        word = tuple(list(word[:-1]) + [word[-1] + "</w>"])
        pairs = get_pairs(word)

        if not pairs:
            return token

        while True:
            bigram = min(pairs, key=lambda pair: self.bpe_ranks.get(pair, float("inf")))
            if bigram not in self.bpe_ranks:
                break
            first, second = bigram
            new_word = []
            i = 0
            while i < len(word):
                try:
                    j = word.index(first, i)
                except ValueError:
                    new_word.extend(word[i:])
                    break
                else:
                    new_word.extend(word[i:j])
                    i = j

                if word[i] == first and i < len(word) - 1 and word[i + 1] == second:
                    new_word.append(first + second)
                    i += 2
                else:
                    new_word.append(word[i])
                    i += 1
            new_word = tuple(new_word)
            word = new_word
            if len(word) == 1:
                break
            else:
                pairs = get_pairs(word)
        word = "@@ ".join(word)
        word = word[:-4]
        self.cache[token] = word
        return word

    def _tokenize(self, text):
        """Tokenize a string."""
        split_tokens = []

        words = re.findall(r"\S+\n?", text)

        for token in words:
            split_tokens.extend([t for t in self.bpe(token).split(" ")])
        return split_tokens

    def _convert_token_to_id(self, token):
        """Converts a token (str) in an id using the vocab."""
        return self.encoder.get(token, self.encoder.get(self.unk_token))

    def _convert_id_to_token(self, index):
        """Converts an index (integer) in a token (str) using the vocab."""
        return self.decoder.get(index, self.unk_token)

    def convert_tokens_to_string(self, tokens):
        """Converts a sequence of tokens (string) in a single string."""
        out_string = " ".join(tokens).replace("@@ ", "").strip()
        return out_string

    def save_vocabulary(self, save_directory: str, filename_prefix: Optional[str] = None) -> Tuple[str]:
        if not os.path.isdir(save_directory):
            logger.error(f"Vocabulary path ({save_directory}) should be a directory")
            return
        out_vocab_file = os.path.join(
            save_directory, (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]
        )
        out_merge_file = os.path.join(
            save_directory, (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["merges_file"]
        )

        if os.path.abspath(self.vocab_file) != os.path.abspath(out_vocab_file):
            copyfile(self.vocab_file, out_vocab_file)

        if os.path.abspath(self.merges_file) != os.path.abspath(out_merge_file):
            copyfile(self.merges_file, out_merge_file)

        return out_vocab_file, out_merge_file

    # def decode(self, token_ids, skip_special_tokens=False, clean_up_tokenization_spaces=True):
    #     filtered_tokens = ' '.join(self.convert_ids_to_tokens(token_ids, skip_special_tokens=skip_special_tokens))
    #     tokens_generated_so_far = re.sub('(@@ )', '', string=filtered_tokens)
    #     tokens_generated_so_far = re.sub('(@@ ?$)', '', string=tokens_generated_so_far)
    #     return ''.join(tokens_generated_so_far)

    def add_from_file(self, f):
        """
        Loads a pre-existing dictionary from a text file and adds its symbols to this instance.
        """
        if isinstance(f, str):
            try:
                with open(f, "r", encoding="utf-8") as fd:
                    self.add_from_file(fd)
            except FileNotFoundError as fnfe:
                raise fnfe
            except UnicodeError:
                raise Exception(f"Incorrect encoding detected in {f}, please rebuild the dataset")
            return

        lines = f.readlines()
        for lineTmp in lines:
            line = lineTmp.strip()
            idx = line.rfind(" ")
            if idx == -1:
                raise ValueError("Incorrect dictionary format, expected '<token> <cnt>'")
            word = line[:idx]
            self.encoder[word] = len(self.encoder)


text:
"use strict";

import { EventEmitter } from 'events';

export default class AnotherExample extends EventEmitter {
  constructor(firstArg, secondArg) {
    super()
    this._alive = true
    this._firstArg = firstArg || "octopus"
    this._secondArg = secondArg || "elephant"
  }
  get alive() {
    return this._alive;
  }
  get firstArg() {
    return this._firstArg;
  }
  get secondArg() {
    return this._secondArg;
  }
}


text:
require 'rubygems'
require 'test/unit'
require 'rack/test'

$LOAD_PATH.unshift(File.dirname(__FILE__))
$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
require 'hello_rubyconf'

class Test::Unit::TestCase
  include Rack::Test::Methods

  def app
    Sinatra::Application
  end

end


text:
'use strict';

const models = require('./index');

/**
 * Intent Classifier.
 *
 * @extends models['ModelInfo']
 */
class IntentClassifier extends models['ModelInfo'] {
  /**
   * Create a IntentClassifier.
   * @property {string} [customPrebuiltDomainName] The domain name.
   * @property {string} [customPrebuiltModelName] The intent name or entity
   * name.
   */
  constructor() {
    super();
  }

  /**
   * Defines the metadata of IntentClassifier
   *
   * @returns {object} metadata of IntentClassifier
   *
   */
  mapper() {
    return {
      required: false,
      serializedName: 'Intent Classifier',
      type: {
        name: 'Composite',
        className: 'IntentClassifier',
        modelProperties: {
          id: {
            required: true,
            serializedName: 'id',
            type: {
              name: 'String'
            }
          },
          name: {
            required: false,
            serializedName: 'name',
            type: {
              name: 'String'
            }
          },
          typeId: {
            required: false,
            serializedName: 'typeId',
            type: {
              name: 'Number'
            }
          },
          readableType: {
            required: true,
            serializedName: 'readableType',
            type: {
              name: 'String'
            }
          },
          customPrebuiltDomainName: {
            required: false,
            serializedName: 'customPrebuiltDomainName',
            type: {
              name: 'String'
            }
          },
          customPrebuiltModelName: {
            required: false,
            serializedName: 'customPrebuiltModelName',
            type: {
              name: 'String'
            }
          }
        }
      }
    };
  }
}

module.exports = IntentClassifier;


text:
// Copyright 2020 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef IOS_CHROME_BROWSER_INFOBARS_OVERLAYS_INFOBAR_MODAL_COMPLETION_NOTIFIER_H_
#define IOS_CHROME_BROWSER_INFOBARS_OVERLAYS_INFOBAR_MODAL_COMPLETION_NOTIFIER_H_

#include <map>

#include "base/memory/weak_ptr.h"
#include "base/observer_list.h"
#include "base/observer_list_types.h"
#include "ios/chrome/browser/overlays/public/overlay_request_callback_installer.h"

class InfoBarIOS;
class OverlayRequestQueueCallbackInstaller;
namespace web {
class WebState;
}

// Helper object that notifies observers when all modal OverlayRequests for an
// infobar have been completed.
class InfobarModalCompletionNotifier {
 public:
  // Observer class to notify objects of when the modal requests for an infobar
  // have been completed.
  class Observer : public base::CheckedObserver {
   public:
    Observer() = default;
    ~Observer() override = default;

    // Called to notify observers of |notifier| that the modal requests for
    // |infobar| have completed.  Banners should remain visible until all
    // requests for modal UI originating from the banner's infobar is completed.
    virtual void InfobarModalsCompleted(
        InfobarModalCompletionNotifier* notifier,
        InfoBarIOS* infobar) {}

    // Called when |notifier| is being destroyed.
    virtual void InfobarModalCompletionNotifierDestroyed(
        InfobarModalCompletionNotifier* notifier) {}
  };

  // Constructs a notifier that observes the completion of modal requests in
  // |web_state|'s queue.
  explicit InfobarModalCompletionNotifier(web::WebState* web_state);
  ~InfobarModalCompletionNotifier();

  // Adds and removes observers of the cancellation dependency state.
  void AddObserver(Observer* observer);
  void RemoveObserver(Observer* observer);

 private:
  // Helper object that observes presentation of infobar overlay UI to detect
  // the dismissal of modals.
  class ModalCompletionInstaller : public OverlayRequestCallbackInstaller {
   public:
    explicit ModalCompletionInstaller(InfobarModalCompletionNotifier* notifier);
    ~ModalCompletionInstaller() override;

   private:
    // Used as a completion callback for the modal OverlayRequests for
    // |infobar|.
    void ModalCompleted(InfoBarIOS* infobar, OverlayResponse* response);

    // OverlayRequestCallbackInstaller:
    const OverlayRequestSupport* GetRequestSupport() const override;
    void InstallCallbacksInternal(OverlayRequest* request) override;

    // The owning notifier.
    InfobarModalCompletionNotifier* notifier_ = nullptr;
    base::WeakPtrFactory<ModalCompletionInstaller> weak_factory_;
  };

  // Called when a completion callback for a modal request for |infobar| has
  // been installed.
  void ModalCompletionInstalled(InfoBarIOS* infobar);

  // Called when a modal request for |infobar| has been completed.
  void ModalRequestCompleted(InfoBarIOS* infobar);

  // Map storing the number of active modal OverlayRequests for a given
  // InfoBarIOS.
  std::map<InfoBarIOS*, size_t> active_modal_request_counts_;
  // The queue callback installer that adds completion callbacks to infobar
  // modal requests.
  std::unique_ptr<OverlayRequestQueueCallbackInstaller> callback_installer_;
  base::ObserverList<Observer, /*check_empty=*/true> observers_;
};

#endif  // IOS_CHROME_BROWSER_INFOBARS_OVERLAYS_INFOBAR_MODAL_COMPLETION_NOTIFIER_H_


text:
@interface CReflectionView : UIView
@property (readwrite, nonatomic, strong) UIImage *image;
@end


text:
from boundary import MetricModify

class MetricUpdate(MetricModify):

    def __init__(self):
        """
        """
        MetricModify.__init__(self, True)
        self.method = "PUT"
        self.description = "Updates a metric definition in an Boundary account"

    def get_description(self):
        """
        """
        return 'Updates a metric definition in an {0} account'.format(self.product_name)


text:
using System;
using System.Collections.Generic;
using System.Data;
using OpenTNF.Library;

namespace OpenTNF.Library.Model
{
    public interface ITnfChange
    {
        string Oid { get; }
        string ClassId { get; }
        string ChangeTransactionOid { get; }
        int OrderNumber { get; }
        int ChangeType { get; }
        string ChangeReason { get; }
        DateTime Timestamp { get; }
        string OldVid { get; }
        string NewVid { get; }
        string CreatorId { get; }
        string Remark { get; }
    }

    public static class TnfClassId
    {
        public const string LINK_SEQUENCE = "LINK_SEQUENCE";
        public const string NODE = "NODE";
        public const string PROPERTY_OBJECT = "PROPERTY_OBJECT";
            //PROPERTY_OBJECT CATALOGUE_OID PROPERTY_OBJECT_TYPE_OID Example: "PROPERTY_OBJECT/ABC123/12345", where "ABC123" is the CATALOGUE_OID and "12345" is the OID of the transport property object type
    }

    public static class TnfChangeType
    {
        public const int Comment = 0;
        public const int Add = 1;
        public const int Modify = 2;
        public const int Delete = 3;
    }

    public class TnfChange : ITnfChange
    {
        public string Oid { get; set; }
        public string ClassId { get; set; }
        public string ChangeTransactionOid { get; set; }
        public int OrderNumber { get; set; }
        public int ChangeType { get; set; }
        public string ChangeReason { get; set; }
        public DateTime Timestamp { get; set; }
        public string OldVid { get; set; }
        public string NewVid { get; set; }
        public string CreatorId { get; set; }
        public string Remark { get; set; }

        public override bool Equals(object obj)
        {
            if (obj is TnfChange)
            {
                var v = obj as TnfChange;

                if (Oid == v.Oid &&
                    ClassId == v.ClassId &&
                    ChangeTransactionOid == v.ChangeTransactionOid &&
                    OrderNumber == v.OrderNumber &&
                    ChangeType == v.ChangeType &&
                    ChangeReason == v.ChangeReason &&
                    Timestamp == v.Timestamp &&
                    OldVid == v.OldVid &&
                    NewVid == v.NewVid &&
                    CreatorId == v.CreatorId &&
                    Remark == v.Remark)
                {
                    return true;
                }
            }

            return false;
        }

        public override int GetHashCode()
        {
            return Hashing.RsHash(
                Oid,
                ClassId,
                ChangeTransactionOid,
                OrderNumber,
                ChangeType,
                ChangeReason,
                Timestamp,
                OldVid,
                NewVid,
                CreatorId,
                Remark);
        }

        public override string ToString()
        {
            return String.Format("TnfChange: Oid = {0}, ClassId = {1}, ChangeTransactionOid = {2}, OrderNumber = {3}, " +
                                 "ChangeType = {4}, ChangeReason = {5}, Timestamp = {6}, OldVid = {7}, NewVid = {8}, " +
                                 "CreatorId = {9}, Remark = {10}",
                Oid,
                ClassId,
                ChangeTransactionOid,
                OrderNumber,
                ChangeType,
                ChangeReason,
                Timestamp,
                OldVid,
                NewVid,
                CreatorId,
                Remark);
        }
    }

    public class TnfChangeManager : TableManager
    {
        private static readonly string[] m_primaryKey = new string[] {"change_transaction_oid", "order_number"};
        public static string TnfChangeTableName = "tnf_change";

        public TnfChangeManager(GeoPackageDatabase db) : base(db, TnfChangeTableName, GetColumnInfos(), string.Join(",", m_primaryKey) )
        {
        }

        protected override string[] Constraints()
        {
            return new[]
                {
                    String.Format("CONSTRAINT fk_tc_cto FOREIGN KEY (change_transaction_oid) REFERENCES {0}(oid)", TnfChangeTransactionManager.TnfChangeTransactionTableName)
                };
        }

        private static ColumnInfo[] GetColumnInfos()
        {
            return new[]
            {
                new ColumnInfo
                {
                    Name = "oid",
                    SqlType = "TEXT NOT NULL",
                    DataType = Type.GetType("System.String")
                },
                new ColumnInfo
                {
                    Name = "class_id",
                    SqlType = "TEXT NOT NULL",
                    DataType = Type.GetType("System.String")
                },
                new ColumnInfo
                {
                    Name = "change_transaction_oid",
                    SqlType = "TEXT NOT NULL",
                    DataType = Type.GetType("System.String")
                },
                new ColumnInfo
                {
                    Name = "order_number",
                    SqlType = "INTEGER NOT NULL",
                    DataType = Type.GetType("System.Int32")
                },
                new ColumnInfo
                {
                    Name = "change_type",
                    SqlType = "INTEGER NOT NULL",
                    DataType = Type.GetType("System.Int32")
                },
                new ColumnInfo
                {
                    Name = "change_reason",
                    SqlType = "TEXT NOT NULL",
                    DataType = Type.GetType("System.String")
                },
                new ColumnInfo
                {
                    Name = "timestamp",
                    SqlType = "DATETIME NOT NULL",
                    DataType = Type.GetType("System.DateTime")
                },
                new ColumnInfo
                {
                    Name = "old_vid",
                    SqlType = "TEXT",
                    DataType = Type.GetType("System.String")
                },
                new ColumnInfo
                {
                    Name = "new_vid",
                    SqlType = "TEXT",
                    DataType = Type.GetType("System.String")
                },
                new ColumnInfo
                {
                    Name = "creator_id",
                    SqlType = "TEXT",
                    DataType = Type.GetType("System.String")
                },
                new ColumnInfo
                {
                    Name = "remark",
                    SqlType = "TEXT",
                    DataType = Type.GetType("System.String")
                }
            };
        }

        public void Add(TnfChange tnfChange)
        {
            Add(new object[]
                {
                    tnfChange.Oid,
                    tnfChange.ClassId,
                    tnfChange.ChangeTransactionOid,
                    tnfChange.OrderNumber,
                    tnfChange.ChangeType,
                    tnfChange.ChangeReason,
                    tnfChange.Timestamp.ToUniversalTime(),
                    tnfChange.OldVid,
                    tnfChange.NewVid,
                    tnfChange.CreatorId,
                    tnfChange.Remark
                });
        }

        public List<TnfChange> Get(int maxResults)
        {

            return Get(ReadObject, maxResults);
        }

        public List<TnfChange> GetPage(int offset, int limit)
        {
            return GetPage(ReadObject, offset, limit);
        }

        public int Update(TnfChange tnfChange)
        {
            return Update(new object[]
                {
                    tnfChange.Oid,
                    tnfChange.ClassId,
                    tnfChange.ChangeTransactionOid,
                    tnfChange.OrderNumber,
                    tnfChange.ChangeType,
                    tnfChange.ChangeReason,
                    tnfChange.Timestamp.ToUniversalTime(),
                    tnfChange.OldVid,
                    tnfChange.NewVid,
                    tnfChange.CreatorId,
                    tnfChange.Remark
                });
        }

        /// <summary>
        /// Delete:s a tnfChange
        /// </summary>
        /// <param name="tnfChange"></param>
        /// <returns></returns>
        public int Delete(TnfChange tnfChange)
        {
            if (m_primaryKey[0] != "change_transaction_oid" || m_primaryKey[1] != "order_number")
            {
                throw new ApplicationException("Delete method expects primary key to be change_transaction_oid,order_number");
            }
            return Delete(new object[]
                {
                    tnfChange.ChangeTransactionOid,
                    tnfChange.OrderNumber,
                });
        }

        private static TnfChange ReadObject(IDataRecord reader)
        {
            var tnfChange = new TnfChange();

            tnfChange.Oid = reader["oid"].FromDbString();
            tnfChange.ClassId = reader["class_id"].FromDbString();
            tnfChange.ChangeTransactionOid = reader["change_transaction_oid"].FromDbString();
            tnfChange.OrderNumber = (Int32)reader["order_number"].ToInt32();
            tnfChange.ChangeType = (Int32)reader["change_type"].ToInt32();
            tnfChange.ChangeReason = reader["change_reason"].FromDbString();
            tnfChange.Timestamp = (DateTime)reader["timestamp"].ToDateTime();
            tnfChange.OldVid = reader["old_vid"].FromDbString();
            tnfChange.NewVid = reader["new_vid"].FromDbString();
            tnfChange.CreatorId = reader["creator_id"].FromDbString();
            tnfChange.Remark = reader["remark"].FromDbString();

            return tnfChange;
        }
    }
}


text:
## ./tour

An interactive guide that familiarizes you with Vantage.

```bash
$ npm install -g vantage
$ vantage tour
```

## ./server

Sets up a basic standalone Vantage server, making use of all of its main commands.

## ./koa

Sets up a Vantage that hooks into Koa.js.

## ./express

Sets up a Vantage that hooks into Express.js.

## ./extensions-usage

Imports the Vantage extension `vantage-repl` and uses this to create an interactive REPL for your app.

## ./extensions-creation

Template for creating your own Node module to extend Vantage's API.

## ./automation

Executes Vantage commands programmatically.

## ./firewall

Sets up a firewall for Vantage.


text:
package cz.brmlab.brmson.blanqa.analysis;

import java.util.LinkedList;
import java.util.List;

import org.oaqa.model.SearchResult;

import cz.brmlab.brmson.blanqa.framework.data.Sentence;
import cz.brmlab.brmson.core.provider.opennlp.OpenNLPWrapper;

/**
 * Split text to a series of sentences.
 */

public class SentenceSplitter {
	private static final int MIN_SENTENCE_LENGTH = 3;
	private static final int MAX_SENTENCE_LENGTH = 512;

	/**
	 * Split a given result with a given text (may be preprocessed)
	 * to a list of contextualized sentences.
	 */
	public static List<Sentence> split(SearchResult srcResult, String srcText) {
		String[] sentenceTexts = OpenNLPWrapper.sentDetect(srcText);

		LinkedList<Sentence> sentences = new LinkedList<Sentence>();
		for (String text : sentenceTexts) {
			if (text.length() <= MIN_SENTENCE_LENGTH)
				continue;
			if (text.length() > MAX_SENTENCE_LENGTH) {
				System.err.println("Omitting extremely long sentence: " + text.substring(0, 64) + " ...");
				continue;
			}
			Sentence s = new Sentence(srcResult, text);
			if (sentences.size() > 0) {
				s.setPrev(sentences.getLast());
				sentences.getLast().setNext(s);
			}
			sentences.add(s);
		}

		return sentences;
	}

	public static String join(List<Sentence> sentences) {
		StringBuilder sb = new StringBuilder();
		for (Sentence s : sentences) {
			sb.append(s.getText());
			sb.append(". ");
		}
		return sb.toString();
	}

	public static void initialize() throws Exception {
		OpenNLPWrapper.initialize();
	}
}


text:
from .tracked_resource import TrackedResource

class Server(TrackedResource):
    """Represents a server.

    Variables are only populated by the server, and will be ignored when
    sending a request.

    All required parameters must be populated in order to send to Azure.

    :ivar id: Resource ID
    :vartype id: str
    :ivar name: Resource name.
    :vartype name: str
    :ivar type: Resource type.
    :vartype type: str
    :param location: Required. The location the resource resides in.
    :type location: str
    :param tags: Application-specific metadata in the form of key-value pairs.
    :type tags: dict[str, str]
    :param sku: The SKU (pricing tier) of the server.
    :type sku: ~azure.mgmt.rdbms.postgresql.models.Sku
    :param administrator_login: The administrator's login name of a server.
     Can only be specified when the server is being created (and is required
     for creation).
    :type administrator_login: str
    :param version: Server version. Possible values include: '9.5', '9.6'
    :type version: str or ~azure.mgmt.rdbms.postgresql.models.ServerVersion
    :param ssl_enforcement: Enable ssl enforcement or not when connect to
     server. Possible values include: 'Enabled', 'Disabled'
    :type ssl_enforcement: str or
     ~azure.mgmt.rdbms.postgresql.models.SslEnforcementEnum
    :param user_visible_state: A state of a server that is visible to user.
     Possible values include: 'Ready', 'Dropping', 'Disabled'
    :type user_visible_state: str or
     ~azure.mgmt.rdbms.postgresql.models.ServerState
    :param fully_qualified_domain_name: The fully qualified domain name of a
     server.
    :type fully_qualified_domain_name: str
    :param earliest_restore_date: Earliest restore point creation time
     (ISO8601 format)
    :type earliest_restore_date: datetime
    :param storage_profile: Storage profile of a server.
    :type storage_profile: ~azure.mgmt.rdbms.postgresql.models.StorageProfile
    """

    _validation = {
        'id': {'readonly': True},
        'name': {'readonly': True},
        'type': {'readonly': True},
        'location': {'required': True},
    }

    _attribute_map = {
        'id': {'key': 'id', 'type': 'str'},
        'name': {'key': 'name', 'type': 'str'},
        'type': {'key': 'type', 'type': 'str'},
        'location': {'key': 'location', 'type': 'str'},
        'tags': {'key': 'tags', 'type': '{str}'},
        'sku': {'key': 'sku', 'type': 'Sku'},
        'administrator_login': {'key': 'properties.administratorLogin', 'type': 'str'},
        'version': {'key': 'properties.version', 'type': 'str'},
        'ssl_enforcement': {'key': 'properties.sslEnforcement', 'type': 'SslEnforcementEnum'},
        'user_visible_state': {'key': 'properties.userVisibleState', 'type': 'str'},
        'fully_qualified_domain_name': {'key': 'properties.fullyQualifiedDomainName', 'type': 'str'},
        'earliest_restore_date': {'key': 'properties.earliestRestoreDate', 'type': 'iso-8601'},
        'storage_profile': {'key': 'properties.storageProfile', 'type': 'StorageProfile'},
    }

    def __init__(self, *, location: str, tags=None, sku=None, administrator_login: str=None, version=None, ssl_enforcement=None, user_visible_state=None, fully_qualified_domain_name: str=None, earliest_restore_date=None, storage_profile=None, **kwargs) -> None:
        super(Server, self).__init__(location=location, tags=tags, **kwargs)
        self.sku = sku
        self.administrator_login = administrator_login
        self.version = version
        self.ssl_enforcement = ssl_enforcement
        self.user_visible_state = user_visible_state
        self.fully_qualified_domain_name = fully_qualified_domain_name
        self.earliest_restore_date = earliest_restore_date
        self.storage_profile = storage_profile


text:
bool ReadRecord(const std::string& path, std::shared_ptr<Disk>& disk);
bool WriteRecord(const std::string& path, std::shared_ptr<Disk>& disk);
bool ReadRecord(HDD& hdd, int record, std::shared_ptr<Disk>& disk);
bool WriteRecord(HDD& hdd, int record, std::shared_ptr<Disk>& disk, bool format = false);

bool UnwrapCPM(std::shared_ptr<Disk>& cpm_disk, std::shared_ptr<Disk>& disk);
bool WrapCPM(std::shared_ptr<Disk>& disk, std::shared_ptr<Disk>& cpm_disk);


text:
package com.jmb.springfactory.model.factory.rol;

public final class RolSamples {

  private RolSamples() {}

  public static final Integer ID_ROL_TEST_1 = 1;
  public static final String NAME_ROL_TEST_1 = "Admin";

  public static final Integer ID_ROL_TEST_2 = 2;
  public static final String NAME_ROL_TEST_2 = "Operator";

  public static final Integer ID_ROL_TEST_3 = 3;
  public static final String NAME_ROL_TEST_3 = "Engineer";
}


text:
class ApacheSparkNoHadoopAT20 < Formula
  desc "Engine for large-scale data processing"
  homepage "https://spark.apache.org/"
  url "https://d3kbcqa49mib13.cloudfront.net/spark-2.0.2-bin-without-hadoop.tgz"
  version "2.0.2"
  sha256 "122ec1af0fcb23c0345f20f77d33cf378422ffe966efe4b9ef90e55cf7a46a3c"

  bottle :unneeded

  def install
    # Rename beeline to distinguish it from hive's beeline
    mv "bin/beeline", "bin/spark-beeline"

    rm_f Dir["bin/*.cmd"]
    libexec.install Dir["*"]
    bin.write_exec_script Dir["#{libexec}/bin/*"]
  end

  test do
    assert_match "Long = 1000", pipe_output(bin/"spark-shell", "sc.parallelize(1 to 1000).count()")
  end
end


text:
<?php

/* @Framework/Form/money_widget.html.php */
class __TwigTemplate_b81b828a4906751696e110febaf57c2bebb19145bae8107a1e78b8f977bce009 extends Twig_Template
{
    public function __construct(Twig_Environment $env)
    {
        parent::__construct($env);

        $this->parent = false;

        $this->blocks = array(
        );
    }

    protected function doDisplay(array $context, array $blocks = array())
    {
        // line 1
        echo "<?php echo str_replace('";
        echo twig_escape_filter($this->env, (isset($context["widget"]) ? $context["widget"] : null), "html", null, true);
        echo "', \$view['form']->block(\$form, 'form_widget_simple'), \$money_pattern) ?>
";
    }

    public function getTemplateName()
    {
        return "@Framework/Form/money_widget.html.php";
    }

    public function isTraitable()
    {
        return false;
    }

    public function getDebugInfo()
    {
        return array (  19 => 1,);
    }
}
/* <?php echo str_replace('{{ widget }}', $view['form']->block($form, 'form_widget_simple'), $money_pattern) ?>*/
/* */


text:
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package sen.semantico.api.literal;

import sen.semantico.api.Literal;

/**
 *
 * @author m1s
 */
public interface BooleanLiteral extends Literal<Boolean> {
}