text:
package com.asakusafw.shafu.internal.ui.wizards;

import java.io.Closeable;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URL;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.window.Window;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.swt.SWT;
import org.eclipse.ui.INewWizard;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkingSet;
import org.eclipse.ui.dialogs.ListDialog;
import org.eclipse.ui.wizards.newresource.BasicNewResourceWizard;

import com.asakusafw.shafu.core.gradle.GradleBuildTask;
import com.asakusafw.shafu.core.gradle.GradleContext;
import com.asakusafw.shafu.core.net.IContentProcessor;
import com.asakusafw.shafu.core.net.ShafuNetwork;
import com.asakusafw.shafu.core.util.IRunnable;
import com.asakusafw.shafu.core.util.IoUtils;
import com.asakusafw.shafu.core.util.StatusUtils;
import com.asakusafw.shafu.internal.ui.Activator;
import com.asakusafw.shafu.internal.ui.LogUtil;
import com.asakusafw.shafu.ui.ShafuUi;
import com.asakusafw.shafu.ui.consoles.ShafuConsole;
import com.asakusafw.shafu.ui.util.ProgressUtils;

/**
 * Wizard of creating project from application templates.
 */
public class NewProjectWizard extends Wizard implements INewWizard {

    private IWorkbench currentWorkbench;

    private IStructuredSelection currentSelection;

    private SelectProjectTemplatePage templatePage;

    private ProjectInformationPage informationPage;

    @Override
    public void init(IWorkbench workbench, IStructuredSelection selection) {
        this.currentWorkbench = workbench;
        this.currentSelection = selection;
        setNeedsProgressMonitor(true);
        setWindowTitle(Messages.NewProjectWizard_title);
    }

    @Override
    public void addPages() {
        this.templatePage = new SelectProjectTemplatePage();
        this.informationPage = new ProjectInformationPage();
        addPage(informationPage);
        addPage(templatePage);
        informationPage.setSelection(currentSelection);
    }

    @Override
    public boolean canFinish() {
        if (getContainer().getCurrentPage().getNextPage() != null) {
            return false;
        }
        return super.canFinish();
    }

    @Override
    public boolean performFinish() {
        final File projectDirectory = computeProjectDirectory();
        if (projectDirectory.exists()) {
            boolean delete = MessageDialog.openConfirm(
                    getShell(),
                    Messages.NewProjectWizard_dialogOverwriteTitle,
                    MessageFormat.format(
                            Messages.NewProjectWizard_dialogOverwriteMessage,
                            projectDirectory));
            if (delete == false) {
                return false;
            }
        }

        final IWorkingSet[] workingSets = informationPage.getSelectedWorkingSets();
        final List<String> taskNames = templatePage.getTaskNames();
        final ShafuConsole console = templatePage.getConsole();
        final AtomicReference<Stage> stageRef = new AtomicReference<>(Stage.INIT);
        final Archive templateArchive = new Archive(templatePage.getTargetFile(), templatePage.getTargetUrl());
        try {
            ProgressUtils.run(getContainer(), new IRunnable() {
                @Override
                public void run(IProgressMonitor monitor) throws CoreException {
                    SubMonitor sub = SubMonitor.convert(monitor);
                    try {
                        perform(sub, projectDirectory, workingSets, templateArchive, taskNames, console, stageRef);
                    } finally {
                        monitor.done();
                    }
                }
            });
        } catch (RuntimeException e) {
            IStatus status = new Status(
                    IStatus.ERROR,
                    Activator.PLUGIN_ID,
                    Messages.NewProjectWizard_errorUnknown,
                    e);
            LogUtil.log(status);
            ErrorDialog.openError(getShell(), null, null, status);
            templatePage.setPageComplete(false);
            return false;
        } catch (CoreException e) {
            if (StatusUtils.hasCancel(e.getStatus())) {
                return false;
            }
            switch (stageRef.get()) {
            case BUILD:
                templatePage.setErrorMessage(Messages.NewProjectWizard_errorTemplateBuild);
                templatePage.openConsole();
                break;
            default:
                templatePage.setErrorMessage(e.getStatus().getMessage());
                LogUtil.log(e.getStatus());
                break;
            }
            templatePage.setPageComplete(false);
            return false;
        } finally {
            templateArchive.close();
        }
        return true;
    }

    private File computeProjectDirectory() {
        if (informationPage.useDefaults()) {
            return informationPage.getLocationPath().append(informationPage.getProjectName()).toFile();
        } else {
            return informationPage.getLocationPath().toFile();
        }
    }

    void perform(
            SubMonitor monitor,
            File projectDirectory, IWorkingSet[] workingSets,
            Archive archive,
            List<String> taskNames, ShafuConsole console, AtomicReference<Stage> stageRef) throws CoreException {
        monitor.beginTask(Messages.NewProjectWizard_monitorMain, 100);
        extractProjectContents(monitor.newChild(20, SubMonitor.SUPPRESS_NONE), projectDirectory, archive);
        boolean succeed = false;
        try {
            stageRef.set(Stage.BUILD);
            buildProject(monitor.newChild(60, SubMonitor.SUPPRESS_NONE), projectDirectory, taskNames, console);

            stageRef.set(Stage.DEPLOY);
            deployProject(monitor.newChild(20, SubMonitor.SUPPRESS_NONE), projectDirectory, workingSets);

            succeed = true;
        } finally {
            if (succeed == false && projectDirectory.exists()) {
                IoUtils.deleteQuietly(projectDirectory);
            }
        }
    }

    private void extractProjectContents(
            SubMonitor monitor,
            File projectDirectory,
            Archive archive) throws CoreException {
        monitor.beginTask(Messages.NewProjectWizard_monitorExtractContents, 100);
        StatusUtils.checkCanceled(monitor);
        File temporaryFolder = archive.extract(monitor.newChild(80));
        try {
            File temporaryProjectFolder = detectProjectEntry(monitor.newChild(10), temporaryFolder);
            if (projectDirectory.exists()) {
                IoUtils.deleteQuietly(projectDirectory);
            }
            copyContents(monitor.newChild(10), temporaryProjectFolder, projectDirectory);
        } finally {
            IoUtils.deleteQuietly(temporaryFolder);
        }
    }

    private File detectProjectEntry(SubMonitor monitor, File temporaryFolder) throws CoreException {
        monitor.beginTask(Messages.NewProjectWizard_monitorInspectProject, 100);
        List<File> results = new ArrayList<>();
        detectProjectEntry0(monitor, temporaryFolder, results);
        if (results.isEmpty()) {
            throw new CoreException(new Status(
                    IStatus.ERROR,
                    Activator.PLUGIN_ID,
                    MessageFormat.format(
                            Messages.NewProjectWizard_errorTemplateInvalid,
                            GradleContext.DEFAULT_BUILD_SCRIPT_NAME)));
        } else {
            File result = selectProjectEntry(temporaryFolder, results);
            if (result == null) {
                throw new CoreException(Status.CANCEL_STATUS);
            }
            return result;
        }
    }

    private File selectProjectEntry(File temporaryFolder, List<File> results) {
        assert results.isEmpty() == false;
        if (results.size() == 1) {
            return results.get(0).getParentFile();
        }
        final List<IPath> paths = new ArrayList<>();
        IPath base = Path.fromOSString(temporaryFolder.getAbsolutePath());
        for (File file : results) {
            IPath path = Path.fromOSString(file.getAbsolutePath());
            paths.add(path.removeFirstSegments(base.segmentCount()));
        }
        Collections.sort(paths, new Comparator<IPath>() {
            @Override
            public int compare(IPath o1, IPath o2) {
                return o1.toPortableString().compareToIgnoreCase(o2.toPortableString());
            }
        });
        IPath selection = selectProjectEntryByDialog(paths);
        if (selection == null) {
            return null;
        }
        return base.append(selection).toFile().getParentFile();
    }

    private IPath selectProjectEntryByDialog(final List<IPath> paths) {
        final AtomicReference<IPath> selectionResult = new AtomicReference<>();
        Activator.getDisplay().syncExec(new Runnable() {
            @Override
            public void run() {
                ListDialog dialog = new ListDialog(getShell()) {
                    @Override
                    protected int getTableStyle() {
                        return super.getTableStyle() | SWT.SINGLE;
                    }
                };
                dialog.setTitle(Messages.NewProjectWizard_selectEntryTitle);
                dialog.setMessage(Messages.NewProjectWizard_selectEntryMessage);
                dialog.setInitialSelections(new Object[] { paths.get(0) });
                dialog.setInput(paths);
                dialog.setContentProvider(ArrayContentProvider.getInstance());
                dialog.setLabelProvider(new ShortenLabelProvider(paths));
                if (dialog.open() != Window.OK) {
                    return;
                }
                Object[] selected = dialog.getResult();
                if (selected.length >= 1) {
                    selectionResult.set((IPath) selected[0]);
                }
            }
        });
        return selectionResult.get();
    }

    private void detectProjectEntry0(SubMonitor monitor, File folder, List<File> results) {
        File file = new File(folder, GradleContext.DEFAULT_BUILD_SCRIPT_NAME);
        if (file.isFile()) {
            results.add(file);
        } else {
            for (File child : folder.listFiles()) {
                if (child.isDirectory()) {
                    detectProjectEntry0(monitor, child, results);
                }
            }
        }
        monitor.worked(1);
        monitor.setWorkRemaining(100);
    }

    private void copyContents(SubMonitor monitor, File from, File to) throws CoreException {
        monitor.beginTask(Messages.NewProjectWizard_monitorCopyContents, 100);
        try {
            IoUtils.move(monitor.newChild(100), from, to);
        } catch (IOException e) {
            throw new CoreException(new Status(
                    IStatus.ERROR,
                    Activator.PLUGIN_ID,
                    MessageFormat.format(
                            Messages.NewProjectWizard_errorProjectFailedToCopyContent,
                            to)));
        }
    }

    private void buildProject(
            SubMonitor monitor,
            File projectDirectory,
            List<String> taskNames,
            ShafuConsole console) throws CoreException {
        GradleContext configuration = ShafuUi.createContext(projectDirectory);
        console.clearConsole();
        console.attachTo(configuration);
        new GradleBuildTask(configuration, taskNames).run(monitor);
    }

    private void deployProject(
            SubMonitor monitor,
            File projectDirectory, IWorkingSet[] workingSets) throws CoreException {
        monitor.beginTask(Messages.NewProjectWizard_monitorLoadProject, 100);
        IProjectDescription description = loadDescription(monitor.newChild(20), projectDirectory);
        IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(description.getName());
        if (project.exists()) {
            throw new CoreException(new Status(
                    IStatus.ERROR,
                    Activator.PLUGIN_ID,
                    MessageFormat.format(
                            Messages.NewProjectWizard_errorProjectConflict,
                            project.getName())));
        }
        project.create(description, new SubProgressMonitor(monitor, 20));
        project.open(new SubProgressMonitor(monitor, 10));
        if (workingSets.length > 0) {
            currentWorkbench.getWorkingSetManager().addToWorkingSets(project, workingSets);
        }
        BasicNewResourceWizard.selectAndReveal(project, currentWorkbench.getActiveWorkbenchWindow());
    }

    private IProjectDescription loadDescription(SubMonitor monitor, File projectDirectory) throws CoreException {
        monitor.beginTask(Messages.NewProjectWizard_monitorLoadDescription, 1);
        try {
            File file = new File(projectDirectory, IProjectDescription.DESCRIPTION_FILE_NAME);
            IPath path = Path.fromOSString(file.getAbsolutePath());
            return ResourcesPlugin.getWorkspace().loadProjectDescription(path);
        } finally {
            monitor.done();
        }
    }

    private enum Stage {

        INIT,

        BUILD,

        DEPLOY,
    }

    private static class ShortenLabelProvider extends LabelProvider {

        private final Map<IPath, IPath> resolved = new HashMap<>();

        public ShortenLabelProvider(List<? extends IPath> paths) {
            if (paths.size() >= 2) {
                int min = getMinimumSize(paths);
                int prefix = getCommonPrefixSize(paths);
                int suffix = getCommonSuffixSize(paths);
                if (prefix + suffix < min) {
                    for (IPath path : paths) {
                        IPath r = path.removeFirstSegments(prefix).removeLastSegments(suffix);
                        if (r.getDevice() != null && r.isAbsolute() == false) {
                            r = r.setDevice(null);
                        }
                        resolved.put(path, r);
                    }
                }
            }
        }

