text:
package org.apache.commons.io;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.stream.Collectors;

import org.apache.commons.io.filefilter.FileFilterUtils;
import org.apache.commons.io.filefilter.IOFileFilter;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;

/**
 * Test cases for FileUtils.listFiles() methods.
 */
public class FileUtilsListFilesTest {

    @TempDir
    public File temporaryFolder;

    private Collection<String> filesToFilenames(final Collection<File> files) {
        return files.stream().map(File::getName).collect(Collectors.toList());
    }

    private Collection<String> filesToFilenames(final Iterator<File> files) {
        final Collection<String> fileNames = new ArrayList<>();
        files.forEachRemaining(f -> fileNames.add(f.getName()));
        return fileNames;
    }

    @SuppressWarnings("ResultOfMethodCallIgnored")
    @BeforeEach
    public void setUp() throws Exception {
        File dir = temporaryFolder;
        File file = new File(dir, "dummy-build.xml");
        FileUtils.touch(file);
        file = new File(dir, "README");
        FileUtils.touch(file);

        dir = new File(dir, "subdir1");
        dir.mkdirs();
        file = new File(dir, "dummy-build.xml");
        FileUtils.touch(file);
        file = new File(dir, "dummy-readme.txt");
        FileUtils.touch(file);

        dir = new File(dir, "subsubdir1");
        dir.mkdirs();
        file = new File(dir, "dummy-file.txt");
        FileUtils.touch(file);
        file = new File(dir, "dummy-index.html");
        FileUtils.touch(file);

        dir = dir.getParentFile();
        dir = new File(dir, "CVS");
        dir.mkdirs();
        file = new File(dir, "Entries");
        FileUtils.touch(file);
        file = new File(dir, "Repository");
        FileUtils.touch(file);
    }

    @Test
    public void testIterateFilesByExtension() {
        final String[] extensions = { "xml", "txt" };

        Iterator<File> files = FileUtils.iterateFiles(temporaryFolder, extensions, false);
        Collection<String> filenames = filesToFilenames(files);
        assertEquals(1, filenames.size());
        assertTrue(filenames.contains("dummy-build.xml"));
        assertFalse(filenames.contains("README"));
        assertFalse(filenames.contains("dummy-file.txt"));

        files = FileUtils.iterateFiles(temporaryFolder, extensions, true);
        filenames = filesToFilenames(files);
        assertEquals(4, filenames.size());
        assertTrue(filenames.contains("dummy-file.txt"));
        assertFalse(filenames.contains("dummy-index.html"));

        files = FileUtils.iterateFiles(temporaryFolder, null, false);
        filenames = filesToFilenames(files);
        assertEquals(2, filenames.size());
        assertTrue(filenames.contains("dummy-build.xml"));
        assertTrue(filenames.contains("README"));
        assertFalse(filenames.contains("dummy-file.txt"));
    }

    @Test
    public void testListFiles() {
        Collection<File> files;
        Collection<String> filenames;
        IOFileFilter fileFilter;
        IOFileFilter dirFilter;

        // First, find non-recursively
        fileFilter = FileFilterUtils.trueFileFilter();
        files = FileUtils.listFiles(temporaryFolder, fileFilter, null);
        filenames = filesToFilenames(files);
        assertTrue(filenames.contains("dummy-build.xml"), "'dummy-build.xml' is missing");
        assertFalse(filenames.contains("dummy-index.html"), "'dummy-index.html' shouldn't be found");
        assertFalse(filenames.contains("Entries"), "'Entries' shouldn't be found");

        // Second, find recursively
        fileFilter = FileFilterUtils.trueFileFilter();
        dirFilter = FileFilterUtils.notFileFilter(FileFilterUtils.nameFileFilter("CVS"));
        files = FileUtils.listFiles(temporaryFolder, fileFilter, dirFilter);
        filenames = filesToFilenames(files);
        assertTrue(filenames.contains("dummy-build.xml"), "'dummy-build.xml' is missing");
        assertTrue(filenames.contains("dummy-index.html"), "'dummy-index.html' is missing");
        assertFalse(filenames.contains("Entries"), "'Entries' shouldn't be found");

        // Do the same as above but now with the filter coming from FileFilterUtils
        fileFilter = FileFilterUtils.trueFileFilter();
        dirFilter = FileFilterUtils.makeCVSAware(null);
        files = FileUtils.listFiles(temporaryFolder, fileFilter, dirFilter);
        filenames = filesToFilenames(files);
        assertTrue(filenames.contains("dummy-build.xml"), "'dummy-build.xml' is missing");
        assertTrue(filenames.contains("dummy-index.html"), "'dummy-index.html' is missing");
        assertFalse(filenames.contains("Entries"), "'Entries' shouldn't be found");

        // Again with the CVS filter but now with a non-null parameter
        fileFilter = FileFilterUtils.trueFileFilter();
        dirFilter = FileFilterUtils.prefixFileFilter("sub");
        dirFilter = FileFilterUtils.makeCVSAware(dirFilter);
        files = FileUtils.listFiles(temporaryFolder, fileFilter, dirFilter);
        filenames = filesToFilenames(files);
        assertTrue(filenames.contains("dummy-build.xml"), "'dummy-build.xml' is missing");
        assertTrue(filenames.contains("dummy-index.html"), "'dummy-index.html' is missing");
        assertFalse(filenames.contains("Entries"), "'Entries' shouldn't be found");

        assertThrows(NullPointerException.class, () -> FileUtils.listFiles(temporaryFolder, null, null));
    }

    @Test
    public void testListFilesByExtension() {
        final String[] extensions = {"xml", "txt"};

        Collection<File> files = FileUtils.listFiles(temporaryFolder, extensions, false);
        assertEquals(1, files.size());
        Collection<String> filenames = filesToFilenames(files);
        assertTrue(filenames.contains("dummy-build.xml"));
        assertFalse(filenames.contains("README"));
        assertFalse(filenames.contains("dummy-file.txt"));

        files = FileUtils.listFiles(temporaryFolder, extensions, true);
        filenames = filesToFilenames(files);
        assertEquals(4, filenames.size());
        assertTrue(filenames.contains("dummy-file.txt"));
        assertFalse(filenames.contains("dummy-index.html"));

        files = FileUtils.listFiles(temporaryFolder, null, false);
        assertEquals(2, files.size());
        filenames = filesToFilenames(files);
        assertTrue(filenames.contains("dummy-build.xml"));
        assertTrue(filenames.contains("README"));
        assertFalse(filenames.contains("dummy-file.txt"));
    }

}


text:
(function() {
    'use strict';

    angular.module('myApp', ['ngRoute', 'templates']);
})();

redpajama_set_name: RedPajamaGithub


text:
package org.sakaiproject.profile2.tool.components;

import org.apache.wicket.AttributeModifier;
import org.apache.wicket.Component;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.form.FormComponent;
import org.apache.wicket.model.IModel;
import org.apache.wicket.model.Model;

/**
 * Label displaying feedback messages for FormComponents.
 *

 * You can use this Label to show the error message near the actual FormComponent, instead of in the FeedbackPanel
 * It's safe to remove the FeedbackPanel if you use this class for every FormComponent in your Form.
 *

 * You can use this code under Apache 2.0 license, as long as you retain the copyright messages.
 *
 * Tested with Wicket 1.3.4
 * @author Daan, StuQ.nl
 * @author Steve Swinsburg, s.swinsburg@lancaster.ac.uk
 */
public class FeedbackLabel extends Label {

	private static final long serialVersionUID = 1L;

	/** Field component holds a reference to the {@link Component} this FeedbackLabel belongs to
     * Generally this is a FormComponent like a TextField, but can also be the Form itself.
     * Using the form itself is useful for collecting errors that come from the Form and not from a FormComponent,
     * like upload too large etc. */
    private Component component = null;

    /** Field text holds a model of the text to be shown in the FeedbackLabel */
    private IModel text = null;

    /**
     * Call this constructor if you just want to display the FeedbackMessage of the component
     * @param id The non-null id of this component
     * @param component The {@link FormComponent} to show the FeedbackMessage for.
     */
    public FeedbackLabel(String id, Component component) {
        super(id);
        this.component = component;
    }

    /**
     * Call this constructor if you want to display a custom text
     * @param id The non-null id of this component
     * @param component The {@link FormComponent} to show the custom text for.
     * @param text The custom text to show when the FormComponent has a FeedbackMessage
     */
    public FeedbackLabel(String id, Component component, String text) {
        this(id, component, new Model(text));
    }

    /**
     * Call this constructor if you want to display a custom model (for easy i18n)
     * @param id The non-null id of this component
     * @param component The {@link FormComponent} to show the custom model for.
     * @param iModel The custom model to show when the {@link FormComponent} has a FeedbackMessage
     */
    public FeedbackLabel(String id, Component component, IModel iModel) {
        super(id);
        this.component = component;
        this.text=iModel;
    }

    /**
     * Set the content of this FeedbackLabel, depending on if the component has a FeedbackMessage.
     *
     * The HTML class attribute will be filled with the error level of the feedback message. That way, you can easily
     * style different messages differently. Examples:
     *
     * class = "feedbacklabel INFO"
     * class = "feedbacklabel ERROR"
     * class = "feedbacklabel DEBUG"
     * class = "feedbacklabel FATAL"
     *
     *
     * @see Component
     */
    @Override
    protected void onBeforeRender() {
        super.onBeforeRender();
        this.setDefaultModel(null);

        if(component.getFeedbackMessage()!=null){
            if(this.text!=null){
                this.setDefaultModel(text);
            } else {
                this.setDefaultModel(new Model(component.getFeedbackMessage().getMessage()));
            }

            this.add(new AttributeModifier("class", true, new Model("feedbackLabel " + component.getFeedbackMessage().getLevelAsString())));
        } else {
            this.setDefaultModel(null);
        }

    }
}


text:
class CreateUsers < ActiveRecord::Migration[5.0]
  def change
    create_table :users do |t|
      t.string :name
      t.string :img_url, default:"https://assets.materialup.com/uploads/ff5ed341-b358-4f3a-aa63-d612facf5013/avatar.png"

      t.timestamps
    end
  end
end


text:
<?php

namespace Anax\Login;

/**
 * Model for Login.
 *
 */
class Login extends \Anax\MVC\CDatabaseModel
{

}


text:
package org.eclipse.bpel.ui.wizards;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

import org.eclipse.bpel.common.ui.editmodel.EditModel;
import org.eclipse.bpel.model.partnerlinktype.PartnerLinkType;
import org.eclipse.bpel.model.partnerlinktype.PartnerlinktypeFactory;
import org.eclipse.bpel.model.partnerlinktype.Role;
import org.eclipse.bpel.ui.BPELEditor;
import org.eclipse.bpel.ui.BPELUIPlugin;
import org.eclipse.bpel.ui.IBPELUIConstants;
import org.eclipse.bpel.ui.commands.AddWSDLImportCommand;
import org.eclipse.bpel.ui.commands.CompoundCommand;
import org.eclipse.bpel.ui.commands.CreatePartnerLinkTypeCommand;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceVisitor;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EcorePackage;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.ui.part.FileEditorInput;
import org.eclipse.wst.wsdl.Definition;
import org.eclipse.wst.wsdl.PortType;

/**
 * @author Michal Chmielewski (michal.chmielewski@oracle.com)
 * @date Aug 14, 2006
 *
 */
public class CreatePartnerLinkWizard extends Wizard {

	CreatePartnerLinkTypeWizardNamePage fFirstPage;
	CreatePartnerLinkTypeWizardRolePage fRolePage1;
	CreatePartnerLinkTypeWizardRolePage fRolePage2;
	PortType fMandatoryPortType;
	PartnerLinkType fPartnerLinkType;

	BPELEditor fEditor;

	public CreatePartnerLinkWizard () {
		setNeedsProgressMonitor(true);
		setDialogSettings(BPELUIPlugin.INSTANCE.getDialogSettingsFor(this));
		setHelpAvailable(false);
		setWindowTitle(Messages.CreatePartnerLinkWizard_0);
	}

	public PartnerLinkType getPartnerLinkType () {
		return fPartnerLinkType;
	}

	public void setMandatoryPortType (PortType pt) {
		fMandatoryPortType = pt;
	}

	public void setBPELEditor ( BPELEditor editor ) {
		fEditor = editor;
	}

