text:
/**
 * Created by ChenLong on 12/10/14.
 */

angular.module('data')
    .service('todoStats', ['url', '$http', '$q', 'todoDataService', function(url, $http, $q, todoDataService) {

        var _start = 0,
            _end = 0;
        var _todos = [];
        var _api = function(p) {
            return url.projectApiUrl(p) + "/todos/completed";
        };
        var _projectId = url.projectId();

        this.getTodoStatsData = function(start, end) {
            var since = d3.time.day.floor(new Date(start)) - 0;
            var until = d3.time.day.ceil(new Date(end)) - 0;
            var projectId = url.projectId();
            if (projectId !== _projectId || _start === 0 || _end === 0 || since !== _start || until !== _end) {
                return $http.get(_api(projectId), {
                    params: {
                        start: start,
                        end: end
                    }
                }).then(function(response) {
                    _start = since;
                    _end = until;
                    _projectId = projectId;
                    _todos = todoDataService.registerTodos(response.data);
                    return _todos;
                });
            } else {
                var deferred = $q.defer();
                deferred.resolve(_todos);
                return deferred.promise;
            }
        };
    }])
    .service('companyTodoStats', ['url', '$http', '$q', 'todoDataService', 'user', function(url, $http, $q, todoDataService, user) {
        var _start = 0,
            _end = 0;
        var _todos = [];
        var _url = 'api/' + url.companyId() + '/stats/completedTodos';

        var processTodo = function(data, userList) {
            return data.map(function(d) {
                if (d.assigneeId === undefined) {
                    d.assigneeId = -1;
                }
                d.assigneeName = "未分配责任人";
                for (var key in userList) {
                    if (userList[key].id === d.assigneeId) {
                        d.assigneeName = userList[key].name;
                        break;
                    }
                }
                return d;
            });
        };

        this.getTodoStatsData = function(start, end) {
            var since = d3.time.day.floor(new Date(start)) - 0;
            var until = d3.time.day.ceil(new Date(end)) - 0;
            if (_start === 0 || _end === 0 || since !== _start || until !== _end) {
                return $q.all([$http.get(_url, {
                    params: {
                        start: start,
                        end: end
                    }
                }), user.getCompanyUsers(false, url.companyId())]).then(function(result) {
                    var userList = result[1];
                    var todos = result[0].data;
                    _start = since;
                    _end = until;
                    //_todos = todoDataService.registerTodos(response.data);
                    _todos = processTodo(todos, userList)
                    return _todos;
                });
            } else {
                var deferred = $q.defer();
                deferred.resolve(_todos);
                return deferred.promise;
            }
        };
    }]);


text:
static void f() {}

@interface I: NSObject
-(void)instanceMethod:(int)arg1 with:(int)arg2;
+(void)classMethod;
@end

@implementation I
-(void)instanceMethod:(int)arg1 with:(int)arg2 {}
+(void)classMethod {}
@end

void g(I *i, int x, int y) {
  [I classMethod];
  [i instanceMethod: x with: y];

  void (^block)(void);
  block = ^{};
  block();
}

// CHECK: analyzer-display-progress.m f
// CHECK: analyzer-display-progress.m -[I instanceMethod:with:]
// CHECK: analyzer-display-progress.m +[I classMethod]
// CHECK: analyzer-display-progress.m g
// CHECK: analyzer-display-progress.m block (line: 22, col: 11)

redpajama_set_name: RedPajamaGithub


text:
<?php

namespace App\Application\Controllers\Api;

use App\Application\Controllers\Controller;
use App\Application\Model\User;
use App\Application\Transformers\UsersTransformers;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;

class UserApi extends Controller
{

    protected $request;
    protected $model;

    public function __construct(User $model , Request $request)
    {
        $this->model = $model;
        $this->request = $request;
        $this->middleware('authApi')->only('update' , 'getUserByToken');
    }

    public function index($limit = 10 , $offset = 0){
       $data =  $this->model->limit($limit)->offset($offset)->get();
        return response(apiReturn(UsersTransformers::transform($data)) , 200 );
    }

    public function getById($id){
        $data =  $this->model->find($id);
        return response(apiReturn(UsersTransformers::transform($data)) , 200 );
    }

    public function login()
    {
        $v = Validator::make($this->request->all(), $this->model->loginValidation());
        if ($v->fails()) {
            return response(apiReturn('' , 'error' , $v->errors())  , 401 );
        }
        if (! $token = auth()->attempt($this->request->only(['email' , 'password']))) {
           return response(apiReturn('' , 'error' , 'invalid_credentials')  , 401 );
        }
        $user = $this->model->where('email' , $this->request->email)->first();
        $user->api_token = $this->generateToken();
        $user->save();
        return response(apiReturn($user)  , 200 );
    }

    public function add(){
        $v = Validator::make($this->request->all(), $this->model->validation(null));
        if ($v->fails()) {
            return response(apiReturn('' , 'error' , $v->errors())  , 401 );
        }
        $request = $this->request->all();
        $request['group_id'] = env('DEFAULT_GROUP');
        $request['password'] = bcrypt($this->request->password);
        $request['api_token'] = $this->generateToken();
        $data = $this->model->create(checkApiHaveImage($request));
        return response(apiReturn(UsersTransformers::transform($data))  , 200 );
    }

    public function update(){
        $v = Validator::make($this->request->all(), $this->model->updateValidation(null));
        if ($v->fails()) {
            return response(apiReturn('' , 'error' , $v->errors())  , 401 );
        }
        $user = auth()->guard('api')->user();
        $request = $this->request->all();
        $request['password'] = bcrypt($this->request->password);
        $data = $user->update(checkApiHaveImage($request));
        return response(apiReturn($data)  , 200 );
    }

    public function getUserByToken(){
        $user = auth()->guard('api')->user();
        return response(apiReturn(UsersTransformers::transform($user))  , 200 );
    }

    public function delete($id){
        $data = $this->model->find($id)->delete();
        return response(apiReturn($data)  , 200 );
    }

    public function generateToken(){
       return str_random(60);
    }

}


text:
package main

import (
	"io/ioutil"
	"os"

	"github.com/BurntSushi/toml"
	"github.com/pkg/errors"
)

// Environment app environment
type Environment string

// app environment
const (
	EnvProd Environment = "production"
	EnvStg              = "staging"
	EnvDev              = "development"
	EnvTest             = "test"
)

// AppConfig application config
type AppConfig struct {
	ServerPort  int    `toml:"server_port"`
	Environment string `toml:"environment"`
	Debug       bool   `toml:"debug"`
}

// NewAppConfig reads config file, and creates AppConfig
func NewAppConfig(path string) (*AppConfig, error) {
	f, err := os.Open(path)
	if err != nil {
		return nil, errors.Wrapf(err, "failed to open config file: %s", path)
	}
	defer f.Close()
	buf, err := ioutil.ReadAll(f)
	if err != nil {
		return nil, errors.Wrap(err, "failed to read config file")
	}
	var config AppConfig
	if err := toml.Unmarshal(buf, &config); err != nil {
		return nil, errors.Wrap(err, "failed to create AppConfig from file")
	}
	return &config, nil
}


text:
package com.hsj.common.receiver;

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

/**
 * @Author:HSJ
 * @E-mail:shengjunhu@foxmail.com
 * @Date:2017/10/30/14:21
 * @Class:NetworkStateReceiver
 * @Description:
 */
public class NetworkStateReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {

    }

}


text:
package org.javaee7.jaxws.endpoint;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import javax.jws.WebService;

/**
 *
 * @author Fermin Gallego
 *
 */
@WebService(endpointInterface = "org.javaee7.jaxws.endpoint.EBookStore",
serviceName="EBookStoreImplService")
public class EBookStoreImpl implements EBookStore{

    private HashMap<String,EBook> eBookCollection=new HashMap<String,EBook>();

    @Override
    public String welcomeMessage(String name) {
        return "Welcome to EBookStore WebService, Mr/Mrs "+name;
    }

    @Override
    public List<String> findEBooks(String text) {
        List<String> foundTitles=new ArrayList<String>();
        for(String title:eBookCollection.keySet()){
            if(title.contains(text)){
                foundTitles.add(title);
            }
        }
        return foundTitles;
    }

    @Override
    public EBook takeBook(String title) {
        return eBookCollection.get(title);
    }

    @Override
    public void saveBook(EBook eBook) {
        eBookCollection.put(eBook.getTitle(), eBook);

    }

    @Override
    public EBook addAppendix(EBook eBook,int appendixPages) {
        eBook.setNumPages((eBook.getNumPages()+appendixPages));
        eBookCollection.put(eBook.getTitle(), eBook);
        return eBook;
    }

}


text:
TestSelector
============

TestSelector is an utility to select a set of smoke test, so that you won't have to run entire regression before delivery

===========
It uses following libraries:
Lua from lua.org
Boost from boost.org
Turtle from turtle.sourceforge.net
PugiXML from pugixml.org


text:
package org.ethereum.gui;

import org.ethereum.core.AccountState;
import org.ethereum.db.ContractDetails;
import org.ethereum.facade.Repository;
import org.ethereum.util.Utils;
import org.ethereum.vm.DataWord;
import org.ethereum.vm.Program;

import org.spongycastle.util.encoders.Hex;

import java.awt.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import java.math.BigInteger;