        @Override
        public String getText(Object element) {
            IPath path = (IPath) element;
            if (path == null) {
                return null;
            }
            IPath result = resolved.get(path);
            if (result == null) {
                result = path;
            }
            return result.toPortableString();
        }

        private int getMinimumSize(List<? extends IPath> paths) {
            int min = paths.get(0).segmentCount();
            for (IPath path : paths) {
                min = Math.min(min, path.segmentCount());
            }
            return min;
        }

        private int getCommonPrefixSize(List<? extends IPath> paths) {
            IPath first = paths.get(0);
            int commonSize = first.segmentCount();
            for (IPath path : paths) {
                if (commonSize == 0) {
                    break;
                }
                commonSize = getCommonPrefixSize(commonSize, first, path);
            }
            return commonSize;
        }

        private int getCommonSuffixSize(List<? extends IPath> paths) {
            assert paths.size() >= 2;
            IPath first = paths.get(0);
            int commonSize = first.segmentCount();
            for (IPath path : paths) {
                if (commonSize == 0) {
                    break;
                }
                commonSize = getCommonSuffixSize(commonSize, first, path);
            }
            return commonSize;
        }

        private int getCommonPrefixSize(int max, IPath a, IPath b) {
            int count = Math.min(max, Math.min(a.segmentCount(), b.segmentCount()));
            if (count == 0) {
                return 0;
            }
            for (int i = 0; i < count; i++) {
                if (a.segment(i).equals(b.segment(i)) == false) {
                    return i;
                }
            }
            return count;
        }

        private int getCommonSuffixSize(int max, IPath a, IPath b) {
            int count = Math.min(max, Math.min(a.segmentCount(), b.segmentCount()));
            if (count == 0) {
                return 0;
            }
            for (int i = count - 1; i >= 0; i--) {
                if (a.segment(i).equals(b.segment(i)) == false) {
                    return i;
                }
            }
            return count;
        }
    }

    private static class Archive implements Closeable {

        private final File file;

        private final URL url;

        private File temporaryFile;

        public Archive(File file, URL url) {
            if (file == null && url == null) {
                throw new IllegalArgumentException();
            }
            this.file = file;
            this.url = url;
        }

        public File extract(SubMonitor monitor) throws CoreException {
            monitor.beginTask(Messages.NewProjectWizard_monitorExtractArchive, 100);
            File archive = getFile(monitor.newChild(50));
            String name = getFileName();
            try {
                if (name.endsWith(".zip") || name.endsWith(".jar")) { //$NON-NLS-1$ //$NON-NLS-2$
                    return IoUtils.extractZip(monitor, archive);
                } else if (name.endsWith(".tar.gz")) { //$NON-NLS-1$
                    return IoUtils.extractTarGz(monitor, archive);
                } else {
                    throw new CoreException(new Status(
                            IStatus.ERROR,
                            Activator.PLUGIN_ID,
                            Messages.NewProjectWizard_errorArchiveNotSupport));
                }
            } catch (IOException e) {
                throw new CoreException(new Status(
                        IStatus.ERROR,
                        Activator.PLUGIN_ID,
                        Messages.NewProjectWizard_errorArchiveExtract));
            }
        }

        private String getFileName() {
            if (file != null) {
                return file.getName();
            } else {
                String path = url.getPath();
                int index = path.lastIndexOf('/');
                return path.substring(index + 1);
            }
        }

        private File getFile(final SubMonitor monitor) throws CoreException {
            if (file != null) {
                return file;
            } else if (temporaryFile != null) {
                return temporaryFile;
            }
            try {
                temporaryFile = File.createTempFile("tmp", ".bin"); //$NON-NLS-1$ //$NON-NLS-2$
                final OutputStream output = new FileOutputStream(temporaryFile);
                try {
                    ShafuNetwork.processContent(url, new IContentProcessor<Void>() {
                        @Override
                        public Void process(InputStream input) throws IOException {
                            byte[] buf = new byte[1024];
                            while (true) {
                                if (monitor.isCanceled()) {
                                    throw new OperationCanceledException();
                                }
                                int read = input.read(buf);
                                if (read < 0) {
                                    break;
                                }
                                monitor.setWorkRemaining(10000);
                                monitor.worked(read);
                                output.write(buf, 0, read);
                            }
                            return null;
                        }
                    });
                } finally {
                    output.close();
                }
                return temporaryFile;
            } catch (OperationCanceledException e) {
                throw new CoreException(Status.CANCEL_STATUS);
            } catch (IOException e) {
                throw new CoreException(new Status(
                        IStatus.ERROR,
                        Activator.PLUGIN_ID,
                        MessageFormat.format(
                                Messages.NewProjectWizard_errorArchiveDownload,
                                url),
                        e));
            }
        }

        @Override
        public void close() {
            if (temporaryFile != null) {
                temporaryFile.delete();
            }
        }
    }
}


text:
package exercices.classes;

public class Main {

	public static void main(String[] args) {
		Rectangle myNewRectangle = new Rectangle(3.4f, 6.7f);
		System.out.println(myNewRectangle.getLength());

		myNewRectangle.setLength(78.45f);

		System.out.println(myNewRectangle.getLength());

	}

}

redpajama_set_name: RedPajamaGithub


text:
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/pnp.h>
#include "base.h"

LIST_HEAD(pnp_cards);
static LIST_HEAD(pnp_card_drivers);

static const struct pnp_card_device_id * match_card(struct pnp_card_driver * drv, struct pnp_card * card)
{
	const struct pnp_card_device_id * drv_id = drv->id_table;
	while (*drv_id->id){
		if (compare_pnp_id(card->id,drv_id->id)) {
			int i = 0;
			for (;;) {
				int found;
				struct pnp_dev *dev;
				if (i == PNP_MAX_DEVICES || ! *drv_id->devs[i].id)
					return drv_id;
				found = 0;
				card_for_each_dev(card, dev) {
					if (compare_pnp_id(dev->id, drv_id->devs[i].id)) {
						found = 1;
						break;
					}
				}
				if (! found)
					break;
				i++;
			}
		}
		drv_id++;
	}
	return NULL;
}

static void card_remove(struct pnp_dev * dev)
{
	dev->card_link = NULL;
}

static void card_remove_first(struct pnp_dev * dev)
{
	struct pnp_card_driver * drv = to_pnp_card_driver(dev->driver);
	if (!dev->card || !drv)
		return;
	if (drv->remove)
		drv->remove(dev->card_link);
	drv->link.remove = &card_remove;
	kfree(dev->card_link);
	card_remove(dev);
}

static int card_probe(struct pnp_card *card, struct pnp_card_driver *drv)
{
	const struct pnp_card_device_id *id;
	struct pnp_card_link *clink;
	struct pnp_dev *dev;

	if (!drv->probe)
		return 0;
	id = match_card(drv,card);
	if (!id)
		return 0;

	clink = pnp_alloc(sizeof(*clink));
	if (!clink)
		return 0;
	clink->card = card;
	clink->driver = drv;
	clink->pm_state = PMSG_ON;

	if (drv->probe(clink, id) >= 0)
		return 1;

	/* Recovery */
	card_for_each_dev(card, dev) {
		if (dev->card_link == clink)
			pnp_release_card_device(dev);
	}
	kfree(clink);
	return 0;
}

/**
 * pnp_add_card_id - adds an EISA id to the specified card
 * @id: pointer to a pnp_id structure
 * @card: pointer to the desired card
 *
 */

int pnp_add_card_id(struct pnp_id *id, struct pnp_card * card)
{
	struct pnp_id * ptr;
	if (!id)
		return -EINVAL;
	if (!card)
		return -EINVAL;
	id->next = NULL;
	ptr = card->id;
	while (ptr && ptr->next)
		ptr = ptr->next;
	if (ptr)
		ptr->next = id;
	else
		card->id = id;
	return 0;
}

static void pnp_free_card_ids(struct pnp_card * card)
{
	struct pnp_id * id;
	struct pnp_id *next;
	if (!card)
		return;
	id = card->id;
	while (id) {
		next = id->next;
		kfree(id);
		id = next;
	}
}

static void pnp_release_card(struct device *dmdev)
{
	struct pnp_card * card = to_pnp_card(dmdev);
	pnp_free_card_ids(card);
	kfree(card);
}

static ssize_t pnp_show_card_name(struct device *dmdev, struct device_attribute *attr, char *buf)
{
	char *str = buf;
	struct pnp_card *card = to_pnp_card(dmdev);
	str += sprintf(str,"%s\n", card->name);
	return (str - buf);
}

static DEVICE_ATTR(name,S_IRUGO,pnp_show_card_name,NULL);

static ssize_t pnp_show_card_ids(struct device *dmdev, struct device_attribute *attr, char *buf)
{
	char *str = buf;
	struct pnp_card *card = to_pnp_card(dmdev);
	struct pnp_id * pos = card->id;

	while (pos) {
		str += sprintf(str,"%s\n", pos->id);
		pos = pos->next;
	}
	return (str - buf);
}

static DEVICE_ATTR(card_id,S_IRUGO,pnp_show_card_ids,NULL);

static int pnp_interface_attach_card(struct pnp_card *card)
{
	int rc = device_create_file(&card->dev,&dev_attr_name);
	if (rc) return rc;

	rc = device_create_file(&card->dev,&dev_attr_card_id);
	if (rc) goto err_name;

	return 0;

err_name:
	device_remove_file(&card->dev,&dev_attr_name);
	return rc;
}

/**
 * pnp_add_card - adds a PnP card to the PnP Layer
 * @card: pointer to the card to add
 */

int pnp_add_card(struct pnp_card * card)
{
	int error;
	struct list_head * pos, * temp;
	if (!card || !card->protocol)
		return -EINVAL;

	sprintf(card->dev.bus_id, "%02x:%02x", card->protocol->number, card->number);
	card->dev.parent = &card->protocol->dev;
	card->dev.bus = NULL;
	card->dev.release = &pnp_release_card;
	error = device_register(&card->dev);

	if (error == 0) {
		pnp_interface_attach_card(card);
		spin_lock(&pnp_lock);
		list_add_tail(&card->global_list, &pnp_cards);
		list_add_tail(&card->protocol_list, &card->protocol->cards);
		spin_unlock(&pnp_lock);

		/* we wait until now to add devices in order to ensure the drivers
		 * will be able to use all of the related devices on the card
		 * without waiting any unresonable length of time */
		list_for_each(pos,&card->devices){
			struct pnp_dev *dev = card_to_pnp_dev(pos);
			__pnp_add_device(dev);
		}

		/* match with card drivers */
		list_for_each_safe(pos,temp,&pnp_card_drivers){
			struct pnp_card_driver * drv = list_entry(pos, struct pnp_card_driver, global_list);
			card_probe(card,drv);
		}
	} else
		pnp_err("sysfs failure, card '%s' will be unavailable", card->dev.bus_id);
	return error;
}

/**
 * pnp_remove_card - removes a PnP card from the PnP Layer
 * @card: pointer to the card to remove
 */

void pnp_remove_card(struct pnp_card * card)
{
	struct list_head *pos, *temp;
	if (!card)
		return;
	device_unregister(&card->dev);
	spin_lock(&pnp_lock);
	list_del(&card->global_list);
	list_del(&card->protocol_list);
	spin_unlock(&pnp_lock);
	list_for_each_safe(pos,temp,&card->devices){
		struct pnp_dev *dev = card_to_pnp_dev(pos);
		pnp_remove_card_device(dev);
	}
}

/**
 * pnp_add_card_device - adds a device to the specified card
 * @card: pointer to the card to add to
 * @dev: pointer to the device to add
 */

int pnp_add_card_device(struct pnp_card * card, struct pnp_dev * dev)
{
	if (!card || !dev || !dev->protocol)
		return -EINVAL;
	dev->dev.parent = &card->dev;
	dev->card_link = NULL;
	snprintf(dev->dev.bus_id, BUS_ID_SIZE, "%02x:%02x.%02x", dev->protocol->number,
		 card->number,dev->number);
	spin_lock(&pnp_lock);
	dev->card = card;
	list_add_tail(&dev->card_list, &card->devices);
	spin_unlock(&pnp_lock);
	return 0;
}

/**
 * pnp_remove_card_device- removes a device from the specified card
 * @dev: pointer to the device to remove
 */

void pnp_remove_card_device(struct pnp_dev * dev)
{
	spin_lock(&pnp_lock);
	dev->card = NULL;
	list_del(&dev->card_list);
	spin_unlock(&pnp_lock);
	__pnp_remove_device(dev);
}