	@Override
	public void addPages() {
		fFirstPage = new CreatePartnerLinkTypeWizardNamePage("name.page"); //$NON-NLS-1$
		fFirstPage.setTitle(Messages.CreatePartnerLinkWizard_2);
		fFirstPage.setDescription(Messages.CreatePartnerLinkWizard_3);
		fFirstPage.setImageDescriptor(BPELUIPlugin.INSTANCE.getImageDescriptor(
				IBPELUIConstants.ICON_WIZARD_BANNER));
		fFirstPage.setDefinitions ( fEditor.getArtifactsDefinition() );

		fRolePage1 = new CreatePartnerLinkTypeWizardRolePage ("role.1"); //$NON-NLS-1$
		fRolePage1.setTitle(Messages.CreatePartnerLinkWizard_5);
		fRolePage1.setDescription(Messages.CreatePartnerLinkWizard_6);
		fRolePage1.setImageDescriptor(BPELUIPlugin.INSTANCE.getImageDescriptor(
				IBPELUIConstants.ICON_WIZARD_BANNER));
		fRolePage1.setMandatoryDefinition( fMandatoryPortType.getEnclosingDefinition() );

		fRolePage2 = new CreatePartnerLinkTypeWizardRolePage ("role.2"); //$NON-NLS-1$
		fRolePage2.setTitle(Messages.CreatePartnerLinkWizard_8);
		fRolePage2.setDescription(Messages.CreatePartnerLinkWizard_9);
		fRolePage2.setImageDescriptor(BPELUIPlugin.INSTANCE.getImageDescriptor(
				IBPELUIConstants.ICON_WIZARD_BANNER));

		IFile file = EditModel.getIFileForURI(fMandatoryPortType.eResource().getURI());
		if (file==null)
			// Bugzilla 324164
			// if WSDL is not a file (e.g. http://service.com?WSDL) use editor's input file project
			file = ((FileEditorInput)fEditor.getEditorInput()).getFile();

		if (file!=null)
			fRolePage2.setOptionalDefinitions( getOptionalDefinitions(file.getProject()) );
		fRolePage2.setOptional(true);

		fRolePage1.setOtherRolePage ( fRolePage2 );
		fRolePage2.setOtherRolePage ( fRolePage1 );

		addPage(fFirstPage);
		addPage(fRolePage1);
		addPage(fRolePage2);

		fRolePage1.setPreviousPage( fFirstPage );
		fRolePage2.setPreviousPage (fRolePage1);
	}

	private List<Definition> getOptionalDefinitions(IProject project) {
		final List<Definition> wsdlDefinitions = new ArrayList<Definition>();
		final List<IFile> wsdlFiles = new ArrayList<IFile>();
		IResourceVisitor visitor = new IResourceVisitor() {
			public boolean visit(org.eclipse.core.resources.IResource resource) throws org.eclipse.core.runtime.CoreException {
				if (resource.getType() == IResource.FILE && "wsdl".equalsIgnoreCase(resource.getFileExtension())) {

					IFile artifactFile = EditModel.getIFileForURI(fEditor.getArtifactsDefinition().eResource().getURI());
					if (artifactFile==null || !(artifactFile.getFullPath().equals(((IFile)resource).getFullPath()))) {
						//filter artifacts WSDL
						wsdlFiles.add((IFile)resource);
					}
				}
				return true;
			}
		};
		try {
			project.accept(visitor);
		}
		catch (CoreException e) {
			e.printStackTrace();
		}

		for (Iterator<IFile> iterator = wsdlFiles.iterator(); iterator.hasNext();) {
			IFile iFile = iterator.next();
			IPath fullPath = iFile.getFullPath();
			URI uri = URI.createPlatformResourceURI(fullPath.toString(), false);
			Resource wsdlResource = fEditor.getResource().getResourceSet().getResource(uri, true);

			EcorePackage instance = EcorePackage.eINSTANCE;
			instance.eAdapters();

			try {
				wsdlResource.load(Collections.EMPTY_MAP);
				EList<EObject> contents = wsdlResource.getContents();
				if (!contents.isEmpty()) {
					Definition def = (Definition) contents.get(0);
					wsdlDefinitions.add(def);
				}
			} catch (Exception e) {
				e.printStackTrace();
			}

		}

		return wsdlDefinitions;
	}

	/**
	 * Create and return the partner link type that this wizard gathered information
	 * about.
	 *
	 * @return
	 */
	PartnerLinkType createPLT () {

		PartnerLinkType plt = PartnerlinktypeFactory.eINSTANCE.createPartnerLinkType();
		plt.setName( fFirstPage.getPartnerLinkTypeName() );

		// Element doc = plt.getDocumentationElement();
		// doc.setNodeValue("Generated by CreatePartnerLinkWizard");

		Role role1 =  PartnerlinktypeFactory.eINSTANCE.createRole();
		role1.setName ( fRolePage1.getRoleName() );
		role1.setPortType( fRolePage1.getMandatoryPortType() );
		plt.getRole().add(role1);

		if (fRolePage2.isSpecified()) {
			Role role2 = PartnerlinktypeFactory.eINSTANCE.createRole();
			role2.setName ( fRolePage2.getRoleName() );
			role2.setPortType( fRolePage2.getOptionalPortType() );
			plt.getRole().add(role2);
		}
		return plt;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.wizard.Wizard#performFinish()
	 */
	@Override
	public boolean performFinish() {

		fPartnerLinkType = createPLT();

		Definition artifactsDefinition = fEditor.getArtifactsDefinition();

		CompoundCommand cmd = new CompoundCommand();
		// We add the import into the artifacts now, because code relies on diving through
		// WSDL imports to find portTypes etc.

		// 1. Add WSDL import to the artifacts file (again, this is a noop if already exists).
		cmd.add( new AddWSDLImportCommand ( artifactsDefinition, fMandatoryPortType ));

		// 2. Create the new Partner Link Type in the artifacts file.
		cmd.add( new CreatePartnerLinkTypeCommand(artifactsDefinition, fPartnerLinkType) );

		fEditor.getCommandFramework().execute( cmd );

		return true;
	}

	@Override
	public boolean canFinish() {
		return super.canFinish();
	}
}


text:
<!DOCTYPE html>

  <title>iNat Observation Streaks by Date Observed</title>
  <link rel="stylesheet" type="text/css" href="style.css">


text:
To start your Phoenix app:

    $ cd elixir_event_tracker
    $ mix phoenix.server

You can also run your app inside IEx (Interactive Elixir) as:

    $ iex -S mix phoenix.server


text:
package de.jcup.code2doc.generator.docbook;

import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Test;

public class DocbookHTMLMarkupTypeSupportTest {

	@Test
	public void test_linesep_makes_paragraphs(){
		String text  ="Test1
Test2";
		assertEquals("Test1<?linebreak?>Test2", htmlMarkupSupport.handleMarkup(text));
	}

	@Test
	public void test_bold_italic_underline_styles(){
		assertEquals("<emphasis role='bold'>text</emphasis>",htmlMarkupSupport.handleMarkup("text"));
		assertEquals("<emphasis role='italic'>text</emphasis>",htmlMarkupSupport.handleMarkup("text"));
		assertEquals("<emphasis role='underline'>text</emphasis>",htmlMarkupSupport.handleMarkup("text"));
	}

	@Test
	public void test_xml_escaping(){
		assertEquals("<para>somehting</para>",htmlMarkupSupport.handleMarkup("<para>somehting</para>"));
	}