import java.net.URL;

import java.util.Map;

import javax.swing.*;
import javax.swing.table.AbstractTableModel;

public class StateExplorerWindow extends JFrame {

    private ToolBar toolBar = null;
    private JTextField txfAccountAddress;
    private WindowTextArea txaPrinter;
    private JButton btnPlayCode;
    private AccountsListWindow accountsListWindow;
    ProgramPlayDialog codePanel;

    private JTable tblStateDataTable;
    private StateDataTableModel dataModel;
    String[] dataTypes = {"String", "Hex", "Number"};

    public StateExplorerWindow(ToolBar toolBar) {
        this.toolBar = toolBar;

        URL url = ClassLoader.getSystemResource("ethereum-icon.png");
        Toolkit kit = Toolkit.getDefaultToolkit();
        Image img = kit.createImage(url);
        this.setIconImage(img);
        setTitle("State Explorer");
        setSize(700, 530);
        setLocation(50, 180);
        setResizable(false);

        /*
         * top search panel
         */
        JPanel panel = new JPanel();
        getContentPane().add(panel);

        Box horizontalBox = Box.createHorizontalBox();
        panel.add(horizontalBox);

        java.net.URL imageURL = ClassLoader.getSystemResource("buttons/list.png");
        ImageIcon image = new ImageIcon(imageURL);
        JToggleButton btnListAccounts = new JToggleButton("");
        btnListAccounts.setIcon(image);
        btnListAccounts.setContentAreaFilled(true);
        btnListAccounts.setToolTipText("Serpent Editor");
        btnListAccounts.setBackground(Color.WHITE);
        btnListAccounts.setBorderPainted(false);
        btnListAccounts.setFocusPainted(false);
        btnListAccounts.setCursor(new Cursor(Cursor.HAND_CURSOR));
        btnListAccounts.addItemListener(e -> SwingUtilities.invokeLater(() -> {
            if (accountsListWindow == null)
                accountsListWindow = new AccountsListWindow();
            accountsListWindow.setVisible(true);
        }));
        horizontalBox.add(btnListAccounts);

        txfAccountAddress = new JTextField();
        horizontalBox.add(txfAccountAddress);
        txfAccountAddress.setColumns(30);

        JButton btnSearch = new JButton("Search");
        horizontalBox.add(btnSearch);
        btnSearch.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent e) {
                byte[] addr = Utils.addressStringToBytes(txfAccountAddress.getText());
                if (addr != null)
                    searchAccount(addr);
            }
        });

        btnPlayCode = new JButton("Play Code");
        horizontalBox.add(btnPlayCode);
        btnPlayCode.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent e) {
                byte[] addr = Utils.addressStringToBytes(txfAccountAddress.getText());
                if (addr != null) {
                    Repository repository = UIEthereumManager.ethereum.getRepository();
                    byte[] code = repository.getCode(addr);
                    if (code != null)
                        ProgramPlayDialog.createAndShowGUI(code, null, null);
                }
            }
        });

        /*
         * center text panel
         */
        JPanel centerPanel = new JPanel();
        panel.add(centerPanel);

        txaPrinter = new WindowTextArea();
        centerPanel.add(txaPrinter);

        /*
         * bottom data panel
         */
        // data type choice boxes
        Box Hbox = Box.createHorizontalBox();
        panel.add(Hbox);

        Box VBox1 = Box.createVerticalBox();
        JLabel l1 = new JLabel("Key Encoding");
        l1.setAlignmentX(Component.CENTER_ALIGNMENT);
        JComboBox cmbKey = new JComboBox(dataTypes);
        cmbKey.setSelectedIndex(1);
        cmbKey.addActionListener(e -> {
            JComboBox cmb = (JComboBox) e.getSource();
            DataEncodingType t = DataEncodingType.getTypeFromString((String) cmb.getSelectedItem());
            dataModel.setKeyEncoding(t);
        });
        VBox1.add(l1);
        VBox1.add(cmbKey);

        Box VBox2 = Box.createVerticalBox();
        VBox2.setAlignmentX(LEFT_ALIGNMENT);
        JLabel l2 = new JLabel("Value Encoding");
        l2.setAlignmentX(Component.CENTER_ALIGNMENT);
        JComboBox cmbValue = new JComboBox(dataTypes);
        cmbValue.setSelectedIndex(1);
        cmbValue.addActionListener(e -> {
            JComboBox cmb = (JComboBox) e.getSource();
            DataEncodingType t = DataEncodingType.getTypeFromString((String) cmb.getSelectedItem());
            dataModel.setValueEncoding(t);
        });
        VBox2.add(l2);
        VBox2.add(cmbValue);

        Hbox.add(VBox1);

        JPanel spacer = new JPanel();
        FlowLayout flowLayout = (FlowLayout) spacer.getLayout();
        flowLayout.setHgap(100);
        Hbox.add(spacer);
        Hbox.add(VBox2);

        // table
        tblStateDataTable = new JTable();
        dataModel = new StateDataTableModel();
        tblStateDataTable.setModel(dataModel);

        JScrollPane scrollPane = new JScrollPane(tblStateDataTable);
        scrollPane.setPreferredSize(new Dimension(600, 200));
        panel.add(scrollPane);
    }

    private void searchAccount(byte[] add) {
        txaPrinter.clean();
        txaPrinter.println(accountDetailsString(add, dataModel));
    }

    private String accountDetailsString(byte[] account, StateDataTableModel dataModel) {
        String ret = "";
        // 1) print account address
        ret = "Account: " + Hex.toHexString(account) + "\n";

        //2) print state
        Repository repository = UIEthereumManager.ethereum.getRepository();
        AccountState state = repository.getAccountState(account);
        if (state != null)
            ret += state.toString() + "\n";

        //3) print storage
        ContractDetails contractDetails = repository.getContractDetails(account);
        if (contractDetails != null) {
            Map<DataWord, DataWord> accountStorage = contractDetails.getStorage();
            dataModel.setData(accountStorage);
        }

        //4) code print
        byte[] code = repository.getCode(account);
        if (code != null) {
            ret += "\n\nCode:\n";
            ret += Program.stringify(code, 0, "");
        }

        return ret;
    }

    private class StateDataTableModel extends AbstractTableModel {

        Map<DataWord, DataWord> data;
        DataEncodingType keyEncodingType = DataEncodingType.HEX;
        DataEncodingType valueEncodingType = DataEncodingType.HEX;
        String[] columns = new String[]{"Key", "Value"};

        public StateDataTableModel() {
        }

        public StateDataTableModel(Map<DataWord, DataWord> initData) {
            setData(initData);
        }

        public void setData(Map<DataWord, DataWord> initData) {
            data = initData;
            fireTableDataChanged();
        }

        public void setKeyEncoding(DataEncodingType type) {
            keyEncodingType = type;
            fireTableDataChanged();
        }

        public void setValueEncoding(DataEncodingType type) {
            valueEncodingType = type;
            fireTableDataChanged();
        }

        @Override
        public String getColumnName(int column) {
            return columns[column];
        }

        @Override
        public int getRowCount() {
            return data == null ? 0 : data.size();
        }

        @Override
        public int getColumnCount() {
            return columns.length;
        }

        @Override
        public Object getValueAt(int rowIndex, int columnIndex) {
            DataWord key = (DataWord) this.data.keySet().toArray()[rowIndex];

            if (columnIndex == 0) {
                return getDataWithEncoding(key.getData(), keyEncodingType);
            } else {
                DataWord value = this.data.get(key);
                return getDataWithEncoding(value.getData(), valueEncodingType);
            }
        }

        private String getDataWithEncoding(byte[] data, DataEncodingType enc) {
            switch (enc) {
                case STRING:
                    return new String(data);
                case HEX:
                    return Hex.toHexString(data);
                case NUMBER:
                    return new BigInteger(data).toString();
            }

            return data.toString();
        }
    }

    private enum DataEncodingType {
        STRING,
        HEX,
        NUMBER;

        static public DataEncodingType getTypeFromString(String value) {
            switch (value) {
                case "String":
                    return STRING;
                case "Hex":
                    return HEX;
                case "Number":
                    return NUMBER;
            }
            return STRING;
        }
    }

    private class WindowTextArea extends TextArea {

        public WindowTextArea() {
            super();
        }

        public void println(String txt) {
            setText(getText() + txt + "\n");
        }

        public void clean() {
            setText("");
        }
    }

    public static void main(String[] args) {
        // Start all Swing applications on the EDT.
        SwingUtilities.invokeLater(() -> new StateExplorerWindow(null).setVisible(true));
    }
}


text:
<?php declare(strict_types=1);

namespace Fedot\DataMapper\Annotation;

use Doctrine\Common\Annotations\Annotation\Enum;
use Doctrine\Common\Annotations\Annotation\Target;

/**
 * @Annotation
 * @Target({"PROPERTY"})
 */
class Field
{
    /**
     * @var string
     * @Enum({"string"})
     */
    public $type = 'string';
}


text:
/* $NetBSD: _wcstod.h,v 1.4 2013/05/17 12:55:57 joerg Exp $ */