/**
 * pnp_request_card_device - Searches for a PnP device under the specified card
 * @clink: pointer to the card link, cannot be NULL
 * @id: pointer to a PnP ID structure that explains the rules for finding the device
 * @from: Starting place to search from. If NULL it will start from the begining.
 */

struct pnp_dev * pnp_request_card_device(struct pnp_card_link *clink, const char * id, struct pnp_dev * from)
{
	struct list_head * pos;
	struct pnp_dev * dev;
	struct pnp_card_driver * drv;
	struct pnp_card * card;
	if (!clink || !id)
		goto done;
	card = clink->card;
	drv = clink->driver;
	if (!from) {
		pos = card->devices.next;
	} else {
		if (from->card != card)
			goto done;
		pos = from->card_list.next;
	}
	while (pos != &card->devices) {
		dev = card_to_pnp_dev(pos);
		if ((!dev->card_link) && compare_pnp_id(dev->id,id))
			goto found;
		pos = pos->next;
	}

done:
	return NULL;

found:
	dev->card_link = clink;
	dev->dev.driver = &drv->link.driver;
	if (pnp_bus_type.probe(&dev->dev))
		goto err_out;
	if (device_bind_driver(&dev->dev))
		goto err_out;

	return dev;

err_out:
	dev->dev.driver = NULL;
	dev->card_link = NULL;
	return NULL;
}

/**
 * pnp_release_card_device - call this when the driver no longer needs the device
 * @dev: pointer to the PnP device stucture
 */

void pnp_release_card_device(struct pnp_dev * dev)
{
	struct pnp_card_driver * drv = dev->card_link->driver;
	if (!drv)
		return;
	drv->link.remove = &card_remove;
	device_release_driver(&dev->dev);
	drv->link.remove = &card_remove_first;
}

/*
 * suspend/resume callbacks
 */
static int card_suspend(struct pnp_dev *dev, pm_message_t state)
{
	struct pnp_card_link *link = dev->card_link;
	if (link->pm_state.event == state.event)
		return 0;
	link->pm_state = state;
	return link->driver->suspend(link, state);
}

static int card_resume(struct pnp_dev *dev)
{
	struct pnp_card_link *link = dev->card_link;
	if (link->pm_state.event == PM_EVENT_ON)
		return 0;
	link->pm_state = PMSG_ON;
	link->driver->resume(link);
	return 0;
}

/**
 * pnp_register_card_driver - registers a PnP card driver with the PnP Layer
 * @drv: pointer to the driver to register
 */

int pnp_register_card_driver(struct pnp_card_driver * drv)
{
	int error;
	struct list_head *pos, *temp;

	drv->link.name = drv->name;
	drv->link.id_table = NULL;	/* this will disable auto matching */
	drv->link.flags = drv->flags;
	drv->link.probe = NULL;
	drv->link.remove = &card_remove_first;
	drv->link.suspend = drv->suspend ? card_suspend : NULL;
	drv->link.resume = drv->resume ? card_resume : NULL;

	error = pnp_register_driver(&drv->link);
	if (error < 0)
		return error;

	spin_lock(&pnp_lock);
	list_add_tail(&drv->global_list, &pnp_card_drivers);
	spin_unlock(&pnp_lock);

	list_for_each_safe(pos,temp,&pnp_cards){
		struct pnp_card *card = list_entry(pos, struct pnp_card, global_list);
		card_probe(card,drv);
	}
	return 0;
}

/**
 * pnp_unregister_card_driver - unregisters a PnP card driver from the PnP Layer
 * @drv: pointer to the driver to unregister
 */

void pnp_unregister_card_driver(struct pnp_card_driver * drv)
{
	spin_lock(&pnp_lock);
	list_del(&drv->global_list);
	spin_unlock(&pnp_lock);
	pnp_unregister_driver(&drv->link);
}

#if 0
EXPORT_SYMBOL(pnp_add_card);
EXPORT_SYMBOL(pnp_remove_card);
EXPORT_SYMBOL(pnp_add_card_device);
EXPORT_SYMBOL(pnp_remove_card_device);
EXPORT_SYMBOL(pnp_add_card_id);
#endif  /*  0  */
EXPORT_SYMBOL(pnp_request_card_device);
EXPORT_SYMBOL(pnp_release_card_device);
EXPORT_SYMBOL(pnp_register_card_driver);
EXPORT_SYMBOL(pnp_unregister_card_driver);


text:
CREATE TABLE `kmrtasks`(
  id integer primary key,
  add_date date,
  task_from text,
  task_date date,
  section text,
  user_id integer,
  category text,
  title text,
  note text,
  tags text,
  status text
);

CREATE TABLE `kmrusers`(
  id integer primary key,
  disp_name text,
  name text,
  password text,
  auth_type text
);

CREATE TABLE `kmrplans`(
  id integer primary key,
  task_id integer,
  title text,
  add_date date,
  user_id integer,
  complete text,
  status text
);

CREATE TABLE `kmractions`(
  id integer primary key,
  plan_id integer,
  add_date date,
  note text,
  user_id integer,
  status text
);

CREATE TABLE `kmrtaskusers`(
  id integer primary key,
  task_id integer,
  user_id integer
);

CREATE TABLE `kmrreadings`(
  id integer primary key,
  add_date date,
  task_id integer,
  user_id integer
);

CREATE TABLE `kmrgoodjobs`(
  id integer primary key,
  add_date date,
  action_id integer,
  user_id integer
);

INSERT INTO kmrusers VALUES (1, "administrator", "admin", "admin", "admin");
INSERT INTO kmrusers VALUES (2, "user", "user", "user", "user");
INSERT INTO kmrusers VALUES (3, "guest", "guest", "guest", "guest");