	@Test
	public void test_listitems(){
		assertEquals("<listitem>item</listitem>",htmlMarkupSupport.handleMarkup("
item
"));
	}

	@Test
	public void test_unsorted_list(){
		assertEquals("<itemizedlist mark='opencircle'>x</itemizedlist>",htmlMarkupSupport.handleMarkup("
x
"));
	}

	@Test
	public void test_unsorted_list_with_entries(){
		assertEquals("<itemizedlist mark='opencircle'><listitem>item1</listitem><listitem>item2</listitem></itemizedlist>",htmlMarkupSupport.handleMarkup("

item1

item2

"));
	}

	@Test
	public void test_links_standard(){
		assertEquals("<ulink url='target'>content</ulink>",htmlMarkupSupport.handleMarkup("content"));
	}

	@Test
	public void test_links_internal(){
		/* target must be uppercased automatically - because IDs are always uppercased by transformer!*/
		assertEquals("<link linkend='targetUpper'>content</link>",htmlMarkupSupport.handleMarkup("content"));
	}

	private DocbookHTMLMarkupTypeSupport htmlMarkupSupport;

	@Before
	public void before(){
		htmlMarkupSupport = new DocbookHTMLMarkupTypeSupport();
	}
}


text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta name="description" content="">
    <meta name="author" content="">

    <title>Pretza</title>

    <link href="css/bootstrap.css" rel="stylesheet">
    <link rel="stylesheet" type="text/css" href="landing-page.css">

    <link href="css/agency.css" rel="stylesheet">

    <link href="font-awesome/css/font-awesome.min.css" rel="stylesheet" type="text/css">
    <link href="https://fonts.googleapis.com/css?family=Montserrat:400,700" rel="stylesheet" type="text/css">
    <link href='https://fonts.googleapis.com/css?family=Kaushan+Script' rel='stylesheet' type='text/css'>
    <link href='https://fonts.googleapis.com/css?family=Droid+Serif:400,700,400italic,700italic' rel='stylesheet' type='text/css'>
    <link href='https://fonts.googleapis.com/css?family=Roboto+Slab:400,100,300,700' rel='stylesheet' type='text/css'>

                <button type="button" class="navbar-toggle" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1">
                    Toggle navigation

                </button>
                Pretty

                        Services

                        Portfolio

                        About

                        Team

                        Contact

Welcome To Our Studio!

It's Nice To Meet You

                Tell Me More

                    Copyright © Your Website 2014

Privacy Policy

Terms of Use


text:
using System.Collections.Generic;

namespace Smartling.Api.Model
{
  public class SampleAuditLogBuilder
  {
    public string actionType { get; set; }
    public string envId { get; set; }
    public string fileUri { get; set; }
    public string translationJobUid { get; set; }
    public string translationJobName { get; set; }
    public string translationJobDueDate { get; set; }
    public bool translationJobAutorize { get; set; }
    public string batchUid { get; set; }
    public string sourceLocaleId { get; set; }
    public List<string> targetLocaleIds { get; set; }
    public string description { get; set; }
    public string clientUserId { get; set; }
    public string clientUserEmail { get; set; }
    public string clientUserName { get; set; }
    public SampleAuditLogData clientData { get; set; }

    public SampleAuditLogBuilder(string envId, string actionType, string userId, string itemId, string fileUri, string path)
    {
      clientData = new SampleAuditLogData();
      this.envId = envId;
      this.actionType = actionType;
      this.clientUserId = userId;
      this.clientData.ItemId = itemId;
      this.fileUri = fileUri;
      this.clientData.Path = path;
    }

    public SampleAuditLogBuilder WithJob(string translationJobName, string translationJobUid, string batchUid)
    {
      this.translationJobName = translationJobName;
      this.translationJobUid = translationJobUid;
      this.batchUid = batchUid;
      return this;
    }

    public SampleAuditLogBuilder WithSourceVersion(int sourceVersion)
    {
      this.clientData.SourceVersion = sourceVersion;
      return this;
    }

    public SampleAuditLogBuilder WithTargetVersion(int targetVersion)
    {
      this.clientData.TargetVersion = targetVersion;
      return this;
    }

    public SampleAuditLogBuilder WithSourceLocale(string sourceLocaleId)
    {
      this.sourceLocaleId = sourceLocaleId;
      return this;
    }

    public SampleAuditLogBuilder WithTargetLocale(string targetLocaleId)
    {
      this.targetLocaleIds = new List<string>() { targetLocaleId };
      return this;
    }

    public static implicit operator SampleAuditLog(SampleAuditLogBuilder builder)
    {
      return new SampleAuditLog(builder);
    }
  }
}


text:
<!DOCTYPE HTML>

        <title>iamavailablefor.work - Contact</title>

        <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
        <meta name="keywords" content="iamavailablefor.work is a website for showcasing your skills as a professional." />

        <link rel="icon" href="<?php echo base_url(); ?>static/images/favicon.ico">
        <link rel="stylesheet" href="<?php echo base_url(); ?>static/css/uikit.css" />
        <link rel="stylesheet" href="<?php echo base_url(); ?>static/css/base.css" />
        <link rel="stylesheet" href="<?php echo base_url(); ?>static/css/home.css" />
        <link rel="stylesheet" href="<?php echo base_url(); ?>static/css/sweetalert.css" />

        <?php $this->load->view('inc.header.php'); ?>

Contact

       <?php $this->load->view('inc.footer.php'); ?>


text:
<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android">

    <translate
        android:duration="400"
        android:fromYDelta="100%"
        android:interpolator="@android:anim/linear_interpolator"
        android:toYDelta="0%"/>

</set>


text:
#ifndef CLOTHING_ACTOR_H
#define CLOTHING_ACTOR_H

#include "ApexActor.h"
#include "ModuleClothingHelpers.h"

#include "ClothingActorParam.h"
#include "ClothingMaterialLibraryParameters.h"
#include "ClothingActorTasks.h"

#include "NxClothingActor.h"
#include "ClothingActorData.h"

#include "ClothingCollision.h"

#include "ClothingRenderProxy.h"

#include "PsSync.h"

#pragma warning(push)
#pragma warning(disable:4324)

class NxClothDesc;
class NxSoftBodyDesc;

namespace physx
{

namespace debugger
{
	namespace comm
	{
		class PvdDataStream;
		class PvdConnectionManager;
	}
	namespace renderer
	{
		class PvdImmediateRenderer;
	}
}

namespace apex
{
class NiApexRenderMeshActor;
class NiApexRenderDebug;
class NxClothingUserRecompute;
class NxClothingVelocityCallback;

namespace clothing
{

class ClothingActorProxy;
class ClothingAsset;
class ClothingCookingTask;
class ClothingMaterial;
class ClothingPreviewProxy;
class ClothingScene;
class ClothingCookedParam;
class SimulationAbstract;

namespace ClothingMaterialLibraryParametersNS
{
struct ClothingMaterial_Type;
}

namespace ClothingPhysicalMeshParametersNS
{
struct SkinClothMapB_Type;
struct SkinClothMapD_Type;
struct PhysicalMesh_Type;
}

struct ClothingGraphicalMeshActor
{
	ClothingGraphicalMeshActor() : active(false), needsTangents(false), renderProxy(NULL)
	{
	}

	bool active;
	bool needsTangents;
	Array<PxU32> morphTargetVertexOffsets;

	ClothingRenderProxy* renderProxy;
};

class ClothingWaitForFetchTask : public PxTask
{
public:
	ClothingWaitForFetchTask()
	{
		mWaiting.set();
	}

	virtual void run();
	virtual void release();
	virtual const char* getName() const;

	Sync mWaiting;
};

class ClothingActor : public ApexActor, public ApexResource
{
public:
	ClothingActor(const NxParameterized::Interface& desc, ClothingActorProxy* apiProxy, ClothingPreviewProxy*, ClothingAsset* asset, ClothingScene* scene);

	ClothingActorProxy*		mActorProxy;
	ClothingPreviewProxy*	mPreviewProxy;

	// from NxApexInterface
	void release();

	// from NxApexActor
	PX_INLINE ClothingAsset* getOwner() const
	{
		return mAsset;
	}
	NxApexRenderable* getRenderable();

	// from NxApexRenderable
	void dispatchRenderResources(NxUserRenderer& api);

	void initializeActorData();

	void fetchResults();

	void waitForFetchResults();

	void syncActorData();

	void reinitActorData()
	{
		bReinitActorData = 1;
	}

	ClothingActorData& getActorData();

	void markRenderProxyReady();

	// from NxApexResourceProvider
	void lockRenderResources()
	{
		ApexRenderable::renderDataLock();
	}
	void unlockRenderResources()
	{
		ApexRenderable::renderDataUnLock();
	}
	void updateRenderResources(bool rewriteBuffers, void* userRenderData);

	// from NxClothingActor
	NxParameterized::Interface* getActorDesc();
	void updateState(const PxMat44& globalPose, const PxMat44* newBoneMatrices, PxU32 boneMatricesByteStride, PxU32 numBoneMatrices, ClothingTeleportMode::Enum teleportMode);
	void updateMaxDistanceScale(PxF32 scale, bool multipliable);
	const PxMat44& getGlobalPose() const;
	void setWind(PxF32 windAdaption, const PxVec3& windVelocity);
	void setMaxDistanceBlendTime(PxF32 blendTime);
	PxF32 getMaxDistanceBlendTime() const;
	void setVisible(bool enable);
	bool isVisibleBuffered() const;
	bool isVisible() const;
	void setFrozen(bool enable);
	bool isFrozenBuffered() const;
	bool shouldComputeRenderData() const;
	ClothSolverMode::Enum getClothSolverMode() const;
	void setLODWeights(PxF32 maxDistance, PxF32 distanceWeight, PxF32 bias, PxF32 benefitBias);
	void setGraphicalLOD(PxU32 lod);
	PxU32 getGraphicalLod();

	NxClothingRenderProxy*	acquireRenderProxy();

	bool rayCast(const PxVec3& worldOrigin, const PxVec3& worldDirection, PxF32& time, PxVec3& normal, PxU32& vertexIndex);
	void attachVertexToGlobalPosition(PxU32 vertexIndex, const PxVec3& worldPosition);
	void freeVertex(PxU32 vertexIndex);

	PxU32 getClothingMaterial() const;
	void setClothingMaterial(PxU32 index);
	void setOverrideMaterial(PxU32 submeshIndex, const char* overrideMaterialName);
	void setUserRecompute(NxClothingUserRecompute* recompute)
	{
		mUserRecompute = recompute;
	}
	void setVelocityCallback(NxClothingVelocityCallback* callback)
	{
		mVelocityCallback = callback;
	}
	void setInterCollisionChannels(PxU32 channels)
	{
		mInterCollisionChannels = channels;
	}
	PxU32 getInterCollisionChannels()
	{
		return mInterCollisionChannels;
	}

	virtual void getPhysicalLodRange(PxF32& min, PxF32& max, bool& intOnly) const;
	virtual PxF32 getActivePhysicalLod() const;
	virtual void forcePhysicalLod(PxF32 lod);

	virtual void getPhysicalMeshPositions(void* buffer, PxU32 byteStride);
	virtual void getPhysicalMeshNormals(void* buffer, PxU32 byteStride);
	virtual PxF32 getMaximumSimulationBudget() const;
	virtual PxU32 getNumSimulationVertices() const;
	virtual const PxVec3* getSimulationPositions();
	virtual const PxVec3* getSimulationNormals();
	virtual bool getSimulationVelocities(PxVec3* velocities);
	virtual PxU32 getNumGraphicalVerticesActive(PxU32 submeshIndex) const;
	virtual PxMat44 getRenderGlobalPose() const;
	virtual const PxMat44* getCurrentBoneSkinningMatrices() const;

	// PhysX scene management
#if NX_SDK_VERSION_MAJOR == 2
	void setPhysXScene(NxScene*);
	NxScene* getPhysXScene() const;
#elif NX_SDK_VERSION_MAJOR == 3
	void setPhysXScene(PxScene*);
	PxScene* getPhysXScene() const;
#endif

	// scene ticks
	void tickSynchBeforeSimulate_LocksPhysX(PxF32 simulationDelta, PxF32 substepSize, PxU32 substepNumber, PxU32 numSubSteps);
	void applyLockingTasks();
	void updateConstrainPositions_LocksPhysX();
	void applyCollision_LocksPhysX();
	void applyGlobalPose_LocksPhysX();
	void applyClothingMaterial_LocksPhysX();
	void skinPhysicsMesh(bool useInterpolatedMatrices, PxF32 substepFraction);
	void tickAsynch_NoPhysX();
	bool needsManualSubstepping();
	bool isSkinningDirty();

	// LoD stuff
	PxF32 computeBenefit();
	PX_INLINE PxF32 getCachedBenefit()
	{
		return mCachedBenefit;
	}
	PxF32 setResource(PxF32 suggested, PxF32 maxAllowed, PxF32 relativeBenefit);
	PxF32 increaseResource(PxF32 maxRemaining);
	PxF32 getCost(PxU32 physicalLod) const;

	// debug rendering
#ifndef WITHOUT_PVD
	void initPvdInstances(physx::debugger::comm::PvdDataStream& pvdStream);
	void destroyPvdInstances();
	void updatePvd();
#endif
	void visualize();

	// cleanup
	void destroy();

	// Tasks
	void initBeforeTickTasks(PxF32 deltaTime, PxF32 substepSize, PxU32 numSubSteps);
	void submitTasksDuring(PxTaskManager* taskManager);
	void setTaskDependenciesBefore(PxBaseTask* after);
	PxTaskID setTaskDependenciesDuring(PxTaskID before, PxTaskID after);

	void startBeforeTickTask();

	PxTaskID getDuringTickTaskID()
	{
		return mDuringTickTask.getTaskID();
	}

	void setFetchContinuation();
	void startFetchTasks();

	// teleport
	void applyTeleport(bool skinningReady, PxU32 substepNumber);

	// validation
	static bool isValidDesc(const NxParameterized::Interface& params);

	// Per Actor runtime cooking stuff
	PxF32 getActorScale()
	{
		return mActorDesc->actorScale;
	}
	bool getHardwareAllowed()
	{
		return mActorDesc->useHardwareCloth;
	}
	ClothingCookedParam* getRuntimeCookedDataPhysX();

	// collision functions
	virtual NxClothingPlane* createCollisionPlane(const PxPlane& pose);
	virtual NxClothingConvex* createCollisionConvex(NxClothingPlane** planes, PxU32 numPlanes);
	virtual NxClothingSphere* createCollisionSphere(const PxVec3& positions, PxF32 radius);
	virtual NxClothingCapsule* createCollisionCapsule(NxClothingSphere& sphere1, NxClothingSphere& sphere2);
	virtual NxClothingTriangleMesh* createCollisionTriangleMesh();

	void releaseCollision(ClothingCollision& collision);
	void notifyCollisionChange()
	{
		bActorCollisionChanged = 1;
	}

protected:
	struct WriteBackInfo;

	// rendering
	void updateBoneBuffer(ClothingRenderProxy* renderProxy);
	void updateRenderMeshActorBuffer(bool freeBuffers, PxU32 graphicalLodId);
	PxBounds3 getRenderMeshAssetBoundsTransformed();
	void updateRenderProxy();

	// handling interpolated skinning matrices
	bool allocateEnoughBoneBuffers_NoPhysX(bool prepareForSubstepping);

	// double buffering internal stuff
	bool isSimulationRunning() const;
	void updateScaledGravity(PxF32 substepSize);
	void updateStateInternal_NoPhysX(bool prepareForSubstepping);

	// compute intensive skinning stuff
	template<bool withBackstop>
	void skinPhysicsMeshInternal(bool useInterpolatedMatrices, PxF32 substepFraction);
	void fillWritebackData_LocksPhysX(const WriteBackInfo& writeBackInfo);

	// wind
	void applyVelocityChanges_LocksPhysX(PxF32 simulationDelta);

	// handling Nx entities
	bool isCookedDataReady();
	void getSimulation(const WriteBackInfo& writeBackInfo);
	void createPhysX_LocksPhysX(PxF32 simulationDelta);
	void removePhysX_LocksPhysX();
	void changePhysicsMesh_LocksPhysX(PxU32 oldGraphicalLodId, PxF32 simulationDelta);
	void updateNxCollision_LocksPhysX(bool useInterpolatedMatrices);
	void updateConstraintCoefficients_LocksPhysX();
	void copyPositionAndNormal_NoPhysX(PxU32 numCopyVertices, SimulationAbstract* oldClothingSimulation);
	void copyAndComputeVelocities_LocksPhysX(PxU32 numCopyVertices, SimulationAbstract* oldClothingSimulation, PxVec3* velocities, PxF32 simulationDelta) const;
	void transferVelocities_LocksPhysX(const SimulationAbstract& oldClothingSimulation,
									const ClothingPhysicalMeshParametersNS::SkinClothMapB_Type* pTCMB,
									const ClothingPhysicalMeshParametersNS::SkinClothMapD_Type* pTCM,
									PxU32 numVerticesInMap, const PxU32* srcIndices, PxU32 numSrcIndices, PxU32 numSrcVertices,
									PxVec3* oldVelocities, PxVec3* newVelocites, PxF32 simulationDelta);
	PxVec3 computeVertexVelFromAnim(PxU32 vertexIndex, const ClothingPhysicalMeshParametersNS::PhysicalMesh_Type* physicalMesh, PxF32 simulationDelta) const;
	void freeze_LocksPhysX(bool on);

	// handling Abstract Simulation
	void createSimulation(PxU32 physicalMeshId, PxI32 submeshId, NxParameterized::Interface* cookedData, const WriteBackInfo& writeBackInfo);

	// handling Lod
	PxU32 getGraphicalMeshIndex(PxU32 lod) const;
	void lodTick_LocksPhysX(PxF32 simulationDelta);

	// debug rendering
	void visualizeSkinnedPositions(NiApexRenderDebug& renderDebug, PxF32 positionRadius, bool maxDistanceOut, bool maxDistanceIn) const;
	void visualizeBackstop(NiApexRenderDebug& renderDebug) const;
	void visualizeBackstopPrecise(NiApexRenderDebug& renderDebug, PxF32 scale) const;
	void visualizeBoneConnections(NiApexRenderDebug& renderDebug, const PxVec3* positions, const PxU16* boneIndices,
								const PxF32* boneWeights, PxU32 numBonesPerVertex, PxU32 numVertices) const;
	void visualizeSpheres(NiApexRenderDebug& renderDebug, const PxVec3* positions, PxU32 numPositions, PxF32 radius, PxU32 color, bool wire) const;

	NiApexRenderMeshActor* createRenderMeshActor(NiApexRenderMeshAsset* renderMeshAsset);

	ClothingMaterialLibraryParametersNS::ClothingMaterial_Type* getCurrentClothingMaterial() const;
	bool clothingMaterialsEqual(ClothingMaterialLibraryParametersNS::ClothingMaterial_Type& a, ClothingMaterialLibraryParametersNS::ClothingMaterial_Type& b);

	struct WriteBackInfo
	{
		WriteBackInfo() : oldSimulation(NULL), oldGraphicalLodId(0), simulationDelta(0.0f) {}
		SimulationAbstract* oldSimulation;
		PxU32 oldGraphicalLodId;
		PxF32 simulationDelta;
	};

	// internal variables
	ClothingAsset*			mAsset;
	ClothingScene*			mClothingScene;
#if NX_SDK_VERSION_MAJOR == 2
	NxScene*				mPhysXScene;
#elif NX_SDK_VERSION_MAJOR == 3
	PxScene*				mPhysXScene;
#endif

	ClothingActorParam*		mActorDesc;
	const char*				mBackendName;

	// current pose of this actor. If using skinning it could be set to idenftity matrix and simply rely on the skinning matrices (bones)
	PX_ALIGN(16, PxMat44)	mInternalGlobalPose;
	PxMat44					mOldInternalGlobalPose;
	PxMat44					mInternalInterpolatedGlobalPose;

	// Bone matrices for physical mesh skinning - provided by the application either in the initial NxClothingActorDesc or "updateBoneMatrices"
	// number 0 is current, 1 is one frame old, 2 is 2 frames old
	//PxMat44* mInternalBoneMatrices[2];
	PxMat44*				mInternalInterpolatedBoneMatrices;

	// Number of cloth solver iterations that will be performed.
	//  If this is set to 0 the simulation enters "static" mode
	PxU32					mCurrentSolverIterations;

	PxVec3					mInternalScaledGravity;

	PxU32					mActivePhysicsLod;
	PxU32					mCurrentPhysicsLod;
	PxI32					mCurrentPhysicsSubmesh;

	PxF32					mInternalMaxDistanceBlendTime;
	PxF32					mMaxDistReduction;

	PxU32					mBufferedGraphicalLod;
	PxU32					mCurrentGraphicalLodId;

	Array<ClothingGraphicalMeshActor> mGraphicalMeshes;

	Mutex					mRenderProxyMutex;
	ClothingRenderProxy*	mRenderProxyReady;

	// for backwards compatibility, to make sure that dispatchRenderResources is
	// called on the same render proxy as updateRenderResources
	ClothingRenderProxy*	mRenderProxyURR;

	ClothingActorData		mData;

	// PhysX SDK simulation objects
	// Per-actor "skinned physical mesh" data is in mSimulationBulk.dynamicSimulationData
	//  these are skinned by APEX in "tickAsynch" using bone matrices provided by the application
	//  they are passed as constraints to the PhysX SDK (mNxCloth) in "tickSync"
	// Per-actor "skinned rendering mesh" data - only used in if the ClothingAsset uses the "skin cloth" approach
	//  these are skinned by APEX in "tickSynch" using the appropriate mesh-to-mesh skinning algorithm in the ClothingAsset
	SimulationAbstract*		mClothingSimulation;

	// Wind
	ClothingActorParamNS::WindParameters_Type mInternalWindParams;

	ClothingActorParamNS::ClothingActorFlags_Type mInternalFlags;

	ClothingActorParamNS::LODWeights_Type mInternalLodWeights;

	PxF32 mCachedBenefit, mRelativeBenefit;

	// max distance scale
	ClothingActorParamNS::MaxDistanceScale_Type mInternalMaxDistanceScale;

	// only needed to detect when it changes on the fly
	PxF32		mCurrentMaxDistanceBias;

	// bounds that are computed for the current frame, get copied over to NxRenderMeshActor during fetchResults
	PxBounds3	mNewBounds;

	PxI32		mForcePhysicalLod;
	PxVec3		mLodCentroid;
	PxF32		mLodRadiusSquared;

	// The Clothing Material
	ClothingMaterialLibraryParametersNS::ClothingMaterial_Type mClothingMaterial;

	// Normal/Tangent recomputation
	NxClothingUserRecompute*		mUserRecompute;

	// velocity callback
	NxClothingVelocityCallback*		mVelocityCallback;

	// inter collision
	PxU32 mInterCollisionChannels;

	// The tasks
	ClothingActorBeforeTickTask		mBeforeTickTask;
	ClothingActorDuringTickTask		mDuringTickTask;
	ClothingActorFetchResultsTask	mFetchResultsTask;

#ifdef PX_PS3
	ClothingActorSkinPhysicsTaskSimpleSpu mSkinPhysicsTaskSimpleSpu;
	ClothingActorFetchResultsTaskSimpleSpu mFetchResultsTaskSimpleSpu;
	ClothingActorFetchResultsTaskSpu mFetchResultsTaskSpu;
	ClothingActorLockingTasks mLockingTasks;
#endif

	ClothingCookingTask*			mActiveCookingTask;

	ClothingWaitForFetchTask		mWaitForFetchTask;
	bool							mFetchResultsRunning;
	Mutex							mFetchResultsRunningMutex;

	shdfnd::Array<PxVec3>			mWindDebugRendering;

	// TODO make a better overrideMaterials API
	HashMap<PxU32, ApexSimpleString>	mOverrideMaterials;

	NxResourceList mCollisionPlanes;
	NxResourceList mCollisionConvexes;
	NxResourceList mCollisionSpheres;
	NxResourceList mCollisionCapsules;
	NxResourceList mCollisionTriangleMeshes;

	// bit flags - aggregate them at the end
	PxU32 bGlobalPoseChanged : 1;						// mBufferedGlobalPose was updated
	PxU32 bBoneMatricesChanged : 1;						// mBufferedBoneMatrices were updated
	PxU32 bBoneBufferDirty : 1;							// need to sync bones to the render mesh actor
	PxU32 bMaxDistanceScaleChanged : 1;					// mBufferedMaxDistanceScale was updated
	PxU32 bBlendingAllowed : 1;

	PxU32 bDirtyActorTemplate : 1;
	PxU32 bDirtyShapeTemplate : 1;
	PxU32 bDirtyClothingTemplate : 1;

	PxU32 bBufferedVisible : 1;
	PxU32 bInternalVisible : 1;

	PxU32 bUpdateFrozenFlag : 1;
	PxU32 bBufferedFrozen : 1;
	PxU32 bInternalFrozen : 1;

	PxU32 bPressureWarning : 1;
	PxU32 bUnsucessfullCreation : 1;

	ClothingTeleportMode::Enum bInternalTeleportDue : 3;

	PxU32 bInternalScaledGravityChanged : 1;
	PxU32 bReinitActorData : 1;

	PxU32 bInternalLocalSpaceSim : 1;

	PxU32 bActorCollisionChanged : 1;
};

}
} // namespace apex
} // namespace physx

#pragma warning(pop)

#endif // CLOTHING_ACTOR_H


text:
package com.microsoft.azure.cognitiveservices.search.videosearch.models;

import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.JsonTypeName;
import com.fasterxml.jackson.annotation.JsonSubTypes;

/**
 * The Thing model.
 */
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = "_type", defaultImpl = Thing.class)
@JsonTypeName("Thing")
@JsonSubTypes({
    @JsonSubTypes.Type(name = "CreativeWork", value = CreativeWork.class)
})
public class Thing extends Response {
    /**
     * The name of the thing represented by this object.
     */
    @JsonProperty(value = "name", access = JsonProperty.Access.WRITE_ONLY)
    private String name;

    /**
     * The URL to get more information about the thing represented by this
     * object.
     */
    @JsonProperty(value = "url", access = JsonProperty.Access.WRITE_ONLY)
    private String url;

    /**
     * The image property.
     */
    @JsonProperty(value = "image", access = JsonProperty.Access.WRITE_ONLY)
    private ImageObject image;

    /**
     * A short description of the item.
     */
    @JsonProperty(value = "description", access = JsonProperty.Access.WRITE_ONLY)
    private String description;

    /**
     * The alternateName property.
     */
    @JsonProperty(value = "alternateName", access = JsonProperty.Access.WRITE_ONLY)
    private String alternateName;

    /**
     * An ID that uniquely identifies this item.
     */
    @JsonProperty(value = "bingId", access = JsonProperty.Access.WRITE_ONLY)
    private String bingId;

    /**
     * Get the name value.
     *
     * @return the name value
     */
    public String name() {
        return this.name;
    }

    /**
     * Get the url value.
     *
     * @return the url value
     */
    public String url() {
        return this.url;
    }

    /**
     * Get the image value.
     *
     * @return the image value
     */
    public ImageObject image() {
        return this.image;
    }

    /**
     * Get the description value.
     *
     * @return the description value
     */
    public String description() {
        return this.description;
    }

    /**
     * Get the alternateName value.
     *
     * @return the alternateName value
     */
    public String alternateName() {
        return this.alternateName;
    }

    /**
     * Get the bingId value.
     *
     * @return the bingId value
     */
    public String bingId() {
        return this.bingId;
    }

}


text:
using UnityEngine;
using System.Collections;

public class ChaseState : IEnermyState {

	private readonly StatePatternEnermy enermy;

	public ChaseState(StatePatternEnermy statePatternEnermy){
		enermy=statePatternEnermy;

	}
	public void UpdateState(){
		Look();
		Chase();

	}
	public void OntriggerEnter(Collider other){

	}
	public void ToPatrolState(){

	}
	public void ToAlertState(){
		enermy.currentState=enermy.alertState;
	}
	public void ToChaseState(){

		Debug.Log ("Cannot Transition to same state");
	}

	private void Look(){
		RaycastHit hit;
		Vector3 enermyToTarger=(enermy.chaseTarget.position+enermy.offSet)-enermy.eyes.transform.position;
		if(Physics.Raycast(enermy.eyes.transform.position,enermy.eyes.transform.forward,out hit,
		                   enermy.sightRange) && (hit.collider.CompareTag("Player"))){

			enermy.chaseTarget=hit.transform;

		}else{

			ToAlertState();
		}

	}

	public void Chase(){
		enermy.meshRndererFlag.material.color=Color.red;
		enermy.navMeshAgent.destination=enermy.chaseTarget.position;
		enermy.navMeshAgent.Resume();

	}

}


text: package org.apache.maven.project;


text:
/*global define*/
define([
        './defaultValue',
        './defined',
        './DeveloperError',
        './freezeObject',
        './Math'
    ], function(
        defaultValue,
        defined,
        DeveloperError,
        freezeObject,
        CesiumMath) {
    "use strict";

    /**
     * A 4D Cartesian point.
     * @alias Cartesian4
     * @constructor
     *
     * @param {Number} [x=0.0] The X component.
     * @param {Number} [y=0.0] The Y component.
     * @param {Number} [z=0.0] The Z component.
     * @param {Number} [w=0.0] The W component.
     *
     * @see Cartesian2
     * @see Cartesian3
     * @see Packable
     */
    var Cartesian4 = function(x, y, z, w) {
        /**
         * The X component.
         * @type {Number}
         * @default 0.0
         */
        this.x = defaultValue(x, 0.0);

        /**
         * The Y component.
         * @type {Number}
         * @default 0.0
         */
        this.y = defaultValue(y, 0.0);

        /**
         * The Z component.
         * @type {Number}
         * @default 0.0
         */
        this.z = defaultValue(z, 0.0);

        /**
         * The W component.
         * @type {Number}
         * @default 0.0
         */
        this.w = defaultValue(w, 0.0);
    };

    /**
     * Creates a Cartesian4 instance from x, y, z and w coordinates.
     *
     * @param {Number} x The x coordinate.
     * @param {Number} y The y coordinate.
     * @param {Number} z The z coordinate.
     * @param {Number} w The w coordinate.
     * @param {Cartesian4} [result] The object onto which to store the result.
     * @returns {Cartesian4} The modified result parameter or a new Cartesian4 instance if one was not provided.
     */
    Cartesian4.fromElements = function(x, y, z, w, result) {
        if (!defined(result)) {
            return new Cartesian4(x, y, z, w);
        }

        result.x = x;
        result.y = y;
        result.z = z;
        result.w = w;
        return result;
    };

    /**
     * Creates a Cartesian4 instance from a {@link Color}. red, green, blue,
     * and alpha map to x, y, z, and w, respectively.
     *
     * @param {Color} color The source color.
     * @param {Cartesian4} [result] The object onto which to store the result.
     * @returns {Cartesian4} The modified result parameter or a new Cartesian4 instance if one was not provided.
     */
    Cartesian4.fromColor = function(color, result) {
        //>>includeStart('debug', pragmas.debug);
        if (!defined(color)) {
            throw new DeveloperError('color is required');
        }
        //>>includeEnd('debug');
        if (!defined(result)) {
            return new Cartesian4(color.red, color.green, color.blue, color.alpha);
        }

        result.x = color.red;
        result.y = color.green;
        result.z = color.blue;
        result.w = color.alpha;
        return result;
    };

    /**
     * Duplicates a Cartesian4 instance.
     *
     * @param {Cartesian4} cartesian The Cartesian to duplicate.
     * @param {Cartesian4} [result] The object onto which to store the result.
     * @returns {Cartesian4} The modified result parameter or a new Cartesian4 instance if one was not provided. (Returns undefined if cartesian is undefined)
     */
    Cartesian4.clone = function(cartesian, result) {
        if (!defined(cartesian)) {
            return undefined;
        }

        if (!defined(result)) {
            return new Cartesian4(cartesian.x, cartesian.y, cartesian.z, cartesian.w);
        }

        result.x = cartesian.x;
        result.y = cartesian.y;
        result.z = cartesian.z;
        result.w = cartesian.w;
        return result;
    };

    /**
     * The number of elements used to pack the object into an array.
     * @type {Number}
     */
    Cartesian4.packedLength = 4;

    /**
     * Stores the provided instance into the provided array.
     *
     * @param {Cartesian4} value The value to pack.
     * @param {Number[]} array The array to pack into.
     * @param {Number} [startingIndex=0] The index into the array at which to start packing the elements.
     */
    Cartesian4.pack = function(value, array, startingIndex) {
        //>>includeStart('debug', pragmas.debug);
        if (!defined(value)) {
            throw new DeveloperError('value is required');
        }
        if (!defined(array)) {
            throw new DeveloperError('array is required');
        }
        //>>includeEnd('debug');

        startingIndex = defaultValue(startingIndex, 0);

        array[startingIndex++] = value.x;
        array[startingIndex++] = value.y;
        array[startingIndex++] = value.z;
        array[startingIndex] = value.w;
    };

    /**
     * Retrieves an instance from a packed array.
     *
     * @param {Number[]} array The packed array.
     * @param {Number} [startingIndex=0] The starting index of the element to be unpacked.
     * @param {Cartesian4} [result] The object into which to store the result.
     * @returns {Cartesian4}  The modified result parameter or a new Cartesian4 instance if one was not provided.
     */
    Cartesian4.unpack = function(array, startingIndex, result) {
        //>>includeStart('debug', pragmas.debug);
        if (!defined(array)) {
            throw new DeveloperError('array is required');
        }
        //>>includeEnd('debug');

        startingIndex = defaultValue(startingIndex, 0);

        if (!defined(result)) {
            result = new Cartesian4();
        }
        result.x = array[startingIndex++];
        result.y = array[startingIndex++];
        result.z = array[startingIndex++];
        result.w = array[startingIndex];
        return result;
    };

    /**
     * Creates a Cartesian4 from four consecutive elements in an array.
     * @function
     *
     * @param {Number[]} array The array whose four consecutive elements correspond to the x, y, z, and w components, respectively.
     * @param {Number} [startingIndex=0] The offset into the array of the first element, which corresponds to the x component.
     * @param {Cartesian4} [result] The object onto which to store the result.
     * @returns {Cartesian4}  The modified result parameter or a new Cartesian4 instance if one was not provided.
     *
     * @example
     * // Create a Cartesian4 with (1.0, 2.0, 3.0, 4.0)
     * var v = [1.0, 2.0, 3.0, 4.0];
     * var p = Cesium.Cartesian4.fromArray(v);
     *
     * // Create a Cartesian4 with (1.0, 2.0, 3.0, 4.0) using an offset into an array
     * var v2 = [0.0, 0.0, 1.0, 2.0, 3.0, 4.0];
     * var p2 = Cesium.Cartesian4.fromArray(v2, 2);
     */
    Cartesian4.fromArray = Cartesian4.unpack;

    /**
     * Computes the value of the maximum component for the supplied Cartesian.
     *
     * @param {Cartesian4} cartesian The cartesian to use.
     * @returns {Number} The value of the maximum component.
     */
    Cartesian4.maximumComponent = function(cartesian) {
        //>>includeStart('debug', pragmas.debug);
        if (!defined(cartesian)) {
            throw new DeveloperError('cartesian is required');
        }
        //>>includeEnd('debug');

        return Math.max(cartesian.x, cartesian.y, cartesian.z, cartesian.w);
    };

    /**
     * Computes the value of the minimum component for the supplied Cartesian.
     *
     * @param {Cartesian4} cartesian The cartesian to use.
     * @returns {Number} The value of the minimum component.
     */
    Cartesian4.minimumComponent = function(cartesian) {
        //>>includeStart('debug', pragmas.debug);
        if (!defined(cartesian)) {
            throw new DeveloperError('cartesian is required');
        }
        //>>includeEnd('debug');

        return Math.min(cartesian.x, cartesian.y, cartesian.z, cartesian.w);
    };

    /**
     * Compares two Cartesians and computes a Cartesian which contains the minimum components of the supplied Cartesians.
     *
     * @param {Cartesian4} first A cartesian to compare.
     * @param {Cartesian4} second A cartesian to compare.
     * @param {Cartesian4} result The object into which to store the result.
     * @returns {Cartesian4} A cartesian with the minimum components.
     */
    Cartesian4.minimumByComponent = function(first, second, result) {
        //>>includeStart('debug', pragmas.debug);
        if (!defined(first)) {
            throw new DeveloperError('first is required.');
        }
        if (!defined(second)) {
            throw new DeveloperError('second is required.');
        }
        if (!defined(result)) {
            throw new DeveloperError('result is required.');
        }
        //>>includeEnd('debug');

        result.x = Math.min(first.x, second.x);
        result.y = Math.min(first.y, second.y);
        result.z = Math.min(first.z, second.z);
        result.w = Math.min(first.w, second.w);

        return result;
    };

    /**
     * Compares two Cartesians and computes a Cartesian which contains the maximum components of the supplied Cartesians.
     *
     * @param {Cartesian4} first A cartesian to compare.
     * @param {Cartesian4} second A cartesian to compare.
     * @param {Cartesian4} result The object into which to store the result.
     * @returns {Cartesian4} A cartesian with the maximum components.
     */
    Cartesian4.maximumByComponent = function(first, second, result) {
        //>>includeStart('debug', pragmas.debug);
        if (!defined(first)) {
            throw new DeveloperError('first is required.');
        }
        if (!defined(second)) {
            throw new DeveloperError('second is required.');
        }
        if (!defined(result)) {
            throw new DeveloperError('result is required.');
        }
        //>>includeEnd('debug');

        result.x = Math.max(first.x, second.x);
        result.y = Math.max(first.y, second.y);
        result.z = Math.max(first.z, second.z);
        result.w = Math.max(first.w, second.w);

        return result;
    };

    /**
     * Computes the provided Cartesian's squared magnitude.
     *
     * @param {Cartesian4} cartesian The Cartesian instance whose squared magnitude is to be computed.
     * @returns {Number} The squared magnitude.
     */
    Cartesian4.magnitudeSquared = function(cartesian) {
        //>>includeStart('debug', pragmas.debug);
        if (!defined(cartesian)) {
            throw new DeveloperError('cartesian is required');
        }
        //>>includeEnd('debug');

        return cartesian.x * cartesian.x + cartesian.y * cartesian.y + cartesian.z * cartesian.z + cartesian.w * cartesian.w;
    };

    /**
     * Computes the Cartesian's magnitude (length).
     *
     * @param {Cartesian4} cartesian The Cartesian instance whose magnitude is to be computed.
     * @returns {Number} The magnitude.
     */
    Cartesian4.magnitude = function(cartesian) {
        return Math.sqrt(Cartesian4.magnitudeSquared(cartesian));
    };

    var distanceScratch = new Cartesian4();

    /**
     * Computes the 4-space distance between two points.
     *
     * @param {Cartesian4} left The first point to compute the distance from.
     * @param {Cartesian4} right The second point to compute the distance to.
     * @returns {Number} The distance between two points.
     *
     * @example
     * // Returns 1.0
     * var d = Cesium.Cartesian4.distance(
     *   new Cesium.Cartesian4(1.0, 0.0, 0.0, 0.0),
     *   new Cesium.Cartesian4(2.0, 0.0, 0.0, 0.0));
     */
    Cartesian4.distance = function(left, right) {
        //>>includeStart('debug', pragmas.debug);
        if (!defined(left) || !defined(right)) {
            throw new DeveloperError('left and right are required.');
        }
        //>>includeEnd('debug');

        Cartesian4.subtract(left, right, distanceScratch);
        return Cartesian4.magnitude(distanceScratch);
    };

    /**
     * Computes the squared distance between two points.  Comparing squared distances
     * using this function is more efficient than comparing distances using {@link Cartesian4#distance}.
     *
     * @param {Cartesian4} left The first point to compute the distance from.
     * @param {Cartesian4} right The second point to compute the distance to.
     * @returns {Number} The distance between two points.
     *
     * @example
     * // Returns 4.0, not 2.0
     * var d = Cesium.Cartesian4.distance(
     *   new Cesium.Cartesian4(1.0, 0.0, 0.0, 0.0),
     *   new Cesium.Cartesian4(3.0, 0.0, 0.0, 0.0));
     */
    Cartesian4.distanceSquared = function(left, right) {
        //>>includeStart('debug', pragmas.debug);
        if (!defined(left) || !defined(right)) {
            throw new DeveloperError('left and right are required.');
        }
        //>>includeEnd('debug');

        Cartesian4.subtract(left, right, distanceScratch);
        return Cartesian4.magnitudeSquared(distanceScratch);
    };

    /**
     * Computes the normalized form of the supplied Cartesian.
     *
     * @param {Cartesian4} cartesian The Cartesian to be normalized.
     * @param {Cartesian4} result The object onto which to store the result.
     * @returns {Cartesian4} The modified result parameter.
     */
    Cartesian4.normalize = function(cartesian, result) {
        //>>includeStart('debug', pragmas.debug);
        if (!defined(cartesian)) {
            throw new DeveloperError('cartesian is required');
        }
        if (!defined(result)) {
            throw new DeveloperError('result is required');
        }
        //>>includeEnd('debug');

        var magnitude = Cartesian4.magnitude(cartesian);

        result.x = cartesian.x / magnitude;
        result.y = cartesian.y / magnitude;
        result.z = cartesian.z / magnitude;
        result.w = cartesian.w / magnitude;
        return result;
    };

    /**
     * Computes the dot (scalar) product of two Cartesians.
     *
     * @param {Cartesian4} left The first Cartesian.
     * @param {Cartesian4} right The second Cartesian.
     * @returns {Number} The dot product.
     */
    Cartesian4.dot = function(left, right) {
        //>>includeStart('debug', pragmas.debug);
        if (!defined(left)) {
            throw new DeveloperError('left is required');
        }
        if (!defined(right)) {
            throw new DeveloperError('right is required');
        }
        //>>includeEnd('debug');

        return left.x * right.x + left.y * right.y + left.z * right.z + left.w * right.w;
    };

    /**
     * Computes the componentwise product of two Cartesians.
     *
     * @param {Cartesian4} left The first Cartesian.
     * @param {Cartesian4} right The second Cartesian.
     * @param {Cartesian4} result The object onto which to store the result.
     * @returns {Cartesian4} The modified result parameter.
     */
    Cartesian4.multiplyComponents = function(left, right, result) {
        //>>includeStart('debug', pragmas.debug);
        if (!defined(left)) {
            throw new DeveloperError('left is required');
        }
        if (!defined(right)) {
            throw new DeveloperError('right is required');
        }
        if (!defined(result)) {
            throw new DeveloperError('result is required');
        }
        //>>includeEnd('debug');

        result.x = left.x * right.x;
        result.y = left.y * right.y;
        result.z = left.z * right.z;
        result.w = left.w * right.w;
        return result;
    };

    /**
     * Computes the componentwise sum of two Cartesians.
     *
     * @param {Cartesian4} left The first Cartesian.
     * @param {Cartesian4} right The second Cartesian.
     * @param {Cartesian4} result The object onto which to store the result.
     * @returns {Cartesian4} The modified result parameter.
     */
    Cartesian4.add = function(left, right, result) {
        //>>includeStart('debug', pragmas.debug);
        if (!defined(left)) {
            throw new DeveloperError('left is required');
        }
        if (!defined(right)) {
            throw new DeveloperError('right is required');
        }
        if (!defined(result)) {
            throw new DeveloperError('result is required');
        }
        //>>includeEnd('debug');

        result.x = left.x + right.x;
        result.y = left.y + right.y;
        result.z = left.z + right.z;
        result.w = left.w + right.w;
        return result;
    };

    /**
     * Computes the componentwise difference of two Cartesians.
     *
     * @param {Cartesian4} left The first Cartesian.
     * @param {Cartesian4} right The second Cartesian.
     * @param {Cartesian4} result The object onto which to store the result.
     * @returns {Cartesian4} The modified result parameter.
     */
    Cartesian4.subtract = function(left, right, result) {
        //>>includeStart('debug', pragmas.debug);
        if (!defined(left)) {
            throw new DeveloperError('left is required');
        }
        if (!defined(right)) {
            throw new DeveloperError('right is required');
        }
        if (!defined(result)) {
            throw new DeveloperError('result is required');
        }
        //>>includeEnd('debug');

        result.x = left.x - right.x;
        result.y = left.y - right.y;
        result.z = left.z - right.z;
        result.w = left.w - right.w;
        return result;
    };

    /**
     * Multiplies the provided Cartesian componentwise by the provided scalar.
     *
     * @param {Cartesian4} cartesian The Cartesian to be scaled.
     * @param {Number} scalar The scalar to multiply with.
     * @param {Cartesian4} result The object onto which to store the result.
     * @returns {Cartesian4} The modified result parameter.
     */
    Cartesian4.multiplyByScalar = function(cartesian, scalar, result) {
        //>>includeStart('debug', pragmas.debug);
        if (!defined(cartesian)) {
            throw new DeveloperError('cartesian is required');
        }
        if (typeof scalar !== 'number') {
            throw new DeveloperError('scalar is required and must be a number.');
        }
        if (!defined(result)) {
            throw new DeveloperError('result is required');
        }
        //>>includeEnd('debug');

        result.x = cartesian.x * scalar;
        result.y = cartesian.y * scalar;
        result.z = cartesian.z * scalar;
        result.w = cartesian.w * scalar;
        return result;
    };

    /**
     * Divides the provided Cartesian componentwise by the provided scalar.
     *
     * @param {Cartesian4} cartesian The Cartesian to be divided.
     * @param {Number} scalar The scalar to divide by.
     * @param {Cartesian4} result The object onto which to store the result.
     * @returns {Cartesian4} The modified result parameter.
     */
    Cartesian4.divideByScalar = function(cartesian, scalar, result) {
        //>>includeStart('debug', pragmas.debug);
        if (!defined(cartesian)) {
            throw new DeveloperError('cartesian is required');
        }
        if (typeof scalar !== 'number') {
            throw new DeveloperError('scalar is required and must be a number.');
        }
        if (!defined(result)) {
            throw new DeveloperError('result is required');
        }
        //>>includeEnd('debug');

        result.x = cartesian.x / scalar;
        result.y = cartesian.y / scalar;
        result.z = cartesian.z / scalar;
        result.w = cartesian.w / scalar;
        return result;
    };

    /**
     * Negates the provided Cartesian.
     *
     * @param {Cartesian4} cartesian The Cartesian to be negated.
     * @param {Cartesian4} result The object onto which to store the result.
     * @returns {Cartesian4} The modified result parameter.
     */
    Cartesian4.negate = function(cartesian, result) {
        //>>includeStart('debug', pragmas.debug);
        if (!defined(cartesian)) {
            throw new DeveloperError('cartesian is required');
        }
        if (!defined(result)) {
            throw new DeveloperError('result is required');
        }
        //>>includeEnd('debug');

        result.x = -cartesian.x;
        result.y = -cartesian.y;
        result.z = -cartesian.z;
        result.w = -cartesian.w;
        return result;
    };

    /**
     * Computes the absolute value of the provided Cartesian.
     *
     * @param {Cartesian4} cartesian The Cartesian whose absolute value is to be computed.
     * @param {Cartesian4} result The object onto which to store the result.
     * @returns {Cartesian4} The modified result parameter.
     */
    Cartesian4.abs = function(cartesian, result) {
        //>>includeStart('debug', pragmas.debug);
        if (!defined(cartesian)) {
            throw new DeveloperError('cartesian is required');
        }
        if (!defined(result)) {
            throw new DeveloperError('result is required');
        }
        //>>includeEnd('debug');

        result.x = Math.abs(cartesian.x);
        result.y = Math.abs(cartesian.y);
        result.z = Math.abs(cartesian.z);
        result.w = Math.abs(cartesian.w);
        return result;
    };

    var lerpScratch = new Cartesian4();
    /**
     * Computes the linear interpolation or extrapolation at t using the provided cartesians.
     *
     * @param {Cartesian4} start The value corresponding to t at 0.0.
     * @param {Cartesian4}end The value corresponding to t at 1.0.
     * @param {Number} t The point along t at which to interpolate.
     * @param {Cartesian4} result The object onto which to store the result.
     * @returns {Cartesian4} The modified result parameter.
     */
    Cartesian4.lerp = function(start, end, t, result) {
        //>>includeStart('debug', pragmas.debug);
        if (!defined(start)) {
            throw new DeveloperError('start is required.');
        }
        if (!defined(end)) {
            throw new DeveloperError('end is required.');
        }
        if (typeof t !== 'number') {
            throw new DeveloperError('t is required and must be a number.');
        }
        if (!defined(result)) {
            throw new DeveloperError('result is required.');
        }
        //>>includeEnd('debug');

        Cartesian4.multiplyByScalar(end, t, lerpScratch);
        result = Cartesian4.multiplyByScalar(start, 1.0 - t, result);
        return Cartesian4.add(lerpScratch, result, result);
    };

    var mostOrthogonalAxisScratch = new Cartesian4();
    /**
     * Returns the axis that is most orthogonal to the provided Cartesian.
     *
     * @param {Cartesian4} cartesian The Cartesian on which to find the most orthogonal axis.
     * @param {Cartesian4} result The object onto which to store the result.
     * @returns {Cartesian4} The most orthogonal axis.
     */
    Cartesian4.mostOrthogonalAxis = function(cartesian, result) {
        //>>includeStart('debug', pragmas.debug);
        if (!defined(cartesian)) {
            throw new DeveloperError('cartesian is required.');
        }
        if (!defined(result)) {
            throw new DeveloperError('result is required.');
        }
        //>>includeEnd('debug');

        var f = Cartesian4.normalize(cartesian, mostOrthogonalAxisScratch);
        Cartesian4.abs(f, f);

        if (f.x <= f.y) {
            if (f.x <= f.z) {
                if (f.x <= f.w) {
                    result = Cartesian4.clone(Cartesian4.UNIT_X, result);
                } else {
                    result = Cartesian4.clone(Cartesian4.UNIT_W, result);
                }
            } else if (f.z <= f.w) {
                result = Cartesian4.clone(Cartesian4.UNIT_Z, result);
            } else {
                result = Cartesian4.clone(Cartesian4.UNIT_W, result);
            }
        } else if (f.y <= f.z) {
            if (f.y <= f.w) {
                result = Cartesian4.clone(Cartesian4.UNIT_Y, result);
            } else {
                result = Cartesian4.clone(Cartesian4.UNIT_W, result);
            }
        } else if (f.z <= f.w) {
            result = Cartesian4.clone(Cartesian4.UNIT_Z, result);
        } else {
            result = Cartesian4.clone(Cartesian4.UNIT_W, result);
        }

        return result;
    };

    /**
     * Compares the provided Cartesians componentwise and returns
     * true if they are equal, false otherwise.
     *
     * @param {Cartesian4} [left] The first Cartesian.
     * @param {Cartesian4} [right] The second Cartesian.
     * @returns {Boolean} true if left and right are equal, false otherwise.
     */
    Cartesian4.equals = function(left, right) {
        return (left === right) ||
               ((defined(left)) &&
                (defined(right)) &&
                (left.x === right.x) &&
                (left.y === right.y) &&
                (left.z === right.z) &&
                (left.w === right.w));
    };

    /**
     * Compares the provided Cartesians componentwise and returns
     * true if they pass an absolute or relative tolerance test,
     * false otherwise.
     *
     * @param {Cartesian4} [left] The first Cartesian.
     * @param {Cartesian4} [right] The second Cartesian.
     * @param {Number} relativeEpsilon The relative epsilon tolerance to use for equality testing.
     * @param {Number} [absoluteEpsilon=relativeEpsilon] The absolute epsilon tolerance to use for equality testing.
     * @returns {Boolean} true if left and right are within the provided epsilon, false otherwise.
     */
    Cartesian4.equalsEpsilon = function(left, right, relativeEpsilon, absoluteEpsilon) {
        return (left === right) ||
               (defined(left) &&
                defined(right) &&
                CesiumMath.equalsEpsilon(left.x, right.x, relativeEpsilon, absoluteEpsilon) &&
                CesiumMath.equalsEpsilon(left.y, right.y, relativeEpsilon, absoluteEpsilon) &&
                CesiumMath.equalsEpsilon(left.z, right.z, relativeEpsilon, absoluteEpsilon) &&
                CesiumMath.equalsEpsilon(left.w, right.w, relativeEpsilon, absoluteEpsilon));
    };

    /**
     * An immutable Cartesian4 instance initialized to (0.0, 0.0, 0.0, 0.0).
     *
     * @type {Cartesian4}
     * @constant
     */
    Cartesian4.ZERO = freezeObject(new Cartesian4(0.0, 0.0, 0.0, 0.0));

    /**
     * An immutable Cartesian4 instance initialized to (1.0, 0.0, 0.0, 0.0).
     *
     * @type {Cartesian4}
     * @constant
     */
    Cartesian4.UNIT_X = freezeObject(new Cartesian4(1.0, 0.0, 0.0, 0.0));

    /**
     * An immutable Cartesian4 instance initialized to (0.0, 1.0, 0.0, 0.0).
     *
     * @type {Cartesian4}
     * @constant
     */
    Cartesian4.UNIT_Y = freezeObject(new Cartesian4(0.0, 1.0, 0.0, 0.0));

    /**
     * An immutable Cartesian4 instance initialized to (0.0, 0.0, 1.0, 0.0).
     *
     * @type {Cartesian4}
     * @constant
     */
    Cartesian4.UNIT_Z = freezeObject(new Cartesian4(0.0, 0.0, 1.0, 0.0));

    /**
     * An immutable Cartesian4 instance initialized to (0.0, 0.0, 0.0, 1.0).
     *
     * @type {Cartesian4}
     * @constant
     */
    Cartesian4.UNIT_W = freezeObject(new Cartesian4(0.0, 0.0, 0.0, 1.0));

    /**
     * Duplicates this Cartesian4 instance.
     *
     * @param {Cartesian4} [result] The object onto which to store the result.
     * @returns {Cartesian4} The modified result parameter or a new Cartesian4 instance if one was not provided.
     */
    Cartesian4.prototype.clone = function(result) {
        return Cartesian4.clone(this, result);
    };

    /**
     * Compares this Cartesian against the provided Cartesian componentwise and returns
     * true if they are equal, false otherwise.
     *
     * @param {Cartesian4} [right] The right hand side Cartesian.
     * @returns {Boolean} true if they are equal, false otherwise.
     */
    Cartesian4.prototype.equals = function(right) {
        return Cartesian4.equals(this, right);
    };

    /**
     * Compares this Cartesian against the provided Cartesian componentwise and returns
     * true if they are within the provided epsilon,
     * false otherwise.
     *
     * @param {Cartesian4} [right] The right hand side Cartesian.
     * @param {Number} epsilon The epsilon to use for equality testing.
     * @returns {Boolean} true if they are within the provided epsilon, false otherwise.
     */
    Cartesian4.prototype.equalsEpsilon = function(right, epsilon) {
        return Cartesian4.equalsEpsilon(this, right, epsilon);
    };

    /**
     * Creates a string representing this Cartesian in the format '(x, y)'.
     *
     * @returns {String} A string representing the provided Cartesian in the format '(x, y)'.
     */
    Cartesian4.prototype.toString = function() {
        return '(' + this.x + ', ' + this.y + ', ' + this.z + ', ' + this.w + ')';
    };

    return Cartesian4;
});


text:
package org.sd.xml;

import java.io.File;
import java.io.IOException;
import java.util.LinkedList;
import java.util.Properties;
import org.sd.io.FileUtil;
import org.sd.util.PropertiesParser;

/**
 * DOM-backed properties container.
 *

 * @author Spence Koehler
 */
public class DataProperties extends BaseDataProperties {

  private LinkedList<DomDataProperties> domDataProperties;
  private Properties properties;
  private String[] remainingArgs;

  /**
   * Construct containing only environment variables.
   */
  public DataProperties() {
    init(new String[]{}, null);
  }

  /**
   * Args of form:
   *  - X.default.properties -- load env's DEFAULT_PROPERTIES_DIR's X.properties file
   *  - X.properties -- load X.properties file
   *  - property=value -- set property
   *  - X.xml -- load X.xml dom config file
   *
   * NOTEs:
   *  - Properties trump config (xml) mappings.
   *  - Later specified properties trump formerly specified properties.
   */
  public DataProperties(String[] args) {
    init(args, null);
  }

  public DataProperties(String[] args, String workingDir) {
    init(args, workingDir);
  }

  public DataProperties(Properties properties) {
    this.properties = properties;
    this.domDataProperties = new LinkedList<DomDataProperties>();
  }

  public DataProperties(DomElement domElement) {
    init(new String[]{}, null);

    final DomDataProperties ddp = new DomDataProperties(domElement);
    doAddDataProperties(ddp);

    final DataProperties elementProperties = domElement.getDataProperties();
    if (elementProperties != null) {
      this.properties = elementProperties.properties;
    }
  }

  public DataProperties(File xmlFile) throws IOException {
    init(new String[]{}, null);

    final DomDataProperties ddp = new DomDataProperties(xmlFile);
    doAddDataProperties(ddp);
  }

  /** Copy constructor. */
  public DataProperties(DataProperties other) {
    if (other == null) {
      init(new String[]{}, null);
    }
    else {
      this.domDataProperties = copy(other.domDataProperties);
      this.properties = copy(other.properties);
      this.remainingArgs = copy(other.remainingArgs);
    }
  }

  private final LinkedList<DomDataProperties> copy(LinkedList<DomDataProperties> otherDomDataProperties) {
    //NOTE: currently no deep copy on DomDataProperties
    return otherDomDataProperties == null ? null : new LinkedList<DomDataProperties>(otherDomDataProperties);
  }

  private final Properties copy(Properties otherProperties) {
    if (otherProperties == null) return null;

    final Properties result = new Properties();
    for (String name : otherProperties.stringPropertyNames()) {
      result.setProperty(name, otherProperties.getProperty(name));
    }

    return result;
  }

  /** copy otherProperties into result */
  private final void doCopy(Properties result, Properties otherProperties) {
    for (String name : otherProperties.stringPropertyNames()) {
      result.setProperty(name, otherProperties.getProperty(name));
    }
  }

  private final String[] copy(String[] otherArgs) {
    String[] result = null;

    if (otherArgs != null) {
      result = new String[otherArgs.length];
      for (int i = 0; i < otherArgs.length; ++i) {
        result[i] = otherArgs[i];
      }
    }

    return result;
  }

  private final void init(String[] args, String workingDir) {
    try {
      this.domDataProperties = new LinkedList<DomDataProperties>();

      final PropertiesParser pp = new PropertiesParser(args, workingDir, true);
      this.properties = pp.getProperties();
      this.remainingArgs = pp.getArgs();

      final File base = (workingDir == null) ? new File(".") : new File(workingDir);

      for (String arg : pp.getArgs()) {
        if (arg.endsWith(".xml")) {
          final DomDataProperties ddp = new DomDataProperties(new File(base, arg));
          doAddDataProperties(ddp);
        }
      }
    }
    catch (IOException e) {
      throw new IllegalStateException(e);
    }
  }

  private final void doAddDataProperties(DomDataProperties ddp) {
    domDataProperties.addFirst(ddp);
    ddp.getDomElement().setDataProperties(this);
  }

  public boolean isEmpty() {
    return (properties == null || properties.size() == 0) && domDataProperties.size() == 0;
  }

  public String[] getRemainingArgs() {
    return remainingArgs;
  }

  public Properties getProperties() {
    return properties;
  }

  public DomElement getDomElement() {
    return domDataProperties.size() > 0 ? domDataProperties.getFirst().getDomElement() : null;
  }

  public DomDataProperties getDomDataProperties() {
    return domDataProperties.size() > 0 ? domDataProperties.getFirst() : null;
  }

  public LinkedList<DomDataProperties> getAllDomDataProperties() {
    return domDataProperties;
  }

  /**
   * Add a dom element as a property.
   */
  public void addDomElement(DomElement domElement) {
    if (domElement != null) {
      final DomDataProperties ddp = new DomDataProperties(domElement);
      doAddDataProperties(ddp);
    }
  }

  /**
   * Get the first (most recently added) DomElement with the given name
   * (or null).
   */
  public DomElement getDomElement(String name) {
    DomElement result = null;

    for (DomDataProperties ddp : domDataProperties) {
      final DomElement curElt = ddp.getDomElement();
      if (name.equals(curElt.getLocalName())) {
        result = curElt;
        break;
      }
    }

    return result;
  }

  /**
   * Build an instance of the domNode's class specified by its relative
   * classXPath that takes the domNode object as its sole construction
   * parameter.
   */
  public Object buildInstance(DomNode domNode, String classXPath) {
    return domDataProperties.size() > 0 ? domDataProperties.getFirst().buildInstance(domNode, classXPath) : null;
  }

  /**
   * Incorporate the other properties into this instance's properties.
   */
  public void incorporate(Properties other) {
    if (other != null) {
      if (properties == null) properties = new Properties();
      doCopy(properties, other);
    }
  }

  /**
   * Incorporate the given propertiesFile into this instance's properties,
   * adding the optionalExtension if needed.
   */
  public DataProperties incorporateProperties(File propertiesFile, String optionalExtension) throws IOException {
    // load the file, adding optionalExtension if needed
    this.properties = FileUtil.loadProperties(this.properties, propertiesFile, optionalExtension);
    return this;
  }

  /**
   * Add a new property or override an existing.
   */
  public void set(String key, String value) {
    if (value == null) {
      properties.remove(key);
    }
    else {
      properties.setProperty(key, value);
    }
  }

  /**
   * Add a new property or override an existing.
   */
  public void set(String key, boolean value) {
    properties.setProperty(key, Boolean.toString(value));
  }

  /**
   * Add a new property or override an existing.
   */
  public void set(String key, int value) {
    properties.setProperty(key, Integer.toString(value));
  }

  /**
   * Set the property to have the value iff its value is currently null.
   */
  public void setIfNull(String key, String value) {
    if (!hasProperty(key)) properties.setProperty(key, value);
  }

  /**
   * Set the property to have the value iff its value is currently null.
   */
  public void setIfNull(String key, boolean value) {
    if (!hasProperty(key)) properties.setProperty(key, Boolean.toString(value));
  }

  /**
   * Set the property to have the value iff its value is currently null.
   */
  public void setIfNull(String key, int value) {
    if (!hasProperty(key)) properties.setProperty(key, Integer.toString(value));
  }

  /**
   * Replace segments of the form "${x}" with getString(x) iff getString(x) != null.
   */
  public String replaceVariables(String text) {
    if (text == null) return null;

    final StringBuilder result = new StringBuilder();

    while (doReplaceVariables(text, result)) {
      text = result.toString();
      result.setLength(0);
    }

    return text;
  }

  public String getFilename(String key) {
    String filename = getString(key);
    return replaceVariables(filename);
  }

  public String getFilename(String key, String defaultValue) {
    String filename = getString(key, defaultValue);
    return replaceVariables(filename);
  }

  /**
   * Get the file referenced by the 'key', replacing variables and taking
   * the value of the 'workingDirKey' into account if present.
   *

   * @return the file or null.
   */
  public File getFile(String key, String workingDirKey) {
    return getWorkingFile(getString(key, null), workingDirKey);
  }

  /**
   * Translate the filename into a File under the workingDir indicated
   * by the key if present -- note that the key itself may be null or
   * the value associated with the key may be null, in which case the
   * filename itself is used as the full file path.
   */
  public File getWorkingFile(String filename, String workingDirKey) {
    File result = null;

    if (filename != null) {
      filename = replaceVariables(filename);
      final char firstChar = ("".equals(filename)) ? (char)0 : filename.charAt(0);
      final String workingDir = (firstChar == '/' || firstChar == '\\') ? null : replaceVariables(getString(workingDirKey, null));
      if (workingDir != null) {
        result = new File(new File(workingDir), filename);
      }
      else {
        result = new File(filename);
      }
    }

    return result;
  }

  private final boolean doReplaceVariables(String text, StringBuilder result) {
    boolean replaced = false;

    int ptr = 0;
    int varEndPos = 0;
    for (int varStartPos = text.indexOf("${"); varStartPos >= 0 && ptr < text.length(); varStartPos = text.indexOf("${", varEndPos + 1)) {
      if (varStartPos > ptr) {
        result.append(text.substring(ptr, varStartPos));
        ptr = varStartPos;
      }

      varEndPos = text.indexOf('}', varStartPos + 2);
      if (varEndPos < 0) {
        break;
      }

      final String var = text.substring(varStartPos + 2, varEndPos);
      final String val = getValueString(var);
      if (val != null) {
        // replace variable with value
        result.append(val);
        replaced = true;
      }
      else {
        // keep variable text unchanged
        result.append(text.substring(varStartPos, varEndPos + 1));
      }

      ptr = varEndPos + 1;
    }

    if (ptr < text.length()) result.append(text.substring(ptr));

    return replaced;
  }

  protected String getValueString(String key) {
    if (properties == null || key == null) return null;

    String result = properties.getProperty(key);

    if (result == null) {
      for (DomDataProperties ddp : domDataProperties) {
        result = ddp.getValueString(key);
        if (result != null) {
          // cache the result for faster access next time
          //set(key, result);
          break;
        }
      }
    }

    return result;
  }
}


text:
package April2021PrepLeetcode;

public class _0100SameTree {
	public static class TreeNode {
		int val;
		TreeNode left;
		TreeNode right;

		TreeNode() {
		}

		TreeNode(int val) {
			this.val = val;
		}

		TreeNode(int val, TreeNode left, TreeNode right) {
			this.val = val;
			this.left = left;
			this.right = right;
		}
	}

	public static void main(String[] args) {
		TreeNode tn1 = new TreeNode(1);
		tn1.left = new TreeNode(2);
		tn1.right = new TreeNode(3);
		TreeNode tn2 = new TreeNode(1);
		tn2.left = new TreeNode(2);
		tn2.right = new TreeNode(3);
		System.out.println(isSameTree(tn1, tn2));

		tn1 = new TreeNode(1);
		tn1.left = new TreeNode(2);
		tn2 = new TreeNode(1);
		tn2.right = new TreeNode(2);
		System.out.println(isSameTree(tn1, tn2));

		tn1 = new TreeNode(1);
		tn1.left = new TreeNode(2);
		tn1.right = new TreeNode(1);
		tn2 = new TreeNode(1);
		tn2.left = new TreeNode(1);
		tn2.right = new TreeNode(2);
		System.out.println(isSameTree(tn1, tn2));
	}

	public static boolean isSameTree(TreeNode p, TreeNode q) {
		if (p == null && q == null)
			return true;
		else if (p == null || q == null)
			return false;
		return p.val == q.val && isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
	}
}


text:
var keyMirror = require('keymirror');

/**
 * Application action constants
 *
 * @global
 * @name AppActionConstants
 * @type {object}
 */
var constants = {
	ActionTypes: {
		cmsUser: keyMirror({
			LOGGED_IN                       : null,
			LOGGED_OUT                      : null,
			SCOPES_RECEIVED                 : null,
			PASSWORD_RESET_SENT             : null,
			REQUEST_SIGN_OUT                : null,
			CANCEL_SIGN_OUT                 : null,
			USER_CHANGED_FORM_EDITING_STATE : null,
			FAILED_AUTHENTICATION           : null,
			VERIFYING_ACCESS_TOKEN          : null
		}),

		alerts: keyMirror({
			ALERT_ERROR           : null,
			ALERT_SUCCESS         : null,
			FAILED_AUTHENTICATION : null,
			FAILED_DATA_RETRIEVAL : null,
			SUCCEED_EDIT_MODEL    : null
		}),

		cms: {
			tableData: keyMirror({
				REORDERED_DATA: null
			}),

			form: keyMirror({
				USER_CHANGED_FORM_EDITING_STATE : null,
				FORM_REGISTER_FORM              : null,
				FORM_EDIT_FIELD                 : null,
				FORM_FIELD_VALIDITIES           : null,
				TYPEAHEAD_QUERY                 : null,
				FORM_CLEAR_TYPEAHEAD_QUERY      : null,
				CLEAR_FORM                      : null
			}),

			pagination: keyMirror({
				RECEIVED_PAGINATED_DATA: null
			}),

			requests: keyMirror({
				UPLOAD_PROGRESS: null
			})
		}
	}
};

module.exports = constants;


text:
require('babel/register')({
  stage: 0,
  plugins: ['typecheck']
});

/**
 * Define isomorphic constants.
 */
global.__CLIENT__ = false;
global.__SERVER__ = true;
delete global.__BROWSER__;

if (process.env.NODE_ENV !== 'production') {
  if (!require('piping')({
      hook: true,
      ignore: /(\/\.|~$|\.json|\.scss$)/i
    })) {
    return;
  }
}

require('./src/server');


text:
json2bean
=========

Convert json string to java bean.

=========

### Input like:

```json
{
  "VirtualMachineCopies": [
    {
      "id": "d141161b-8d68-4ed0-be9b-39e01ec9fdd3",
      "servicePlans": [
        {
          "id": "a4e81175-7578-47bd-b140-d6157844f198",
          "name": "Bronze"
        }
      ],
      "phasepitPhaseOptions": {
        "throttle": "4",
        "includeAllDisks": "true",
        "expireKeepCopyCount": "7",
        "rpCopyType": "CDP"
      },
      "version": "vmx-09",
      "numCPUs": "1",
      "powerState": "poweredOff"
    }
  ]
}
```

##Output like:

```
Log output:

[INFO] - force mkdir [C:\json-2-bean\].
[INFO] - start parse json object
[INFO] - private List<VirtualMachineCopy> VirtualMachineCopies;
[INFO] - JSONObject: [VirtualMachineCopy] VirtualMachineCopy
[INFO] - file [C:\json-2-bean\VirtualMachineCopy.java] exists.
[INFO] - private String id;
[INFO] - private String powerState;
[INFO] - private List<ServicePlan> servicePlans;
[INFO] - private String numCPUs;
[INFO] - private PhasepitPhaseOptions phasepitPhaseOptions;
[INFO] - private String version;
[INFO] - JSONObject: [ServicePlan] servicePlan
[INFO] - file [C:\json-2-bean\ServicePlan.java] exists.
[INFO] - private String id;
[INFO] - private String name;
[INFO] - JSONObject: [PhasepitPhaseOptions] phasepitPhaseOptions
[INFO] - file [C:\json-2-bean\PhasepitPhaseOptions.java] exists.
[INFO] - private String throttle;
[INFO] - private String includeAllDisks;
[INFO] - private String expireKeepCopyCount;
[INFO] - private String rpCopyType;
[INFO] - end parse json object

Created Java File:

VirtualMachineCopy.java

package com.emc.vsi.providers.data;

/**
*
* @author weichx
*
*/
public class VirtualMachineCopy {

private String id;
private String powerState;
private List<ServicePlan> servicePlans;
private String numCPUs;
private PhasepitPhaseOptions phasepitPhaseOptions;
private String version;

}

PhasepitPhaseOptions.java

package com.emc.vsi.providers.data;

/**
*
* @author weichx
*
*/
public class PhasepitPhaseOptions {

private String throttle;
private String includeAllDisks;
private String expireKeepCopyCount;
private String rpCopyType;

}

ServicePlan.java

package com.emc.vsi.providers.data;

/**
*
* @author weichx
*
*/
public class ServicePlan {

private String id;
private String name;

}

```

# 使用说明:

- 输入json字符串
- 输出java bean类文件

### json字符串要求(key:value value的类型要求)
- Boolean
- String
- Integer
- Long
- Short
- Character
- JsonObject
- JsonArray
- 其它类型暂不支持


text:
<?php
namespace Jmondi\Gut\Infrastructure\Template\LeagueCommonMark;

interface MarkdownParserInterface
{
    public function render(string $string): string;
}


text:
from kinto.core.utils import instance_uri
from datetime import datetime

def on_resource_changed(event):
    """
    Everytime an object is created/changed/deleted, we create an entry in the
    ``history`` resource. The entries are served as read-only in the
    :mod:`kinto.plugins.history.views` module.
    """
    payload = event.payload
    resource_name = payload['resource_name']
    event_uri = payload['uri']

    bucket_id = None
    bucket_uri = None
    collection_uri = None

    storage = event.request.registry.storage
    permission = event.request.registry.permission

    targets = []
    for impacted in event.impacted_records:
        target = impacted['new']
        obj_id = target['id']

        try:
            bucket_id = payload['bucket_id']
        except KeyError:
            # e.g. DELETE /buckets
            bucket_id = obj_id
        bucket_uri = instance_uri(event.request, 'bucket', id=bucket_id)

        if 'collection_id' in payload:
            collection_id = payload['collection_id']
            collection_uri = instance_uri(event.request,
                                          'collection',
                                          bucket_id=bucket_id,
                                          id=collection_id)

        # On POST .../records, the URI does not contain the newly created
        # record id.
        parts = event_uri.split('/')
        if resource_name in parts[-1]:
            parts.append(obj_id)
        else:
            # Make sure the id is correct on grouped events.
            parts[-1] = obj_id
        uri = '/'.join(parts)
        targets.append((uri, target))

    # Prepare a list of object ids to be fetched from permission backend,
    # and fetch them all at once. Use a mapping for later convenience.
    all_perms_objects_ids = [oid for (oid, _) in targets]
    all_perms_objects_ids.append(bucket_uri)
    if collection_uri is not None:
        all_perms_objects_ids.append(collection_uri)
    all_perms_objects_ids = list(set(all_perms_objects_ids))
    all_permissions = permission.get_objects_permissions(all_perms_objects_ids)
    perms_by_object_id = dict(zip(all_perms_objects_ids, all_permissions))

    bucket_perms = perms_by_object_id[bucket_uri]
    collection_perms = {}
    if collection_uri is not None:
        collection_perms = perms_by_object_id[collection_uri]

    # The principals allowed to read the bucket and collection.
    # (Note: ``write`` means ``read``)
    read_principals = set(bucket_perms.get('read', []))
    read_principals.update(bucket_perms.get('write', []))
    read_principals.update(collection_perms.get('read', []))
    read_principals.update(collection_perms.get('write', []))

    # Create a history entry for each impacted record.
    for (uri, target) in targets:
        obj_id = target['id']
        # Prepare the history entry attributes.
        perms = {k: list(v) for k, v in perms_by_object_id[uri].items()}
        eventattrs = dict(**payload)
        eventattrs.pop('bucket_id', None)
        eventattrs.setdefault('%s_id' % resource_name, obj_id)
        eventattrs['uri'] = uri
        attrs = dict(date=datetime.now().isoformat(),
                     target={'data': target, 'permissions': perms},
                     **eventattrs)

        # Create a record for the 'history' resource, whose parent_id is
        # the bucket URI (c.f. views.py).
        # Note: this will be rolledback if the transaction is rolledback.
        entry = storage.create(parent_id=bucket_uri,
                               collection_id='history',
                               record=attrs)

        # The read permission on the newly created history entry is the union
        # of the record permissions with the one from bucket and collection.
        entry_principals = set(read_principals)
        entry_principals.update(perms.get('read', []))
        entry_principals.update(perms.get('write', []))
        entry_perms = {'read': list(entry_principals)}
        # /buckets/{id}/history is the URI for the list of history entries.
        entry_perm_id = '/buckets/%s/history/%s' % (bucket_id, entry['id'])
        permission.replace_object_permissions(entry_perm_id, entry_perms)


text:
function analysis(Dir,Dat)
%

close all;

%% load the subject matlab file
cd(Dir.anadir);
eval(sprintf('fl=dir(''%s_1.mat'');',Dat.file(1:(end-4))));
load(fl(1).name);

ds=Dat.ds;
thechan = [3 4 5 6 7 8 9 10 11 12 13 14 15 16];% Emotiv EEG Channels

 for k=1:length(thechan)
%% Time domain plot
cd(Dir.croth);
t=linspace(0,length(data(thechan(k),:))/ds,length(data(thechan(k),:)));
tempe=data(thechan(k),:)-mean(data(thechan(k),:));
figure,plot(t,tempe);xlabel('Time in seconds');ylabel('Amplitude');
title('Mean Removed Time domain plot')

%saveas(gcf,strcat('TimeDomain_channel', int2str(k)), 'pdf')
%saveas(gcf,strcat('TimeDomain_channel', int2str(k+4)), 'pdf')
close all

% PSD plot
% Hs=spectrum.welch;
% Hs.SegmentLength=128;% set to sampling rate
% figure,psd(Hs,data(thechan(k),:),'Fs',ds);
%% Freq domain
% FFT code
L=length(tempe);
NFFT = 2^nextpow2(L); % Next power of 2 from length of y
Y = fft(tempe,NFFT)/L;
f = ds/2*linspace(0,1,NFFT/2+1);

% Plot single-sided amplitude spectrum.
figure,plot(f,2*abs(Y(1:NFFT/2+1)))
title('Single-Sided Amplitude Spectrum using FFT')
xlabel('Frequency (Hz)')
ylabel('|Y(f)|')

%saveas(gcf,strcat('FFT_channel', int2str(k)), 'pdf')

% Spectrogram plot
%[S,Freq,T,P]=spectrogram(x,window,noverlap,F,fs);% S-STFT;Freq=rounded freq,T=vector of times at which
% specgram is % %computed,P=power spectral intensity of each segment;noverlap is less than window size
[S,Freq,T,P] = spectrogram(tempe,ds,32,ds,ds); figure
surf(T,Freq,10*log10(P),'edgecolor','none'); axis tight;
view(0,90);title('Spectrogram showing Entire spectrum for whole session');colorbar
xlabel('Time (Seconds)'); ylabel('Hz');
%eval(sprintf('Spectrogram_channel%0.0f.png -m2.5 -painters',k))
%saveas(gcf,strcat('Specgram_channel', int2str(k)), 'fig')
%saveas(gcf,strcat('Specgram_channel', int2str(k)), 'pdf')
close all

 end
end