/*-
 * Copyright (c) 2002 Tim J. Robbins
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * aINre met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * Original version ID:
 *   FreeBSD: /repoman/r/ncvs/src/lib/libc/locale/wcstod.c,v 1.4 2004/04/07 09:47:56 tjr Exp
 *   NetBSD: wcstod.c,v 1.8 2006/04/13 01:25:13 tnozaki Exp
 */

/*
 * function template for wcstof, wcstod, wcstold.
 *
 * parameters:
 *	_FUNCNAME    : function name
 *	_RETURN_TYPE : return type
 *	_STRTOD_FUNC : real conversion function
 */
#ifndef __WCSTOD_H_
#define __WCSTOD_H_

#include <locale.h>
#include "setlocale_local.h"
#define INT_NAME_(pre, middle, post) pre ## middle ## post
#define INT_NAME(pre, middle, post) INT_NAME_(pre, middle, post)

/*
 * Convert a string to a double-precision number.
 *
 * This is the wide-character counterpart of strto{f,d,ld}(). So that
 * we do not have to duplicate the code of strto{f,d,ld}() here,
 * we convert the supplied wide-character string to multibyte and
 * call strto{f,d,ld}() on the result.
 * This assumes that the multibyte encoding is compatible with ASCII
 * for at least the digits, radix character and letters.
 */
static _RETURN_TYPE
INT_NAME(_int_, _FUNCNAME, _l)(const wchar_t * __restrict nptr,
			   wchar_t ** __restrict endptr, locale_t loc)
{
	const wchar_t *src, *start;
	_RETURN_TYPE val;
	char *buf, *end;
	size_t bufsiz, len;

	_DIAGASSERT(nptr != NULL);
	/* endptr may be null */

	src = nptr;
	while (iswspace_l((wint_t)*src, loc) != 0)
		++src;
	if (*src == L'\0')
		goto no_convert;

	/*
	 * Convert the supplied numeric wide-char. string to multibyte.
	 *
	 * We could attempt to find the end of the numeric portion of the
	 * wide-char. string to avoid converting unneeded characters but
	 * choose not to bother; optimising the uncommon case where
	 * the input string contains a lot of text after the number
	 * duplicates a lot of strto{f,d,ld}()'s functionality and
	 * slows down the most common cases.
	 */
	start = src;
	len = wcstombs_l(NULL, src, 0, loc);
	if (len == (size_t)-1)
		/* errno = EILSEQ */
		goto no_convert;

	_DIAGASSERT(len > 0);

	bufsiz = len;
	buf = (void *)malloc(bufsiz + 1);
	if (buf == NULL)
		/* errno = ENOMEM */
		goto no_convert;

	len = wcstombs_l(buf, src, bufsiz + 1, loc);

	_DIAGASSERT(len == bufsiz);
	_DIAGASSERT(buf[len] == '\0');

	/* Let strto{f,d,ld}() do most of the work for us. */
	val = _STRTOD_FUNC(buf, &end, loc);
	if (buf == end) {
		free(buf);
		goto no_convert;
	}

	/*
	 * We only know where the number ended in the _multibyte_
	 * representation of the string. If the caller wants to know
	 * where it ended, count multibyte characters to find the
	 * corresponding position in the wide-char string.
	 */
	if (endptr != NULL)
		/* XXX Assume each wide char is one byte. */
		*endptr = __UNCONST(start + (size_t)(end - buf));

	free(buf);

	return val;

no_convert:
	if (endptr != NULL)
		*endptr = __UNCONST(nptr);
	return 0;
}

_RETURN_TYPE
INT_NAME(, _FUNCNAME, )(const wchar_t * __restrict nptr,
    wchar_t ** __restrict endptr)
{
	return INT_NAME(_int_, _FUNCNAME, _l)(nptr, endptr, _current_locale());
}

_RETURN_TYPE
INT_NAME(, _FUNCNAME, _l)(const wchar_t * __restrict nptr,
    wchar_t ** __restrict endptr, locale_t loc)
{
	return INT_NAME(_int_, _FUNCNAME, _l)(nptr, endptr, loc);
}
#endif /*__WCSTOD_H_*/


text:
WORKDIR=$(pwd)
GENOME=hg38
OUTDIR=fragLibrary
TEMPLATE=slurm_fragLibrary_paired

mkdir -p $OUTDIR
cat sampleList.txt | awk '{if(NF==4)print $1}' > All_conditions.txt