text:
![NeutrinoScript](https://raw.githubusercontent.com/active9/neutrinoscript/master/neutrino.png)
Like C for Javascript

# About

Neutrino script is a subset of javascript designed to allow low level memory management, shortcodes, defines, and more. See our website at http://neutrinoscript.com/ for more detailed documentation.

The syntax is fresh yet similar to javascript while providing extra abstraction layers to allow more logical code production. This means a script written in Neutrino script can be converted into javascript as it is converted into javascript during the complation process.

# Supported Javascript

Currently Neutrino script is designed to run under EMCAScript 5 equivalent javascript syntax. Neutrino script itself supports EMCAScript 6 style functions to be defined that get converted to EMCAScript 5 syntax.

# Installing

Using npm on your command prompt / terminal run the following commands:

```bash
npm install -g neutrino
npm install -g neutrino-memory
```

# Getting Started

See our documentation on our website http://neutrinoscript.com/ for examples of how to write neutrinoscript .neu files.

# Converting NeutrinoScript to Javascript

neutrino convert /path/to/your/script.neu /output/path/script.js

# Running via NodeJS

neutrino /path/to/your/script.neu

# Running in the Browser

Please see the documentation on how to use the provided build/neutrino.js file on the web.

** Changes from 1.0.1 to 1.1.0 introduce a new way to load neutrino script via the web.

Simply replace:

```javascript
window.neutrino.web(document);
```

with

```javascript
var neutrino = require('neutrino');
neutrino.web(document);
```

# License

Neutrino script is licensed under the MIT license


text:
package me.codeboy.android.aligntextview.example;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.Window;

import me.codeboy.android.aligntextview.CBAlignTextView;

/**
 * AlignTextView 空指针
 *
 * @author yuedong.li
 */
public class AlignTextViewNpeExample extends Activity {

    private CBAlignTextView mTextViewTv;
    private String text = "这是一段中英文混合的文本,I am very happy today." +
            "测试TextView文本对齐\n\nAlignTextView可以通过setAlign()" +
            "方法设置每一段尾行的对齐方式,默认尾行居左对齐" +
            ".CBAlignTextView可以像原生TextView一样操作,但是需要使用getRealText()获取文本,欢迎访问open.codeboy.me";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        this.requestWindowFeature(Window.FEATURE_NO_TITLE);

        setContentView(R.layout.activity_align_text_view_npe_text);

        mTextViewTv = (CBAlignTextView) findViewById(R.id.align_text_view);
        mTextViewTv.setText(text);

        final Handler handler = new Handler() {
            @Override
            public void dispatchMessage(Message msg) {
                super.dispatchMessage(msg);
                mTextViewTv.setText("");
            }
        };

        new Thread() {
            public void run() {
                try {
                    Thread.sleep(3000);
                    handler.sendEmptyMessage(0);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }.start();

    }
}


text:
@class ARTabbedViewController;

/// Takes the View Controller selection state and updates the navigation bar

@interface ARHostSelectionController : NSObject

- (instancetype)initWithHostViewControlller:(ARTabbedViewController *)hostViewController;

@property (nonatomic, readonly, weak) ARTabbedViewController *hostVC;

- (void)setupDefaultToolbarItems;
- (void)selectionStateChanged;

- (void)startListening;
- (void)stopListening;

- (void)startSelectingAnimated:(BOOL)animated;
- (void)endSelectingAnimated:(BOOL)animated;

- (void)switchCancelToDone;

- (void)removeAllButtonHighlights;

@property (nonatomic, strong, readonly) UIBarButtonItem *doneActionButton;
@property (nonatomic, assign, readwrite) BOOL addEditButton;
@end


text:
package org.apache.jackrabbit.oak.plugins.index.lucene;

public enum IndexFormatVersion {
    /**
     * Index confirming to Oak version upto 1.0.8
     */
    V1(1),
    /**
     * Index confirming to Oak version upto 1.0.9
     */
    V2(2);

    private final int version;

    IndexFormatVersion(int version) {
        this.version = version;
    }

    /**
     * Returns true if this version is at least as high as the
     * given version.
     *
     * @param version the other version to compare.
     * @return true if this version is at least as high as the
     *         provided; false otherwise.
     */
    public boolean isAtLeast(IndexFormatVersion version) {
        return this.version >= version.getVersion();
    }

    public int getVersion() {
        return version;
    }

    public static IndexFormatVersion getVersion(int version) {
        switch(version){
            case 1 : return V1;
            case 2 : return V2;
            default : throw new IllegalArgumentException("Unknown version : " + version);
        }
    }

    public static IndexFormatVersion getDefault(){
        return V2;
    }

    public static IndexFormatVersion max(IndexFormatVersion o1, IndexFormatVersion o2){
        return o1.version > o2.version ? o1 : o2;
    }

}


text:
import { Injectable } from '@angular/core';
import {HttpClient} from '@angular/common/http';

@Injectable({
  providedIn: 'root'
})
export class ApiService {

  private baseUrl = '/api';

  constructor(private readonly http: HttpClient) { }

  public verifyEmail(token: string) {
    return this.http.post(`${this.baseUrl}/users/verification/${token}`, {});
  }

  public getInvitation(token: string) {
    return this.http.get(`${this.baseUrl}/invitations/${token}`);
  }

  public getPublicTeam(teamId: string) {
    return this.http.get(`${this.baseUrl}/teams/${teamId}`);
  }

}


text:
@import UIKit;
#import "LAppDelegate.h"

int main(int argc, char * argv[])
{
    @autoreleasepool {
        return UIApplicationMain(argc, argv, nil, NSStringFromClass([LAppDelegate class]));
    }
}


text:
namespace search
{
struct SearchQueryParams;

namespace v2
{
namespace impl
{
bool Match(vector<strings::UniString> const & tokens, strings::UniString const & token);

bool PrefixMatch(vector<strings::UniString> const & prefixes, strings::UniString const & token);
}  // namespace impl

// The order and numeric values are important here.  Please, check all
// use-cases before changing this enum.
enum NameScore
{
  NAME_SCORE_ZERO = 0,
  NAME_SCORE_SUBSTRING_PREFIX = 1,
  NAME_SCORE_SUBSTRING = 2,
  NAME_SCORE_FULL_MATCH_PREFIX = 3,
  NAME_SCORE_FULL_MATCH = 4,

  NAME_SCORE_COUNT
};

template <typename TSlice>
NameScore GetNameScore(string const & name, TSlice const & slice)
{
  if (slice.Empty())
    return NAME_SCORE_ZERO;

  vector<strings::UniString> tokens;
  SplitUniString(NormalizeAndSimplifyString(name), MakeBackInsertFunctor(tokens), Delimiters());
  return GetNameScore(tokens, slice);
}

template <typename TSlice>
NameScore GetNameScore(vector<strings::UniString> const & tokens, TSlice const & slice)
{
  if (slice.Empty())
    return NAME_SCORE_ZERO;

  size_t const n = tokens.size();
  size_t const m = slice.Size();

  bool const lastTokenIsPrefix = slice.IsPrefix(m - 1);

  NameScore score = NAME_SCORE_ZERO;
  for (int offset = 0; offset + m <= n; ++offset)
  {
    bool match = true;
    for (int i = 0; i < m - 1 && match; ++i)
      match = match && impl::Match(slice.Get(i), tokens[offset + i]);
    if (!match)
      continue;

    if (impl::Match(slice.Get(m - 1), tokens[offset + m - 1]))
    {
      if (m == n)
        return NAME_SCORE_FULL_MATCH;
      score = max(score, NAME_SCORE_SUBSTRING);
    }
    if (lastTokenIsPrefix && impl::PrefixMatch(slice.Get(m - 1), tokens[offset + m - 1]))
    {
      if (m == n)
        return NAME_SCORE_FULL_MATCH_PREFIX;
      score = max(score, NAME_SCORE_SUBSTRING_PREFIX);
    }
  }
  return score;
}

string DebugPrint(NameScore score);
}  // namespace v2
}  // namespace search


text:
var passport = require('passport');
var bcrypt = require('bcrypt-nodejs');
var Model = require('./model');
var bodyParser = require('body-parser');

var getConnection  = require('./connectionpool');

var sessionIdArr = [];

//***********************************************************

var end = function(req, res, next) {
  if (!req.isAuthenticated()) {
    res.redirect('/signin');
  } else {

    var user = req.user;
    var username = req.user.username
    //console.log(username)
    //console.log(user)

    sessionId = req.params.sessionId;
    sessionIdArr.push(sessionId);

  getConnection(function (err, connection) {
    var datas = connection.query('SELECT persons2.*, history.*, history_review.*, testing.*, vision.*, hearing.*, physicalexam.* FROM persons2, history, history_review, testing, vision, hearing, physicalexam WHERE' + "'" + sessionId + "'" + '=persons2.sessionId AND' + "'" + sessionId + "'" + '=history.sessionId AND' + "'" + sessionId + "'" + '=history_review.sessionId AND' + "'" + sessionId + "'" + '=testing.sessionId AND' + "'" + sessionId + "'" + '=vision.sessionId AND' + "'" + sessionId + "'" + '=hearing.sessionId AND' + "'" + sessionId + "'" + '=physicalexam.sessionId',
      function(err, rows) {
          console.log('glasses: ' + rows[0].glasses)
      var corrected;
      if(rows[0].hearingaidright == '1' || rows[0].hearingaidleft == '1' || rows[0].hearingaidneither == '1') {
        corrected = '1';
      } else {
        corrected = '0';
      }

    connection.query('SELECT * FROM moreinfo WHERE username = ' + "'" + req.user.attributes.username + "'",
    function(err, moreInfoRows) {
        console.log(req.user.attributes.username)
        console.log(moreInfoRows[0])
        var whatWork = moreInfoRows[0].what;
        var md = '0';
        var DO = '0';
        var pa = '0';
        var ch = '0';
        var apn = '0';
        var op = '0';

    if(whatWork == 'md') {
        var md = '1';
        }

    if(whatWork == 'do') {
        var DO = '1';
        }

    if(whatWork == 'pa') {
        var pa = '1';
        }

    if(whatWork == 'ch') {
        var ch = '1';
        }

    if(whatWork == 'apn') {
        var apn = '1';
        }

     if(whatWork == 'op') {
        var op = '1';
        }

      var fs = require('fs');
      var pdfFiller = require('pdffiller');

      var sourcePDF = "medForm.pdf";
      // var destinationPDF =  "../../Desktop/watch8.pdf";
      var destinationPDF = "watch9.pdf";
      var shouldFlatten = false;

      var d = new Date();
      var monthFix = Number(d.getMonth()) + 1;
      var date = monthFix + "/" + d.getDate() + "/" + d.getFullYear();
      ////console.log(str);

      var avgRight = (parseInt(rows[0].right500) + parseInt(rows[0].right1000) + parseInt(rows[0].right2000)) / 3;
      var avgLeft = (parseInt(rows[0].left500) + parseInt(rows[0].left1000) + parseInt(rows[0].left2000)) / 3;

    if (user !== undefined) {
      user = user.toJSON();
    }

    connection.query('SELECT * from vision WHERE vision.sessionId = ' + "'" + sessionId + "'",
      function(err, rows4) {
      var visionObj = rows4[0]

      connection.query('SELECT * from hearing WHERE hearing.sessionId = ' + "'" + sessionId + "'",
        function(err, rows3) {
        var hearingObj = rows3[0]

        connection.query('SELECT * FROM testing WHERE testing.sessionId = ' + "'" + sessionId + "'",
          function(err, rows2) {
          var testingObj = rows2[0];

          connection.query('SELECT followUpBrainInjury, followUpEpilepsy, followUpEye, followUpEar, followUpHeart, followUpPacemaker, followupBloodPressure, followUpHighCholesterol, followUpBreathingProblems, followUpLungDisease, followUpKidneyProblems, followUpStomachProblems, followUpDiabetes, followUpInsulin, followUpAnxiety, followUpFainting, followUpDizziness, followUpUnExplainedWeightLoss, followUpStroke, followUpMissingLimbs, followUpBackProblems, followUpBoneProblems, followUpBloodClots, followUpCancer, followUpChronicDiseases, followUpSleepDisorders, followUpSleepTest, followUpNightInHospital, followUpBrokenBone, followUpUseTobacco, followUpDrinkAlcohol, followUpIllegalSubstance, followUpFailedDrugTest FROM history_review WHERE history_review.sessionId = ' + "'" + sessionId + "'",
            function(err, rows5) {

            var obj = rows5[0];
            console.log(rows5[0])

            var certificate_0 = "Due to missing limbs, with a SPE certificate, a maximum of 1 year certificate can be issued.";
            var certificate_1 = "Due to head/brain injuries, a neurologist's release is required and a maximum of 1 year certificate can be issued.";
            var certificate_2 = "Due to head/brain injuries, a maximum of 2 year certificate can be issued.";
            var certificate_3 = "Due to heart issues, a maximum of 1 year certificate can be issued after a two month wait period. A cardiologist release is needed and an exersize tolerance test must be administered every two years.";
            var certificate_4 = "Due to heart issues, a cardiologist release is needed. A maximum of 2 year certificate can be issued after a 3 month wait period. After 5 years, an annual ETT is required.";
            var certificate_5 = "Due to issues with a pacemaker, AV block / sinus node dysfunction, a maximum of one year certificate can be issued after a 1 month wait period.";
            var certificate_6 = "Due to issues with a pacemaker, ICD (defibrillator), the driver is disqualified.";
            var certificate_7 = "Due to seizures/epilepsy, a neurologist's release is required or there is a 10 year wait period before a certificate can be issued.";
            var certificate_8 = "Due to issues with a pacemaker, neurocardiogenic syncope, a maximum of one year certificate can be issued after a 3 month wait period.";
            var certificate_9 = "Due to lung issues, oxygen therapy, the driver is disqualified.";
            var certificate_10 = "Due to lung issues, cough syncope, the driver is disqualified.";
            var certificate_11 = "the patient is disqualified.";
            var certificate_12 = "Due to stroke issues, cerebellar or brainstem, a maximum of one year certificate can be issued after a one year wait period. A neurologist's release is also required.";
            var certificate_13 = "Due to stroke issues, cortical/subcortical, a maximum of one year certificate can be issued after a five year wait period. A neurologist's release is also required.";
            var certificate_14 = "Due to stroke issues, TIA, a maximum of 1 year certificate can be issued after a one year wait period."
            var certificate_15 = "Due to kidney issues, the patient is disqualified.";
            var certificate_16 = "Due to stomach issues, the patient is disqualified.";
            var certificate_17 = "Due to insulin use, the patient is disqualified.";
            var certificate_18 = "Due to anxiety issues, the patient is disqualified.";
            var certificate_19 = "Due to fainting issues, the patient is disqualified.";
            var certificate_20 = "Due to dizziness issues, the patient is disqualified.";
            var certificate_21 = "Due to unexplained weight loss, the patient is disqualified.";
            var certificate_22 = "Due to breathing issues, the patient is disqualified.";
            var certificate_23 = "Due to missing limbs, the patient is disqualified.";
            var certificate_24 = "Due to back/neck issues, the patient is disqualified.";
            var certificate_25 = "Due to bone issues, the patient is disqualified.";
            var certificate_26 = "Due to blood clot issues, the patient is disqualified.";
            var certificate_27 = "Due to cancer issues, the patient is disqualified.";
            var certificate_28 = "Due to infections/chronic diseases, the patient is disqualified.";
            var certificate_29 = "Due to sleep disorders, the patient is disqualified.";
            var certificate_30 = "Due to sleep test issues, the patient is disqualified.";
            var certificate_31 = "Due to hospital visits, the patient is disqualified.";
            var certificate_32 = "Due to broken bone issues, the patient is disqualified.";
            var certificate_33 = "Due to tobacco use, the patient is disqualified.";
            var certificate_34 = "Due to alcohol issues, the patient is disqualified.";
            var certificate_35 = "Due to illegal drug issues, the patient is disqualified.";
            var certificate_36 = "Due to failed drug test history, the patient is disqualified.";
            var certificate_37 = "Due to head/brain injuries, the patient is disqualified.";
            var certificate_38 = "Due to heart issues without a cardiologist's release, the patient is disqualified.";
            var certificate_39 = "Due to epilepsy without a neurologist's release, the patient is disqualified.";
            var certificate_40 = "Due to Neurocardiogenic syncope without a 3 month wait period, the patient is disqualified.";
            var certificate_41 = "Due to Cerebellar or Brainstem without a neurologist's release, the patient is disqualified.";
            var certificate_42 = "Due to Cortical/Subcortical without a neurologist's release, the patient is disqualified.";
            var certificate_43 = "Due to TIA without a 1 year wait, the patient is disqualified.";

            var filtered = [];
            for (prop in obj) {
              if (obj[prop] == 'undefined' || obj[prop] == 'na' || obj[prop] == '') {
              delete obj[prop]
              }else {
                filtered.push(obj[prop])
              }
            }

            console.log("filtered: " + filtered)

            for (i = 0; i < filtered.length; i++){

            }

            console.log(obj)

            // var disqualifiedState;
            // var disqualified;
            var dqArr = [];
            var certArr = [];
            var arr = [];
            var timeline = [];
            var reason = '';
            var reasonb = '';

            for (i = 0; i < filtered.length; i++) {
              if(filtered[i] == "valueZero") {
                arr.push(certificate_0);
                timeline.push(certificate_0);
                certArr.push(3);
                reasonb += "missing limbs with a SPE certificate / "

              }
              if(filtered[i] == "valueOne") {
                arr.push(certificate_1);
                timeline.push(certificate_1);
                certArr.push(3);
                reasonb += "head or brain injuries with a neurologist's release / "
              }
              if(filtered[i] == "valueTwo") {
                arr.push(certificate_2)
                timeline.push(certificate_2)
              }
              if(filtered[i] == "valueThree") {
                arr.push(certificate_3)
                timeline.push(certificate_3)
                dqArr.push(0)
              }
              if(filtered[i] == "valueFour") {
                arr.push(certificate_4)
                timeline.push(certificate_4)
                dqArr.push(0)
                reason += "heart issues / ";
              }
              if(filtered[i] == "valueFive") {
                arr.push(certificate_5)
                timeline.push(certificate_5)
                certArr.push(3);
                reasonb += "AV block - sinus node dysfunction after a 1 month wait / "
              }
              if(filtered[i] == "valueSix") {
                arr.push(certificate_6)
                timeline.push(certificate_6)
                dqArr.push(0)
                reason += "pacemaker, ICD (defibrillator) / ";
              }
              if(filtered[i] == "valueSeven") {
                arr.push(certificate_7)
                timeline.push(certificate_7)
                dqArr.push(0)
              }
              if(filtered[i] == "valueEight") {
                arr.push(certificate_8)
                timeline.push(certificate_8)
                certArr.push(3);
                reasonb += "neurocardiogenic syncope after a 3 month wait / "
              }
              if(filtered[i] == "valueNine") {
                arr.push(certificate_9)
                timeline.push(certificate_9)
                dqArr.push(0)
                reason += "lung issues, oxygen therapy / "
              }
              if(filtered[i] == "valueTen") {
                arr.push(certificate_10)
                timeline.push(certificate_10)
                dqArr.push(0)
                reason += "lung issues, cough syncope / "
              }
              if(filtered[i] == "valueTwelve") {
                arr.push(certificate_12)
                timeline.push(certificate_12)
                certArr.push(3);
                reasonb += "cerebellar or brainstem with a neurologist's release and a 1 year wait / "
              }
              if(filtered[i] == "valueThirteen") {
                arr.push(certificate_13)
                timeline.push(certificate_13)
                dqArr.push(0)
              }
              if(filtered[i] == "valueFourteen") {
                arr.push(certificate_14)
                timeline.push(certificate_14)
                dqArr.push(0)
              }
              if(filtered[i] == "valueFifteen") {
                arr.push(certificate_15)
                timeline.push(certificate_15)
                dqArr.push(0)
                reason += "kidney issues / "
              }
              if(filtered[i] == "valueSixteen") {
                arr.push(certificate_16)
                timeline.push(certificate_16)
                dqArr.push(0)
                reason += "stomach issues / "
              }
              if(filtered[i] == "valueSeventeen") {
                arr.push(certificate_17)
                timeline.push(certificate_17)
                dqArr.push(0)
                reason += "insulin use / "
              }
              if(filtered[i] == "valueEighteen") {
                arr.push(certificate_18)
                timeline.push(certificate_18)
                dqArr.push(0)
                reason += "anxiety issues / "
              }
              if(filtered[i] == "valueNineteen") {
                arr.push(certificate_19)
                timeline.push(certificate_19)
                dqArr.push(0)
                reason += "fainting issues / "
              }
              if(filtered[i] == "valueTwenty") {
                arr.push(certificate_20)
                timeline.push(certificate_20)
                dqArr.push(0)
                reason += "dizziness issues / "
              }
              if(filtered[i] == "valueTwentyOne") {
                arr.push(certificate_21)
                timeline.push(certificate_21)
                dqArr.push(0)
                reason += "unexplained weight loss / "
              }
              if(filtered[i] == "valueTwentyTwo") {
                arr.push(certificate_22)
                timeline.push(certificate_22)
                dqArr.push(0)
                reason += "breathing issues / "
              }
              if(filtered[i] == "valueTwentyThree") {
                arr.push(certificate_23)
                timeline.push(certificate_23)
                dqArr.push(0)
                reason += "missing limbs / "
              }
              if(filtered[i] == "valueTwentyFour") {
                arr.push(certificate_24)
                timeline.push(certificate_24)
                dqArr.push(0)
                reason += "back issues / "
              }
              if(filtered[i] == "valueTwentyFive") {
                arr.push(certificate_25)
                timeline.push(certificate_25)
                dqArr.push(0)
                reason += "bone issues / "
              }
              if(filtered[i] == "valueTwentySix") {
                arr.push(certificate_26)
                timeline.push(certificate_26)
                dqArr.push(0)
                reason += "bloodclot issues / "
              }
              if(filtered[i] == "valueTwentySeven") {
                arr.push(certificate_27)
                timeline.push(certificate_27)
                dqArr.push(0)
                reason += "cancer issues / "
              }
              if(filtered[i] == "valueTwentyEight") {
                arr.push(certificate_28)
                timeline.push(certificate_28)
                dqArr.push(0)
                reason += "infections or chronic diseases / "
              }
              if(filtered[i] == "valueTwentyNine") {
                arr.push(certificate_29)
                timeline.push(certificate_29)
                dqArr.push(0)
                reason += "sleep disorders / "
              }
              if(filtered[i] == "valueThirty") {
                arr.push(certificate_30)
                timeline.push(certificate_30)
                dqArr.push(0)
                reason += "sleep test results / "
              }
              if(filtered[i] == "valueThirtyOne") {
                arr.push(certificate_31)
                timeline.push(certificate_31)
                dqArr.push(0)
                reason += "hospital visits / "
              }
              if(filtered[i] == "valueThirtyTwo") {
                arr.push(certificate_32)
                timeline.push(certificate_32)
                dqArr.push(0)
                reason += "broken bones / "
              }
              if(filtered[i] == "valueThirtyThree") {
                arr.push(certificate_33)
                timeline.push(certificate_33)
                dqArr.push(0)
                reason += "tobacco use / "
              }
              if(filtered[i] == "valueThirtyFour") {
                arr.push(certificate_34)
                timeline.push(certificate_34)
                dqArr.push(0)
                reason += "alcohol issues / "
              }
              if(filtered[i] == "valueThirtyFive") {
                arr.push(certificate_35)
                timeline.push(certificate_35)
                dqArr.push(0)
                reason += "illegal drugs / "
              }
              if(filtered[i] == "valueThirtySix") {
                arr.push(certificate_36)
                timeline.push(certificate_36)
                dqArr.push(0)
                reason += "failed drug test history / "
              }
              if(filtered[i] == "valueThirtySeven") {
                arr.push(certificate_37)
                timeline.push(certificate_37)
                dqArr.push(0)
                reason += "head or brain injuries / "
              }
              if(filtered[i] == "valueThirtyEight") {
                arr.push(certificate_38)
                timeline.push(certificate_38)
                dqArr.push(0)
                reason += "heart issues / "
              }
              if(filtered[i] == "valueThirtyNine") {
                arr.push(certificate_39)
                timeline.push(certificate_39)
                dqArr.push(0)
                reason += "epilepsy / "
              }
              if(filtered[i] == "valueFourty") {
                arr.push(certificate_40)
                timeline.push(certificate_40)
                dqArr.push(0)
                reason += "neurocardiogenic syncope / "
              }
              if(filtered[i] == "valueFourtyOne") {
                arr.push(certificate_41)
                timeline.push(certificate_41)
                dqArr.push(0)
                reason += "Cerebellar or Brainstem / "
              }
              if(filtered[i] == "valueFourtyTwo") {
                arr.push(certificate_42)
                timeline.push(certificate_42)
                dqArr.push(0)
                reason += "Cortical/Subcortical / "
              }
              if(filtered[i] == "valueFourtyThree") {
                arr.push(certificate_43)
                timeline.push(certificate_43)
                dqArr.push(0)
                reason += "TIA / "
              }
            }

            //console.log("arr: " + arr)

            var bloodPressureIssue = '';
          if (parseInt(testingObj.systolic1) >= 140 &&
              parseInt(testingObj.systolic1) <= 159 &&
              parseInt(testingObj.systolic2) >= 140 &&
              parseInt(testingObj.systolic2) <= 159 ||
              parseInt(testingObj.diastolic1) >= 90 &&
              parseInt(testingObj.diastolic1) <= 99 &&
              parseInt(testingObj.diastolic2) >= 90 &&
              parseInt(testingObj.diastolic2) <= 99) {
              bloodPressureIssue = "Due to stage 1 hypertension, a 1 year certificate can be issued.";
              timeline.push(bloodPressureIssue)
              reasonb += "stage 1 hypertension / "
            }

          if (parseInt(testingObj.systolic1) >= 160 &&
              parseInt(testingObj.systolic1) <= 179 &&
              parseInt(testingObj.systolic2) >= 160 &&
              parseInt(testingObj.systolic2) <= 179 ||
              parseInt(testingObj.diastolic1) >= 100 &&
              parseInt(testingObj.diastolic1) <= 109 &&
              parseInt(testingObj.diastolic2) >= 100 &&
              parseInt(testingObj.diastolic2) <= 109) {
              bloodPressureIssue = "Due to stage 2 hypertension, a 3 month certificate can be issued.";
              certArr.push(1)
              timeline.push(bloodPressureIssue)
              reasonb += "stage 2 hypertension / "
            }

          if (parseInt(testingObj.systolic1) >= 180 &&
              parseInt(testingObj.systolic2) >= 180 ||
              parseInt(testingObj.diastolic1) >= 110 &&
              parseInt(testingObj.diastolic2) >= 110) {
              bloodPressureIssue = "Due to stage 3 hypertension, The driver may not be qualified, even temporarily, until reduced to 140/90 or less.";
              dqArr.push(0)
              timeline.push(bloodPressureIssue)
              reason += "stage 3 hypertension / "
            }

            var hearingIssue = '';
          if (parseInt(hearingObj.rightear) < 5 &&
              parseInt(hearingObj.leftear) < 5 &&
              parseInt(hearingObj.right500) < 40 ||
              parseInt(hearingObj.right1000) < 40 ||
              parseInt(hearingObj.right2000) < 40 ||
              parseInt(hearingObj.left500) < 40 ||
              parseInt(hearingObj.left1000) < 40 ||
              parseInt(hearingObj.left2000) < 40) {
              hearingIssue = "Due to hearing issues, the driver is disqualified."
              dqArr.push(0)
              timeline.push(bloodPressureIssue)
              reason += "hearing issues / "
            }

            var visionIssue = '';
          if (parseInt(visionObj.rightcorrected) > 40 ||
              parseInt(visionObj.rightuncorrected) > 40 ||
              parseInt(visionObj.leftcorrected) > 40 ||
              parseInt(visionObj.leftuncorrected) > 40 ||
              parseInt(visionObj.bothcorrected) > 40 ||
              parseInt(visionObj.bothuncorrected) > 40 ||
              parseInt(visionObj.fieldright) < 70 ||
              parseInt(visionObj.fieldleft) < 70 ){
              visionIssue = "Due to vision problems, the driver is disqualified."
              dqArr.push(0)
              timeline.push(bloodPressureIssue)
              reason += "vision issues / "
            }

            console.log("timeline: " + timeline)
            console.log("dqArr: " + dqArr)
            console.log("certArr: " + certArr)

            var historyCount = timeline.length;
            var dq;
            var dqState;
            var cert;

            console.log("dqArr.length: " + dqArr.length)
            console.log("certArr.length: " + certArr.length)

            if (dqArr.length == 0 && certArr.length == 0) {
              cert = 'x'
              dq = 1;
              dqState = 3;
            } else if (dqArr.length != 0){
              cert = 'x';
              dq = 0;
              dqState = 0;
            } else {
              dq = 'x';
              dqState = 'x';
              cert = Math.min.apply(null, certArr)
            }

            console.log("cert: " + cert)

      var data = {
        "MCSA-5875[0].Page1[0].privacyStatement[0].privacyDate[0]": date,
        "MCSA-5875[0].Page1[0].medRecord[0].medNumber[0]": moreInfoRows[0].medicalNumber,
        "MCSA-5875[0].Page1[0].driverPersonal[0].nameLast[0]": rows[0].lastname,
        "MCSA-5875[0].Page1[0].driverPersonal[0].nameFirst[0]": rows[0].firstname,
        "MCSA-5875[0].Page1[0].driverPersonal[0].nameInitial[0]": rows[0].middlename,
        "MCSA-5875[0].Page1[0].driverPersonal[0].birthDate[0]": rows[0].dob,
        "MCSA-5875[0].Page1[0].driverPersonal[0].driverAge[0]": rows[0].age,
        "MCSA-5875[0].Page1[0].driverPersonal[0].driverAddress[0]": rows[0].streetaddress,
        "MCSA-5875[0].Page1[0].driverPersonal[0].driverCity[0]": rows[0].city,
        "MCSA-5875[0].Page1[0].driverPersonal[0].driverState[0]": rows[0].state,
        "MCSA-5875[0].Page1[0].driverPersonal[0].driverZip[0]": rows[0].zip,
        "MCSA-5875[0].Page1[0].driverPersonal[0].driverLicense[0]": rows[0].dln,
        "MCSA-5875[0].Page1[0].driverPersonal[0].licenseState[0]": rows[0].issuing,
        "MCSA-5875[0].Page1[0].driverPersonal[0].driverPhone[0]": rows[0].phone,
        "MCSA-5875[0].Page1[0].driverPersonal[0].genderGroup[0].genderButtons[0]": rows[0].gender,
        "MCSA-5875[0].Page1[0].driverPersonal[0].emailAddress[0]": rows[0].email,
        "MCSA-5875[0].Page1[0].driverPersonal[0].cdlLicense[0].cdlButtonList[0]": rows[0].holder,
        "MCSA-5875[0].Page1[0].driverPersonal[0].driverVerify[0]": rows[0].verified,
        "MCSA-5875[0].Page1[0].driverPersonal[0].certDenyGroup[0].certDenyButtons[0]": rows[0].denied,
        "MCSA-5875[0].Page1[0].surgeryGroup[0].surgeryButtons[0]": rows[0].surgeryButton,
        "MCSA-5875[0].Page1[0].surgeryGroup[0].surgeryDescribe[0]": rows[0].surgeryComments,
        "MCSA-5875[0].Page1[0].medicineGroup[0].medicineButtons[0]": rows[0].medicationButton,
        "MCSA-5875[0].Page1[0].medicineGroup[0].medicineDescribe[0]": rows[0].medicationComments,
        "MCSA-5875[0].Page1[0].attachButton[0]": "",
        "MCSA-5875[0].Page2[0].pageHead2[0].nameLastHead2[0]": rows[0].lastname,
        "MCSA-5875[0].Page2[0].pageHead2[0].nameFirstHead2[0]": rows[0].firstname,
        "MCSA-5875[0].Page2[0].pageHead2[0].nameInitialHead2[0]": rows[0].middlename,
        "MCSA-5875[0].Page2[0].pageHead2[0].dateBirth2[0]": rows[0].dob,
        "MCSA-5875[0].Page2[0].pageHead2[0].dateForm2[0]": date,
        "MCSA-5875[0].Page2[0].driverHealth[0].headGroup[0].headButtons[0]": rows[0].brainInjuries,
        "MCSA-5875[0].Page2[0].driverHealth[0].seizeGroup[0].seizeButtons[0]": rows[0].seizures,
        "MCSA-5875[0].Page2[0].driverHealth[0].eyeGroup[0].eyeButtons[0]": rows[0].eyeProblems,
        "MCSA-5875[0].Page2[0].driverHealth[0].earGroup[0].earButtons[0]": rows[0].earProblems,
        "MCSA-5875[0].Page2[0].driverHealth[0].heartGroup[0].heartButtons[0]": rows[0].heartProblems,
        "MCSA-5875[0].Page2[0].driverHealth[0].paceGroup[0].paceButtons[0]": rows[0].paceMaker,
        "MCSA-5875[0].Page2[0].driverHealth[0].highGroup[0].highButtons[0]": rows[0].highBloodPressure,
        "MCSA-5875[0].Page2[0].driverHealth[0].cholesterolGroup[0].cholesterolButtons[0]": rows[0].highCholesterol,
        "MCSA-5875[0].Page2[0].driverHealth[0].breathGroup[0].breathButtons[0]": rows[0].breathingProblems,
        "MCSA-5875[0].Page2[0].driverHealth[0].lungGroup[0].lungButtons[0]": rows[0].lungDisease,
        "MCSA-5875[0].Page2[0].driverHealth[0].kidneyGroup[0].kidneyButtons[0]": rows[0].kidneyProblems,
        "MCSA-5875[0].Page2[0].driverHealth[0].stomachGroup[0].stomachButtons[0]": rows[0].stomachProblems,
        "MCSA-5875[0].Page2[0].driverHealth[0].sugarGroup[0].sugarButtons[0]": rows[0].diabetes,
        "MCSA-5875[0].Page2[0].driverHealth[0].insulinGroup[0].insulinButtons[0]": rows[0].insulin,
        "MCSA-5875[0].Page2[0].driverHealth[0].mentalGroup[0].mentalButtons[0]": rows[0].anxiety,
        "MCSA-5875[0].Page2[0].driverHealth[0].faintGroup[0].faintButtons[0]": rows[0].fainting,
        "MCSA-5875[0].Page2[0].driverHealth[0].dizzyGroup[0].dizzyButtons[0]": rows[0].dizziness,
        "MCSA-5875[0].Page2[0].driverHealth[0].weightGroup[0].weightButtons[0]": rows[0].unexplainedWeightLoss,
        "MCSA-5875[0].Page2[0].driverHealth[0].strokeGroup[0].strokeButtons[0]": rows[0].stroke,
        "MCSA-5875[0].Page2[0].driverHealth[0].uselimitGroup[0].uselimitButtons[0]": rows[0].missingLimbs,
        "MCSA-5875[0].Page2[0].driverHealth[0].neckbackGroup[0].neckbackButtons[0]": rows[0].backProblems,
        "MCSA-5875[0].Page2[0].driverHealth[0].boneGroup[0].boneButtons[0]": rows[0].boneProblems,
        "MCSA-5875[0].Page2[0].driverHealth[0].bloodGroup[0].bloodButtons[0]": rows[0].bloodClots,
        "MCSA-5875[0].Page2[0].driverHealth[0].cancerGroup[0].cancerButtons[0]": rows[0].cancer,
        "MCSA-5875[0].Page2[0].driverHealth[0].infectGroup[0].infectButtons[0]": rows[0].chronicDiseases,
        "MCSA-5875[0].Page2[0].driverHealth[0].apneaGroup[0].apneaButtons[0]": rows[0].sleepDisorders,
        "MCSA-5875[0].Page2[0].driverHealth[0].sleeptestGroup[0].sleeptestButtons[0]": rows[0].sleepTest,
        "MCSA-5875[0].Page2[0].driverHealth[0].hospitalGroup[0].hospitalButtons[0]": rows[0].nightInHospital,
        "MCSA-5875[0].Page2[0].driverHealth[0].brokenGroup[0].brokenButtons[0]": rows[0].brokenBone,
        "MCSA-5875[0].Page2[0].driverHealth[0].tobaccoGroup[0].tobaccoButtons[0]": rows[0].useTobacco,
        "MCSA-5875[0].Page2[0].driverHealth[0].alcoholGroup[0].alcoholButtons[0]": rows[0].drinkAlcohol,
        "MCSA-5875[0].Page2[0].driverHealth[0].illegalGroup[0].illegalButtons[0]": rows[0].illegalSubstance,
        "MCSA-5875[0].Page2[0].driverHealth[0].failedGroup[0].failedButtons[0]": rows[0].failedDrugTest,
        "MCSA-5875[0].Page2[0].otherGroup[0].otherButtons[0]": rows[0].otherButton,
        "MCSA-5875[0].Page2[0].otherGroup[0].otherDescribe[0]": rows[0].otherComments,
        "MCSA-5875[0].Page2[0].commentGroup[0].commentButtons[0]": rows[0].yesButton,
        "MCSA-5875[0].Page2[0].commentGroup[0].commentDescribe[0]": rows[0].yesDescribe,
        "MCSA-5875[0].Page2[0].attachButton[0]": "",
        "MCSA-5875[0].Page2[0].driverSignature[0].signatureDate[0]": date,
        "MCSA-5875[0].Page2[0].#area[2].driveReview[0].examinerComment[0]": "",
        "MCSA-5875[0].Page2[0].#area[2].driveReview[0].attachButton2[0]": "",
        "MCSA-5875[0].Page3[0].pageHead3[0].nameLastHead3[0]": rows[0].lastname,
        "MCSA-5875[0].Page3[0].pageHead3[0].nameFirstHead3[0]": rows[0].firstname,
        "MCSA-5875[0].Page3[0].pageHead3[0].nameInitialHead3[0]": rows[0].middlename,
        "MCSA-5875[0].Page3[0].pageHead3[0].dateBirth3[0]": rows[0].dob,
        "MCSA-5875[0].Page3[0].pageHead3[0].dateForm3[0]": date,
        "MCSA-5875[0].Page3[0].driveTest[0].basicStats[0].pulseMeasure[0]": rows[0].pulserate,
        "MCSA-5875[0].Page3[0].driveTest[0].basicStats[0].pulserhythmGroup[0].pulserhythmButtons[0]": rows[0].pulserhythm,
        "MCSA-5875[0].Page3[0].driveTest[0].basicStats[0].#area[1].feetHeight[0]": rows[0].heightfeet,
        "MCSA-5875[0].Page3[0].driveTest[0].basicStats[0].#area[1].inchesHeight[0]": rows[0].heightinches,
        "MCSA-5875[0].Page3[0].driveTest[0].basicStats[0].#area[1].poundsWeight[0]": rows[0].weight,
        "MCSA-5875[0].Page3[0].driveTest[0].bloodPressure[0].Row1[0].sitSys[0]": rows[0].systolic1,
        "MCSA-5875[0].Page3[0].driveTest[0].bloodPressure[0].Row1[0].sitDias[0]": rows[0].diastolic1,
        "MCSA-5875[0].Page3[0].driveTest[0].bloodPressure[0].Row2[0].secSys[0]": rows[0].systolic2,
        "MCSA-5875[0].Page3[0].driveTest[0].bloodPressure[0].Row2[0].secDias[0]": rows[0].diastolic2,
        "MCSA-5875[0].Page3[0].driveTest[0].otherTesting[0]": rows[0].othertesting,
        "MCSA-5875[0].Page3[0].driveTest[0].urineTest[0].urineAnalysis[0].Row1[0].spgrNumber[0]": rows[0].urinesp,
        "MCSA-5875[0].Page3[0].driveTest[0].urineTest[0].urineAnalysis[0].Row1[0].proteinNumber[0]": rows[0].urineprotein,
        "MCSA-5875[0].Page3[0].driveTest[0].urineTest[0].urineAnalysis[0].Row1[0].bloodNumber[0]": rows[0].urineblood,
        "MCSA-5875[0].Page3[0].driveTest[0].urineTest[0].urineAnalysis[0].Row1[0].sugarNumber[0]": rows[0].urinesugar,
        "MCSA-5875[0].Page3[0].driveTest[0].visionTest[0].uncorrectRight[0]": rows[0].rightuncorrected,
        "MCSA-5875[0].Page3[0].driveTest[0].visionTest[0].correctRight[0]": rows[0].rightcorrected,
        "MCSA-5875[0].Page3[0].driveTest[0].visionTest[0].fieldRight[0]": rows[0].fieldright,
        "MCSA-5875[0].Page3[0].driveTest[0].visionTest[0].uncorrectLeft[0]": rows[0].leftuncorrected,
        "MCSA-5875[0].Page3[0].driveTest[0].visionTest[0].correctLeft[0]": rows[0].leftcorrected,
        "MCSA-5875[0].Page3[0].driveTest[0].visionTest[0].fieldLeft[0]": rows[0].fieldleft,
        "MCSA-5875[0].Page3[0].driveTest[0].visionTest[0].uncorrectBoth[0]": rows[0].bothuncorrected,
        "MCSA-5875[0].Page3[0].driveTest[0].visionTest[0].correctBoth[0]": rows[0].bothcorrected,
        "MCSA-5875[0].Page3[0].driveTest[0].visionTest[0].distinguishGroup[0].distinguishButtons[0]": rows[0].traficlight,
        "MCSA-5875[0].Page3[0].driveTest[0].visionTest[0].monocularGroup[0].monocularButtons[0]": rows[0].monocular,
        "MCSA-5875[0].Page3[0].driveTest[0].visionTest[0].referredGroup[0].referredButtons[0]": rows[0].optometrist,
        "MCSA-5875[0].Page3[0].driveTest[0].visionTest[0].documentGroup[0].documentButtons[0]": rows[0].documentation,
        "MCSA-5875[0].Page3[0].driveTest[0].hearingTest[0].#area[0].hearingaidGroup[0].rightBox[0]": rows[0].hearingaidright,
        "MCSA-5875[0].Page3[0].driveTest[0].hearingTest[0].#area[0].hearingaidGroup[0].leftBox[0]": rows[0].hearingaidleft,
        "MCSA-5875[0].Page3[0].driveTest[0].hearingTest[0].#area[0].hearingaidGroup[0].nichtBox[0]": rows[0].hearingaidneither,
        "MCSA-5875[0].Page3[0].driveTest[0].hearingTest[0].#area[0].whisperRight[0]": rows[0].rightear,
        "MCSA-5875[0].Page3[0].driveTest[0].hearingTest[0].#area[0].whisperLeft[0]": rows[0].leftear,
        "MCSA-5875[0].Page3[0].driveTest[0].hearingTest[0].#area[0].#area[2].right500[0]": rows[0].right500,
        "MCSA-5875[0].Page3[0].driveTest[0].hearingTest[0].#area[0].#area[2].right1000[0]": rows[0].right1000,
        "MCSA-5875[0].Page3[0].driveTest[0].hearingTest[0].#area[0].#area[2].right2000[0]": rows[0].right2000,
        "MCSA-5875[0].Page3[0].driveTest[0].hearingTest[0].#area[0].#area[2].left500[0]": rows[0].left500,
        "MCSA-5875[0].Page3[0].driveTest[0].hearingTest[0].#area[0].#area[2].left1000[0]": rows[0].left1000,
        "MCSA-5875[0].Page3[0].driveTest[0].hearingTest[0].#area[0].#area[2].left2000[0]": rows[0].left2000,
        "MCSA-5875[0].Page3[0].driveTest[0].hearingTest[0].#area[0].#area[2].rightAverage[0]": avgRight,
        "MCSA-5875[0].Page3[0].driveTest[0].hearingTest[0].#area[0].#area[2].leftAverage[0]": avgLeft,
        "MCSA-5875[0].Page3[0].driveExam[0].bodysys1[0].generalButtons[0]": rows[0].general,
        "MCSA-5875[0].Page3[0].driveExam[0].bodysys1[0].skinButtons[0]": rows[0].skin,
        "MCSA-5875[0].Page3[0].driveExam[0].bodysys1[0].eyesButtons[0]": rows[0].eyes,
        "MCSA-5875[0].Page3[0].driveExam[0].bodysys1[0].earsButtons[0]": rows[0].ears,
        "MCSA-5875[0].Page3[0].driveExam[0].bodysys1[0].mouthButtons[0]": rows[0].mouth,
        "MCSA-5875[0].Page3[0].driveExam[0].bodysys1[0].heartButtons[0]": rows[0].cardiovascular,
        "MCSA-5875[0].Page3[0].driveExam[0].bodysys1[0].chestButtons[0]": rows[0].lungs,
        "MCSA-5875[0].Page3[0].driveExam[0].bodysys2[0].abdomenButtons[0]": rows[0].abdomen,
        "MCSA-5875[0].Page3[0].driveExam[0].bodysys2[0].herniaButtons[0]": rows[0].hernia,
        "MCSA-5875[0].Page3[0].driveExam[0].bodysys2[0].backButtons[0]": rows[0].back,
        "MCSA-5875[0].Page3[0].driveExam[0].bodysys2[0].jointsButtons[0]": rows[0].joints,
        "MCSA-5875[0].Page3[0].driveExam[0].bodysys2[0].neuroButtons[0]": rows[0].neuro,
        "MCSA-5875[0].Page3[0].driveExam[0].bodysys2[0].gaitButtons[0]": rows[0].gait,
        "MCSA-5875[0].Page3[0].driveExam[0].bodysys2[0].vascularButtons[0]": rows[0].vascular,
        "MCSA-5875[0].Page3[0].driveExam[0].examComment[0]": rows[0].examtextarea,
        "MCSA-5875[0].Page3[0].driveExam[0].attachButton3[0]": "",
        "MCSA-5875[0].Page4[0].pageHead4[0].nameLastHead4[0]": rows[0].lastname,
        "MCSA-5875[0].Page4[0].pageHead4[0].nameFirstHead4[0]": rows[0].firstname,
        "MCSA-5875[0].Page4[0].pageHead4[0].nameInitialHead4[0]": rows[0].middlename,
        "MCSA-5875[0].Page4[0].pageHead4[0].dateBirth4[0]": rows[0].dob,
        "MCSA-5875[0].Page4[0].pageHead4[0].dateForm4[0]": date,
        "MCSA-5875[0].Page4[0].fedDetermination[0].standardButtonList[0]": dq,
        "MCSA-5875[0].Page4[0].fedDetermination[0].notStandardsWhy[0]": reason,
        "MCSA-5875[0].Page4[0].fedDetermination[0].butStandardsWhy[0]": "",
        "MCSA-5875[0].Page4[0].fedDetermination[0].qualifiedButtonList[0]": cert,
        "MCSA-5875[0].Page4[0].fedDetermination[0].otherQualify[0]": "",
        "MCSA-5875[0].Page4[0].fedDetermination[0].restrictVary[0].correctLenses[0]": rows[0].glasses,
        "MCSA-5875[0].Page4[0].fedDetermination[0].restrictVary[0].hearingAid[0]": corrected,
        "MCSA-5875[0].Page4[0].fedDetermination[0].restrictVary[0].waiverQualify[0]": "",
        "MCSA-5875[0].Page4[0].fedDetermination[0].restrictVary[0].waiverEnter[0]": "",
        "MCSA-5875[0].Page4[0].fedDetermination[0].restrictVary[0].speQualify[0]": "",
        "MCSA-5875[0].Page4[0].fedDetermination[0].restrictVary[0].cfrQualify[0]": "",
        "MCSA-5875[0].Page4[0].fedDetermination[0].restrictVary[0].exemptQualify[0]": "",
        "MCSA-5875[0].Page4[0].fedDetermination[0].incompleteButtonList[0]": "",
        "MCSA-5875[0].Page4[0].fedDetermination[0].deterPending[0]": "",
        "MCSA-5875[0].Page4[0].fedDetermination[0].pendingWhy[0]": "",
        "MCSA-5875[0].Page4[0].fedDetermination[0].returnExam[0]": "",
        "MCSA-5875[0].Page4[0].fedDetermination[0].returnDate[0]": "",
        "MCSA-5875[0].Page4[0].fedDetermination[0].reportAmend[0]": "",
        "MCSA-5875[0].Page4[0].fedDetermination[0].amendWhy[0]": "",
        "MCSA-5875[0].Page4[0].fedDetermination[0].ifAmendDate[0]": "",
        "MCSA-5875[0].Page4[0].fedDetermination[0].incompleteWhy[0]": "",
        "MCSA-5875[0].Page4[0].fedDetermination[0].examName[0]": moreInfoRows[0].fname + ' ' + moreInfoRows[0].lname,
        "MCSA-5875[0].Page4[0].fedDetermination[0].medicalAddress[0]": moreInfoRows[0].registerAddress,
        "MCSA-5875[0].Page4[0].fedDetermination[0].medicalCity[0]": moreInfoRows[0].registerCity,
        "MCSA-5875[0].Page4[0].fedDetermination[0].medicalState[0]": moreInfoRows[0].registerState,
        "MCSA-5875[0].Page4[0].fedDetermination[0].medicalZip[0]": moreInfoRows[0].registerZip,
        "MCSA-5875[0].Page4[0].fedDetermination[0].medicalPhone[0]": moreInfoRows[0].registerPhone,
        "MCSA-5875[0].Page4[0].fedDetermination[0].examDate[0]": date,
        "MCSA-5875[0].Page4[0].fedDetermination[0].certNumber[0]": moreInfoRows[0].stateLicense,
        "MCSA-5875[0].Page4[0].fedDetermination[0].issueState[0]": moreInfoRows[0].stateLicenseState,
        "MCSA-5875[0].Page4[0].fedDetermination[0].md[0]": md,
        "MCSA-5875[0].Page4[0].fedDetermination[0].do[0]": DO,
        "MCSA-5875[0].Page4[0].fedDetermination[0].physAssist[0]": pa,
        "MCSA-5875[0].Page4[0].fedDetermination[0].chiroPractor[0]": ch,
        "MCSA-5875[0].Page4[0].fedDetermination[0].pracNurse[0]": apn,
        "MCSA-5875[0].Page4[0].fedDetermination[0].otherPrac[0]": op,
        "MCSA-5875[0].Page4[0].fedDetermination[0].nationalRegister[0]": moreInfoRows[0].nationalLicense,
        "MCSA-5875[0].Page4[0].fedDetermination[0].expireDate[0]": moreInfoRows[0].exp,
        "MCSA-5875[0].Page4[0].fedDetermination[0].otherPracSpecify[0]": moreInfoRows[0].specify,
        "MCSA-5875[0].Page5[0].pageHead5[0].nameLastHead5[0]": rows[0].lastname,
        "MCSA-5875[0].Page5[0].pageHead5[0].nameFirstHead5[0]": rows[0].firstname,
        "MCSA-5875[0].Page5[0].pageHead5[0].nameInitialHead5[0]": rows[0].middlename,
        "MCSA-5875[0].Page5[0].pageHead5[0].dateBirth5[0]": rows[0].dob,
        "MCSA-5875[0].Page5[0].pageHead5[0].dateForm5[0]": date,
        "MCSA-5875[0].Page5[0].stateDetermination[0].standardButtonListState[0]": dqState,
        "MCSA-5875[0].Page5[0].stateDetermination[0].notStandardsWhyState[0]": reason,
        "MCSA-5875[0].Page5[0].stateDetermination[0].butStandardsWhyState[0]": "",
        "MCSA-5875[0].Page5[0].stateDetermination[0].qualifiedButtonListState[0]": cert,
        "MCSA-5875[0].Page5[0].stateDetermination[0].otherQualifyState[0]": "rows[0].",
        "MCSA-5875[0].Page5[0].stateDetermination[0].varyRestrict[0].correctLensesState[0]": rows[0].glasses,
        "MCSA-5875[0].Page5[0].stateDetermination[0].varyRestrict[0].hearingAidState[0]": corrected,
        "MCSA-5875[0].Page5[0].stateDetermination[0].waiverQualifyState[0]": "x",
        "MCSA-5875[0].Page5[0].stateDetermination[0].waiverEnterState[0]": "rows[0].",
        "MCSA-5875[0].Page5[0].stateDetermination[0].speQualifyState[0]": "rows[0].",
        "MCSA-5875[0].Page5[0].stateDetermination[0].grandQualifyState[0]": "rows[0].",
        "MCSA-5875[0].Page5[0].stateDetermination[0].examNameState[0]": moreInfoRows[0].fname + ' ' + moreInfoRows[0].lname,
        "MCSA-5875[0].Page5[0].stateDetermination[0].examDateState[0]": date,
        "MCSA-5875[0].Page5[0].stateDetermination[0].medicalAddressState[0]": moreInfoRows[0].registerAddress,
        "MCSA-5875[0].Page5[0].stateDetermination[0].medicalCityState[0]": moreInfoRows[0].registerCity,
        "MCSA-5875[0].Page5[0].stateDetermination[0].medicalStateState[0]": moreInfoRows[0].registerState,
        "MCSA-5875[0].Page5[0].stateDetermination[0].medicalZipState[0]": moreInfoRows[0].registerZip,
        "MCSA-5875[0].Page5[0].stateDetermination[0].medicalPhoneState[0]": moreInfoRows[0].registerPhone,
        "MCSA-5875[0].Page5[0].stateDetermination[0].certNumberState[0]": moreInfoRows[0].stateLicense,
        "MCSA-5875[0].Page5[0].stateDetermination[0].issueStateState[0]": moreInfoRows[0].stateLicenseState,
        "MCSA-5875[0].Page5[0].stateDetermination[0].mdState[0]": md,
        "MCSA-5875[0].Page5[0].stateDetermination[0].doState[0]": DO,
        "MCSA-5875[0].Page5[0].stateDetermination[0].physAssistState[0]": pa,
        "MCSA-5875[0].Page5[0].stateDetermination[0].chiroPractorState[0]": ch,
        "MCSA-5875[0].Page5[0].stateDetermination[0].pracNurseState[0]": apn,
        "MCSA-5875[0].Page5[0].stateDetermination[0].otherPracState[0]": op,
        "MCSA-5875[0].Page5[0].stateDetermination[0].otherSpec[0]": moreInfoRows[0].specify,
        "MCSA-5875[0].Page5[0].stateDetermination[0].nationalRegisterState[0]": moreInfoRows[0].nationalLicense,
        "MCSA-5875[0].Page5[0].stateDetermination[0].expireDateState[0]": moreInfoRows[0].exp
      };

      //0 state = does not meet
      //1 state = does not meet
      //2 state = meets but periodic
      //3 state = meets

      //0 fed = does not meet
      //1 fed = meets
      //2 fed = does not meet
      //3 fed = meetsbut periodic

      pdfFiller.fillForm(sourcePDF, destinationPDF, data, shouldFlatten, function(err) {
        if (err) throw err;
        //console.log("In callback (we're done).");
      });

console.log("arr: " + arr)
            res.render('end', {
              title: 'End',
              user: user,
              data: timeline,
              count: historyCount
            });

            connection.release();
            })
          })
        })
      })
    })
  })
})
  }
}
//-------------------------------------------------------
var endPost = function(req, res, next) {

  var user = req.user;

  res.redirect('/pdf/' + sessionId)

};

module.exports.end = end;
module.exports.endPost = endPost;


text:
<!DOCTYPE html>
<html dir="ltr">
<head>
  <meta charset="UTF-8">
  <title>List - Basic</title>
  <meta name="viewport" content="width=device-width, initial-scale=1.0, minimum-scale=1.0, maximum-scale=1.0, user-scalable=no">
  <script src="/dist/ionic.js"></script>
</head>
<body>
  <ion-app>

      <ion-header>
        <ion-toolbar>
          <ion-title>List - Inset</ion-title>
        </ion-toolbar>
      </ion-header>

      <ion-content id="content">
        <ion-list inset>
          <ion-item>
            <ion-label>Normal Input</ion-label>
            <ion-input></ion-input>
          </ion-item>

          <ion-item>
            <ion-label position="stacked">Stacked Input</ion-label>
            <ion-input></ion-input>
          </ion-item>

          <ion-item>
            <ion-label>Normal Select</ion-label>
            <ion-select>
              <ion-select-option>1</ion-select-option>
              <ion-select-option>2</ion-select-option>
              <ion-select-option>3</ion-select-option>
            </ion-select>
          </ion-item>

          <ion-item>
            <ion-label position="stacked">Stacked Select</ion-label>
            <ion-select>
              <ion-select-option>1</ion-select-option>
              <ion-select-option>2</ion-select-option>
              <ion-select-option>3</ion-select-option>
            </ion-select>
          </ion-item>

          <ion-item>
            <ion-label>Normal Datetime</ion-label>
            <ion-datetime></ion-datetime>
          </ion-item>

          <ion-item>
            <ion-label position="stacked">Stacked Datetime</ion-label>
            <ion-datetime></ion-datetime>
          </ion-item>

        </ion-list>
      </ion-content>

  </ion-app>

  <style>
    ion-content .scroll {
      background: #e5e5e5;
    }
  </style>
</body>
</html>


text:
// Copyright 2021 Cloud Native Foundation.
// Licensed under the Apache 2.0 license.
// See LICENSE file in the project root for full license information.

namespace CloudNative.CloudEvents.Core
{
    /// <summary>
    /// Enum of attribute types, to allow efficient switching over <see cref="CloudEventAttributeType"/>.
    /// Each attribute type has a unique value, returned by <see cref="CloudEventAttributeType.Ordinal"/>.
    /// </summary>
    /// <remarks>
    /// This type is in the "Core" namespace and exposed via CloudEventAttributeTypes as relatively few consumers will need to use it.
    /// </remarks>
    public enum CloudEventAttributeTypeOrdinal
    {
        // Note: changing the values here is a breaking change.

        /// <summary>
        /// Ordinal for <see cref="CloudEventAttributeType.Binary"/>
        /// </summary>
        Binary = 0,
        /// <summary>
        /// Ordinal for <see cref="CloudEventAttributeType.Boolean"/>
        /// </summary>
        Boolean = 1,
        /// <summary>
        /// Ordinal for <see cref="CloudEventAttributeType.Integer"/>
        /// </summary>
        Integer = 2,
        /// <summary>
        /// Ordinal for <see cref="CloudEventAttributeType.String"/>
        /// </summary>
        String = 3,
        /// <summary>
        /// Ordinal for <see cref="CloudEventAttributeType.Uri"/>
        /// </summary>
        Uri = 4,
        /// <summary>
        /// Ordinal for <see cref="CloudEventAttributeType.UriReference"/>
        /// </summary>
        UriReference = 5,
        /// <summary>
        /// Ordinal for <see cref="CloudEventAttributeType.Timestamp"/>
        /// </summary>
        Timestamp = 6
    }
}


text:
<?xml version="1.0"?>
<!-- Smack configuration file. -->
<smack>

    <!-- Classes that will be loaded when Smack starts -->
    <startupClasses>
        <className>org.jivesoftware.smackx.ServiceDiscoveryManager</className>
        <className>org.jivesoftware.smack.PrivacyListManager</className>
        <className>org.jivesoftware.smackx.XHTMLManager</className>
        <className>org.jivesoftware.smackx.muc.MultiUserChat</className>
        <className>org.jivesoftware.smackx.filetransfer.FileTransferManager</className>
        <className>org.jivesoftware.smackx.LastActivityManager</className>
        <className>org.jivesoftware.smack.ReconnectionManager</className>
    </startupClasses>

    <!-- Paket reply timeout in milliseconds -->
    <packetReplyTimeout>5000</packetReplyTimeout>

    <!-- Keep-alive interval in milleseconds -->
    <keepAliveInterval>30000</keepAliveInterval>

</smack>


text:
// import { injectReducer } from '../../../store/reducers'
import { GeneralCommentsRoute } from './routes/GeneralComments'
import { LessonCommentsRoute } from './routes/LessonComments'

export const CourseRoute = (store) => ({
  path : 'section/:courseId',
  /*  Async getComponent is only invoked when route matches   */
  indexRoute: {
    getComponent (nextState, cb) {
      /*  Webpack - use 'require.ensure' to create a split point
      and embed an async module loader (jsonp) when bundling   */
      require.ensure([], (require) => {
        /*  Webpack - use require callback to define
        dependencies for bundling   */

        const MainView = require('./MainView').default

        /*  Add the reducer to the store on key 'counter'  */

        /*  Return getComponent   */
        cb(null, MainView)

        /* Webpack named bundle   */
      }, 'section/:courseId')
    }
  },
  childRoutes: [
    GeneralCommentsRoute(store),
    LessonCommentsRoute(store)
  ]
})


text:
@interface MWMLocationNotFoundAlert : MWMDefaultAlert

+ (instancetype)alertWithOkBlock:(TMWMVoidBlock)okBlock;

@end


text:
#include "prelude.hpp"
#include "builtin/proc.hpp"
#include "vm/object_utils.hpp"
#include "objectmemory.hpp"
#include "builtin/class.hpp"
#include "builtin/block_environment.hpp"
#include "builtin/compiledmethod.hpp"
#include "builtin/system.hpp"
#include "builtin/location.hpp"
#include "builtin/nativemethod.hpp"
#include "builtin/nativefunction.hpp"

#include "arguments.hpp"

#include "vmmethod.hpp"
#include "arguments.hpp"
#include "dispatch.hpp"
#include "call_frame.hpp"
#include "configuration.hpp"

#include "ontology.hpp"

namespace rubinius {

  void Proc::init(STATE) {
    GO(proc).set(ontology::new_class(state, "Proc", G(object)));
    G(proc)->set_object_type(state, ProcType);
  }

  Proc* Proc::create(STATE, Object* self) {
    return state->new_object<Proc>(as<Class>(self));
  }

  Proc* Proc::from_env(STATE, Object* self, Object* env) {
    if(Proc* p = try_as<Proc>(env)) {
      return p;
    }

    if(BlockEnvironment* be = try_as<BlockEnvironment>(env)) {
      Proc* proc = Proc::create(state, self);
      proc->block(state, be);
      return proc;
    }

    return reinterpret_cast<Proc*>(Primitives::failure());
  }

  Object* Proc::call(STATE, CallFrame* call_frame, Arguments& args) {
    bool lambda_style = CBOOL(lambda_);
    int flags = 0;

    // Check the arity in lambda mode
    if(lambda_style && !block_->nil_p()) {
      flags = CallFrame::cIsLambda;
      int total = block_->code()->total_args()->to_native();
      int required = block_->code()->required_args()->to_native();

      bool arity_ok = false;
      if(Fixnum* fix = try_as<Fixnum>(block_->code()->splat())) {
        switch(fix->to_native()) {
        case -2:
          arity_ok = true;
          break;
        case -4:
          // splat = -4 means { |(a, b)| }
          if(args.total() == 1) {
            Array* ary = 0;
            Object* obj = args.get_argument(0);

            if(!(ary = try_as<Array>(obj))) {
              if(CBOOL(obj->respond_to(state, state->symbol("to_ary"), cFalse))) {
                obj = obj->send(state, call_frame, state->symbol("to_ary"));
                if(!(ary = try_as<Array>(obj))) {
                  Exception::type_error(state, "to_ary must return an Array", call_frame);
                  return 0;
                }
              }
            }

            if(ary) args.use_argument(ary);
          }
          // fall through for arity check
        case -3:
          // splat = -3 is used to distinguish { |a, | } from { |a| }
          if(args.total() == (size_t)required) arity_ok = true;
          break;
        default:
          if(args.total() >= (size_t)required) {
            arity_ok = true;
          }
        }

      /* For blocks taking one argument { |a|  }, in 1.8, there is a warning
       * issued but no exception raised when less than or more than one
       * argument is passed. If more than one is passed, 'a' receives an Array
       * of all the arguments.
       */
      } else if(required == 1 && LANGUAGE_18_ENABLED(state)) {
        arity_ok = true;
      } else {
        arity_ok = args.total() <= (size_t)total &&
                   args.total() >= (size_t)required;
      }

      if(!arity_ok) {
        Exception* exc =
          Exception::make_argument_error(state, required, args.total(),
              state->symbol("__block__"));
        exc->locations(state, Location::from_call_stack(state, call_frame));
        state->raise_exception(exc);
        return NULL;
      }
    }

    Object* ret;
    if(bound_method_->nil_p()) {
      ret = block_->call(state, call_frame, args, flags);
    } else if(NativeMethod* nm = try_as<NativeMethod>(bound_method_)) {
      ret = nm->execute(state, call_frame, nm, G(object), args);
    } else if(NativeFunction* nf = try_as<NativeFunction>(bound_method_)) {
      ret = nf->call(state, args, call_frame);
    } else {
      Dispatch dis(state->symbol("__yield__"));
      ret = dis.send(state, call_frame, args);
    }

    return ret;
  }

  Object* Proc::yield(STATE, CallFrame* call_frame, Arguments& args) {
    if(bound_method_->nil_p()) {
      // NOTE! To match MRI semantics, this explicitely ignores lambda_.
      return block_->call(state, call_frame, args, 0);
    } else if(NativeMethod* nm = try_as<NativeMethod>(bound_method_)) {
      return nm->execute(state, call_frame, nm, G(object), args);
    } else if(NativeFunction* nf = try_as<NativeFunction>(bound_method_)) {
      return nf->call(state, args, call_frame);
    } else {
      return call_prim(state, call_frame, NULL, NULL, args);
    }
  }

  Object* Proc::call_prim(STATE, CallFrame* call_frame, Executable* exec, Module* mod,
                          Arguments& args) {
    return call(state, call_frame, args);
  }

  Object* Proc::call_on_object(STATE, CallFrame* call_frame,
                               Executable* exec, Module* mod, Arguments& args) {
    bool lambda_style = !lambda_->nil_p();
    int flags = 0;

    // Check the arity in lambda mode
    if(lambda_style) {
      flags = CallFrame::cIsLambda;
      int required = block_->code()->required_args()->to_native();

      if(args.total() < 1 || (required >= 0 && (size_t)required != args.total() - 1)) {
        Exception* exc =
          Exception::make_argument_error(state, required, args.total(), state->symbol("__block__"));
        exc->locations(state, Location::from_call_stack(state, call_frame));
        state->raise_exception(exc);
        return NULL;
      }
    }

    // Since we allow Proc's to be created without setting block_, we need to check
    // it.
    if(block_->nil_p()) {
      Exception* exc =
        Exception::make_type_error(state, BlockEnvironment::type, block_, "Invalid proc style");
      exc->locations(state, Location::from_call_stack(state, call_frame));
      state->raise_exception(exc);
      return NULL;
    }

    return block_->call_on_object(state, call_frame, args, flags);
  }
}


text:
Location Extractor
====================================

This module extracts country from states in text content. It requires pycountry for analysis.

##Examples:
```python
from locationExtractor import locationExtractor

print locationExtractor.detect("I live in New York")
>>> {'city': 'new york', 'code': u'US', 'country': u'United States'}

print locationExtractor.detect("ankara")
>>> {'city': 'ankara', 'code': u'TR', 'country': u'Turkey'}

```

If you want to change memcache host;
```python
locationExtractor.Locations.memcacheHost = "Your Host"
```

But when you did this changes for memcachehost, You must init manually for this condition.

```python
locationEXtractor.Location.init()
```


text:
<ons-page id="confirm-transaction-page">
    <ons-toolbar>

            <ons-back-button>Částka</ons-back-button>

    </ons-toolbar>

    <ons-row>
        <ons-col class="center-block upper-margin">

        </ons-col>
        <ons-col class="center-block">
            <ons-icon  icon="ion-person" size="70px"></ons-icon>
        </ons-col>
        <ons-col class="center-block upper-margin">

        </ons-col>
    </ons-row>

Odesílaná částka

    <ons-list>
        <ons-list-header>Zpráva</ons-list-header>
        <ons-list-item>
            <ons-input class="message-input-field" id="message-input" float></ons-input>
        </ons-list-item>
        <ons-list-header>Potvrzení platby</ons-list-header>
        <ons-list-item>
        <ons-icon icon="ion-locked" size="30px" ></ons-icon>

                <ons-input class="message-input-field" id="pin-input" type="password" inputmode="numeric" pattern="[0-9]*" placeholder="Zadejte PIN" float></ons-input>

        </ons-list-item>
    </ons-list>
    <ons-button id="submit-button" modifier="large">Tu</ons-button>

</ons-list>
</ons-page>