for CONDITION in $(cat All_conditions.txt | sed s/_rep[0-9]// | uniq); do
  sed -e s%XXWORKDIRXX%$WORKDIR% -e s%XXOUTDIRXX%$OUTDIR% -e s%XXCONDITIONXX%$CONDITION% -e s%XXGENOMEXX%$GENOME% $TEMPLATE > scripts/fragLibrary_${CONDITION}.slurm
done


text:
using System;

class horriblrCode
{
    static void Main()
    {
        Console.WriteLine("Hi, I am horribly formatted program");
        Console.WriteLine("Numbers and squares:");
        for (int i = 0;i < 10;i++)
        {
            Console.WriteLine(i +" --> " + i*i);
        }
    }
}


text:
package com.bstek.designer.editor.actions;

import com.intellij.openapi.actionSystem.DefaultActionGroup;
import icons.DoradoIcons;

/**
 * Created with IntelliJ IDEA.
 * User: robin
 * Date: 13-9-29
 * Time: 下午4:08
 * To change this template use File | Settings | File Templates.
 */
public class DoradoActionGroup extends DefaultActionGroup {

    public DoradoActionGroup() {
        super("Dorado7", true);
        getTemplatePresentation().setDescription("Dorado7");
        getTemplatePresentation().setIcon(DoradoIcons.DORADO7_ICON);
    }
}


text:
'use strict';

/* jshint ignore:start */
/**
 * This code was generated by
 * \ / _    _  _|   _  _
 *  | (_)\/(_)(_|\/| |(/_  v1.0.0
 *       /       /
 */
/* jshint ignore:end */

var Holodeck = require('../../../../../holodeck');  /* jshint ignore:line */
var Request = require(
    '../../../../../../../lib/http/request');  /* jshint ignore:line */
var Response = require(
    '../../../../../../../lib/http/response');  /* jshint ignore:line */
var RestException = require(
    '../../../../../../../lib/base/RestException');  /* jshint ignore:line */
var Twilio = require('../../../../../../../lib');  /* jshint ignore:line */

var client;
var holodeck;

describe('Bucket', function() {
  beforeEach(function() {
    holodeck = new Holodeck();
    client = new Twilio('ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX', 'AUTHTOKEN', {
      httpClient: holodeck
    });
  });
  it('should generate valid create request',
    function(done) {
      holodeck.mock(new Response(500, {}));

      var opts = {'max': 1, 'interval': 1};
      var promise = client.verify.v2.services('VAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                                    .rateLimits('RKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                                    .buckets.create(opts);
      promise.then(function() {
        throw new Error('failed');
      }, function(error) {
        expect(error.constructor).toBe(RestException.prototype.constructor);
        done();
      }).done();

      var serviceSid = 'VAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';
      var rateLimitSid = 'RKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';
      var url = `https://verify.twilio.com/v2/Services/${serviceSid}/RateLimits/${rateLimitSid}/Buckets`;

      var values = {'Max': 1, 'Interval': 1, };
      holodeck.assertHasRequest(new Request({
          method: 'POST',
          url: url,
          data: values
      }));
    }
  );
  it('should generate valid create_bucket response',
    function(done) {
      var body = {
          'sid': 'BLaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
          'rate_limit_sid': 'RKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
          'service_sid': 'VAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
          'account_sid': 'ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
          'max': 5,
          'interval': 60,
          'date_created': '2015-07-30T20:00:00Z',
          'date_updated': '2015-07-30T20:00:00Z',
          'url': 'https://verify.twilio.com/v2/Services/VAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/RateLimits/RKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Buckets/BLaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
      };

      holodeck.mock(new Response(201, body));

      var opts = {'max': 1, 'interval': 1};
      var promise = client.verify.v2.services('VAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                                    .rateLimits('RKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                                    .buckets.create(opts);
      promise.then(function(response) {
        expect(response).toBeDefined();
        done();
      }, function() {
        throw new Error('failed');
      }).done();
    }
  );
  it('should generate valid update request',
    function(done) {
      holodeck.mock(new Response(500, {}));

      var promise = client.verify.v2.services('VAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                                    .rateLimits('RKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                                    .buckets('BLXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX').update();
      promise.then(function() {
        throw new Error('failed');
      }, function(error) {
        expect(error.constructor).toBe(RestException.prototype.constructor);
        done();
      }).done();

      var serviceSid = 'VAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';
      var rateLimitSid = 'RKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';
      var sid = 'BLXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';
      var url = `https://verify.twilio.com/v2/Services/${serviceSid}/RateLimits/${rateLimitSid}/Buckets/${sid}`;

      holodeck.assertHasRequest(new Request({
        method: 'POST',
        url: url
      }));
    }
  );
  it('should generate valid update_bucket response',
    function(done) {
      var body = {
          'sid': 'BLaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
          'rate_limit_sid': 'RKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
          'service_sid': 'VAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
          'account_sid': 'ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
          'max': 5,
          'interval': 60,
          'date_created': '2015-07-30T20:00:00Z',
          'date_updated': '2015-07-30T20:00:00Z',
          'url': 'https://verify.twilio.com/v2/Services/VAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/RateLimits/RKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Buckets/BLaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
      };

      holodeck.mock(new Response(200, body));

      var promise = client.verify.v2.services('VAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                                    .rateLimits('RKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                                    .buckets('BLXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX').update();
      promise.then(function(response) {
        expect(response).toBeDefined();
        done();
      }, function() {
        throw new Error('failed');
      }).done();
    }
  );
  it('should generate valid fetch request',
    function(done) {
      holodeck.mock(new Response(500, {}));

      var promise = client.verify.v2.services('VAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                                    .rateLimits('RKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                                    .buckets('BLXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX').fetch();
      promise.then(function() {
        throw new Error('failed');
      }, function(error) {
        expect(error.constructor).toBe(RestException.prototype.constructor);
        done();
      }).done();

      var serviceSid = 'VAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';
      var rateLimitSid = 'RKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';
      var sid = 'BLXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';
      var url = `https://verify.twilio.com/v2/Services/${serviceSid}/RateLimits/${rateLimitSid}/Buckets/${sid}`;

      holodeck.assertHasRequest(new Request({
        method: 'GET',
        url: url
      }));
    }
  );
  it('should generate valid fetch_bucket response',
    function(done) {
      var body = {
          'sid': 'BLaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
          'rate_limit_sid': 'RKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
          'service_sid': 'VAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
          'account_sid': 'ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
          'max': 5,
          'interval': 60,
          'date_created': '2015-07-30T20:00:00Z',
          'date_updated': '2015-07-30T20:00:00Z',
          'url': 'https://verify.twilio.com/v2/Services/VAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/RateLimits/RKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Buckets/BLaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
      };

      holodeck.mock(new Response(200, body));

      var promise = client.verify.v2.services('VAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                                    .rateLimits('RKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                                    .buckets('BLXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX').fetch();
      promise.then(function(response) {
        expect(response).toBeDefined();
        done();
      }, function() {
        throw new Error('failed');
      }).done();
    }
  );
  it('should treat the first each arg as a callback',
    function(done) {
      var body = {
          'buckets': [
              {
                  'sid': 'BLaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
                  'rate_limit_sid': 'RKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
                  'service_sid': 'VAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
                  'account_sid': 'ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
                  'max': 5,
                  'interval': 60,
                  'date_created': '2015-07-30T20:00:00Z',
                  'date_updated': '2015-07-30T20:00:00Z',
                  'url': 'https://verify.twilio.com/v2/Services/VAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/RateLimits/RKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Buckets/BLaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
              }
          ],
          'meta': {
              'page': 0,
              'page_size': 50,
              'first_page_url': 'https://verify.twilio.com/v2/Services/VAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/RateLimits/RKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Buckets?PageSize=50&Page=0',
              'previous_page_url': null,
              'url': 'https://verify.twilio.com/v2/Services/VAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/RateLimits/RKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Buckets?PageSize=50&Page=0',
              'next_page_url': null,
              'key': 'buckets'
          }
      };
      holodeck.mock(new Response(200, body));
      client.verify.v2.services('VAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                      .rateLimits('RKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                      .buckets.each(() => done());
    }
  );
  it('should treat the second arg as a callback',
    function(done) {
      var body = {
          'buckets': [
              {
                  'sid': 'BLaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
                  'rate_limit_sid': 'RKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
                  'service_sid': 'VAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
                  'account_sid': 'ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
                  'max': 5,
                  'interval': 60,
                  'date_created': '2015-07-30T20:00:00Z',
                  'date_updated': '2015-07-30T20:00:00Z',
                  'url': 'https://verify.twilio.com/v2/Services/VAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/RateLimits/RKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Buckets/BLaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
              }
          ],
          'meta': {
              'page': 0,
              'page_size': 50,
              'first_page_url': 'https://verify.twilio.com/v2/Services/VAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/RateLimits/RKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Buckets?PageSize=50&Page=0',
              'previous_page_url': null,
              'url': 'https://verify.twilio.com/v2/Services/VAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/RateLimits/RKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Buckets?PageSize=50&Page=0',
              'next_page_url': null,
              'key': 'buckets'
          }
      };
      holodeck.mock(new Response(200, body));
      client.verify.v2.services('VAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                      .rateLimits('RKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                      .buckets.each({pageSize: 20}, () => done());
      holodeck.assertHasRequest(new Request({
          method: 'GET',
          url: 'https://verify.twilio.com/v2/Services/${serviceSid}/RateLimits/${rateLimitSid}/Buckets',
          params: {PageSize: 20},
      }));
    }
  );
  it('should find the callback in the opts object',
    function(done) {
      var body = {
          'buckets': [
              {
                  'sid': 'BLaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
                  'rate_limit_sid': 'RKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
                  'service_sid': 'VAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
                  'account_sid': 'ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
                  'max': 5,
                  'interval': 60,
                  'date_created': '2015-07-30T20:00:00Z',
                  'date_updated': '2015-07-30T20:00:00Z',
                  'url': 'https://verify.twilio.com/v2/Services/VAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/RateLimits/RKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Buckets/BLaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
              }
          ],
          'meta': {
              'page': 0,
              'page_size': 50,
              'first_page_url': 'https://verify.twilio.com/v2/Services/VAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/RateLimits/RKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Buckets?PageSize=50&Page=0',
              'previous_page_url': null,
              'url': 'https://verify.twilio.com/v2/Services/VAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/RateLimits/RKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Buckets?PageSize=50&Page=0',
              'next_page_url': null,
              'key': 'buckets'
          }
      };
      holodeck.mock(new Response(200, body));
      client.verify.v2.services('VAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                      .rateLimits('RKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                      .buckets.each({callback: () => done()}, () => fail('wrong callback!'));
    }
  );
  it('should generate valid list request',
    function(done) {
      holodeck.mock(new Response(500, {}));

      var promise = client.verify.v2.services('VAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                                    .rateLimits('RKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                                    .buckets.list();
      promise.then(function() {
        throw new Error('failed');
      }, function(error) {
        expect(error.constructor).toBe(RestException.prototype.constructor);
        done();
      }).done();

      var serviceSid = 'VAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';
      var rateLimitSid = 'RKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';
      var url = `https://verify.twilio.com/v2/Services/${serviceSid}/RateLimits/${rateLimitSid}/Buckets`;

      holodeck.assertHasRequest(new Request({
        method: 'GET',
        url: url
      }));
    }
  );
  it('should generate valid read_empty response',
    function(done) {
      var body = {
          'buckets': [],
          'meta': {
              'page': 0,
              'page_size': 50,
              'first_page_url': 'https://verify.twilio.com/v2/Services/VAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/RateLimits/RKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Buckets?PageSize=50&Page=0',
              'previous_page_url': null,
              'url': 'https://verify.twilio.com/v2/Services/VAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/RateLimits/RKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Buckets?PageSize=50&Page=0',
              'next_page_url': null,
              'key': 'buckets'
          }
      };

      holodeck.mock(new Response(200, body));

      var promise = client.verify.v2.services('VAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                                    .rateLimits('RKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                                    .buckets.list();
      promise.then(function(response) {
        expect(response).toBeDefined();
        done();
      }, function() {
        throw new Error('failed');
      }).done();
    }
  );
  it('should generate valid read_full response',
    function(done) {
      var body = {
          'buckets': [
              {
                  'sid': 'BLaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
                  'rate_limit_sid': 'RKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
                  'service_sid': 'VAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
                  'account_sid': 'ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
                  'max': 5,
                  'interval': 60,
                  'date_created': '2015-07-30T20:00:00Z',
                  'date_updated': '2015-07-30T20:00:00Z',
                  'url': 'https://verify.twilio.com/v2/Services/VAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/RateLimits/RKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Buckets/BLaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
              }
          ],
          'meta': {
              'page': 0,
              'page_size': 50,
              'first_page_url': 'https://verify.twilio.com/v2/Services/VAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/RateLimits/RKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Buckets?PageSize=50&Page=0',
              'previous_page_url': null,
              'url': 'https://verify.twilio.com/v2/Services/VAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/RateLimits/RKaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Buckets?PageSize=50&Page=0',
              'next_page_url': null,
              'key': 'buckets'
          }
      };

      holodeck.mock(new Response(200, body));

      var promise = client.verify.v2.services('VAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                                    .rateLimits('RKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                                    .buckets.list();
      promise.then(function(response) {
        expect(response).toBeDefined();
        done();
      }, function() {
        throw new Error('failed');
      }).done();
    }
  );
  it('should generate valid remove request',
    function(done) {
      holodeck.mock(new Response(500, {}));

      var promise = client.verify.v2.services('VAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                                    .rateLimits('RKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                                    .buckets('BLXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX').remove();
      promise.then(function() {
        throw new Error('failed');
      }, function(error) {
        expect(error.constructor).toBe(RestException.prototype.constructor);
        done();
      }).done();

      var serviceSid = 'VAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';
      var rateLimitSid = 'RKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';
      var sid = 'BLXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';
      var url = `https://verify.twilio.com/v2/Services/${serviceSid}/RateLimits/${rateLimitSid}/Buckets/${sid}`;

      holodeck.assertHasRequest(new Request({
        method: 'DELETE',
        url: url
      }));
    }
  );
  it('should generate valid delete response',
    function(done) {
      var body = null;

      holodeck.mock(new Response(204, body));

      var promise = client.verify.v2.services('VAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                                    .rateLimits('RKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                                    .buckets('BLXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX').remove();
      promise.then(function(response) {
        expect(response).toBe(true);
        done();
      }, function() {
        throw new Error('failed');
      }).done();
    }
  );
});


text:
class PrefService;

namespace blink {
class StorageKey;
}  // namespace blink

namespace net {
class SiteForCookies;
}  // namespace net

namespace permissions {
class BluetoothDelegateImpl;
}

namespace weblayer {

class FeatureListCreator;
class SafeBrowsingService;
struct MainParams;

#if BUILDFLAG(ENABLE_ARCORE)
class XrIntegrationClientImpl;
#endif  // BUILDFLAG(ENABLE_ARCORE)

class ContentBrowserClientImpl : public content::ContentBrowserClient {
 public:
  explicit ContentBrowserClientImpl(MainParams* params);
  ~ContentBrowserClientImpl() override;

  // ContentBrowserClient overrides.
  std::unique_ptr<content::BrowserMainParts> CreateBrowserMainParts(
      bool is_integration_test) override;
  std::string GetApplicationLocale() override;
  std::string GetAcceptLangs(content::BrowserContext* context) override;
  content::AllowServiceWorkerResult AllowServiceWorker(
      const GURL& scope,
      const net::SiteForCookies& site_for_cookies,
      const absl::optional<url::Origin>& top_frame_origin,
      const GURL& script_url,
      content::BrowserContext* context) override;
  bool AllowSharedWorker(const GURL& worker_url,
                         const net::SiteForCookies& site_for_cookies,
                         const absl::optional<url::Origin>& top_frame_origin,
                         const std::string& name,
                         const blink::StorageKey& storage_key,
                         content::BrowserContext* context,
                         int render_process_id,
                         int render_frame_id) override;
  void AllowWorkerFileSystem(
      const GURL& url,
      content::BrowserContext* browser_context,
      const std::vector<content::GlobalRenderFrameHostId>& render_frames,
      base::OnceCallback<void(bool)> callback) override;
  bool AllowWorkerIndexedDB(const GURL& url,
                            content::BrowserContext* browser_context,
                            const std::vector<content::GlobalRenderFrameHostId>&
                                render_frames) override;
  bool AllowWorkerCacheStorage(
      const GURL& url,
      content::BrowserContext* browser_context,
      const std::vector<content::GlobalRenderFrameHostId>& render_frames)
      override;
  bool AllowWorkerWebLocks(const GURL& url,
                           content::BrowserContext* browser_context,
                           const std::vector<content::GlobalRenderFrameHostId>&
                               render_frames) override;
  std::unique_ptr<content::WebContentsViewDelegate> GetWebContentsViewDelegate(
      content::WebContents* web_contents) override;
  bool CanShutdownGpuProcessNowOnIOThread() override;
  std::unique_ptr<content::DevToolsManagerDelegate>
  CreateDevToolsManagerDelegate() override;
  void LogWebFeatureForCurrentPage(content::RenderFrameHost* render_frame_host,
                                   blink::mojom::WebFeature feature) override;
  std::string GetProduct() override;
  std::string GetUserAgent() override;
  std::string GetFullUserAgent() override;
  std::string GetReducedUserAgent() override;
  blink::UserAgentMetadata GetUserAgentMetadata() override;
  void OverrideWebkitPrefs(content::WebContents* web_contents,
                           blink::web_pref::WebPreferences* prefs) override;
  void ConfigureNetworkContextParams(
      content::BrowserContext* context,
      bool in_memory,
      const base::FilePath& relative_partition_path,
      network::mojom::NetworkContextParams* network_context_params,
      cert_verifier::mojom::CertVerifierCreationParams*
          cert_verifier_creation_params) override;
  void OnNetworkServiceCreated(
      network::mojom::NetworkService* network_service) override;
  std::vector<std::unique_ptr<blink::URLLoaderThrottle>>
  CreateURLLoaderThrottles(
      const network::ResourceRequest& request,
      content::BrowserContext* browser_context,
      const base::RepeatingCallback<content::WebContents*()>& wc_getter,
      content::NavigationUIData* navigation_ui_data,
      int frame_tree_node_id) override;
  bool IsHandledURL(const GURL& url) override;
  std::vector<url::Origin> GetOriginsRequiringDedicatedProcess() override;
  bool MayReuseHost(content::RenderProcessHost* process_host) override;
  void OverridePageVisibilityState(
      content::RenderFrameHost* render_frame_host,
      content::PageVisibilityState* visibility_state) override;
  bool ShouldDisableSiteIsolation(
      content::SiteIsolationMode site_isolation_mode) override;
  std::vector<std::string> GetAdditionalSiteIsolationModes() override;
  void PersistIsolatedOrigin(
      content::BrowserContext* context,
      const url::Origin& origin,
      content::ChildProcessSecurityPolicy::IsolatedOriginSource source)
      override;
  base::OnceClosure SelectClientCertificate(
      content::WebContents* web_contents,
      net::SSLCertRequestInfo* cert_request_info,
      net::ClientCertIdentityList client_certs,
      std::unique_ptr<content::ClientCertificateDelegate> delegate) override;
  bool CanCreateWindow(content::RenderFrameHost* opener,
                       const GURL& opener_url,
                       const GURL& opener_top_level_frame_url,
                       const url::Origin& source_origin,
                       content::mojom::WindowContainerType container_type,
                       const GURL& target_url,
                       const content::Referrer& referrer,
                       const std::string& frame_name,
                       WindowOpenDisposition disposition,
                       const blink::mojom::WindowFeatures& features,
                       bool user_gesture,
                       bool opener_suppressed,
                       bool* no_javascript_access) override;
  content::ControllerPresentationServiceDelegate*
  GetControllerPresentationServiceDelegate(
      content::WebContents* web_contents) override;
  void OpenURL(
      content::SiteInstance* site_instance,
      const content::OpenURLParams& params,
      base::OnceCallback<void(content::WebContents*)> callback) override;
  std::vector<std::unique_ptr<content::NavigationThrottle>>
  CreateThrottlesForNavigation(content::NavigationHandle* handle) override;
  content::GeneratedCodeCacheSettings GetGeneratedCodeCacheSettings(
      content::BrowserContext* context) override;
  void RegisterAssociatedInterfaceBindersForRenderFrameHost(
      content::RenderFrameHost& render_frame_host,
      blink::AssociatedInterfaceRegistry& associated_registry) override;
  void ExposeInterfacesToRenderer(
      service_manager::BinderRegistry* registry,
      blink::AssociatedInterfaceRegistry* associated_registry,
      content::RenderProcessHost* render_process_host) override;
  void BindMediaServiceReceiver(content::RenderFrameHost* render_frame_host,
                                mojo::GenericPendingReceiver receiver) override;
  void RegisterBrowserInterfaceBindersForFrame(
      content::RenderFrameHost* render_frame_host,
      mojo::BinderMapWithContext<content::RenderFrameHost*>* map) override;
  void BindHostReceiverForRenderer(
      content::RenderProcessHost* render_process_host,
      mojo::GenericPendingReceiver receiver) override;
  void RenderProcessWillLaunch(content::RenderProcessHost* host) override;
// TODO(crbug.com/1052397): Revisit once build flag switch of lacros-chrome is
// complete.
#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS_LACROS) || \
    BUILDFLAG(IS_ANDROID)
  void GetAdditionalMappedFilesForChildProcess(
      const base::CommandLine& command_line,
      int child_process_id,
      content::PosixFileDescriptorInfo* mappings) override;
#endif  // BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS_LACROS) ||
        // BUILDFLAG(IS_ANDROID)
  void AppendExtraCommandLineSwitches(base::CommandLine* command_line,
                                      int child_process_id) override;
#if BUILDFLAG(IS_ANDROID)
  bool WillCreateURLLoaderFactory(
      content::BrowserContext* browser_context,
      content::RenderFrameHost* frame,
      int render_process_id,
      URLLoaderFactoryType type,
      const url::Origin& request_initiator,
      absl::optional<int64_t> navigation_id,
      ukm::SourceIdObj ukm_source_id,
      mojo::PendingReceiver<network::mojom::URLLoaderFactory>* factory_receiver,
      mojo::PendingRemote<network::mojom::TrustedURLLoaderHeaderClient>*
          header_client,
      bool* bypass_redirect_checks,
      bool* disable_secure_dns,
      network::mojom::URLLoaderFactoryOverridePtr* factory_override) override;
  WideColorGamutHeuristic GetWideColorGamutHeuristic() override;
  std::unique_ptr<content::LoginDelegate> CreateLoginDelegate(
      const net::AuthChallengeInfo& auth_info,
      content::WebContents* web_contents,
      const content::GlobalRequestID& request_id,
      bool is_request_for_primary_main_frame,
      const GURL& url,
      scoped_refptr<net::HttpResponseHeaders> response_headers,
      bool first_auth_attempt,
      LoginAuthRequiredCallback auth_required_callback) override;
  std::unique_ptr<content::TtsEnvironmentAndroid> CreateTtsEnvironmentAndroid()
      override;
  bool ShouldObserveContainerViewLocationForDialogOverlays() override;
  content::BluetoothDelegate* GetBluetoothDelegate() override;
#endif  // BUILDFLAG(IS_ANDROID)
  content::SpeechRecognitionManagerDelegate*
  CreateSpeechRecognitionManagerDelegate() override;
  bool ShouldSandboxNetworkService() override;
#if BUILDFLAG(ENABLE_ARCORE)
  content::XrIntegrationClient* GetXrIntegrationClient() override;
#endif  // BUILDFLAG(ENABLE_ARCORE)
  ukm::UkmService* GetUkmService() override;
  bool HasErrorPage(int http_status_code) override;
  bool IsClipboardPasteAllowed(
      content::RenderFrameHost* render_frame_host) override;
  bool ShouldPreconnectNavigation(
      content::BrowserContext* browser_context) override;

  void CreateFeatureListAndFieldTrials();

 private:
  std::unique_ptr<PrefService> CreateLocalState();

#if BUILDFLAG(IS_ANDROID)
  SafeBrowsingService* GetSafeBrowsingService();

  std::unique_ptr<permissions::BluetoothDelegateImpl> bluetooth_delegate_;
#endif

  raw_ptr<MainParams> params_;

  // Local-state is created early on, before BrowserProcess. Ownership moves to
  // BrowserMainParts, then BrowserProcess. BrowserProcess ultimately owns
  // local-state so that it can be destroyed along with other BrowserProcess
  // state.
  std::unique_ptr<PrefService> local_state_;

  std::unique_ptr<FeatureListCreator> feature_list_creator_;

#if BUILDFLAG(ENABLE_ARCORE)
  std::unique_ptr<XrIntegrationClientImpl> xr_integration_client_;
#endif  // BUILDFLAG(ENABLE_ARCORE)
};

}  // namespace weblayer

#endif  // WEBLAYER_BROWSER_CONTENT_BROWSER_CLIENT_IMPL_H_


text:
using System;
using System.Text;
using Renci.SshNet.Sftp.Responses;

namespace Renci.SshNet.Sftp.Requests
{
    internal class SftpLStatRequest : SftpRequest
    {
        public override SftpMessageTypes SftpMessageType
        {
            get { return SftpMessageTypes.LStat; }
        }

        public string Path { get; private set; }

        public Encoding Encoding { get; private set; }

        public SftpLStatRequest(uint protocolVersion, uint requestId, string path, Encoding encoding, Action<SftpAttrsResponse> attrsAction, Action<SftpStatusResponse> statusAction)
            : base(protocolVersion, requestId, statusAction)
        {
            this.Path = path;
            this.Encoding = encoding;
            this.SetAction(attrsAction);
        }

        protected override void LoadData()
        {
            base.LoadData();
            this.Path = this.ReadString(this.Encoding);
        }

        protected override void SaveData()
        {
            base.SaveData();
            this.Write(this.Path, this.Encoding);
        }
    }
}


text:
class RecordFileReader {
public:
  virtual ~RecordFileReader() {}

  virtual bool Initialize(FILE* file) = 0;

  // Read a record from opened reader.
  // If operation is successful, 0 is returned.
  // Otherwise, the value indicates an error.
  virtual int Read(VisitingRecord* record) = 0;

  virtual void Close() = 0;
};

class RecordFileWriter {
public:
  virtual ~RecordFileWriter() {}

  virtual bool Initialize(FILE* file) = 0;

  // Write a record to opened writer.
  // If operation is successful, 0 is returned.
  // Otherwise, negative value indicates an error.
  virtual int Write(const VisitingRecord& record) = 0;

  virtual void Close() = 0;
};

class RecordFileIOFactory {
public:
  // Create a writer.
  // Caller should take care of the returned pointer.
  static RecordFileWriter* CreateWriter(const std::string& path);

  // Create a reader.
  // Caller should take care of the returned pointer.
  static RecordFileReader* CreateReader(const std::string& path);

private:
  static const uint64 kVersionA = 200801012108ULL;

  RecordFileIOFactory() {}
};

#endif // SITEMAPSERVICE_RECORDFILEIO_H__


text:
## How to parse invoice in C# and ByteScout Robotic Process Automation ByteScout Robotic Process Automation: set of tools for rapid implementation of robotic process automation applications.

## REQUEST FREE TECH SUPPORT

[Click here to get in touch](https://bytescout.zendesk.com/hc/en-us/requests/new?subject=ByteScout%20Robotic%20Process%20Automation%20Question)

or just send email to [support@bytescout.com](mailto:support@bytescout.com?subject=ByteScout%20Robotic%20Process%20Automation%20Question)

## ON-PREMISE OFFLINE SDK

[Get Your 60 Day Free Trial](https://bytescout.com/download/web-installer?utm_source=github-readme)
[Explore Documentation](https://bytescout.com/documentation/index.html?utm_source=github-readme)
[Explore Source Code Samples](https://github.com/bytescout/ByteScout-SDK-SourceCode/)
[Sign Up For Online Training](https://academy.bytescout.com/)

## ON-DEMAND REST WEB API

[Get your API key](https://app.pdf.co/signup?utm_source=github-readme)
[Security](https://pdf.co/security)
[Explore Web API Documentation](https://apidocs.pdf.co?utm_source=github-readme)
[Explore Web API Samples](https://github.com/bytescout/ByteScout-SDK-SourceCode/tree/master/PDF.co%20Web%20API)

## VIDEO REVIEW

[https://www.youtube.com/watch?v=gEjuZ0zgtHo](https://www.youtube.com/watch?v=gEjuZ0zgtHo)

<!-- code block begin -->

##### **InvoiceParsing.VS2005.csproj:**

```
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
    <ProjectGuid>{BF74D299-912C-4259-A022-71628F76F2B9}</ProjectGuid>
    <OutputType>Exe</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>InvoiceParsing</RootNamespace>
    <AssemblyName>InvoiceParsing</AssemblyName>
    <FileAlignment>512</FileAlignment>
    <ProductVersion>8.0.50727</ProductVersion>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
    <PlatformTarget>AnyCPU</PlatformTarget>
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <Optimize>false</Optimize>
    <OutputPath>bin\Debug\</OutputPath>
    <DefineConstants>DEBUG;TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
    <PlatformTarget>AnyCPU</PlatformTarget>
    <DebugType>pdbonly</DebugType>
    <Optimize>true</Optimize>
    <OutputPath>bin\Release\</OutputPath>
    <DefineConstants>TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Bytescout.PDFExtractor, Version=6.30.0.2431, Culture=neutral, PublicKeyToken=f7dd1bd9d40a50eb, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>C:\Program Files\Bytescout PDF Extractor SDK\net2.00\Bytescout.PDFExtractor.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Data" />
    <Reference Include="System.Drawing" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Program.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
  </ItemGroup>
  <ItemGroup>
    <Content Include="Invoice.pdf">
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
    </Content>
  </ItemGroup>
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>
```

<!-- code block end -->

<!-- code block begin -->

##### **InvoiceParsing.VS2008.csproj:**

```
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
    <ProjectGuid>{BF74D299-912C-4259-A022-71628F76F2B9}</ProjectGuid>
    <OutputType>Exe</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>InvoiceParsing</RootNamespace>
    <AssemblyName>InvoiceParsing</AssemblyName>
    <TargetFrameworkVersion>v2.0</TargetFrameworkVersion>
    <FileAlignment>512</FileAlignment>
    <ProductVersion>9.0.30729</ProductVersion>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
    <PlatformTarget>AnyCPU</PlatformTarget>
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <Optimize>false</Optimize>
    <OutputPath>bin\Debug\</OutputPath>
    <DefineConstants>DEBUG;TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
    <PlatformTarget>AnyCPU</PlatformTarget>
    <DebugType>pdbonly</DebugType>
    <Optimize>true</Optimize>
    <OutputPath>bin\Release\</OutputPath>
    <DefineConstants>TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Bytescout.PDFExtractor, Version=6.30.0.2431, Culture=neutral, PublicKeyToken=f7dd1bd9d40a50eb, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>C:\Program Files\Bytescout PDF Extractor SDK\net2.00\Bytescout.PDFExtractor.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Data" />
    <Reference Include="System.Drawing" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Program.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
  </ItemGroup>
  <ItemGroup>
    <Content Include="Invoice.pdf">
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
    </Content>
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>
```

<!-- code block end -->

<!-- code block begin -->

##### **InvoiceParsing.VS2010.csproj:**

```
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
    <ProjectGuid>{BF74D299-912C-4259-A022-71628F76F2B9}</ProjectGuid>
    <OutputType>Exe</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>InvoiceParsing</RootNamespace>
    <AssemblyName>InvoiceParsing</AssemblyName>
    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
    <FileAlignment>512</FileAlignment>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
    <PlatformTarget>AnyCPU</PlatformTarget>
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <Optimize>false</Optimize>
    <OutputPath>bin\Debug\</OutputPath>
    <DefineConstants>DEBUG;TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
    <PlatformTarget>AnyCPU</PlatformTarget>
    <DebugType>pdbonly</DebugType>
    <Optimize>true</Optimize>
    <OutputPath>bin\Release\</OutputPath>
    <DefineConstants>TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Bytescout.PDFExtractor, Version=6.30.0.2431, Culture=neutral, PublicKeyToken=f7dd1bd9d40a50eb, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>C:\Program Files\Bytescout PDF Extractor SDK\net2.00\Bytescout.PDFExtractor.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Data" />
    <Reference Include="System.Drawing" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Program.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
  </ItemGroup>
  <ItemGroup>
    <Content Include="Invoice.pdf">
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
    </Content>
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>
```

<!-- code block end -->

<!-- code block begin -->

##### **InvoiceParsing.VS2012.csproj:**

```
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
    <ProjectGuid>{BF74D299-912C-4259-A022-71628F76F2B9}</ProjectGuid>
    <OutputType>Exe</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>InvoiceParsing</RootNamespace>
    <AssemblyName>InvoiceParsing</AssemblyName>
    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
    <FileAlignment>512</FileAlignment>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
    <PlatformTarget>AnyCPU</PlatformTarget>
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <Optimize>false</Optimize>
    <OutputPath>bin\Debug\</OutputPath>
    <DefineConstants>DEBUG;TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
    <PlatformTarget>AnyCPU</PlatformTarget>
    <DebugType>pdbonly</DebugType>
    <Optimize>true</Optimize>
    <OutputPath>bin\Release\</OutputPath>
    <DefineConstants>TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Bytescout.PDFExtractor, Version=6.30.0.2431, Culture=neutral, PublicKeyToken=f7dd1bd9d40a50eb, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>C:\Program Files\Bytescout PDF Extractor SDK\net2.00\Bytescout.PDFExtractor.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Data" />
    <Reference Include="System.Drawing" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Program.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
  </ItemGroup>
  <ItemGroup>
    <Content Include="Invoice.pdf">
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
    </Content>
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>
```

<!-- code block end -->

<!-- code block begin -->

##### **InvoiceParsing.VS2013.csproj:**

```
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
    <ProjectGuid>{BF74D299-912C-4259-A022-71628F76F2B9}</ProjectGuid>
    <OutputType>Exe</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>InvoiceParsing</RootNamespace>
    <AssemblyName>InvoiceParsing</AssemblyName>
    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
    <FileAlignment>512</FileAlignment>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
    <PlatformTarget>AnyCPU</PlatformTarget>
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <Optimize>false</Optimize>
    <OutputPath>bin\Debug\</OutputPath>
    <DefineConstants>DEBUG;TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
    <PlatformTarget>AnyCPU</PlatformTarget>
    <DebugType>pdbonly</DebugType>
    <Optimize>true</Optimize>
    <OutputPath>bin\Release\</OutputPath>
    <DefineConstants>TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Bytescout.PDFExtractor, Version=6.30.0.2431, Culture=neutral, PublicKeyToken=f7dd1bd9d40a50eb, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>C:\Program Files\Bytescout PDF Extractor SDK\net2.00\Bytescout.PDFExtractor.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Data" />
    <Reference Include="System.Drawing" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Program.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
  </ItemGroup>
  <ItemGroup>
    <Content Include="Invoice.pdf">
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
    </Content>
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>
```

<!-- code block end -->

<!-- code block begin -->

##### **InvoiceParsing.VS2015.csproj:**

```
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
    <ProjectGuid>{BF74D299-912C-4259-A022-71628F76F2B9}</ProjectGuid>
    <OutputType>Exe</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>InvoiceParsing</RootNamespace>
    <AssemblyName>InvoiceParsing</AssemblyName>
    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
    <FileAlignment>512</FileAlignment>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
    <PlatformTarget>AnyCPU</PlatformTarget>
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <Optimize>false</Optimize>
    <OutputPath>bin\Debug\</OutputPath>
    <DefineConstants>DEBUG;TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
    <PlatformTarget>AnyCPU</PlatformTarget>
    <DebugType>pdbonly</DebugType>
    <Optimize>true</Optimize>
    <OutputPath>bin\Release\</OutputPath>
    <DefineConstants>TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Bytescout.PDFExtractor, Version=6.30.0.2431, Culture=neutral, PublicKeyToken=f7dd1bd9d40a50eb, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>C:\Program Files\Bytescout PDF Extractor SDK\net2.00\Bytescout.PDFExtractor.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Data" />
    <Reference Include="System.Drawing" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Program.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
  </ItemGroup>
  <ItemGroup>
    <Content Include="Invoice.pdf">
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
    </Content>
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>
```

<!-- code block end -->

<!-- code block begin -->

##### **Program.cs:**

```
using System;
using System.Drawing;
using Bytescout.PDFExtractor;

namespace InvoiceParsing
{
	/// <summary>
	/// This example demonstrates parsing and data extraction from typical invoice.
	/// </summary>
	class Program
	{
		static void Main(string[] args)
		{
			// Create TextExtractor instance
			TextExtractor textExtractor = new TextExtractor("demo", "demo");
			textExtractor.WordMatchingMode = WordMatchingMode.ExactMatch; // Set exact search (default is SmartSearch that works like in Adobe Reader)

			// Create XMLExtractor instance
			XMLExtractor xmlExtractor = new XMLExtractor("demo", "demo");

			// Load document
			textExtractor.LoadDocumentFromFile("Invoice.pdf");
			xmlExtractor.LoadDocumentFromFile("Invoice.pdf");

			// Results
			string invoiceNo = string.Empty;
			string invoiceDate = string.Empty;
			string total = string.Empty;
			string tableData = string.Empty;

			// Iterate pages
			for (int i = 0; i < textExtractor.GetPageCount(); i++)
			{
				RectangleF pageRectangle = textExtractor.GetPageRectangle(i);
				RectangleF tableRect = new RectangleF(0, 0, pageRectangle.Width, 0);

				// Search for "Invoice No."
				if (textExtractor.Find(i, "Invoice No.", false))
				{
					// Get the found text rectangle
					RectangleF textRect = textExtractor.FoundText.Bounds;
					// Assume the text at right is the invoice number.
					// Shift the rectangle to the right:
					textRect.X = textRect.Right;
					textRect.Width = pageRectangle.Right - textRect.Left;
					// Set the extraction region and extract the text
					textExtractor.SetExtractionArea(textRect);
					invoiceNo = textExtractor.GetTextFromPage(i).Trim();
				}

				// Search for "Invoice Date" and extract text at right
				if (textExtractor.Find(i, "Invoice Date", false))
				{
					RectangleF textRect = textExtractor.FoundText.Bounds;
					textRect.X = textRect.Right;
					textRect.Width = pageRectangle.Right - textRect.Left;
					textExtractor.SetExtractionArea(textRect);
					invoiceDate = textExtractor.GetTextFromPage(i).Trim();
				}

				// Search for "Quantity" keyword to detect the top of the tabular data rectangle
				if (textExtractor.Find(i, "Quantity", false))
				{
					// Keep the top table coordinate
					tableRect.Y = textExtractor.FoundText.Bounds.Top; // use textRect.Bottom if you want to skip column headers
				}

				// Search for "TOTAL" (it will be also the bottom of tabular data rectangle)
				if (textExtractor.Find(i, "TOTAL", true /* case sensitive! */))
				{
					RectangleF textRect = textExtractor.FoundText.Bounds;
					textRect.X = textRect.Right;
					textRect.Width = pageRectangle.Right - textRect.Left;
					textExtractor.SetExtractionArea(textRect);
					total = textExtractor.GetTextFromPage(i).Trim();

					// Calculate the table height
					tableRect.Height = textRect.Top - tableRect.Top;
				}

				// Extract tabular data using XMLExtractor
				if (tableRect.Height > 0)
				{
					xmlExtractor.SetExtractionArea(tableRect);
					tableData = xmlExtractor.GetXMLFromPage(i);
				}
			}

			// Display extracted data
			Console.WriteLine("Invoice No.: " + invoiceNo);
			Console.WriteLine("Invoice Date: " + invoiceDate);
			Console.WriteLine("TOTAL: " + total);
			Console.WriteLine("Table Data: ");
			Console.WriteLine(tableData);

			Console.WriteLine("Press any key...");
			Console.ReadKey();
		}
	}
}

```

<!-- code block end -->


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

angular.module('Spinner')
.component('loadingSpinner', {
  templateUrl: 'src/spinner/loadingspinner.template.html',
  controller: SpinnerController
});

SpinnerController.$inject = ['$rootScope']
function SpinnerController($rootScope) {
  var $ctrl = this;
  var cancellers = [];

  $ctrl.$onInit = function () {
    var cancel = $rootScope.$on('$stateChangeStart',
    function(event, toState, toParams, fromState, fromParams, options){
      $ctrl.showSpinner = true;
    });
    cancellers.push(cancel);

    cancel = $rootScope.$on('$stateChangeSuccess',
    function(event, toState, toParams, fromState, fromParams){
      $ctrl.showSpinner = false;
    });
    cancellers.push(cancel);

    cancel = $rootScope.$on('$stateChangeError',
    function(event, toState, toParams, fromState, fromParams, error){
      $ctrl.showSpinner = false;
    });
    cancellers.push(cancel);
  };

  $ctrl.$onDestroy = function () {
    cancellers.forEach(function (item) {
      item();
    });
  };

};

})();


text:
package org.fusesource.fabric.agent.mvn;

/**
 * Properties resolver.
 *
 * @author Alin Dreghiciu
 * @since 0.5.0, January 16, 2008
 */
public interface PropertyResolver {

    /**
     * Resolves a property based on it's name.
     *
     * @param propertyName property name to be resolved
     * @return value of property or null if property is not set or is empty.
     */
    String get(String propertyName);

}


text:
package org.zstack.sdk;

import org.zstack.sdk.ImageInventory;

public class BackupStorageMigrateImageResult {
    public ImageInventory inventory;
    public void setInventory(ImageInventory inventory) {
        this.inventory = inventory;
    }
    public ImageInventory getInventory() {
        return this.inventory;
    }

}


text:
				<button id='call-accept' class='btn btn-success'>Accept</button>

				<button id='call-reject' class='btn btn-danger'>Reject</button>

				<button id='call-cancel' class='btn btn-danger'>Cancel</button>

			<button class='btn' id='document-close'>Close</button>

Preferences

Multimedia

Application

Share

About

		<form id='prefFrmMedia' class='modal-tab-content'>

Microphone

<select id='audioDeviceSelector'></select>

Playback Volume

<input type='range' min='0' max='1' step='0.05' id='sliderVolume' class='trackbar' />

Camera

<select id='videoDeviceSelector'></select>

<input type='checkbox' id='videoDeviceQuality'/>Prefer HD video

		</form>

		<form id='prefFrmApp' class='modal-tab-content'>

Your Nickname

<input type='text' id='inputPrefsNickname' />

<input type='checkbox' id='confirmClose'/>Show confirmation on closing

<input type='checkbox' id='enableMiniMode'/>Show mini window during call

		</form>

		<form id='prefFrmShare' class='modal-tab-content'>

Room Link

<input type='text' id='shareRoomLink' value='' readonly />

		</form>

		<form id='prefFrmAbout' class='modal-tab-content'>

SpeakUP

Created by LinkShift. Project is available on GitHub.

3-rd party resources:

SimpleWebRTC.js from &yet

SVGeneration by DDKnoll

Standalone clients based on electron

Icons by IcoMoon App

PT Sans Font by Google Fonts and ParaType

		</form>

<button id='prefsCancel' class='btn'>%svg:icon-cancel icon-dark% Cancel</button>

<button id='prefsSave' class='btn'>%svg:icon-ok icon-dark% Save</button>


text:
#import "WebDeviceOrientationProviderMock.h"

#import <WebCore/DeviceOrientationClientMock.h>
#import <wtf/OwnPtr.h>

@interface WebDeviceOrientationProviderMockInternal : NSObject {
    OwnPtr<WebCore::DeviceOrientationClientMock> m_core;
}

- (id)init;

- (void)setOrientation:(WebDeviceOrientation*)orientation;

- (void)setController:(WebCore::DeviceOrientationController*)controller;

- (void)startUpdating;
- (void)stopUpdating;
- (WebDeviceOrientation*)lastOrientation;
@end

@interface WebDeviceOrientationProviderMock (Internal)
- (void)setController:(WebCore::DeviceOrientationController*)controller;
@end


text:
package org.pentaho.osgi.metastore.locator.api;

import org.pentaho.metastore.api.IMetaStore;

/**
 * Created by tkafalas on 6/19/2017
 */
public interface MetastoreLocator {
  final String LOCAL_PROVIDER_KEY = "LocalMetastoreProvider";
  final String REPOSITORY_PROVIDER_KEY = "RepositoryMetastoreProvider";

  /**
   * Attempts to pick the best the MetaStore based on environment; either
   * the local or repository metastore.
   * @return The metastore to use
   */
  IMetaStore getMetastore();

  /**
   * Works similar to (@link #getMetastore()) except that it will fall back to a metastore with a key of
   * providerKey if the both repository and local metastore both are not found.
   * @param providerKey
   * @return
   */
  IMetaStore getMetastore( String providerKey );

  /**
   * Registers a metastore provider that returns the received metastore with the current thread. {@link #getMetastore()}
   * will used this metastore iff the repository and local metastore provider cannot be found.
   * @param metastore
   * @return
   */
  String setEmbeddedMetastore( IMetaStore metastore );

  /**
   * Dispose a metastore provider assciated with the providerKey
   * @param providerKey The key to the metastore provider.
   */
  public void disposeMetastoreProvider( String providerKey );

  /**
   * Unconditionally returns the metastore stored with the given provider key, or null if it does not exist.
   * @param providerKey
   * @return
   */
  public IMetaStore getExplicitMetastore( String providerKey );
}


text:
@interface ChatRoomCell : UITableViewCell

@property (nonatomic) UILabel* titleLabel;
@property (nonatomic) UILabel* subtitleLabel;
@property (nonatomic) UIImageView* roomIconView;

@end


text:
<?php
/**
 * The template for displaying search results pages.
 *
 * @package Sydney
 */

get_header(); ?>

		<?php if ( have_posts() ) : ?>

<?php printf( __( 'Search Results for: %s', 'sydney' ), '' . get_search_query() . '' ); ?></h31>

			<?php /* Start the Loop */ ?>
			<?php while ( have_posts() ) : the_post(); ?>

				<?php
				/**
				 * Run the loop for the search to output the results.
				 * If you want to overload this in a child theme then include a file
				 * called content-search.php and that will be used instead.
				 */
				get_template_part( 'content', 'search' );
				?>

			<?php endwhile; ?>

			<?php the_posts_navigation(); ?>

		<?php else : ?>

			<?php get_template_part( 'content', 'none' ); ?>

		<?php endif; ?>

<?php get_sidebar(); ?>
<?php get_footer(); ?>


text:
using glm::vec2;
using glm::vec3;
using glm::vec4;
using glm::mat4;
using std::map;
//Macro
#define PI 3.141592653589793
#define TWOPI 6.2831853071795862
#define TWOPI_F 6.2831853f

class Drawable
{
protected:
	struct Vertex
	{
		vec4* m_vPosition;
		vec4* m_vNormals;
		vec4* m_vTangents;
		vec2* m_vUVCoords;
	};

	struct
	{
		mat4 m_mModelTrans;
		GLuint m_uiIndexCount;
		int m_iIDN;
	} Data;

	struct
	{
		GLuint m_uiVAO;
		GLuint m_uiVBO;
		GLuint m_uiIBO;
	} Handle;

public:
	Drawable();
	~Drawable();

	virtual void Render() const = NULL;

	void SetObjTransform(mat4 a_mNewTransform);
	mat4 GetObjTransform() const;
	void SetID(int a_iIDN);
	int GetID() const;
	GLuint GetIndices() const;

	GLuint GetVAO() const;
	GLuint GetVBO() const;
	GLuint GetIBO() const;
};
  //////////////////////
 //
//
class Plane : public Drawable
{
private:
	int m_iFaces;
public:
	Plane ();
	~Plane();

	void GenPlane(glm::vec2 a_vDimensions, glm::ivec2 a_vDivisions, float a_fSMax, float a_fTMax);

	void Render() const override;
};

class Cube : public Drawable
{
public:
	Cube();
	~Cube();

	void GenCube();
	virtual void Render() const override;
};

class Sphere : public Drawable
{
private:
	float m_fRadius;
	float m_fSlices;
	float m_fStacks;
	GLuint m_uiVertices;

	void GenerateVerts(float* a_fVerticies, float* a_fNormals, float* a_fUVCoord, unsigned int* a_uiElements);

public:
	Sphere();
	~Sphere();

	void GenSphere(float a_fRadius, int a_iSlices, int a_iStacks);

	void Render() const override;
};

class Torus : public Drawable
{
private:
	int m_iFaces;
	int m_iRings;
	int m_iSides;

	void GenerateVerts(float* a_fVerticies, float* a_fNormals, float* a_fUVCoord,
		unsigned int* a_uiElements, float a_fOuterRadius, float a_fInnerRadius);

public:
	Torus();
	~Torus();

	void GenTorus(float a_fOuterRadius, float a_fInnerRadius, int a_iNumOfSides, int a_iNumOfRings);

	void Render() const;
};

using std::string;

#define MAX_OBJ 100

class Gizzle
{
private:
	map<string, Drawable*> m_moActiveObjects;
	enum
	{
		PLANE,
		CUBE,
		SPHERE,
		TORUS,
		MESH,
		SKINNED_MESH,
		NONE
	} Objects;
	string m_sAlphaID;
	int m_iActiveObjects,
		m_iNumOfPlane,
		m_iNumOfCube,
		m_iNumOfSphere,
		m_iNumOfTorus,
		m_iNumOfMesh;
	static int m_iID;

	void AddPlane(vec2 a_vDimensions, glm::ivec2 a_vDivisions, float a_fSMax, float a_fTMax);
	void AddCube();
	void AddSphere(float a_fRadius, int a_iSlices, int a_iStacks);
	void AddTorus(float a_fOuterRadius, float a_fInnerRadius, int a_iNumOfSides, int a_iNumOfRings);
	void AddMesh(const char* a_pccFileName, bool a_bReCenterMesh = false, bool a_bLoadTex = false, bool a_bGenTangents = false) {}
	void AddSkinnedMesh(){}

	void GenID();

public:
	Gizzle();
	~Gizzle();

	void CreateObject(int a_iObjID,
		float* a_fFloatValues = nullptr,
		int* a_iIntValues = nullptr,
		bool* a_bOptions = nullptr,
		const char* a_pccFileName = nullptr);

	void DeleteObject(int a_iObjID) {}

	void Draw();
};
#endif //!_GIZZLE_H_