val_snippets.csv

code,language
"from sys import argv, exit
from PyQt5.QtCore import Qt
from PyQt5.QtWidgets import QApplication, QMainWindow, QWidget
class MainWindow(QMainWindow):
    def __init__(self, parent=None):
        super(MainWindow, self).__init__(parent)
        self.setCentralWidget(CustomWidget(self))
        self.show()
class CustomWidget(QWidget):
    def __init__(self, parent=None):
        super(CustomWidget, self).__init__(parent)
        self.setFocusPolicy(Qt.StrongFocus)
        pass
    def mousePressEvent(self, event):
        print(event)
    def keyPressEvent(self, event):
        print(event)
if __name__ == ""__main__"":
    app = QApplication(argv)
    ex = MainWindow()
    exit(app.exec_())",python
"package dto

type Feature struct {
	Name     string
	FilePath string
	Line     int
}",go
"

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    frmGaugeRound w;
    w.show();
    return a.exec();
}",cpp
"





























int sc_main(int, char*[]) 
{  
  tb_env* env;
  tb_test* test;
  env = new tb_env(""env"");
  test = new tb_test(""test"");
  uvm::uvm_root::get()->set_report_verbosity_level(uvm::UVM_FULL);
  test->set_report_verbosity_level(uvm::UVM_FULL);
  env->set_report_verbosity_level(uvm::UVM_FULL);
  uvm::uvm_report_server::get_server()->set_max_quit_count(10);
  uvm::run_test();
  delete env;
  delete test;
  return 0;
}",cpp
"DELETE FROM acesso.rlc_menus_perfis
 WHERE cod_perfil_fk not in (1);
DELETE FROM acesso.rlc_perfis_funcionalidades_acoes
 WHERE cod_perfil_fk not in (1);
DELETE FROM acesso.rlc_usuarios_perfis
 WHERE cod_perfil_fk not in (1)
DELETE FROM acesso.tab_perfis
 WHERE cod_perfil not in (1)
DELETE FROM acesso.rlc_usuarios_perfis
 WHERE cod_usuario_fk not in  (1,5)
DELETE FROM acesso.tab_usuarios
 WHERE cod_usuario not in (1,5)
 DELETE FROM public.tab_parametros
 WHERE modulo_fk=2
 DELETE FROM acesso.tab_modulos
 WHERE cod_modulo not in (1)
DELETE FROM acesso.tab_menus
 WHERE cod_menu not in ( 
 select cod_menu_fk FROM acesso.rlc_menus_perfis
 WHERE cod_perfil_fk in (1)
 );",mysql
"import Vue from 'vue'
import Cookies from 'js-cookie'
import 'normalize.css/normalize.css' // a modern alternative to CSS resets
import Element from 'element-ui'
import './styles/element-variables.scss'

import '@/styles/index.scss' // global css
import App from './App'
import store from './store'
import router from './router'
import './icons' // icon

import './permission' // permission control
import './utils/error-log' // error log
import * as filters from './filters' // global filters
import echarts from 'echarts'
Vue.prototype.$echarts = echarts
Vue.use(Element, {
  size: Cookies.get('size') || 'medium' // set element-ui default size

})

Object.keys(filters).forEach(key => {
  Vue.filter(key, filters[key])
})
Vue.config.productionTip = false
new Vue({
  el: '#app',
  router,
  store,
  render: h => h(App)
})",javascript
"class Pwgen < Formula
  desc ""Password generator""
  homepage ""http://pwgen.sourceforge.net/""
  url ""https://downloads.sourceforge.net/project/pwgen/pwgen/2.07/pwgen-2.07.tar.gz""
  sha256 ""eb74593f58296c21c71cd07933e070492e9222b79cedf81d1a02ce09c0e11556""
  def install
    system ""./configure"", ""--disable-debug"", ""--disable-dependency-tracking"",
                          ""--prefix=#{prefix}"",
                          ""--mandir=#{man}""
    system ""make"", ""install""
  end
  test do
    system ""#{bin}/pwgen"", ""--secure"", ""20"", ""10""
  end
end",ruby
"'use strict';
const Hapi = require('hapi');
const Path = require('path');
const server = new Hapi.Server();
server.connection({ port: 3003, host: 'localhost' });
server.route({
  method: 'GET',
  path: '/{name}',
  handler: function (request, reply) {
    reply('Hello, ' + encodeURIComponent(request.params.name) + '!');
  }
});
server.register(require('inert'), (err) => {
  server.route({
    method: 'GET',
    path: '/',
    handler: function (request, reply) {
      reply.file('index.html');
    }
  });
  server.route({
    method: 'GET',
    path: '/bundle.js',
    handler: function (request, reply) {
      reply.file('bundle.js');
    }
  });
});
server.start(err => {
  if (err) {
    throw err;
  }
  console.log(`Server running at ${server.info.uri}`);
});",javascript
"package model

const (
	OpAdd    = ""ADD""
	OpRemove = ""REMOVE""
)",go
"public class Teacher extends Profession {
    void teach(String name) {
    }
}",java
"package com.deer.wms.message.model;

public class HelpContentDto extends HelpContent
{
	
	private String categoryName;
	
	private Integer parentId;
	
	private String parentName;
	public String getCategoryName() {
		return categoryName;
	}
	public void setCategoryName(String categoryName) {
		this.categoryName = categoryName;
	}
	public Integer getParentId() {
		return parentId;
	}
	public void setParentId(Integer parentId) {
		this.parentId = parentId;
	}
	public String getParentName() {
		return parentName;
	}
	public void setParentName(String parentName) {
		this.parentName = parentName;
	}
}",java
"-- trans.test
-- 
-- execsql {
--     DROP INDEX i1;
--     SELECT * FROM t1 WHERE c<1;
-- }
DROP INDEX i1;
SELECT * FROM t1 WHERE c<1;",mysql
"export const ic_event_seat_twotone = {""viewBox"":""0 0 24 24"",""children"":[{""name"":""path"",""attribs"":{""d"":""M0 0h24v24H0V0z"",""fill"":""none""},""children"":[]},{""name"":""path"",""attribs"":{""d"":""M9 5h6v7H9z"",""opacity"":"".3""},""children"":[]},{""name"":""path"",""attribs"":{""d"":""M4 21h2v-4h12v4h2v-6H4zM17 5c0-1.1-.9-2-2-2H9c-1.1 0-2 .9-2 2v9h10V5zm-2 7H9V5h6v7zm4-2h3v3h-3zM2 10h3v3H2z""},""children"":[]}]};",javascript
"package com.cloud.gateway;
import com.cloud.common.cache.annotation.EnableProCache;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@EnableDiscoveryClient
@SpringBootApplication
@EnableProCache
public class CloudGatewayApplication {
	public static void main(String[] args) {
		SpringApplication.run(CloudGatewayApplication.class, args);
	}
}",java
"package main

























































































",go
"-- RNGSEED: 1
-- EXPLAIN (FORMAT JSON)
select  dt.d_year
 	,item.i_category_id
 	,item.i_category
 	,sum(ss_ext_sales_price)
 from 	date_dim dt
 	,store_sales
 	,item
 where dt.d_date_sk = store_sales.ss_sold_date_sk
 	and store_sales.ss_item_sk = item.i_item_sk
 	and item.i_manager_id = 1
 	and dt.d_moy=12
 	and dt.d_year=2000
 group by 	dt.d_year
 		,item.i_category_id
 		,item.i_category
 order by       sum(ss_ext_sales_price) desc,dt.d_year
 		,item.i_category_id
 		,item.i_category
limit 100 ;",mysql
"













package reconcile
import (
	""github.com/go-logr/logr""
	""k8s.io/apimachinery/pkg/runtime""
	""k8s.io/client-go/tools/record""
	""sigs.k8s.io/controller-runtime/pkg/client""
	""github.com/signalfx/splunk-otel-collector-operator/apis/o11y/v1alpha1""
)

type Params struct {
	Client   client.Client
	Instance v1alpha1.SplunkOtelAgent
	Log      logr.Logger
	Scheme   *runtime.Scheme
	Recorder record.EventRecorder
}
func (p Params) WithDefaults() Params {
	return p
}",go
"package com.javarush.task.task13.task1324;
import java.awt.*;

public class Solution {
    public static void main(String[] args) throws Exception {
    }
    public interface Animal {
        Color getColor();
        Integer getAge();
    }
    public static abstract class Fox implements Animal {
        public String getName() {
            return ""Fox"";
        }
    }
}",java
"select count(distinct q1.id) from
site, post_link pl, question q1, question q2, comment c1, comment c2,
tag, tag_question tq1, tag_question tq2
where
site.site_name = 'german' and
pl.site_id = site.site_id and
pl.site_id = q1.site_id and
pl.post_id_from = q1.id and
pl.site_id = q2.site_id and
pl.post_id_to = q2.id and
c1.site_id = q1.site_id and
c1.post_id = q1.id and
c2.site_id = q2.site_id and
c2.post_id = q2.id and
c1.date < c2.date and
tag.name in ('sql', 'mysql', 'excel', 'swift', 'c#') and
tag.id = tq1.tag_id and
tag.site_id = tq1.site_id and
tag.id = tq2.tag_id and
tag.site_id = tq1.site_id and
tag.site_id = pl.site_id and
tq1.site_id = q1.site_id and
tq1.question_id = q1.id and
tq2.site_id = q2.site_id and
tq2.question_id = q2.id;",mysql
"




UpdateGlobalConfigTask::UpdateGlobalConfigTask(const std::string &script) : WeexTask("""") {
    this->script = script;
}
void UpdateGlobalConfigTask::run(WeexRuntime *runtime) {
    runtime->updateGlobalConfig(script);
}",cpp
"package com.fanjiao.common.core.utils;
import java.io.PrintWriter;
import java.io.StringWriter;
import org.apache.commons.lang3.exception.ExceptionUtils;

public class ExceptionUtil
{
    
    public static String getExceptionMessage(Throwable e)
    {
        StringWriter sw = new StringWriter();
        e.printStackTrace(new PrintWriter(sw, true));
        String str = sw.toString();
        return str;
    }
    public static String getRootErrorMseeage(Exception e)
    {
        Throwable root = ExceptionUtils.getRootCause(e);
        root = (root == null ? e : root);
        if (root == null)
        {
            return """";
        }
        String msg = root.getMessage();
        if (msg == null)
        {
            return ""null"";
        }
        return StringUtils.defaultString(msg);
    }
}",java
"CREATE TABLE migrations (
  id       integer PRIMARY KEY,
  name     varchar(255),
  applied  timestamp with time zone DEFAULT current_timestamp
);",mysql
"count = input('How many people will be in the dinner group? ')
count = int(count)
if count > 8:
    print('You\'ll have to wait for a table.')
else:
    print('The table is ready.')",python
"
package com.amazonaws.services.lexmodelbuilding.model;
import javax.annotation.Generated;

@Generated(""com.amazonaws:aws-java-sdk-code-generator"")
public enum SlotConstraint {
    Required(""Required""),
    Optional(""Optional"");
    private String value;
    private SlotConstraint(String value) {
        this.value = value;
    }
    @Override
    public String toString() {
        return this.value;
    }
    
    public static SlotConstraint fromValue(String value) {
        if (value == null || """".equals(value)) {
            throw new IllegalArgumentException(""Value cannot be null or empty!"");
        }
        for (SlotConstraint enumEntry : SlotConstraint.values()) {
            if (enumEntry.toString().equals(value)) {
                return enumEntry;
            }
        }
        throw new IllegalArgumentException(""Cannot create enum from "" + value + "" value!"");
    }
}",java
"

package fake
import (
	superherov1alpha1 ""github.com/spotahome/kooper/test/integration/operator/apis/superhero/v1alpha1""
	v1 ""k8s.io/apimachinery/pkg/apis/meta/v1""
	runtime ""k8s.io/apimachinery/pkg/runtime""
	schema ""k8s.io/apimachinery/pkg/runtime/schema""
	serializer ""k8s.io/apimachinery/pkg/runtime/serializer""
)
var scheme = runtime.NewScheme()
var codecs = serializer.NewCodecFactory(scheme)
var parameterCodec = runtime.NewParameterCodec(scheme)
func init() {
	v1.AddToGroupVersion(scheme, schema.GroupVersion{Version: ""v1""})
	AddToScheme(scheme)
}














func AddToScheme(scheme *runtime.Scheme) {
	superherov1alpha1.AddToScheme(scheme)
}",go
"
class Dict_word_jumbler(object):
    def __init__(self):
        self.dict = self.build_dict()
    def build_dict(self):
        """"""""Build a dictionary to hold all of the words/letters""""""
        dic = {}
        f = open(""/usr/share/dict/words"", ""r"")
        word_list = f.readlines()
        for word in word_list:
            word = word.strip().lower()
            words = ''.join(sorted(word))
            dic[words] = word
        return dic
    def unscramble(self, words):
        """"""Build a function to unscramble the letters""""""
        for word in words:
            word = word.strip().lower()
            word_sorted = ''.join(sorted(word))
            if word_sorted in self.dict:
                unscrambled = self.dict[word_sorted]
                print(unscrambled)
            else:
                return None
if __name__ == '__main__':


    words = ['tefon', 'sokik', 'niumem', 'siconu']
    jumble = Dict_word_jumbler()
    jumble.unscramble(words)







",python
"package com.airmap.airmapsdk.util;
import android.support.annotation.Nullable;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class CopyCollections {
    @Nullable
    public static <T> ArrayList<T> copy(@Nullable List<T> list) {
        return list != null ? new ArrayList<>(list) : null;
    }
    @Nullable
    public static <T> HashSet<T> copy(@Nullable Set<T> set) {
        return set != null ? new HashSet<>(set) : null;
    }
}",java
"
package org.assertj.core.internal;
import static java.lang.Math.abs;
import org.assertj.core.util.VisibleForTesting;

public class Doubles extends RealNumbers<Double> {
  private static final Doubles INSTANCE = new Doubles();
  
  public static Doubles instance() {
    return INSTANCE;
  }
  @VisibleForTesting
  Doubles() {
    super();
  }
  public Doubles(ComparisonStrategy comparisonStrategy) {
    super(comparisonStrategy);
  }
  @Override
  protected Double zero() {
    return 0.0d;
  }
  @Override
  protected Double one() {
    return 1.0d;
  }
  @Override
  protected Double NaN() {
    return Double.NaN;
  }
  @Override
  protected Double absDiff(Double actual, Double other) {
    return abs(other.doubleValue() - actual.doubleValue());
  }
}",java
"package websocket
import (
	""encoding/json""
	""time""
	""github.com/peterzernia/lets-fork/utils""
)
func setParty(p Party) error {
	rdb := utils.GetRDB()
	jsn, err := json.Marshal(p)
	if err != nil {
		return err
	}
	rdb.Set(""party:""+*p.ID, string(jsn), time.Hour)
	if err != nil {
		return err
	}
	return nil
}
func getParty(id string) (*Party, error) {
	var party Party
	rdb := utils.GetRDB()
	p, err := rdb.Get(""party:"" + id).Result()
	if err != nil {
		return nil, err
	}
	err = json.Unmarshal([]byte(p), &party)
	return &party, err
}
func setUser(u User) error {
	rdb := utils.GetRDB()
	jsn, err := json.Marshal(u)
	if err != nil {
		return err
	}
	rdb.Set(""user:""+*u.ID, string(jsn), time.Hour)
	if err != nil {
		return err
	}
	return nil
}
func getUser(id string) (*User, error) {
	var user User
	rdb := utils.GetRDB()
	p, err := rdb.Get(""user:"" + id).Result()
	if err != nil {
		return nil, err
	}
	err = json.Unmarshal([]byte(p), &user)
	return &user, err
}",go
"SELECT tg.track_id, tg.genre_id, t.name AS track_name, g.name AS genre_name
FROM track_genre AS tg
INNER JOIN track AS t ON t.id = tg.track_id
INNER JOIN genre AS g ON g.id = tg.genre_id;",mysql
"package main
import (
	""fmt""
)
func main() {

	var levels int
	fmt.Println(""Enter number of levels: "")
	fmt.Scan(&levels)

	pyramid := make([][]int, levels)
	for i := range pyramid {
		pyramid[i] = make([]int, levels)
	}

	fmt.Println(""Please only enter positive integers"")
	for r := 0; r <= levels-1; r++ {
		fmt.Printf(""Enter %d items for level %d: "", r+1, r)
		for c := 0; c <= r; c++ {
			fmt.Scan(&pyramid[r][c])
		}
	}

	fmt.Println(""Here's the pyramid: "")
	for r := 0; r < levels; r++ {
		for c := 0; c <= r; c++ {
			fmt.Printf(""%d "", pyramid[r][c])
		}
		fmt.Println("""")
	}
	fmt.Printf(""Minimum-Sum Descent for created pyramid (Tabular): %d"", tabular(pyramid, levels-1))
	fmt.Println("""")
}

func minimum(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func tabular(arr [][]int, n int) int {
	for r := n; r >= 0; r-- {
		for c := 0; c <= r; c++ {
			if r != n {
				arr[r][c] = arr[r][c] + minimum(arr[r+1][c], arr[r+1][c+1])
			}
		}
	}
	return arr[0][0]
}",go
"
""""""
Copyright (c) 2019 - present AppSeed.us
""""""
from django.contrib import admin

from django.contrib import admin
from .models import RemOrganization, RemRole, RemUser, Nursery, NurseryPlantsHistory, MotherTree, Plantation, BeninYield, AlteiaData, DeptSatellite, CommuneSatellite, SpecialTuple
admin.site.register(RemOrganization)
admin.site.register(RemRole)
admin.site.register(RemUser)
admin.site.register(Nursery)
admin.site.register(NurseryPlantsHistory)
admin.site.register(MotherTree)
admin.site.register(Plantation)
admin.site.register(BeninYield)
admin.site.register(AlteiaData)
admin.site.register(DeptSatellite)
admin.site.register(CommuneSatellite)
admin.site.register(SpecialTuple)",python
"-- file:domain.sql ln:210 expect:true
SELECT cast('1' as dnotnull)",mysql
"package gslb
type Gslbvserverdomainbinding struct {
	Backupip         string `json:""backupip,omitempty""`
	Backupipflag     bool   `json:""backupipflag,omitempty""`
	Cookiedomain     string `json:""cookie_domain,omitempty""`
	Cookiedomainflag bool   `json:""cookie_domainflag,omitempty""`
	Cookietimeout    int    `json:""cookietimeout,omitempty""`
	Domainname       string `json:""domainname,omitempty""`
	Name             string `json:""name,omitempty""`
	Sitedomainttl    int    `json:""sitedomainttl,omitempty""`
	Ttl              int    `json:""ttl,omitempty""`
}",go
"package models
type User struct {
    ID          uint    `json:""-""`
    Username    string  `json:""username""`
    FirstName   string  `json:""first_name""`
    LastName    string  `json:""last_name""`
    Email       string  `json:""email""`
    PwdHash     string  `json:""-""`
    IsAdmin     bool    `json:""is_admin""`
    AccountIDs  []uint  `json:""account_ids""`
}",go
"package com.datastax.oss.driver.shaded.guava.common.util.concurrent;
import com.datastax.oss.driver.shaded.guava.common.util.concurrent.RateLimiter.SleepingStopwatch;
public class BurstyRateLimiterFactory {
    public static RateLimiter create(double permitsPerSecond, double maxBurstSeconds) {
        return create(SleepingStopwatch.createFromSystemTimer(), permitsPerSecond, maxBurstSeconds);
    }
    public static RateLimiter create(SleepingStopwatch stopwatch, double permitsPerSecond, double maxBurstSeconds) {
        RateLimiter rateLimiter = new SmoothRateLimiter.SmoothBursty(stopwatch, maxBurstSeconds );
        rateLimiter.setRate(permitsPerSecond);
        return rateLimiter;
    }
}",java
"
package com.yunmel.db.dialect;
public interface Dialect {
	
	public boolean supportsOffset();
	
	public String getLimitString(String query, int offset, int limit);
	
	public String getCountSql(String query);
	
	public String getSelectGUIDString();
	
	public String getSequenceNextValString(String tablename);
}",java
"
require ""test_helper""
require ""stubs/test_server""
class ActionCable::Connection::StringIdentifierTest < ActionCable::TestCase
  class Connection < ActionCable::Connection::Base
    identified_by :current_token
    def connect
      self.current_token = ""random-string""
    end
    def send_async(method, *args)
      send method, *args
    end
  end
  test ""connection identifier"" do
    run_in_eventmachine do
      open_connection
      assert_equal ""random-string"", @connection.connection_identifier
    end
  end
  private
    def open_connection
      server = TestServer.new
      env = Rack::MockRequest.env_for ""/test"", ""HTTP_HOST"" => ""localhost"", ""HTTP_CONNECTION"" => ""upgrade"", ""HTTP_UPGRADE"" => ""websocket""
      @connection = Connection.new(server, env)
      @connection.process
      @connection.send :on_open
    end
end",ruby
"package iox
import (
	""bufio""
	""fmt""
	""os""
	""strings""
)
func EnterToContinue() {
	fmt.Print(""Press 'Enter' to continue..."")
	bufio.NewReader(os.Stdin).ReadBytes('\n')
}
func ReadLine(prompt string) string {
	fmt.Print(prompt)
	input, _ := bufio.NewReader(os.Stdin).ReadString('\n')
	return strings.TrimSpace(input)
}",go
"package com.marklogic.client.modulesloader;
import java.io.File;
public class Asset {
    private File file;
    private String path;
    public Asset(File file, String path) {
        super();
        this.file = file;
        this.path = path;
    }
    public File getFile() {
        return file;
    }
    public String getPath() {
        return path;
    }
}",java
"class Engine:
    PANDAS = ""pandas""
    POSTGRES = ""postgres""
    PRESTO = ""Presto""
    SPARK = ""Spark""
    SQL_SERVER = ""SqlServer""
    known_engines = {PANDAS, POSTGRES, PRESTO, SPARK, SQL_SERVER}",python
"
package webhook
import (
	""sigs.k8s.io/controller-runtime/pkg/manager""
)

var AddToManagerFuncs []func(manager.Manager) error




func AddToManager(m manager.Manager) error {
	for _, f := range AddToManagerFuncs {
		if err := f(m); err != nil {
			return err
		}
	}
	return nil
}",go
"
package com.dtstack.flinkx.classloader;

@FunctionalInterface
public interface ClassLoaderSupplier<T> {
    
    T get(ClassLoader cl) throws Exception;
}",java
"from celery import shared_task
from .signals import slack_event_received
@shared_task
def receive_slack_signal_task(sender, event_type, event_data, **data):
    slack_event_received.send(sender=sender, event_type=event_type, event_data=event_data, **data)",python
"-- Local test migration.
-- This will be run on development environments. It should mirror what you
-- intend to apply on production, but do not include any sensitive data.
--
-- Data for Name: office_users; Type: TABLE DATA; Schema: public; Owner: postgres
--
INSERT INTO public.office_users VALUES ('7df9f7e9-597c-4b8b-b24d-e2ef0bd85ff3', NULL, 'Test', 'Test32', NULL, 'test32@test.com', '(800) 555-5869', '6dc9c87d-37af-4157-a1ce-af45bb954eba', '2018-08-07 18:16:25.630098', '2018-08-07 18:16:25.630098');",mysql
"class API
    def self.list_breweries
        url = 'https://api.openbrewerydb.org/breweries?by_city=brooklyn'
        response = HTTParty.get(url)
        response.each do |hash| 
        Brewery.new(
            hash['name'],
            hash['brewery_type'],
            hash['street'],
            hash['phone'],
            hash['website_url'],
        ) 
        end 
    end 
end",ruby
"package com.aftertoday.redisdemo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class RedisDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(RedisDemoApplication.class,args);
    }
}",java
"package code_test
import (
	""testing""
	. ""github.com/pingcap/check""
	""github.com/pingcap/failpoint/code""
)
func TestNewRestorer(t *testing.T) {
	TestingT(t)
}
var _ = Suite(&restorerSuite{})
type restorerSuite struct{}
func (s *restorerSuite) TestRestore(c *C) {
	restorer := code.NewRestorer(""not-exists-path"")
	err := restorer.Restore()
	c.Assert(err, ErrorMatches, `lstat not-exists-path: no such file or directory`)
}",go
"let data = {
	""body"": ""<path d=\""M7.57 20c-1.34 0-2.43-1.09-2.43-2.43c0-1.07 1.18-3.07 2.43-4.76C8.82 14.5 10 16.5 10 17.57A2.43 2.43 0 0 1 7.57 20M12 2A10 10 0 0 0 2 12c0 1.75.45 3.38 1.24 4.81c.16-.81.57-1.74 1.07-2.64A7.69 7.69 0 0 1 4 12a8 8 0 0 1 8-8a8 8 0 0 1 8 8a8 8 0 0 1-8 8c-.24 0-.47 0-.71-.04c-.47.74-1.15 1.32-1.95 1.67c.85.24 1.74.37 2.66.37a10 10 0 0 0 10-10A10 10 0 0 0 12 2m0 12c-.41 0-.81.04-1.19.12c.35.63.66 1.28.88 1.88H12c1.25 0 2.32.5 2.77 1.23l1.42-1.42C15.29 14.72 13.75 14 12 14m3.5-6c-.8 0-1.5.7-1.5 1.5s.7 1.5 1.5 1.5s1.5-.7 1.5-1.5S16.3 8 15.5 8M10 9.5C10 8.7 9.3 8 8.5 8S7 8.7 7 9.5S7.7 11 8.5 11s1.5-.7 1.5-1.5\"" fill=\""currentColor\""/>"",
	""width"": 24,
	""height"": 24
};
export default data;",javascript
"



namespace gaem {
class GaemModel {
public:
  struct Vertex {
    glm::vec2 position;
    glm::vec3 color;
    static std::vector<VkVertexInputBindingDescription>
    getBindingDescriptions();
    static std::vector<VkVertexInputAttributeDescription>
    getAtributeDescriptions();
  };
  GaemModel(GaemDevice &gaemDevice, const std::vector<Vertex> &vertices);
  ~GaemModel();
  GaemModel(const GaemModel &) = delete;
  GaemModel &operator=(const GaemModel &) = delete;
  void bind(VkCommandBuffer commandBuffer);
  void draw(VkCommandBuffer commandBuffer);
private:
  GaemDevice &gaemDevice;
  VkBuffer vertexBuffer;
  VkDeviceMemory vertexBufferMemory;
  uint32_t vertexCount;
  void createVertexBuffers(const std::vector<Vertex> &vertices);
};
} // namespace gaem",cpp
"module Invitational
  class Engine < ::Rails::Engine
  end
end",ruby
"select title, tags, akas
from aws.aws_dms_replication_instance
where arn = '{{ output.resource_aka.value }}';",mysql
"











from datetime import datetime
from DateTime.DateTime import DateTime
import six
MAX32 = int(2 ** 31 - 1)
def safe_callable(ob):

    try:
        ob.__class__
        try:
            return bool(ob.__call__)
        except AttributeError:
            return isinstance(ob, six.class_types)
    except AttributeError:
        return callable(ob)
def datetime_to_minutes(value, precision=1,
                        max_value=MAX32, min_value=-MAX32):
    if value is None:
        return value
    if isinstance(value, (str, datetime)):
        value = DateTime(value)
    if isinstance(value, DateTime):
        value = value.millis() / 1000 / 60  # flatten to minutes

    if precision > 1:
        value = value - (value % precision)
    value = int(value)
    if value > max_value or value < min_value:

        raise OverflowError(
            '{0} is not within the range of dates allowed.'.format(value))
    return value",python
"package com.jnape.palatable.lambda.semigroup.builtin;
import com.jnape.palatable.lambda.functions.Fn1;
import com.jnape.palatable.lambda.semigroup.Semigroup;
import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
import static com.jnape.palatable.lambda.semigroup.builtin.MinBy.minBy;

public final class Min<A extends Comparable<A>> implements Semigroup<A> {
    private static final Min<?> INSTANCE = new Min<>();
    private Min() {
    }
    @Override
    public A apply(A x, A y) {
        return minBy(id(), x, y);
    }
    @SuppressWarnings(""unchecked"")
    public static <A extends Comparable<A>> Min<A> min() {
        return (Min<A>) INSTANCE;
    }
    public static <A extends Comparable<A>> Fn1<A, A> min(A x) {
        return Min.<A>min().apply(x);
    }
    public static <A extends Comparable<A>> A min(A x, A y) {
        return min(x).apply(y);
    }
}",java
"
namespace trview
{
    ICamera::~ICamera()
    {
    }
}",cpp
"
package qrcoder;




public class FFT {









































































































}",java
"
Rails.application.config.session_store :cookie_store, key: '_resistance_session'",ruby
"
package cmd
import (
	""fmt""
	""os""
	""github.com/spf13/cobra""
)
var rootCmd = &cobra.Command{
	Use:   ""edgeca"",
	Short: ""EdgeCA is an ephemeral certificate authority"",
}

func Execute() {
	if err := rootCmd.Execute(); err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
}",go
"package qetcd
import ""errors""
var (
	ErrConf          = errors.New(""conf error"")
	ErrHasRegistered = errors.New(""address has registed"")
)",go
"CREATE TABLE cognipro.alarm_state_timesum_shift (
	shiftname varchar NOT NULL,
	machine_id varchar NOT NULL,
	starttime timestamptz NULL,
	endtime timestamptz NULL,
	update_date timestamptz NULL,
	date_string varchar NOT NULL,
	property_name varchar NOT NULL,
	property_sum float4 NULL,
	CONSTRAINT alarm_state_timesum_shift_pk PRIMARY KEY (shiftname,machine_id,date_string,property_name)
)
WITH (
	OIDS=FALSE
) ;",mysql
"
using namespace std;
int main() {
    int iterations;
    int square_size = 2;
    cin >> iterations;
    for (int i = 0 ; i < iterations; i++){
        square_size += square_size -1;
    }
    cout << square_size*square_size << ""\n"";
    return 0;
}",cpp
"


using namespace robosw;
struct PolylineTest : testing::Test {
  PolylineTest() {
    polyline.AddPoint(0, 0);
    polyline.AddPoint(0.5, 0.25);
    polyline.AddPoint(1.0, 1.0);
    polyline.AddPoint(1.5, 1.75);
    polyline.AddPoint(2.0, 2);
  }
  Polyline polyline;
};
TEST_F(PolylineTest, Evaluate) {
  ASSERT_TRUE(polyline.GetPoints().size() == 5)
      << ""Incorrect number of points in polyline"";
}",cpp
"

















namespace ngraph
{
    namespace op
    {
        namespace v0
        {
            class NGRAPH_API BroadcastDistributed : public Op
            {
            public:
                static constexpr NodeTypeInfo type_info{""BroadcastDistributed"", 0};
                const NodeTypeInfo& get_type_info() const override { return type_info; }
                BroadcastDistributed() = default;
                BroadcastDistributed(const Output<Node>& arg, int64_t root_id = 0);
                bool visit_attributes(AttributeVisitor& visitor) override;
                void validate_and_infer_types() override;
                virtual std::shared_ptr<Node>
                    copy_with_new_args(const NodeVector& new_args) const override;
                int64_t get_root_id() const;
                void set_root_id(int64_t root_id);
            private:
                int64_t m_root_id;
            };
        }
        using v0::BroadcastDistributed;
    }
}",cpp
"


from __future__ import unicode_literals

import unittest
class TestExtraesiaSettings(unittest.TestCase):
	pass",python
"$(function () {
    $('#navbar-toggler').on('click', function () {
        var nav = $('#ta-left-sidebar');
        if (nav.hasClass('in')) {
            nav.animate({ 'left': '-260px' }, 300);
            nav.removeClass('in');
        }
        else {
            nav.animate({ 'left': '0px' }, 300);
            nav.addClass('in');
        }
    });
});",javascript
"SELECT CustomerID
	, MAX(Amount) AS [MaxAmount]
FROM PurchaseOrder
WHERE TransactionDate BETWEEN '2019-01-01' AND '2019-12-31'
GROUP BY CustomerID",mysql
"-- Copyright 2021 The Go Authors. All rights reserved.
-- Use of this source code is governed by a BSD-style
-- license that can be found in the LICENSE file.
BEGIN;
ALTER TABLE search_documents RENAME path_id TO package_path_id;
ALTER TABLE search_documents ADD COLUMN module_path_id INTEGER;
END;",mysql
"-- This file should undo anything in `up.sql`
DROP TABLE solutions;",mysql
"package misudo
import (
	""bytes""
	""image""
	""image/jpeg""
	""image/png""
	""log""
)
type Decoder struct {
	Raw    []byte
	Format string
	Decode image.Image
}
func (d *Decoder) decode() image.Image {
	if d.Format == ""jpeg"" {
		d.jpegDecoder()
	} else if d.Format == ""png"" {
		d.pngDecoder()
	} else if d.Format == ""gif"" {
		d.gifDecoder()
	} else {
	}
	return d.Decode
}
func (d *Decoder) jpegDecoder() {
	img, err := jpeg.Decode(bytes.NewReader(d.Raw))
	if err != nil {
		log.Fatal(err)
	}
	d.Decode = img
}
func (d *Decoder) gifDecoder() {
	img, err := jpeg.Decode(bytes.NewReader(d.Raw))
	if err != nil {
		log.Fatal(err)
	}
	d.Decode = img
}
func (d *Decoder) pngDecoder() {
	img, err := png.Decode(bytes.NewReader(d.Raw))
	if err != nil {
		log.Fatal(err)
	}
	d.Decode = img
}",go
"class Carro
end
novo_carro = Carro.new
puts ""Variavel carro: #{novo_carro}""
a = ""RUBY PARA INICIANTES""
b = a
b.downcase!
puts a",ruby
"from . import Simulations 
from . import Spacecraft",python
"module Events::LocalitiesHelper
  def display_hospitality_assignment(reg)
    if reg.hospitality.nil?
      '--'
    else
      reg.hospitality.lodging.name
    end
  end
  def calculate_payment(registration)
    return number_to_currency(0) if !registration.has_been_paid
    number_to_currency(@event.registration_cost - registration.payment_adjustment)
  end
end",ruby
"

import sys
from common import reverse_items
if len(sys.argv) != 3:
  print(""Reverse key and value of all pairs"")
  print((""Usage: "", sys.argv[0], ""[input] [output]""))
  exit(1)
reverse_items(sys.argv[1], sys.argv[2])",python
"import getPokemonType from './get-pokemon-type'
describe('src/utils/get-pokemon-type', () => {
  it('function getPokemonType - SHOULD return a pokemon type if found', () => {
    expect(getPokemonType('normal')).toEqual({
      name: 'normal',
      namePtBr: 'Normal',
      iconUrl:
        'https://upload.wikimedia.org/wikipedia/commons/thumb/a/aa/Pok%C3%A9mon_Normal_Type_Icon.svg/120px-Pok%C3%A9mon_Normal_Type_Icon.svg.png',
    })
  })
  it('function getPokemonType - SHOULD return a empty object if no type is found', () => {
    expect(getPokemonType('empty-type')).toEqual({})
  })
})",javascript
"

package providerhub
import (
	""github.com/pulumi/pulumi/sdk/v3/go/pulumi""
)

func LookupSkus(ctx *pulumi.Context, args *LookupSkusArgs, opts ...pulumi.InvokeOption) (*LookupSkusResult, error) {
	var rv LookupSkusResult
	err := ctx.Invoke(""azure-native:providerhub:getSkus"", args, &rv, opts...)
	if err != nil {
		return nil, err
	}
	return &rv, nil
}
type LookupSkusArgs struct {

	ProviderNamespace string `pulumi:""providerNamespace""`

	ResourceType string `pulumi:""resourceType""`

	Sku string `pulumi:""sku""`
}
type LookupSkusResult struct {

	Id string `pulumi:""id""`

	Name       string                        `pulumi:""name""`
	Properties SkuResourceResponseProperties `pulumi:""properties""`

	Type string `pulumi:""type""`
}",go
"





using namespace phoenix;
using namespace std;
class X
{
public:
    X(int i_ = 1)
    :   i(i_)
    {}
    int i;
};

int
main()
{
    int i2 = 2;
    X   x3(3);
    BOOST_TEST(new_<int>()() != NULL);
    BOOST_TEST(*new_<int>(arg1)(i2) == 2);
    BOOST_TEST(new_<X>()() != NULL);
    BOOST_TEST(new_<X>()()->i == 1);
    BOOST_TEST(new_<X>(arg1)(i2)->i == 2);
    BOOST_TEST(new_<X>(arg1)(x3)->i == 3);
    return boost::report_errors();
}",cpp
"""""""
WSGI config for billsengine_31836 project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/2.2/howto/deployment/wsgi/
""""""
import os
from django.core.wsgi import get_wsgi_application
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'billsengine_31836.settings')
application = get_wsgi_application()",python
"package miniprogram
import (
	""encoding/json""
	""fmt""
	""github.com/fintcloud/wechat/util""
)
const (
	code2SessionURL = ""https://api.weixin.qq.com/sns/jscode2session?appid=%s&secret=%s&js_code=%s&grant_type=authorization_code""
)

type ResCode2Session struct {
	util.CommonError
	OpenID     string `json:""openid""`      // 用户唯一标识
	SessionKey string `json:""session_key""` // 会话密钥
	UnionID    string `json:""unionid""`     // 用户在开放平台的唯一标识符，在满足UnionID下发条件的情况下会返回
}

func (wxa *MiniProgram) Code2Session(jsCode string) (result ResCode2Session, err error) {
	urlStr := fmt.Sprintf(code2SessionURL, wxa.AppID, wxa.AppSecret, jsCode)
	var response []byte
	response, err = util.HTTPGet(urlStr)
	if err != nil {
		return
	}
	err = json.Unmarshal(response, &result)
	if err != nil {
		return
	}
	if result.ErrCode != 0 {
		err = fmt.Errorf(""Code2Session error : errcode=%v , errmsg=%v"", result.ErrCode, result.ErrMsg)
		return
	}
	return
}",go
"Template.chapterContent.onCreated(function() {
    console.log('chapterContent template created');
    var instance = this;
    instance.autorun(function() {
      console.log('autorun chapterContent');
    });
});
Template.chapterContent.onRendered(function() {
    console.log('chapterContent template rendered');
});
Template.chapterContent.helpers({
  content: function() {
    
    if(!this.chapterData)
      this.chapterData = ReactiveMethod.call(""getChapterData"", Session.get('currentWorkId'), Session.get('currentChapterId'));
    return this.chapterData;
  },
  targetClass: function() {
    if(this.target != undefined)
      return (this.target.get() != null) ? ""targeted"" : null;
    return null;
  },
  chapterClasses: function() {
    var classes = ""chapter"";
    if(this.target != undefined && this.target.get() != null)
      classes += "" highlight"";
    return classes;
  },
  isTranslationOn: function() {
    return Session.get('activeTranslation');
  }
});",javascript
"




int APIENTRY wWinMain(_In_ HINSTANCE instance, _In_opt_ HINSTANCE prev,
                      _In_ wchar_t *command_line, _In_ int show_command) {


  if (!::AttachConsole(ATTACH_PARENT_PROCESS) && ::IsDebuggerPresent()) {
    CreateAndAttachConsole();
  }


  ::CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);
  flutter::DartProject project(L""data"");
  std::vector<std::string> command_line_arguments =
      GetCommandLineArguments();
  project.set_dart_entrypoint_arguments(std::move(command_line_arguments));
  FlutterWindow window(project);
  Win32Window::Point origin(10, 10);
  Win32Window::Size size(1280, 720);
  if (!window.CreateAndShow(L""cupertino_cupertinotextformfieldrow_2"", origin, size)) {
    return EXIT_FAILURE;
  }
  window.SetQuitOnClose(true);
  ::MSG msg;
  while (::GetMessage(&msg, nullptr, 0, 0)) {
    ::TranslateMessage(&msg);
    ::DispatchMessage(&msg);
  }
  ::CoUninitialize();
  return EXIT_SUCCESS;
}",cpp
"macDetailCallback(""006094000000/24"",[{""d"":""1998-04-22"",""t"":""add"",""a"":""PO BOX 12195\nE89/664\nRTP,  NC  27709-2195\n"",""c"":""UNITED STATES"",""o"":""IBM CORP.""},{""d"":""2000-09-08"",""t"":""change"",""a"":""PO BOX 12195\nCE6A/664\n3039 CORNWALLIS\nRTP,  NC 27709-2195"",""c"":""UNITED STATES"",""o"":""IBM CORP.""},{""d"":""2001-10-24"",""t"":""change"",""a"":""PO BOX 12195\nCE6A/664 3039 CORNWALLIS\nRTP NC 27709-2195\n"",""c"":""UNITED STATES"",""o"":""IBM CORP.""},{""d"":""2010-12-02"",""t"":""change"",""a"":""3039 E Cornwallis Road\nPO BOX 12195\nResearch Triangle Park NC 27709-2195\n"",""c"":""UNITED STATES"",""o"":""IBM Corp""},{""d"":""2015-08-27"",""t"":""change"",""a"":""3039 E Cornwallis Road Research Triangle Park NC US 27709-2195"",""c"":""US"",""o"":""IBM Corp""}]);",javascript
"
using namespace std;
ifstream input(""../README.md"", ios::in);
ofstream output(""yourOutputFile.txt"", ios::out);
char letter;
int main(){
	letter = input.get();
	output.put(letter);
	output << ""David Britt"";
	input.close();
	output.close();
	return 0;
}",cpp
"package mhfpacket
import ( 
 ""errors"" 
 	""github.com/Solenataris/Erupe/network/clientctx""
	""github.com/Solenataris/Erupe/network""
	""github.com/Andoryuuta/byteframe""
)

type MsgMhfExchangeFpoint2Item struct{
	AckHandle uint32
	ItemHash uint32
	ItemType uint16
	ItemId uint16
	Quantity byte
}

func (m *MsgMhfExchangeFpoint2Item) Opcode() network.PacketID {
	return network.MSG_MHF_EXCHANGE_FPOINT_2_ITEM
}

func (m *MsgMhfExchangeFpoint2Item) Parse(bf *byteframe.ByteFrame, ctx *clientctx.ClientContext) error {
	m.AckHandle = bf.ReadUint32()
	m.ItemHash = bf.ReadUint32()
	m.ItemType = bf.ReadUint16()
	m.ItemId = bf.ReadUint16()
	m.Quantity = bf.ReadUint8()
	return nil
}

func (m *MsgMhfExchangeFpoint2Item) Build(bf *byteframe.ByteFrame, ctx *clientctx.ClientContext) error {
	return errors.New(""NOT IMPLEMENTED"")
}",go
"package org.firstinspires.ftc.teamcode.auto;
import org.firstinspires.ftc.teamcode.bot.components.Robot;
    public class MainParkingAuto {
        Robot bot;
    Side side;
    boolean park_on_wall;
    public MainParkingAuto(Robot bot, Side side, boolean wall_park) {
        this.side = side;
        this.bot = bot;
        this.park_on_wall = wall_park;
    }
    public void run() {
        bot.raise_foundations();
        if (!park_on_wall) bot.drive_forward(0.5, 20);
        bot.pause(2000);
        bot.strafe_right(0.5, side.coeff*15);
    }
}",java
"package generators
import (
	""github.com/atla/dungeonsrv/pkg/entities""
	""github.com/atla/dungeonsrv/pkg/repository""
	log ""github.com/sirupsen/logrus""
)


type ItemGenerator interface {
	CreateItemWithTemplate(itemTemplate *entities.ItemTemplate) *entities.Item
}
type itemGenerator struct {
	itemRepository          repository.ItemsRepository
	itemTemplatesRepository repository.ItemTemplatesRepository
}

func NewItemGenerator(ir repository.ItemsRepository, itr repository.ItemTemplatesRepository) ItemGenerator {
	return &itemGenerator{
		itemRepository:          ir,
		itemTemplatesRepository: itr,
	}
}
func (ig *itemGenerator) CreateItemWithTemplate(template *entities.ItemTemplate) *entities.Item {
	newItem := &entities.Item{
		Name:        template.Name,
		Description: template.Description,
		ItemType:    template.ItemType,
	}
	log.Debug(""Executing post onCreate script"")





	return newItem
}",go
"require 'bundler/setup'
Bundler.setup
require File.expand_path(""./lib/event_object"")
RSpec.configure do |config|
  config.color = true
end",ruby
"
SELECT COUNT_BIG(1) as TotalCount  FROM dbo.Sales(nolock)
-- #ROW_NUMBER_COUNT# 
--let's execute the below query 
-- We have Data from SALES,Products,MillennialCustomers and Twitter.
select CustKey, UserName, Emailstatus, Department, [Twitter Sentiment], cast(round(TotalSale/10000,0) as int) as Revenue
from (SELECT P.Department, TA.Sentiment AS [Twitter Sentiment],
        sum(S.TotalAmount) as TotalSale,
        M.UserName, M.Emailstatus, M.CustKey
    FROM dbo.Sales as S
        inner join dbo.Products as P on P.Products_ID= S.ProductId inner join [dbo].[Dim_Customer] DC
        left outer join dbo.[TwitterAnalytics] TA on TA.[username]=DC.[userName] on DC.[id]=S.[Customerid]
        inner join dbo.[MillennialCustomers] as M on M.CustKey = S.Customerid
    where DC.[FullName]!='N/A'
    group by DC.[FullName],P.Department,TA.Sentiment,M.UserName,M.CustKey,M.Emailstatus)
  as result",mysql
"CREATE TABLE `randwikirss` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `lang` char(3) NOT NULL DEFAULT '',
  `page_id` bigint(11) unsigned NOT NULL default '0',
  `title` varchar(255) NOT NULL DEFAULT '',
  `image` varchar(255) NOT NULL DEFAULT '',
  `link` text NOT NULL,
  `text` text NOT NULL,
  PRIMARY KEY (`id`),
  KEY (`lang`),
  KEY (`page_id`),
  KEY (`time`)
);",mysql
"require 'formula'
class Reposurgeon < Formula
  homepage 'http://www.catb.org/esr/reposurgeon/'
  url 'http://www.catb.org/~esr/reposurgeon/reposurgeon-3.6.tar.gz'
  sha256 'c07354319813095f5db6c416fd491eb8efd4d7c67db7161c88fd2c3afe0d5386'
  depends_on 'asciidoc'
  depends_on 'xmlto'
  def install
    ENV['XML_CATALOG_FILES'] = ""#{etc}/xml/catalog""
    system ""make""
    tools = %w{reposurgeon repopuller repodiffer}
    bin.install tools
    man1.install tools.map { |m| ""#{m}.1"" }
  end
end",ruby
"import React, { Component } from 'react';
import SignInForm from './signinForm';
import PageTitle from '../pageTitle';
import {connect} from ""react-redux"";
import * as actions from ""../../actions"";
class SignIn extends Component {
    componentDidMount() {
        this.props.setHeaderLinks([]);
        this.props.setNavbarLinks([]);
    }
    onSubmit = (fields) => {
        console.log(fields);
    }
    render() {
        return (
            <div className='sign-in'>
                <PageTitle className=""sign-in__page-title"" title=""Login""/>
                <SignInForm onSubmit={this.onSubmit} className='sign-in__form' />
            </div>
        )
    }
}
SignIn = connect(null, actions)(SignIn);
export default SignIn;",javascript
"
package com.webank.wedatasphere.dss.appconn.eventchecker.adapter;
import org.apache.log4j.Logger;
import java.util.Properties;
public interface EventCheckAdapter {
    boolean sendMsg(int jobId, Properties props, Logger log);
    boolean reciveMsg(int jobId, Properties props, Logger log);
}",java
"
from django.db import migrations, models
class Migration(migrations.Migration):
    dependencies = [
        ('workshops', '0006_auto_20200414_2235'),
    ]
    operations = [
        migrations.AddField(
            model_name='workshop',
            name='name',
            field=models.CharField(default='kkkk', max_length=100, verbose_name='Название'),
        ),
    ]",python
"maintainer       ""YOUR_COMPANY_NAME""
maintainer_email ""YOUR_EMAIL""
license          ""All rights reserved""
description      ""Installs/Configures class2go-python""
long_description IO.read(File.join(File.dirname(__FILE__), 'README.md'))
version          ""0.0.1""",ruby
"require 'sinatra'
require 'haml'
class Piwi < Sinatra::Base
  get '/' do
    @left_pins = [0, 1, 4, 17, 21, 22, 10, 9, 11]
    @right_pins = [18, 23, 24, 25, 8, 7]
    haml :index
  end
end",ruby
"from terregex.mlr import Node, NodeList, Literal, NotLiteral, \
  In, Negate, Range, Category, MinRepeat, MaxRepeat, \
  SubPattern, Branch, Any, parse
from terregex.transform import Transformer",python
"from PuzzleLib.Cuda.Kernels.RadixSort import backendTest
def unittest():
	from PuzzleLib.Hip import Backend
	backendTest(Backend)
if __name__ == ""__main__"":
	unittest()",python
"CREATE PROCEDURE [spGetNextModelId]
AS 
BEGIN
	BEGIN TRY
		DECLARE @ObjectName NVARCHAR(200) = OBJECT_NAME(@@PROCID),
				@Category NVARCHAR(20),
				@Title NVARCHAR(50),
				@MessageContent NVARCHAR(1500),
				@ModelId int 
		SELECT @ModelId = MAX([ModelId]) FROM [Model]
		SET @ModelId = ISNULL(@ModelId, 0)
		EXEC [Logging].[Write] @ObjectName, 'Info', 'Successfully completed', 'Successfully completed selecting data from [Model]'
		RETURN @ModelId + 1 
	END TRY
	BEGIN CATCH 
		SET @MessageContent = ERROR_MESSAGE()
		EXEC [Logging].[Write] @ObjectName, 'Error', 'Error occured', @MessageContent
		RETURN -1
	END CATCH 
END",mysql
"package com.walmartlabs.concord.it.tasks.serializationtest;

import com.walmartlabs.concord.sdk.Context;
import com.walmartlabs.concord.sdk.Task;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.inject.Named;
@Named(""serializationTest"")
public class SerializationTestTask implements Task {
    private static final Logger log = LoggerFactory.getLogger(SerializationTestTask.class);
    @Override
    public void execute(Context ctx) {
        log.info(""Setting a variable..."");
        ctx.setVariable(""test"", new NonSerializableThingy(""Hello!""));
    }
}",java
"var Game = require('crtrdg-gameloop')
var Touch = require('./index')
var canvas = document.createElement('canvas')
canvas.style.background = 'rgb(100,100,100)'
document.body.appendChild(canvas)
var game = new Game({
  canvas: canvas
})
game.width = canvas.width = 800
game.height = canvas.height = 400
var touch = new Touch(game)
touch.on('<tapDownLeft>', function (loc) {
  console.log('tapDownLeft at: ', loc)
})
touch.on('<tapDownRight>', function (loc) {
  console.log('tapDownRight at: ', loc)
})
touch.on('<tapUpRight>', function (loc) {
  console.log('tapUpRight at: ', loc)
})
touch.on('<tapUpLeft>', function (loc) {
  console.log('tapUpLeft at: ', loc)
})
touch.on('<swipeUp>', function (loc) {
  console.log('swipeUp at: ', loc)
})
touch.on('<swipeDown>', function (loc) {
  console.log('swipeDown at: ', loc)
})
touch.on('<swipeLeft>', function (loc) {
  console.log('swipeLeft at: ', loc)
})
touch.on('<swipeRight>', function (loc) {
  console.log('swipeRight at: ', loc)
})",javascript
"from client_database_connection import mycursor
import os
sql = ""INSERT INTO free_node (node_id) VALUES (%s)""
val = (node_id)
mycursor.execute(sql, val)
command = 'python get_code_when_free.py'
os.system(command)",python
"
/\uD809[\uDC00-\uDC62\uDC70-\uDC73]|\uD808[\uDC00-\uDF6E]/;",javascript
"def Node P =
  Choose1 {
    cons = { head = P; tail = Node P };
    nil  = {}
  }
def Main = Node (Match1 'a')",mysql
"package com.github.common.db.entity.primary;
import com.baomidou.mybatisplus.annotation.TableField;
import io.swagger.annotations.ApiModel;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;

@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@ApiModel(value=""LetDefendantJobType对象"", description=""被反映人和是否村干关联表"")
public class LetDefendantJobType implements Serializable {
    private static final long serialVersionUID = 1L;
    @TableField(""defendant_id"")
    private String defendantId;
    @TableField(""job_type_id"")
    private Integer jobTypeId;
    public static final String DEFENDANT_ID = ""defendant_id"";
    public static final String JOB_TYPE_ID = ""job_type_id"";
}",java
"class AuthenticationController < ApplicationController
  before_action :authenticate_user
 def authenticate
   command = AuthenticateUser.call(params[:username], params[:password])
   if command.success?
     render json: { auth_token: command.result }
   else
     render json: { error: command.errors }, status: :unauthorized
   end
 end
end",ruby
"
package enum
import ""strconv""
const _Preemption_name = ""nonedso_localdso_preemptable""
var _Preemption_index = [...]uint8{0, 4, 13, 28}
func (i Preemption) String() string {
	if i >= Preemption(len(_Preemption_index)-1) {
		return ""Preemption("" + strconv.FormatInt(int64(i), 10) + "")""
	}
	return _Preemption_name[_Preemption_index[i]:_Preemption_index[i+1]]
}",go
"
package org.apache.ibatis.submitted.lazyload_proxyfactory_comparison;
public class UserWithGetXxxWithInterface implements Owned<Group> {
    private Integer id;
    private String name;
    private Group owner;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public Group getOwner() {
        return owner;
    }
    @Override
    public void setOwner(Group owner) {
        this.owner = owner;
    }
    public Object getXxx() {
        return null;
    }
}",java
"from scrapy.spider import BaseSpider
from scrapy.http import Request
from scrapy.selector import XmlXPathSelector
from openrecipes.spiders.elanaspantry_spider import ElanaspantryMixin
class ElanaspantryfeedSpider(BaseSpider, ElanaspantryMixin):
    name = ""elanaspantry.feed""
    allowed_domains = [
        ""www.elanaspantry.com"",
        ""feeds.feedburner.com"",
        ""feedproxy.google.com"",
    ]
    start_urls = [
        ""http://feeds.feedburner.com/elanaspantry"",
    ]
    def parse(self, response):
        xxs = XmlXPathSelector(response)
        links = xxs.select(""//item/*[local-name()='origLink']/text()"").extract()
        return [Request(x, callback=self.parse_item) for x in links]",python
"

namespace mindspore {
REGISTER_PRIMITIVE_C(kNameLogicalNot, LogicalNot);
}  // namespace mindspore",cpp
"
















from case import Case
class Case1_2_5(Case):
   DESCRIPTION = """"""Send binary message message with payload of length 128.""""""
   EXPECTATION = """"""Receive echo'ed binary message (with payload as sent). Clean close with normal code.""""""
   def onOpen(self):
      payload = ""\xfe"" * 128
      self.expected[Case.OK] = [(""message"", payload, True)]
      self.expectedClose = {""closedByMe"":True,""closeCode"":[self.p.CLOSE_STATUS_CODE_NORMAL],""requireClean"":True}
      self.p.sendFrame(opcode = 2, payload = payload)
      self.p.killAfter(1)",python
"package bbgo
import (
	""encoding/json""
	""io/ioutil""
	""os""
	""path""
	""reflect""
	""github.com/pkg/errors""
)
type DataFetcher func() (interface{}, error)




func WithCache(key string, obj interface{}, fetcher DataFetcher) error {
	cacheDir := CacheDir()
	cacheFile := path.Join(cacheDir, key+"".json"")
	if _, err := os.Stat(cacheFile); os.IsNotExist(err) {
		data, err := fetcher()
		if err != nil {
			return err
		}
		out, err := json.Marshal(data)
		if err != nil {
			return err
		}
		if err := ioutil.WriteFile(cacheFile, out, 0666); err != nil {
			return err
		}
		rv := reflect.ValueOf(obj).Elem()
		if !rv.CanSet() {
			return errors.New(""can not set cache object value"")
		}
		rv.Set(reflect.ValueOf(data))
	} else {
		data, err := ioutil.ReadFile(cacheFile)
		if err != nil {
			return err
		}
		if err := json.Unmarshal(data, obj); err != nil {
			return err
		}
	}
	return nil
}",go
"CREATE TABLE [dbo].[DDLSnapshots] (
    [DatabaseID]           INT           NOT NULL,
    [SnapshotDate]         DATETIME2 (3) NOT NULL,
    [ValidatedDate]        DATETIME2 (3) NOT NULL,
    [DDLSnapshotOptionsID] INT           NULL,
    [Created]              INT           NULL,
    [Modified]             INT           NULL,
    [Dropped]              INT           NULL,
    CONSTRAINT [PK_DDLSnapshots] PRIMARY KEY CLUSTERED ([DatabaseID] ASC, [SnapshotDate] ASC),
    CONSTRAINT [FK_DBSnapshots_Databases] FOREIGN KEY ([DatabaseID]) REFERENCES [dbo].[Databases] ([DatabaseID]),
    CONSTRAINT [FK_DDLSnapshots_DDLSnapshotOptions] FOREIGN KEY ([DDLSnapshotOptionsID]) REFERENCES [dbo].[DDLSnapshotOptions] ([DDLSnapshotOptionsID])
);",mysql
"package com.vsp.dicty.domain.model;
public class Lang implements Comparable<Lang> {
    private String langCode;
    private String lang;
    @Override
    public int compareTo(Lang lang) {
        return this.lang.compareToIgnoreCase(lang.getLang());
    }
    public String getLang() {
        return lang;
    }
    public void setLang(String lang) {
        this.lang = lang;
    }
    public String getLangCode() {
        return langCode;
    }
    public void setLangCode(String langCode) {
        this.langCode = langCode;
    }
    @Override
    public String toString() {
        return lang;
    }
}",java
"package myservice.mynamespace.service.api;
import org.apache.olingo.server.api.processor.EntityProcessor;
public interface IEntityProcessor extends EntityProcessor, ICanHandleODataUri {
}",java
"

shibari_tls_linker::shibari_tls_linker(std::vector<shibari_module*>* extended_modules, shibari_module* main_module)
    : extended_modules(extended_modules), main_module(main_module) {}
shibari_tls_linker::~shibari_tls_linker()
{
}
shibari_linker_errors shibari_tls_linker::link_modules() {
    for (auto& module : *extended_modules) {
        if (module->get_module_image().get_tls().get_callbacks().size()) {
            for (auto& item : module->get_module_image().get_tls().get_callbacks()) {
                main_module->get_module_image().get_tls().get_callbacks().push_back({
                    module->get_module_position().get_address_offset() + item.rva_callback ,item.use_relocation
                    });
            }
        }
    }
    return shibari_linker_errors::shibari_linker_ok;
}",cpp
"
package io.fabric8.kubernetes.client;
public class ApiextensionsAPIGroupExtensionAdapter extends APIGroupExtensionAdapter<ApiextensionsAPIGroupClient> {
  @Override
  protected String getAPIGroupName() {
    return ""apiextension"";
  }
  @Override
  public Class<ApiextensionsAPIGroupClient> getExtensionType() {
    return ApiextensionsAPIGroupClient.class;
  }
  @Override
  protected ApiextensionsAPIGroupClient newInstance(Client client) {
    return new ApiextensionsAPIGroupClient(client);
  }
}",java
"module.exports = {
    singleQuote: true,
    printWidth: 360,
    bracketSpacing: true,
    arrowParens: ""always"",
    useTabs: false,
    trailingComma: ""none"",
    tabWidth: 2
};",javascript
"import React from ""react""
import Layout from ""../../layout/page-container.js""
import AboutMe from ""./content/about-me.js""
import data from ""../../api.json"";
const AboutMePage = (props) => (
	<Layout>
		AboutMe
		<AboutMe data={data} />
	</Layout>
)
export default AboutMePage",javascript
"





package cgotest

import ""C""

func issue8148Callback(t *C.T) C.int {
	return t.i
}
func Issue8148() int {
	return int(C.get())
}",go
"cask ""fellow"" do
  version ""1.0.17""
  sha256 ""e774f48ab63009190de94ffc470455dac89bb1f3c1c469e61f5c4982737b1888""
  url ""https://cdn.fellow.app/desktop/#{version}/darwin/stable/Fellow.dmg""
  appcast ""https://macupdater.net/cgi-bin/check_urls/check_url_redirect.cgi?url=https://fellow.app/desktop/download/darwin/latest/""
  name ""Fellow""
  desc ""Collaborative meeting agendas, notes, and action items""
  homepage ""https://fellow.app/""
  app ""Fellow.app""
end",ruby
"-- Provide a query that shows the total number of tracks in each playlist.
 -- The Playlist name should be include on the resulant table.
 -- #15
select
  p.name as PlaylistName,
  count (t.TrackId) as Number_Of_Tracks
from
  Playlist p,
  PlaylistTrack plt,
  Track t
where
  plt.PlaylistId = p.PlaylistId
and
  plt.TrackId = t.TrackId
group by PlaylistName;",mysql
"
package com.huawei.chitchatapp.videoplayer.contract;
public interface OnDialogInputValueListener {
    void dialogInputListener(String inputText);
}",java
"INSERT INTO `aplicativos` VALUES (1, 'Usuarios', 1, 'users', NULL, 'i-users', 1, '0000-0-0 00:00:00', '0000-0-0 00:00:00');
INSERT INTO `aplicativos` VALUES (2, 'Doc. Receptor', 2, 'docreceptor', NULL, 'i-stack-list', 1, '0000-0-0 00:00:00', '0000-0-0 00:00:00');
INSERT INTO `aplicativos` VALUES (3, 'Siseftran', 2, 'siseftran/plannacional', NULL, 'i-books', 1, '0000-0-0 00:00:00', '0000-0-0 00:00:00');",mysql
"polyline = {
	""vertices"" : {
		[0,0,0],
		[0,100,0],
		[100,100,0],
		[100,0,0]
	},
	""numberFloors"": ""none"",
	""buildingType"": ""office""
}",javascript
"require ""test_helper""
class StoreTest < ActiveSupport::TestCase



end",ruby
"





package aero.aixm;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlType;
import javax.xml.bind.annotation.XmlValue;

@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = ""CodeVerticalReferenceType"", propOrder = {
    ""value""
})
public class CodeVerticalReferenceType {
    @XmlValue
    protected String value;
    @XmlAttribute(name = ""nilReason"")
    protected String nilReason;
    
    public String getValue() {
        return value;
    }
    
    public void setValue(String value) {
        this.value = value;
    }
    public boolean isSetValue() {
        return (this.value!= null);
    }
    
    public String getNilReason() {
        return nilReason;
    }
    
    public void setNilReason(String value) {
        this.nilReason = value;
    }
    public boolean isSetNilReason() {
        return (this.nilReason!= null);
    }
}",java
"class Finance::FinanceFee < ApplicationRecord
  belongs_to :finance_fee_collection ,:foreign_key => 'fee_collection_id'
  has_many   :finance_transactions ,:as=>:finance
  has_many :components, :class_name => 'FinanceFeeComponent', :foreign_key => 'fee_id'
  belongs_to :student
end",ruby
"'use strict';
const Q = require('./lib/server.js');
Q.start();
const db = new Q('database');
db.monitorEvents('create');
db.monitorEvents('read');
db.monitorEvents('update');
db.monitorEvents('delete');",javascript
"class EC():
    def __init__(self, id=None):
        self.database = 'EC'
        self.id = id
        self._long_name = 'EC (Enzyme Commission) number of the Nomenclature Committee of the International Union of Biochemistry and Molecular Biology (IUBMB) Database of Interacting Proteins'
        self._web = 'https://iubmb.qmul.ac.uk/enzyme/'
    def __call__(self):
        tmp_dict = {
                'database' : 'EC',
                'id' : self.id
                }
        return tmp_dict
    def __repr__(self):
        return f'<EC: {self.id}>'
    def __str__(self):
        return f'EC: {self.id}'
    def __deepcopy__(self):
        return EC(id=self.id)
    def _webid(self):
        return self._web
    def _repr_html_(self):
        return f'<a href=""https://enzyme.expasy.org/EC/{self.id}"">{self.database}: {self.id}</a>'",python
"


function createListForEachDepth(rootNode, arrayOfLists, level) {

  if (rootNode === null) {
    return ;
  }

  if (arrayOfLists.length < level) {
    arrayOfLists.push(new LinkedList());
  }

  arrayOfLists[level - 1].appendNode = rootNode;

  createListForEachDepth(rootNode.left, arrayOfLists, level + 1);
  createListForEachDepth(rootNode.right, arrayOfLists, level + 1);
}
var ourList = createListForEachDepth(binaryTree, [], 0);",javascript
"--
-- Copyright (c) 2020 Alexander (Oleksandr) Sinitsyn
--
CREATE OR ALTER FUNCTION sspm.GetTablesByPS (@PSName sysname)
RETURNS table
AS
RETURN
(
  SELECT
    i.object_id,
    table_name = sch.name + '.' + o.name
  FROM sys.partition_schemes ps with(nolock)
    join sys.indexes i with(nolock)
      on i.data_space_id = ps.data_space_id
    join sys.objects o with(nolock)
      on o.object_id = i.object_id
    join sys.schemas sch with(nolock)
      on sch.schema_id = o.schema_id
  WHERE i.index_id in (0, 1)
    and ps.name = @PSName
)
go",mysql
"class Micropost < ApplicationRecord
  belongs_to :user
  default_scope -> {order(created_at: :desc)}
  mount_uploader :picture, PictureUploader
  validates :user_id, presence: true
  validates :content, presence: true, length: {maximum: 140}
  validate :picture_size
  def picture_size
    if picture.size > 5.megabytes
      errors.add(:picture, ""should be less than 5MB"")
    end
  end
end",ruby
"

Distance::Distance()
{
}
Distance::Distance(PointProcessed* point, double distance){
    p = point;
    d = distance;
}
double Distance::getDistance(){
    return d;
}
PointProcessed* Distance::getPoint()const {
    return p;
}
bool Distance::operator<(Distance dis)const{
    return d < dis.d;
}
bool Distance::operator==(Distance dis)const{
    return d == dis.d;
}
bool Distance::operator!=(Distance dis)const{
    return d != dis.d;
}
bool Distance::operator<=(Distance dis)const{
    return d <= dis.d;
}
bool Distance::operator>(Distance dis)const{
    return d > dis.d;
}
bool Distance::operator>=(Distance dis)const{
    return d >= dis.d;
}",cpp
"require 'test_helper'
class ScheduleServiceTest < ActiveSupport::TestCase
    test ""test ScheduleService group_and_flatten_schedules"" do
        data = {:schedule_group=>""minutes_15"", :scheduled_pins=>[{:scheduled_pin_id=>1, :board_uuid=>""856176647848743913""}, {:scheduled_pin_id=>2, :board_uuid=>""856176647848743913""}, {:scheduled_pin_id=>3, :board_uuid=>""7777777777""}, {:scheduled_pin_id=>4, :board_uuid=>""7777777777""}, {:scheduled_pin_id=>5, :board_uuid=>""856176647848743913""}]}
        grouped_schedules = ScheduleService.group_and_flatten_schedules data[:scheduled_pins]
        puts grouped_schedules.inspect
        result = [{:board_uuid=>""856176647848743913"", :ids=>[1, 2, 5]}, {:board_uuid=>""7777777777"", :ids=>[3, 4]}]
        assert grouped_schedules.length == 2
        assert grouped_schedules == result
    end
end",ruby
"from flask import Flask
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///posts.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

db = SQLAlchemy(app)",python
"






Pod::Spec.new do |s|

  s.name         = ""MFPictureBrowser""
  s.version      = ""0.6.2""
  s.summary      = ""Elegant Picture Browser""





  s.homepage     = ""https://github.com/GodzzZZZ/MFPictureBrowser""



  s.license      = ""MIT""









    s.author           = { 'GodzzZZZ' => 'GodzzZZZ@qq.com' }






  s.platform     = :ios, ""9.0""







  s.source       = { :git => ""https://github.com/GodzzZZZ/MFPictureBrowser.git"", :tag => ""#{s.version}"" }







  s.source_files  = ""Classes"", ""MFPictureBrowserDemo/MFPictureBrowserDemo/MFPictureBrowser/*.{h,m}""

















  s.frameworks = ""UIKit"", ""Foundation""



  s.requires_arc = true
  s.dependency 'YYWebImage'
  s.dependency 'YYImage/WebP'
  s.dependency 'MFCategory'

end",ruby
"









class FeatureType;
namespace search
{
struct RankingInfo
{
  static double const kMaxDistMeters;
  static void PrintCSVHeader(std::ostream & os);
  void ToCSV(std::ostream & os) const;


  double GetLinearModelRank() const;
  double GetErrorsMadePerToken() const;

  double m_distanceToPivot = kMaxDistMeters;

  uint8_t m_rank = 0;

  uint8_t m_popularity = 0;

  std::pair<uint8_t, float> m_rating = {0, 0.0f};

  NameScore m_nameScore = NAME_SCORE_ZERO;

  ErrorsMade m_errorsMade;

  size_t m_numTokens = 0;



  std::array<TokenRange, Model::TYPE_COUNT> m_tokenRanges;

  double m_matchedFraction = 0.0;


  bool m_allTokensUsed = true;

  bool m_exactMatch = true;


  bool m_exactCountryOrCapital = true;

  Model::Type m_type = Model::TYPE_COUNT;


  bool m_pureCats = false;



  bool m_falseCats = false;

  bool m_categorialRequest = false;

  bool m_hasName = false;
};
std::string DebugPrint(RankingInfo const & info);
}  // namespace search",cpp
"
package org.springframework.beans.factory;

@SuppressWarnings(""serial"")
public class BeanIsAbstractException extends BeanCreationException {
	
	public BeanIsAbstractException(String beanName) {
		super(beanName, ""Bean definition is abstract"");
	}
}",java
"
CKEDITOR.plugins.setLang( 'stylescombo', 'bg', {
	label: 'Стилове',
	panelTitle: 'Стилове за форматиране',
	panelTitle1: 'Блокови стилове',
	panelTitle2: 'Вътрешни стилове',
	panelTitle3: 'Обектни стилове'
} );",javascript
"from rest_framework import viewsets
from periodic_tasks_api.models import CustomExtendedPeriodicTask
from periodic_tasks_api.serializers import PeriodicTaskSerializer
from periodic_tasks_api.filters import PeriodicTaskFilterSet
class PeriodicTaskView(viewsets.ModelViewSet):
    queryset = CustomExtendedPeriodicTask.objects.all()
    serializer_class = PeriodicTaskSerializer
    filter_backends = [PeriodicTaskFilterSet]",python
"











int main(int argc, const char * argv[]) {
    std::cout << ""target2 says Hello!\n"";
    auto shared = Shared();
    shared.action1();
    return 0;
}",cpp
"package handlers
import (
	baselog ""github.com/Ubivius/microservice-character-data/pkg/log""
)
var log = baselog.MLog.WithName(""handler"")",go
"DROP TABLE IF EXISTS `bb_oper_logs`;
CREATE TABLE bb_oper_logs (
  id         bigint(11) unsigned NOT NULL AUTO_INCREMENT,
  emp_id     varchar(32)         NOT NULL,
  emp_name   varchar(128)        NOT NULL,
  controller varchar(64)         NOT NULL,
  operation  varchar(64)         NOT NULL,
  ip         varchar(24)         NOT NULL,
  created_at timestamp                    DEFAULT CURRENT_TIMESTAMP,
  updated_at timestamp                    DEFAULT CURRENT_TIMESTAMP
  ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (id)
)
  ENGINE = InnoDB
  DEFAULT CHARSET = utf8;
CREATE INDEX bb_oper_logs_emp_id
  on bb_oper_logs (emp_id);
CREATE INDEX bb_oper_logs_emp_name
  on bb_oper_logs (emp_id);",mysql
"package airpaste
import ""github.com/micro/mdns""
const (
	defaultServiceName = ""default""
)
type Server struct {
	IPAddr string
	Port   int
}
func SearchForOpenServer(serviceName string) Server {
	var waitingServer Server

	entriesCh := make(chan *mdns.ServiceEntry)
	go func() {
		for entry := range entriesCh {
			waitingServer = Server{
				IPAddr: entry.Addr.String(),
				Port:   entry.Port,
			}
		}
	}()
	mdns.Lookup(serviceName, entriesCh)
	close(entriesCh)
	return waitingServer
}",go
"package main
import (
	""github.com/stscoundrel/advent-of-code-2021/day16/reader""
	""github.com/stscoundrel/advent-of-code-2021/day16/transmissions""
)
func SumVersionNumbers(fileName string) int {
	hexTransmission := reader.ReadGTransmissionFromFile(fileName)
	versionSum := transmissions.SumVersionNumbers(hexTransmission)
	return versionSum
}
func GetTransmissionValue(fileName string) int {
	hexTransmission := reader.ReadGTransmissionFromFile(fileName)
	return transmissions.GetValue(hexTransmission)
}",go
"-- randexpr1.test
-- 
-- db eval {SELECT coalesce((select max(13) from t1 where f= -case when exists(select 1 from t1 where not t1.b>=e and b in (select b from t1 union select (+(t1.f-d)) from t1) or 19 in (select min(e) from t1 union select  -~+++ -abs(min(17*t1.d)) from t1) or not t1.a>a) then 13 else t1.c end+a | ~11),19) FROM t1 WHERE (exists(select 1 from t1 where t1.c>19)) and a>d-a}
SELECT coalesce((select max(13) from t1 where f= -case when exists(select 1 from t1 where not t1.b>=e and b in (select b from t1 union select (+(t1.f-d)) from t1) or 19 in (select min(e) from t1 union select  -~+++ -abs(min(17*t1.d)) from t1) or not t1.a>a) then 13 else t1.c end+a | ~11),19) FROM t1 WHERE (exists(select 1 from t1 where t1.c>19)) and a>d-a",mysql
"CREATE PROCEDURE [dbo].[spCustomers_GetAll]
AS
BEGIN
	SET NOCOUNT ON;
	SELECT [CustomerId], [FirstName], [LastName], [FullName], [Address], [Phone], [Email], [PayCentreId], [UploadReceipts]
	FROM [dbo].[Customers]
END",mysql
"
from django.db import migrations, models
class Migration(migrations.Migration):
    dependencies = [
        ('notes', '0001_initial'),
    ]
    operations = [
        migrations.AlterField(
            model_name='note',
            name='media',
            field=models.ImageField(help_text='Optional image to add to note.', upload_to='media'),
        ),
    ]",python
"

namespace WeexCore {
  RenderActionMoveElement::RenderActionMoveElement(const std::string &pageId, const std::string &ref,
                                                   const std::string &parentRef, int index) {
    this->mPageId = pageId;
    this->mRef = ref;
    this->mParentRef = parentRef;
    this->mIndex = index;
  }
  void RenderActionMoveElement::ExecuteAction() {
    Bridge_Impl_Android::getInstance()->callMoveElement(mPageId.c_str(), mRef.c_str(), mParentRef.c_str(), mIndex);
  }
}",cpp
"require File.join(File.dirname(__FILE__), '..', '..', '..', 'puppet/provider/elastic_rest')
Puppet::Type.type(:elasticsearch_license).provide(
  :shield,
  :api_resource_style => :bare,
  :parent => Puppet::Provider::ElasticREST,
  :metadata => :content,
  :metadata_pipeline => [
    lambda { |data| Puppet_X::Elastic.deep_to_s data },
    lambda { |data| Puppet_X::Elastic.deep_to_i data }
  ],
  :api_uri => '_license',
  :query_string => {
    'acknowledge' => 'true'
  }
) do
  desc 'A REST API based provider to manage Elasticsearch Shield licenses.'
  mk_resource_methods
  def self.process_body(body)
    JSON.parse(body).map do |_object_name, api_object|
      {
        :name     => name.to_s,
        :ensure   => :present,
        metadata  => { 'license' => process_metadata(api_object) },
        :provider => name
      }
    end
  end
end",ruby
"const config	= require('./config.js');
let exec		= require('child_process').exec;
const args = process.env.npm_config_argv;

let env    = JSON.parse(args).original[2] !== undefined ? JSON.parse(args).original[2].replace('--','') : null;
if (env != 'production') env = 'staging';
let cmd = 'rsync -azP';
for (let e of config.deploy[env].exclude) cmd += ` --exclude '${e}'`;
cmd += ` ${config.deploy[env].source} ${config.deploy[env].username}@${config.deploy[env].hostname}:${config.deploy[env].destination}`;
exec(cmd, (e) => {
	if (e !== null) console.log(e);
});",javascript
"package com.google.android.play.core.tasks;
import java.util.concurrent.Executor;

final class C2103f<ResultT> implements C2104g<ResultT> {
    
    private final Executor f1072a;
    
    
    public final Object f1073b = new Object();
    
    
    public final OnSuccessListener<? super ResultT> f1074c;
    public C2103f(Executor executor, OnSuccessListener<? super ResultT> onSuccessListener) {
        this.f1072a = executor;
        this.f1074c = onSuccessListener;
    }
    
    public final void mo34389a(Task<ResultT> task) {
        if (task.isSuccessful()) {
            synchronized (this.f1073b) {
                if (this.f1074c != null) {
                    this.f1072a.execute(new C2102e(this, task));
                }
            }
        }
    }
}",java
"
package org.encog.mathutil.dimension;

public class DimensionConstraint {
	
	private final MultiDimension lower;
	
	private final MultiDimension upper;
	
	public DimensionConstraint(int n, int theLower, int theUpper) {
		this.lower = new MultiDimension(n);
		this.upper = new MultiDimension(n);
		for (int i = 0; i < n; i++) {
			this.lower.setDimension(i, theLower);
			this.upper.setDimension(i, theUpper);
		}
	}
	
	public MultiDimension getLower() {
		return lower;
	}
	
	public MultiDimension getUpper() {
		return upper;
	}
	
	public int getLower(int d) {
		return lower.getDimension(d);
	}
	
	public int getUpper(int d) {
		return upper.getDimension(d);
	}
	
	public int getRange(int d) {
		return (upper.getDimension(d) - lower.getDimension(d))+1;
	}
	public int getMiddle(int d) {
		return getRange(d)/2;
	}
}",java
"
using namespace std;
void solve() {
    int n; cin >> n;
    vector<int> a(n+1, 0);
    auto sieve = [&](){
        int cnt = 1;
        for (int p = 2; p <= n; p++) {
            if (!a[p]) {
                a[p] = cnt;
                for (long long i = 1ll*p*p; i <= n; i+=p) {
                    a[i] = cnt;
                }
                cnt++;
            }
        }
    };
    sieve();
    for (int i = 2; i <= n; i++) {
        cout << a[i] << ' ';
    }
}
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    solve();
    cout << endl;
}",cpp
"




namespace LogicService {
Yb::ElementTree::ElementPtr ping(
        Yb::Session &session, Yb::ILogger &logger,
        const Yb::StringDict &params)
{
    session.engine()->exec_select(""select 1 from dual"", Yb::Values());
    Yb::ElementTree::ElementPtr resp = mk_resp(""success"");
    return resp;
}
Yb::ElementTree::ElementPtr check_kek(
        Yb::Session &session, Yb::ILogger &logger,
        const Yb::StringDict &params)
{
    Yb::ElementTree::ElementPtr resp = mk_resp(""success"");

    TokenizerConfig &tcfg(theTokenizerConfig::instance().refresh());

    TokenizerConfig tcfg;

    std::string ver = params.get(""kek_version"", """");
    int kek_version = -1;
    if (ver.empty())
        kek_version = tcfg.get_active_master_key_version();
    else
        kek_version = boost::lexical_cast<int>(ver);
    resp->sub_element(""check_kek"",
            tcfg.is_kek_valid(kek_version)? ""true"": ""false"");
    return resp;
}
} // LogicService
",cpp
"class Image < ActiveRecord::Base
  self.table_name = 'sir_trevor_images'
	mount_uploader :file, ImageUploader
	validates :file, :presence => true
end",ruby
"""use strict"";
Object.defineProperty(exports, ""__esModule"", { value: true });
const create_1 = require(""../../../../../path/create"");
function Create() {
    return new create_1.default('/anggota/jabatan');
}
exports.default = Create;",javascript
"
class Foo
  def initialize
    @foo = 'baz'
  end

  def bar
    @foo
  end

end",ruby
"
module BaseField
  class BaseField < ApplicationComponent
    def initialize(id:, label:, help: nil, errors: [], hide_label: false, **)
      super
      @id = id
      @label = label
      @help = help
      @errors = errors
      @hide_label = hide_label
    end
    private
    attr_reader :id, :label, :help, :errors, :hide_label
  end
end",ruby
"package apptools
import (
	""io""
	""net/http""
	""time""
)
type App interface {
	Init(Registry)
}
type Registry interface {
	Init()
	GetConfig() Config
	GetDispatchHandler() DispatchHandler
	GetAssetRegistry() AssetRegistry
	GetAssetTestRegistry() AssetRegistry
}
type DispatchHandler interface {
	Attach(func(func(w http.ResponseWriter, r *http.Request)) func(w http.ResponseWriter, r *http.Request))
	AddTeamObject(string, bool)
}
type AssetRegistry interface {
	Add(string, Asset)
	AddAssets(map[string][]Asset)
	AddTemplates(map[string]Asset, map[string]Asset)
}
type Asset struct {
	Url        string
	GetModTime func() time.Time
	GetReader  func() io.Reader
}
type Config interface {
	Get(key string) string
}",go
"class Subscription < ActiveRecord::Base
  belongs_to :user, :counter_cache => true
  belongs_to :conversation, :counter_cache => true
  validates_presence_of :user_id, :conversation_id
  def new_messages_count
    if self.conversation_id == user.personal_conversation_id
      self.conversation.messages.count :conditions => [""id > ?"", self.last_message_id]
    else
      self.conversation.messages.count :conditions => [""id > ? and system_message is FALSE"", self.last_message_id]
    end
  end
  def mark_read
    self.update_attributes(:last_message_id => self.conversation.messages.last.id) unless self.conversation.messages.blank?
  end
  def activate
    self.mark_read
    self.activated_at = Time.now
    self.save
  end
end",ruby
alter table gx_email_template add column sender_email_address varchar(200);,mysql
"











package template
import (
	""time""
	chaosmeshv1alph1 ""github.com/chaos-mesh/chaos-mesh/api/v1alpha1""
	""github.com/chaos-mesh/chaos-mesh/pkg/workflow/errors""
)
type NetworkChaosTemplate interface {
	Template
	ChaosNamePrefix() string
	NetworkChaosSpec() chaosmeshv1alph1.NetworkChaosSpec
	Duration() (time.Duration, error)
}
func ParseNetworkChaosTemplate(raw interface{}) (NetworkChaosTemplate, error) {
	op := ""template.NetworkChaosTemplate""
	if target, ok := raw.(NetworkChaosTemplate); ok {
		return target, nil
	}
	return nil, errors.NewParseSerialTemplateFailedError(op, raw)
}",go
"from django.apps import AppConfig
class MarkersConfig(AppConfig):
    name = 'markers'",python
"""""""A flexible Python library for atomic structure generation.""""""",python
"CREATE SEQUENCE SEQ_IACUC_PROTO_CORR_ID INCREMENT BY 1 START WITH 1 NOCACHE
/",mysql
"


namespace Bootloader
{
    CommandFlashLock::CommandFlashLock(
        const char* device,
        uint32_t baudRate
    ) : Command { device, baudRate }
    {
    }
    CommandFlashLock::~CommandFlashLock()
    {
        Command::Close();
    }
    int32_t CommandFlashLock::Execute()
    {
        BLDR_CommandMessage_t commandMessageTx;
        BLDR_CommandMessage_t commandMessageRx;
        BLDR_InitCommandMessageStruct(&commandMessageTx);
        BLDR_InitCommandMessageStruct(&commandMessageRx);
        commandMessageTx.Id     = BLDR_IDC_FLASH_LOCK;
        commandMessageTx.Length = 0;
        Command::Transmit(&commandMessageTx);
        Command::Receive(&commandMessageRx);
        Command::Print(&commandMessageTx, ""----TX----"");
        Command::Print(&commandMessageRx, ""----RX----"");
        return NO_FAILURE;
    }
}",cpp
"


const tailwindcss = {
	theme: {
		screens: {
			xs: `${16 + 512 + 16}px`,

			sm: `${16 + 640 + 16}px`,

			md: `${16 + 768 + 16}px`,

			lg: `${16 + 1024 + 16}px`,

			xl: `${16 + 1280 + 16}px`,

		},
	},
}
export default tailwindcss",javascript
"
package bean;
import datos.Usuario;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

@Stateless
public class UsuarioFacade extends AbstractFacade<Usuario> {
    @PersistenceContext(unitName = ""GC_DAIPU"")
    private EntityManager em;
    @Override
    protected EntityManager getEntityManager() {
        return em;
    }
    public UsuarioFacade() {
        super(Usuario.class);
    }
}",java
"























































threads_count = Integer(ENV['RAILS_MAX_THREADS'] || 16)
threads threads_count, threads_count





































workers Integer(ENV['WEB_CONCURRENCY'] || 2)







































































",ruby
"












package internalsrv
import (
	""github.com/mholt/caddy""
	""github.com/mholt/caddy/caddyhttp/httpserver""
)
func init() {
	caddy.RegisterPlugin(""internal"", caddy.Plugin{
		ServerType: ""http"",
		Action:     setup,
	})
}

func setup(c *caddy.Controller) error {
	paths, err := internalParse(c)
	if err != nil {
		return err
	}


	config := httpserver.GetConfig(c)
	config.HiddenFiles = append(config.HiddenFiles, paths...)
	config.AddMiddleware(func(next httpserver.Handler) httpserver.Handler {
		return Internal{Next: next, Paths: paths}
	})
	return nil
}
func internalParse(c *caddy.Controller) ([]string, error) {
	var paths []string
	for c.Next() {
		if c.NextArg() {
			paths = append(paths, c.Val())
		}
		if c.NextArg() {
			return nil, c.ArgErr()
		}
	}
	return paths, nil
}",go
"










package delegate
import (
	""fmt""
	""github.com/cockroachdb/cockroach/pkg/sql/sem/tree""
)
func (d *delegator) delegateShowDatabaseIndexes(
	n *tree.ShowDatabaseIndexes,
) (tree.Statement, error) {
	const getAllIndexesQuery = `
    SELECT table_name,
           index_name,
           non_unique::BOOL,
           seq_in_index,
           column_name,
           direction,
           storing::BOOL,
           implicit::BOOL
      FROM %s.information_schema.statistics`
	return parse(fmt.Sprintf(getAllIndexesQuery, n.Database.String()))
}",go
"package me.erudev.ch02._0003;

public class Solution {
    static class Node {
        private int value;
        private Node next;
        public Node(int value) {
            this.value = value;
        }
    }
    public static Node removeMidNode(Node head) {
        if (head == null || head.next == null) {
            return null;
        }
        if (head.next.next == null) {
            return head.next;
        }
        Node pre = head;
        Node cur = head.next.next;
        while (cur.next != null && cur.next.next != null) {
            pre = pre.next;
            cur = cur.next.next;
        }
        pre.next = pre.next.next;
        return head;
    }
}",java
"module BusinessUnitTypes::Validations
  extend ActiveSupport::Concern
  included do
    validates :name, :business_unit_label, presence: true
    validates :review_prefix, presence: true, uniqueness: {
      case_sensitive: false, scope: :organization_id
    }, if: :review_prefix_should_be_checked?
    validates :name, :business_unit_label, :project_label, :review_prefix,
      length: { maximum: 255 }, allow_nil: true, allow_blank: true
    validates :name, uniqueness: {
      case_sensitive: false, scope: :organization_id
    }
    validate :all_units_marked_for_destruction_can_be_destroyed
  end
  private
    def all_units_marked_for_destruction_can_be_destroyed
      locked = business_units.any? do |bu|
        bu.marked_for_destruction? && !bu.can_be_destroyed?
      end
      errors.add :business_units, :locked if locked
    end
    def review_prefix_should_be_checked?
      SHOW_REVIEW_AUTOMATIC_IDENTIFICATION
    end
end",ruby
"




namespace kbcr
{
	ConceptNetEdge::ConceptNetEdge(QString id, QString language, std::shared_ptr<ConceptNetConcept> firstConcept,
									std::shared_ptr<ConceptNetConcept> secondConcept, QString relation, double weight)
	{
		this->id = id;
		this->language = language;
		this->firstConcept = firstConcept;
		this->secondConcept = secondConcept;
		this->weight = weight;
		this->relation = relation;
	}
	ConceptNetEdge::~ConceptNetEdge()
	{
	}
	std::string ConceptNetEdge::toString()
	{
		std::stringstream ss;
		ss << ""Edge: "" << this->firstConcept->term.toStdString() << "" Sense: ""
				<< this->firstConcept->senseLabel.toStdString() << "" "" << this->relation.toStdString() << "" ""
				<< this->secondConcept->term.toStdString() << "" Sense: ""
				<< this->secondConcept->senseLabel.toStdString() << "" Weight: "" << this->weight << "" Number of sources: ""
				<< this->sources.size() << std::endl;
		return ss.str();
	}
} ",cpp
"




using namespace std;
int main() {

	freopen(""/home/shiva/Learning/1.txt"", ""r"", stdin);
	freopen(""/home/shiva/Learning/2.txt"", ""w"", stdout);

	ios::sync_with_stdio(false); cin.tie(0);
	ll t, n; cin >> t;
	bool flag = false;
	while (t--) {
		flag = false;
		cin >> n;
		ll start = 1, end = sqrt(n), ss, ee;
		if ((end * end) == n) cout << ""Yes\n"";
		else {
			while (start <= end) {
				ss = start * start; ee = end * end;
				if (ss + ee == n){cout << ""Yes\n""; flag=true; break;}
				else if (ss + ee < n) start++;
				else end--;
			}
			if(!flag) cout<<""No\n"";
		}
	}
}",cpp
"-- -----------------------------------------------------
-- Table `dummy`
-- -----------------------------------------------------
CREATE TABLE IF NOT EXISTS `dummy` (
  `iddummy` INT(15) NOT NULL AUTO_INCREMENT,
  `test_string` VARCHAR(45) NOT NULL,
  `test_int` INT(15) NOT NULL,
  `test_float` FLOAT NOT NULL,
  `test_null` VARCHAR(45) NULL,
  `lastupdate` INT(15) NULL,
  `created` INT(15) NULL,
  `dummy4_iddummy4` INT(15) NULL,
  PRIMARY KEY (`iddummy`),
  INDEX `fk_dummy_dummy41_idx` (`dummy4_iddummy4` ASC),
  CONSTRAINT `fk_dummy_dummy41`
    FOREIGN KEY (`dummy4_iddummy4`)
    REFERENCES `nbonnici`.`dummy4` (`iddummy4`)
    ON DELETE NO ACTION
    ON UPDATE NO ACTION)
ENGINE = InnoDB;",mysql
"
package org.openehealth.ipf.platform.camel.flow.process;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.openehealth.ipf.commons.flow.FlowException;
import org.openehealth.ipf.commons.flow.FlowManager;
import org.openehealth.ipf.commons.flow.ManagedMessage;
import org.openehealth.ipf.platform.camel.flow.PlatformMessage;

public class FlowErrorProcessor extends FlowProcessor {
    private static final Logger LOG = LoggerFactory.getLogger(FlowErrorProcessor.class);
    @Override
    public String toString() {
        return ""FlowErrorProcessor["" + getProcessor() + ""]"";
    }
    
    @Override
    protected void processMessage(PlatformMessage message) {
        try {
            flowManager.invalidateFlow(message);
        } catch (FlowException e) {

            LOG.warn(""invalidate flow operation failed"", e);
        } catch (Exception e) {

            LOG.error(e.getMessage(), e);
        }
    }
}",java
"package domain
import (
	""context""
	""github.com/opencars/toolkit""
)
type VehicleService interface {
	FindByNumber(ctx context.Context, number string) (*Result, error)
	FindByVIN(ctx context.Context, vin string) (*Result, error)
	FindByImage(ctx context.Context, url string) (*Result, error)
}
type Recognizer interface {
	Recognize(ctx context.Context, url string) ([]toolkit.ResultALPR, error)
}
type MessageService interface {
	Create(ctx context.Context, msg *Message) error
}",go
"-- Funkce ST_X() a ST_Y() ze sloupce protorového typu POINT (event.souradnice) získávají příslušnou souřadnici (Y - latitude; X - longitude)
-- Napište níže část SQL dotazu k seřazení záznamů podle souřadnice k získání jednoho _nejZÁPADNĚJŠÍHO_ záznamu
-- Povinně uvádějte způsob řazení podle ASC nebo DESC.
-- příklad: ORDER BY ST_Y(souradnice) DESC LIMIT 0,1",mysql
"


from enum import Enum
__all__ = [
    'CostAllocationPolicyType',
    'CostAllocationResourceType',
    'RuleStatus',
]
class CostAllocationPolicyType(str, Enum):
    """"""
    Method of cost allocation for the rule
    """"""
    FIXED_PROPORTION = ""FixedProportion""
class CostAllocationResourceType(str, Enum):
    """"""
    Type of resources contained in this cost allocation rule
    """"""
    DIMENSION = ""Dimension""
    TAG = ""Tag""
class RuleStatus(str, Enum):
    """"""
    Status of the rule
    """"""
    NOT_ACTIVE = ""NotActive""
    ACTIVE = ""Active""
    PROCESSING = ""Processing""",python
"
package org.springframework.nativex.hint;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface FieldHint {
	
	String name();
	
	boolean allowUnsafeAccess() default false;

}",java
"const webpack = require('webpack')
module.exports = {
    webpack: function (cfg)  {
        cfg.plugins.push(new webpack.DefinePlugin({
            'process.env': {
                'NODE_ENV': JSON.stringify(process.env.NODE_ENV)
            }
        }))
        return cfg
    }
}",javascript
"









using namespace std;
int main() {
	ifstream file;
	while (true) {
	file.open(""test.lang"");
	std::ostringstream out;
	out << file.rdbuf();
	file.close();
	string programText = out.str();
		Tokenizer tokenizer;
		vector<Token> tokens = tokenizer.tokenize(programText);

		for (int i = 0; i < tokens.size(); i++) {
			cout << tokens.at(i).m_type << "" "" << tokens.at(i).m_value << endl;
		}
		Parser parser;
		Statement* statement = parser.parse(tokens);
		statement->execute();
		for (auto it = variables.begin(); it != variables.end(); it++) {

		}
		system(""pause"");
	}
	return 0;
}",cpp
"


TEST(AgradRevErrorHandlingScalar, CheckConsistentSizeVarCheckVectorized) {
  using stan::math::check_consistent_sizes;
  using stan::math::var;
  using std::vector;
  int N = 5;
  const char* function = ""check_consistent_size"";
  vector<var> a;
  vector<var> b;
  for (int i = 0; i < N; ++i) {
    b.push_back(var(i + 1));
    a.push_back(var(i));
  }
  size_t stack_size = stan::math::ChainableStack::var_stack_.size();
  EXPECT_EQ(10U, stack_size);
  EXPECT_NO_THROW(check_consistent_sizes(function, ""a"", a, ""b"", b));
  size_t stack_size_after_call = stan::math::ChainableStack::var_stack_.size();
  EXPECT_EQ(10U, stack_size_after_call);
  stan::math::recover_memory();
}",cpp
"CREATE TABLE [dbo].[Ticket] (
    [TicketId]        INT IDENTITY (1, 1) NOT NULL,
    [UserId]          INT NOT NULL,
    [MovieShowtimeId] INT NOT NULL,
    [SeatId]          INT NULL,
    CONSTRAINT [PK_Ticket] PRIMARY KEY CLUSTERED ([TicketId] ASC),
    CONSTRAINT [FK_Ticket_MovieShowtime] FOREIGN KEY ([MovieShowtimeId]) REFERENCES [dbo].[MovieShowtime] ([MovieShowtimeId]),
    CONSTRAINT [FK_Ticket_User] FOREIGN KEY ([UserId]) REFERENCES [dbo].[User] ([UserId])
);",mysql
"PRAGMA foreign_keys = ON;
DELETE FROM post_history;
DELETE FROM post_categories;
DELETE FROM post_tags;
DELETE FROM category;
DELETE FROM tag;
DELETE FROM post;
DELETE FROM user;",mysql
"module Reports
  class QuarterlyFacilityState < Reports::View
    self.table_name = ""reporting_quarterly_facility_states""
    belongs_to :facility
    def self.materialized?
      true
    end
  end
end",ruby
"import React from ""react""
import ReactDOM from ""react-dom""
import { Router, Route, Switch } from ""react-router-dom""
import { Provider } from ""react-redux""
import store from ""./store""
import history from ""./history""
import Dashboard from ""./components/Dashboard""
import Login from ""./components/Login""
import Logout from ""./components/Logout""
import { PrivateRoute } from ""./components/PrivateRoute""
import ""bootstrap/dist/css/bootstrap.min.css""
import ""./index.css""
ReactDOM.render(
  <Provider store={store}>
    <Router history={history}>
      <Switch>
        <PrivateRoute exact path=""/"" component={Dashboard} />
        <Route path=""/login"" component={Login} />
        {}
      </Switch>
    </Router>
  </Provider>,
  document.getElementById(""root"")
)",javascript
"INSERT INTO public.territorios_dashboard (
       id,
       descricao,
       categoria,
       the_geom
   )
SELECT
  (featureid + 800000000) AS id,
  name AS descricao,
  categoria,
  geom as the_geom
FROM public.tis_tmp ;",mysql
"


@class MetalView;
namespace clove {
	class MetalPresentQueue : public GhaPresentQueue {

	private:
		id<MTLCommandQueue> commandQueue;
		MetalView *view{ nullptr };

	public:
		MetalPresentQueue() = delete;
		MetalPresentQueue(id<MTLCommandQueue> commandQueue, MetalView *view);
		MetalPresentQueue(MetalPresentQueue const &other) = delete;
		MetalPresentQueue(MetalPresentQueue &&other) noexcept;
		MetalPresentQueue &operator=(MetalPresentQueue const &other) = delete;
		MetalPresentQueue &operator=(MetalPresentQueue &&other) noexcept;
		~MetalPresentQueue();
		Result present(PresentInfo const &presentInfo) override;
	};
}",cpp
"module Ravelry






  class Comment
    attr_reader :highlighted_project, :user, :html, :id




    def initialize(data)
      @data = data
      @user = Ravelry::User.new
      @user.data = data[:user]
      @highlighted_project = data[:highlighted_project]      
      @html = data[:html]
      @id = data[:id]
    end
    def replies
      @reply_list ||= []
      return @reply_list if @reply_list.any?
      @data[:replies].map do |reply|
        @reply_list << Ravelry::Comment.new(reply)
      end
    end
  end
end",ruby
"
'use strict';
angular.module('users').directive('userMenuIcon',['Authentication',function(Authentication){
    return {
        restrict : 'E',
        replace : true,
        scope: true,
        templateUrl : '/modules/users/client/views/user-menu-icon.client.view.html',
        link : function(scope, elements, attrs) {

            scope.enablemenu = attrs.enablemenu;
            scope.authentication = Authentication;
        }
    };
}]);",javascript
"

""""""
Created on Thu Nov  8 15:25:03 2018
@author: bathmann
""""""
from .TreeDynamicTimeStepping import TreeDynamicTimeStepping
from .TreeDynamicTimeLoop import TreeDynamicTimeLoop
from .SimpleTimeLoop.SimpleLoop import Loop",python
"

package securibench.micro.collections;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.LinkedList;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import securibench.micro.BasicTestCase;
import securibench.micro.MicroTestCase;

public class Collections12 extends BasicTestCase implements MicroTestCase {
    private static final String FIELD_NAME = ""name"";
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        String s1 = req.getParameter(FIELD_NAME);
        LinkedList c1 = new LinkedList();
        c1.addLast(s1);
        Object[] array = c1.toArray();
        PrintWriter writer = resp.getWriter();  
      	writer.println(array[0]);                    
    }
    public String getDescription() {
        return ""collection copying through an array"";
    }
    public int getVulnerabilityCount() {
        return 1;
    }
}",java
"

const abTroubleshoot = require(""./troubleshooting"");
const result = abTroubleshoot();
if(result === 2) {
	console.log(""Congrats! You got the correct answer"");
} else if(typeof result === 'number') {
	console.log(`You returned the number ${result}, the result should be the number 2`);
} else {
	console.log(`You returned string ""${result}"", the result should be the number 2`);
}",javascript
"package ru.stqa.pft.sandbox;
public class Rectangle {
    public double a;
    public double b;
    public Rectangle(double a, double b) {
        this.a = a;
        this.b = b;
    }
    public double area() {
        return this.a * this.b;
    }
}",java
"package org.digitalcrafting.theOne.service.users.dataaccess.discovery;
import lombok.Data;
@Data
public class DiscoveryRegisterServiceRequest {
    private String serviceName;
    private String serviceIp;
    private String servicePort;
}",java
"import React from 'react';
import pure from 'recompose/pure';
import SvgIcon from '../../SvgIcon';
let AvArtTrack = (props) => (
  <SvgIcon {...props}>
    <path d=""M22 13h-8v-2h8v2zm0-6h-8v2h8V7zm-8 10h8v-2h-8v2zm-2-8v6c0 1.1-.9 2-2 2H4c-1.1 0-2-.9-2-2V9c0-1.1.9-2 2-2h6c1.1 0 2 .9 2 2zm-1.5 6l-2.25-3-1.75 2.26-1.25-1.51L3.5 15h7z""/>
  </SvgIcon>
);
AvArtTrack = pure(AvArtTrack);
AvArtTrack.displayName = 'AvArtTrack';
AvArtTrack.muiName = 'SvgIcon';
export default AvArtTrack;",javascript
"package xyz.malkki.yeeja.connection.commands;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.List;
import java.util.function.Function;
public class AdjustBright extends YeelightCommand<Void> {
    private int percentage;
    private int duration;
    public AdjustBright(int percentage, int duration) {
        this.percentage = percentage;
        this.duration = duration;
    }
    @NotNull
    @Override
    public String getMethod() {
        return ""adjust_bright"";
    }
    @NotNull
    @Override
    public Object[] getParams() {
        return new Object[] { percentage, duration };
    }
    @NotNull
    @Override
    public Function<List<Object>, Void> responseParser() {
        return response -> null;
    }
}",java
"def fact (n):
    if n == 1:
        return 1
    else:
        return n*fact(n-1)
print(fact(5))",python
"""use strict"";








const myoffset = 0
var inoffset = 0
const pglimit = 500
const detail = 'full'
const Cpapi = require('../class/cpapi')
const path = require('path');
const scriptname = path.basename(__filename);
module.exports = async (cpSession, mycmd, mydata) => {
	try {
		var myres = []
		var myarr = {}
		var myobj = []
		const myApi = new Cpapi(cpSession)
		if (mydata) {
			myApi.setData(mydata)
		}
		myApi.setCnt(myoffset, pglimit)
		myApi.setDetail(detail)
		myApi.setCmd(mycmd)
		myarr = await myApi.apiPost()
		myobj = myobj.concat(myarr)
		if (myarr.total > myarr.to) {

			while (myarr.total >= inoffset) {
				console.log('From ' + myarr.from + ' to ' + myarr.to + ' of ' + myarr.total + ' indexed')
				inoffset = Number(myarr.to)
				myApi.setCnt(inoffset, pglimit)
				myarr = await myApi.apiPost()

				myobj = myobj.concat(myarr)
			}
			return await myobj
		} else {
		return await myobj
		}
	} catch (error) {

		return
	}
}",javascript
"require File.expand_path('../boot', __FILE__)
require ""active_model/railtie""
require ""active_record/railtie""
require ""action_controller/railtie""
require ""action_view/railtie""
require ""action_mailer/railtie""
Bundler.require
require ""asset_hash""
module Dummy
  class Application < Rails::Application



















    config.encoding = ""utf-8""

    config.filter_parameters += [:password]
  end
end",ruby
"





package com.dnb.services.industry;
import javax.xml.bind.annotation.XmlEnum;
import javax.xml.bind.annotation.XmlEnumValue;
import javax.xml.bind.annotation.XmlType;

@XmlType(name = ""SeverityType"")
@XmlEnum
public enum SeverityType {
    @XmlEnumValue(""Error"")
    ERROR(""Error""),
    @XmlEnumValue(""Fatal"")
    FATAL(""Fatal""),
    @XmlEnumValue(""Information"")
    INFORMATION(""Information""),
    @XmlEnumValue(""Warning"")
    WARNING(""Warning"");
    private final String value;
    SeverityType(String v) {
        value = v;
    }
    public String value() {
        return value;
    }
    public static SeverityType fromValue(String v) {
        for (SeverityType c: SeverityType.values()) {
            if (c.value.equals(v)) {
                return c;
            }
        }
        throw new IllegalArgumentException(v);
    }
}",java
"
package version
import (
	""fmt""
)



var (
	CCVersion       = ""17.03.28""
	CCTag           = ""2017-03-28 Release""
	CCBRANCH        = """"
	CCBuildTime     = ""2017-03-28 19:50:00""
	CCGitHash       = ""unknown""
	CCRunMode       = ""product"" // product, test, dev
	CCDistro        = ""enterprise""
	CCDistroVersion = ""9999.9999.9999""
)

var (
	CCRunModeProduct = ""product""
	CCRunModeTest    = ""test""
	CCRunModeDev     = ""dev""
)

func ShowVersion() {
	fmt.Printf(""%s"", GetVersion())
}

func GetVersion() string {
	version := fmt.Sprintf(`Version  : %s
Tag      : %s
Branch   : %s
BuildTime: %s
GitHash  : %s
RunMode  : %s
`, CCVersion, CCTag, CCBRANCH, CCBuildTime, CCGitHash, CCRunMode)
	return version
}",go
"window.onload=function(){
    id=$(""#id"").html();
    $(""#agree"").click(function(){
        window.location.href=""/index.php/Index/sx/sx_hkHandle?id="" + id + ""&option=1""
    })
    $(""#disagree"").click(function(){
        window.location.href=""/index.php/Index/sx/sx_hkHandle?id="" + id + ""&option=0""
    })
}",javascript
"module.exports = {
  rules: [
    {
      test: /\.(le|c)ss$/,
      use: [
        'style-loader',
        'css-loader',
        'postcss-loader',
        'less-loader'
      ]
    }
  ]
};",javascript
"
""""""


 This script initializes the plugin, making it known to QGIS.
""""""
__version__ = ""0.4.0""

def classFactory(iface):  # pylint: disable=invalid-name
    """"""Load SimplePhotogrammetryRoutePlanner class from file SimplePhotogrammetryRoutePlanner.
    :param iface: A QGIS interface instance.
    :type iface: QgsInterface
    """"""

    from .SimplePhotogrammetryRoutePlanner import SimplePhotogrammetryRoutePlanner
    return SimplePhotogrammetryRoutePlanner(iface)",python
"
define(['Modernizr', 'createElement'], function( Modernizr, createElement ) {

  Modernizr.addTest('dataset', function() {
    var n = createElement(""div"");
    n.setAttribute(""data-a-b"", ""c"");
    return !!(n.dataset && n.dataset.aB === ""c"");
  });
});",javascript
"from reports import suite as reports_suite
from orders import suite as orders_suite",python
"




ONEFLOW_API_PYBIND11_MODULE(""eager.multi_client"", m) {
  using namespace oneflow;
  namespace py = pybind11;
  m.def(
      ""Sync"", []() { vm::ClusterSync().GetOrThrow(); }, py::call_guard<py::gil_scoped_release>());
  py::class_<one::DevVmDepObjectConsumeModeGuard,
             std::shared_ptr<one::DevVmDepObjectConsumeModeGuard>>(
      m, ""DevVmDepObjectConsumeModeGuard"");
  m.def(""SourceOpOnlyResourceDependenceModeGuard"", []() {
    return std::make_shared<one::DevVmDepObjectConsumeModeGuard>(
        one::DevVmDepObjectConsumeMode::NONE);
  });
}",cpp
"




namespace RED4ext
{
namespace game::data { 
struct LifePath_Record : game::data::TweakDBRecord
{
    static constexpr const char* NAME = ""gamedataLifePath_Record"";
    static constexpr const char* ALIAS = ""LifePath_Record"";
    uint8_t unk48[0x60 - 0x48]; // 48
};
RED4EXT_ASSERT_SIZE(LifePath_Record, 0x60);
} // namespace game::data
using LifePath_Record = game::data::LifePath_Record;
} // namespace RED4ext",cpp
"
namespace geohash {

const char Base32::kInvalid_ = std::numeric_limits<char>::max();

const std::array<char, 32> Base32::encode_ =
    std::array<char, 32>({'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'b',
                          'c', 'd', 'e', 'f', 'g', 'h', 'j', 'k', 'm', 'n', 'p',
                          'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'});
}  // namespace geohash",cpp
"package com.example.application.knowledge;
import java.util.Arrays;
import java.util.List;
import org.hibernate.integrator.spi.Integrator;
import org.hibernate.jpa.boot.spi.IntegratorProvider;
public class CustomIntegratorProvider implements IntegratorProvider  {
    @Override
    public List<Integrator> getIntegrators() {
        return Arrays.asList(new CustomEventListenerIntegrator());
    }
}",java
"public static double[][] dissim(int nrow, int ncol, double[] mass, double[][] A) {
        double[][] Adiss = new double[nrow][nrow];
        for (int i1 = 0; i1 < nrow; i1++) {
            for (int i2 = 0; i2 < nrow; i2++) {
                Adiss[i1][i2] = 0.0;
            }
        }
        for (int i1 = 0; i1 < nrow; i1++) {
            for (int i2 = 0; i2 < i1; i2++) {
                for (int j = 0; j < ncol; j++) {
                    Adiss[i1][i2] += 0.5 * Math.pow(A[i1][j] - A[i2][j], 2.0);
                }
                Adiss[i2][i1] = Adiss[i1][i2];
            }
        }
        return Adiss;
    }",java
"













using namespace std;
int main()
{
  int n;
  string s;
  scr(s);
  n= s.size();
  vector<int> v(n,0);

  int k=n;
  for(int i=n-1;i>=0;i--)
  {
    if(s[i]=='>' && k>(i+1)) {v[i] = k;k--;}
  }
  int boo = 0;

  for(int i=n-1;i>=0;i--)
  {
    if(s[i]=='<'&& k<(i+1)) {v[i] = k;k--;}
    else if(s[i]=='<') {boo = 1;break;}
  }

  for(int i=0;i<n;i++) if(v[i]==0) boo = 1;
  if(boo) cout<<""Impossible""<<endl;
  else 
  {
    cout<<""Possible\n"";
    for(int i=0;i<v.size();i++) cout<<v[i]<<"" "";cout<<endl;
  }
  return 0;
}",cpp
"package dtos;
import lombok.Data;
@Data
public class SellersDto {
    private Long id;
    private String title;
    private String country_code;
}",java
"






















from google.cloud import vmmigration_v1
async def sample_create_utilization_report():

    client = vmmigration_v1.VmMigrationAsyncClient()

    request = vmmigration_v1.CreateUtilizationReportRequest(
        parent=""parent_value"",
        utilization_report_id=""utilization_report_id_value"",
    )

    operation = client.create_utilization_report(request=request)
    print(""Waiting for operation to complete..."")
    response = await operation.result()

    print(response)
",python
"import unittest
from repeater import repeater
def test_repeater(benchmark):
    assert benchmark(repeater,'a',5) == 'aaaaa'
    assert benchmark(repeater,'Wub', 6 ) == 'Wub Wub Wub Wub Wub Wub '",python
"




namespace ewn
{
	BaseApplication::~BaseApplication() = default;
	bool BaseApplication::Run()
	{
		for (const auto& reactorPtr : m_reactors)
		{
			reactorPtr->Poll([&](bool outgoing, std::size_t clientId, Nz::UInt32 data) { HandlePeerConnection(outgoing, clientId, data); },
			                 [&](std::size_t clientId, Nz::UInt32 data) { HandlePeerDisconnection(clientId, data); },
			                 [&](std::size_t clientId, Nz::NetPacket&& packet) { HandlePeerPacket(clientId, std::move(packet)); });
		}
		return Application::Run();
	}
	void BaseApplication::SetupNetwork(std::size_t peerPerReactor, const Nz::IpAddress& ipAddress)
	{
		m_peerPerReactor = peerPerReactor;
		m_reactors.emplace_back(std::make_unique<NetworkReactor>(0, ipAddress, peerPerReactor));
	}
	void BaseApplication::OnConfigLoaded(const ConfigFile& )
	{
	}
	Nz::Clock BaseApplication::s_appClock;
}",cpp
"package org.ds.algos.practice.ds.algos.sorting;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
class MergeSortTest {
    MergeSort mergeSort;
    public MergeSortTest() {
        mergeSort = new MergeSort();
    }
    @Test
    void shouldSortAnUnsortedArray() {
        int[] arr = {1,5,8,1,9};
        int[] sortedArray = {1,1,5,8,9};
        assertArrayEquals(sortedArray, mergeSort.sort(arr));
    }
    @Test
    void shouldSortAnAlreadtSortedArray() {
        int[] sortedArray = {1,1,5,8,9};
        assertArrayEquals(sortedArray, mergeSort.sort(sortedArray));
    }
    @Test
    void shouldHandleEmptyArrayWithoutError() {
        int[] sortedArray = {};
        assertArrayEquals(sortedArray, mergeSort.sort(sortedArray));
    }
    @Test
    void shouldThrowExceptionForNullArray() {
        assertThrows(IllegalArgumentException.class, () -> mergeSort.sort(null));
    }
}",java
"
from django.db import migrations, models
class Migration(migrations.Migration):
    dependencies = [
        ('vespawatch', '0052_auto_20210824_1131'),
    ]
    operations = [
        migrations.AddField(
            model_name='managementaction',
            name='result',
            field=models.CharField(choices=[('ST', 'Successfully treated'), ('UT', 'Unsuccessfully treated'), ('UN', 'Untreated'), ('UK', 'UK')], default='UK', max_length=3, verbose_name='Result'),
        ),
    ]",python
"




























package objabi

type SymKind uint8





const (

	Sxxx SymKind = iota

	STEXT

	SRODATA

	SNOPTRDATA

	SDATA

	SBSS

	SNOPTRBSS

	STLSBSS

	SDWARFINFO
	SDWARFRANGE
	SDWARFLOC
	SDWARFLINES






	SABIALIAS

)",go
"




namespace NetworKit {

class KPathCentrality: public Centrality {
public:
    
    count k;
    
    double alpha;
    
    KPathCentrality(const Graph& G, double alpha=0.2, count k=0);
    
    void run() override;
};
} 
",cpp
"from django.urls import path
from .views import audit_view
urlpatterns = [
    path('', audit_view, name=""audit"")
]",python
"package utils
import (
	""fmt""
	""os""
	""os/exec""
	""strings""
	""go.uber.org/zap""
)
type CmdExecutor struct {
	log *zap.SugaredLogger
}
func NewExecutor(log *zap.SugaredLogger) *CmdExecutor {
	return &CmdExecutor{
		log: log,
	}
}
func (c *CmdExecutor) ExecuteCommandWithOutput(command string, env []string, arg ...string) (string, error) {
	commandWithPath, err := exec.LookPath(command)
	if err != nil {
		return fmt.Sprintf(""unable to find command:%s in path"", command), err
	}
	c.log.Infow(""running command"", ""command"", commandWithPath, ""args"", strings.Join(arg, "" ""))
	cmd := exec.Command(commandWithPath, arg...)
	cmd.Env = os.Environ()
	cmd.Env = append(cmd.Env, env...)
	return runCommandWithOutput(cmd, true)
}
func runCommandWithOutput(cmd *exec.Cmd, combinedOutput bool) (string, error) {
	var output []byte
	var err error
	if combinedOutput {
		output, err = cmd.CombinedOutput()
	} else {
		output, err = cmd.Output()
	}
	out := strings.TrimSpace(string(output))
	return out, err
}",go
"module HasEnum
  def self.included(base)
    base.extend(ClassMethods)
  end
  module ClassMethods
    def has_enum(name, options={})
      options.symbolize_keys!
      options.assert_valid_keys(:column, :identifiers, :attributes)
      field_attr_name = ""#{name}_column""
      class_inheritable_accessor field_attr_name.to_sym
      column_name = options[:column] || ""#{name}_map""
      self.send(""#{field_attr_name}="".to_sym, column_name)
      identifiers = options[:identifiers] || []
      attributes = options[:attributes] || []
      enum_class = Class.new(PackedEnum) do
        class_eval <<-EOF
          def initialize(value=nil)
            super(#{identifiers.inspect}, #{attributes.inspect}, value)
          end
        EOF
      end
      enum_class_name = name.to_s.classify
      const_set(enum_class_name, enum_class)
      composed_of name.to_sym, :class_name => ""#{self.class_name}::#{enum_class_name}"", :mapping => [column_name, ""value""]
    end
  end
end",ruby
"





namespace ssvu
{
namespace MPL
{
namespace Impl
{
template <typename, typename>
struct ReverseHlpr;
template <typename T, typename... Ts, typename TR>
struct ReverseHlpr<List<T, Ts...>, TR>
{
    using Type = typename ReverseHlpr<List<Ts...>,
        typename TR::template PushFront<T>>::Type;
};
template <typename TR>
struct ReverseHlpr<List<>, TR>
{
    using Type = TR;
};
template <typename... Ts>
using Reverse = typename ReverseHlpr<List<Ts...>, List<>>::Type;
} // namespace Impl
} // namespace MPL
} // namespace ssvu
",cpp
"package com.showka.entity;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import lombok.Getter;
import lombok.Setter;

@Entity
@Table(name = ""c_uriage"")
@Getter
@Setter
public class CUriage extends EntityBase implements Serializable {
	
	private static final long serialVersionUID = 1l;
	
	@Id
	@Column(name = ""uriage_id"", nullable = false, length = 255)
	private String uriageId;
	
	@ManyToOne(fetch = FetchType.EAGER)
	@JoinColumn(name = ""uriage_id"", referencedColumnName = ""record_id"", insertable = false, updatable = false)
	private TUriage uriage;
}",java
"package com.salesmanager.web.entity.catalog.product.attribute;
import java.io.Serializable;
import java.util.List;
public class PersistableProductOptionValue extends ProductOptionValueEntity
		implements Serializable {
	
	private static final long serialVersionUID = 1L;
	private List<ProductOptionValueDescription> descriptions;
	public void setDescriptions(List<ProductOptionValueDescription> descriptions) {
		this.descriptions = descriptions;
	}
	public List<ProductOptionValueDescription> getDescriptions() {
		return descriptions;
	}
}",java
"






namespace ngraph {
namespace op {
class TRANSFORMATIONS_API ScaleShiftIE : public Op {
public:
    static constexpr NodeTypeInfo type_info{""ScaleShiftIE"", 1};
    const NodeTypeInfo& get_type_info() const override { return type_info; }
    ScaleShiftIE(const Output<Node>& data_batch,
                 const Output<Node>& weights,
                 const Output<Node>& bias);
    void validate_and_infer_types() override;
    std::shared_ptr<Node> clone_with_new_inputs(const OutputVector& new_args) const override;
};
}  // namespace op
}  // namespace ngraph",cpp
"CREATE DATABASE IF NOT EXISTS testdb ;
USE testdb;
DROP TABLE IF EXISTS sign_product;
CREATE TABLE sign_product (
    id         BIGINT PRIMARY KEY      NOT NULL AUTO_INCREMENT,
    code       VARCHAR(32) DEFAULT ''  NOT NULL,
    full_name  VARCHAR(128) DEFAULT '' NOT NULL,
    inventory  INT DEFAULT 0           NOT NULL,
    gmt_create TIMESTAMP                        DEFAULT current_timestamp,
    gmt_update TIMESTAMP                        DEFAULT current_timestamp
    ON UPDATE current_timestamp
)
    ENGINE = InnoDB
    DEFAULT CHARSET = utf8mb4;
INSERT INTO sign_product  (code, full_name, inventory) VALUES ('893341', '远见产品3号', 12);
INSERT INTO sign_product  (code, full_name, inventory) VALUES ('213324', '这是测试产品', 543);
INSERT INTO sign_product  (code, full_name, inventory) VALUES ('123873', '正式环境产品53', 76);
INSERT INTO sign_product  (code, full_name, inventory) VALUES ('678567', '招商银行限量', 9765);",mysql
"from numpy import *
import numpy as np


def detrending_coeff(win_len , order):


	n = (win_len-1)/2
	A = mat(ones((win_len,order+1)))
	x = np.arange(-n , n+1)
	for j in range(0 , order + 1):
		A[:,j] = mat(x ** j).T
	coeff_output = (A.T * A).I * A.T
	return coeff_output , A


",python
"export const timer16F = ""M10 1H6V0h4zm3.998 4.405a7.018 7.018 0 1 1-2.403-2.403l1.884-1.884 2.403 2.403zM3 9H2v1h1zm5 5H7v1h1zm3-5H8V5H7v5h4z"";",javascript
"'use strict'
const { Model } = require('../../class')
const { query } = require('../mysql')
class AdminLogModel extends Model {
  constructor() {
    super('admin_log')
  }
  create({ userId = 0, url = '', params = '' }) {
    const post = [userId, url, params]
    const sql = `
      insert into \`${this.tableName}\`
        (user_id, url, params)
      values
        (?, ?, ?)
    `
    return query(sql, post)
  }
  getList({ startId = 0, pageSize = 10 }) {
    const post = [startId, pageSize]
    const sql = `
      select
        id,
        user_id,
        url,
        params,
        create_at
      from ${this.tableName}
      where
        id >= ?
        and is_valid = 1
      order by id desc
      limit ? offset 0
    `
    return query(sql, post)
  }
}
module.exports = new AdminLogModel()",javascript
"




namespace daal
{
namespace algorithms
{
namespace decision_forest
{
namespace classification
{
namespace training
{
namespace interface2
{
template class BatchContainer<DAAL_FPTYPE, defaultDense, DAAL_CPU>;
}
namespace internal
{
template class ClassificationTrainBatchKernel<DAAL_FPTYPE, defaultDense, DAAL_CPU>;
}
} // namespace training
} // namespace classification
} // namespace decision_forest
} // namespace algorithms
} // namespace daal",cpp
"from django.contrib.auth.models import User
from rest_framework.test import APITestCase
class FVHAPITestCase(APITestCase):
    def assert_dict_contains(self, superset, subset, path=''):
        for key, expected in subset.items():
            full_path = path + key
            received = superset.get(key, None)
            if isinstance(expected, dict) and isinstance(received, dict):
                self.assert_dict_contains(superset[key], expected, full_path + '.')
            else:
                assert received == expected, 'Value mismatch for key {}: {} != {}'.format(
                    full_path, expected, received
                )
    def create_user(self):
        return User.objects.create(
                username='courier', first_name='Coranne', last_name='Courier', email='coranne@couriersrus.com')
    def create_and_login_user(self):
        user = self.create_user()
        self.client.force_login(user)
        return user",python
"require File.dirname(__FILE__) + '/../test_helper'
class PermissionTest < ActiveSupport::TestCase

    def test_truth
        assert true
    end
end",ruby
"

def example1():
    """"""Slice operator.
    seq[::stride]         # [seq[0],   seq[stride],     ..., seq[-1]    ]
    seq[low::stride]      # [seq[low], seq[low+stride], ..., seq[-1]    ]
    seq[:high:stride]     # [seq[0],   seq[stride],     ..., seq[high-1]]
    seq[low:high:stride]  # [seq[low], seq[low+stride], ..., seq[high-1]]
    """"""
    l = list(""01234567"")
    assert l[::2] == list(""0246"")  # 从 index(0) 开始, 隔2个取一个
    assert l[1::2] == list(""1357"")  # 从 index(1) 开始, 隔2个取一个
    assert l[:4:2] == list(""02"")  # 从头开始到 index(4-1) 为止，隔2个取一个
    assert l[2:6:2] == list(""24"")  # 从index(2)开始到index(6-1)为止，隔2个取一个
example1()
def example2():
    """"""Reversed slice operator
    """"""
    l = list(""01234567"")
    assert l[::-1] == list(""76543210"")  # 从最后一个开始，逆序排列
    assert l[::-2] == list(""7531"")  # 从最后一个开始，隔2个取一个
    assert l[-2::-2] == list(""6420"")  # 从-2开始，隔2个取一个
    assert l[:3:-2] == list(""75"")  # 从最后开始，到3为止，隔2个取一个
example2()",python
"







namespace mapnik
{
struct MAPNIK_DECL polygon_symbolizer : public symbolizer_base
{
    polygon_symbolizer();
    explicit polygon_symbolizer(color const& fill);
    color const& get_fill() const;
    void set_fill(color const& fill);
    void set_opacity(double opacity);
    double get_opacity() const;
    void set_gamma(double gamma);
    double get_gamma() const;
    void set_gamma_method(gamma_method_e gamma_method);
    gamma_method_e get_gamma_method() const;
private:
    color fill_;
    double opacity_;
    double gamma_;
    gamma_method_e gamma_method_;
};
}
",cpp
"-- phpMyAdmin SQL Dump
-- version 4.6.5.2
-- https://www.phpmyadmin.net/
--
-- Servidor: 127.0.0.1
-- Tiempo de generación: 08-11-2017 a las 23:42:52
-- Versión del servidor: 10.1.21-MariaDB
-- Versión de PHP: 5.6.30
SET SQL_MODE = ""NO_AUTO_VALUE_ON_ZERO"";
SET time_zone = ""+00:00"";
;
;
;
;
--
-- Base de datos: `cartilla_educacion`
--
-- --------------------------------------------------------
--
-- Estructura de tabla para la tabla `Datos personales`
--
CREATE TABLE `datos personales` (
  `pri_ape` varchar(24) NOT NULL,
  `seg_ape` varchar(24) NOT NULL,
  `nom` varchar(35) NOT NULL,
  `curp` varchar(18) NOT NULL,
  `grup` varchar(10) NOT NULL,
  `turno` varchar(15) NOT NULL,
  `nom_esc` varchar(60) NOT NULL,
  `cct` varchar(10) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
;
;
;",mysql
"import numpy as np
import random
import matplotlib.pyplot as plt
points=np.loadtxt('points.txt')
herring_r = np.loadtxt('distribution.txt')
herring=np.zeros((802,350))
for i in range(350):
    for j in range(802):
        herring[j,349-i]=herring_r[i,j]















s=0
for i in range(802):
    for j in range(350):
        if herring[i,j]>0:
            s+=herring[i,j]
print(s)",python
"
require ""test_helper""
module ThreeLittlePigs
  class StoryTest < Minitest::Test
    attr_reader :chapters
    def test_tells_the_whole_story



      suppress_output { Story.tell }
    end
  end
end",ruby
"package medal
import (
	""go-common/app/job/main/usersuit/conf""
	""go-common/app/service/main/usersuit/rpc/client""
	""go-common/library/cache/memcache""
	""go-common/library/database/sql""
	bm ""go-common/library/net/http/blademaster""
)
var (
	_updateinfo = ""/mingpai/api/updateinfo/%s""
)

type Dao struct {
	db         *sql.DB
	c          *conf.Config
	client     *bm.Client
	suitRPC    *client.Service2
	updateInfo string

	mc *memcache.Pool
}

func New(c *conf.Config) (d *Dao) {
	d = &Dao{
		c:          c,
		db:         sql.NewMySQL(c.Mysql),
		client:     bm.NewClient(c.HTTPClient),
		updateInfo: c.Properties.UpInfoURL + _updateinfo,
		suitRPC:    client.New(c.SuitRPC),

		mc: memcache.NewPool(c.Memcache.Config),
	}
	return
}

func (d *Dao) Close() {
	if d.db != nil {
		d.db.Close()
	}
}",go
"
package org.springframework.format;
import org.springframework.core.convert.converter.ConverterRegistry;
import java.lang.annotation.Annotation;

public interface FormatterRegistry extends ConverterRegistry {
	
	void addFormatter(Formatter<?> formatter);
	
	void addFormatterForFieldType(Class<?> fieldType, Formatter<?> formatter);
	
	void addFormatterForFieldType(Class<?> fieldType, Printer<?> printer, Parser<?> parser);
	
	void addFormatterForFieldAnnotation(AnnotationFormatterFactory<? extends Annotation> annotationFormatterFactory);
}",java
"

int WINAPI WinMain(HINSTANCE instance, HINSTANCE prev, LPSTR args, int cmd)
{
    Gui display(""Visualiser: Press 'O' to open PPM file"");
    App app;
    app.setupOpenCL();
    app.setupMask();
    display.onInput([&](int key, int state) {
        if (key == GLFW_KEY_DOWN && state == GLFW_PRESS)
            app.updateRadius(-1);
        if (key == GLFW_KEY_UP && state == GLFW_PRESS) 
            app.updateRadius(1);
        if (key == GLFW_KEY_1 && state == GLFW_PRESS)
            app.showSource();
        if (key == GLFW_KEY_2 && state == GLFW_PRESS)
            app.showSecondPass();
        if (key == GLFW_KEY_3 && state == GLFW_PRESS)
            app.showFinalResult();
        if (key == GLFW_KEY_O && state == GLFW_PRESS)
            app.updateFile();
    });
    display.onPaint([&]() {
        auto title = app.toString();
        app.updateTexture();
        if (app.hasImage())
        {
            display.title(title);
            display.quad(1.0);
        }
    });
}",cpp
"module TD::Types










  class InputIdentityDocument < Base
    attribute :number, TD::Types::String
    attribute :expiry_date, TD::Types::Date
    attribute :front_side, TD::Types::InputFile
    attribute :reverse_side, TD::Types::InputFile
    attribute :selfie, TD::Types::InputFile
    attribute :translation, TD::Types::Array.of(TD::Types::InputFile)
  end
end",ruby
"require_relative ""text_part""
require ""json""
module VoiceBase
  module Request
    class HashPart < TextPart
      def initialize(name:, hash:)
        @name = name
        @body = ::JSON.dump(hash)
      end
    end
  end
end",ruby
"--
-- Regression Tests for Custom Plan APIs
--
-- construction of test data
CREATE TABLE t1 (
    a   int,
	b	double precision
);
INSERT INTO t1 SELECT generate_series(1,3), 2.3;
INSERT INTO t1 SELECT generate_series(1,3), 3.3;
INSERT INTO t1 SELECT generate_series(1,3), 4.3;
VACUUM ANALYZE t1;
create extension vectorize_engine;
SET enable_vectorize_engine TO on;
SELECT * FROM t1;
SELECT b FROM t1;
SELECT b+1 FROM t1;
SELECT count(b) FROM t1;
SELECT a, sum(b), avg(b)  FROM t1 group by a;
SELECT a, sum(b), avg(b)  FROM t1 where a < 3 group by a;
drop extension vectorize_engine;",mysql
"package me.pzheng.conn;
import android.graphics.drawable.Drawable;

public class NavigationItem {
    private String mText;
    private Drawable mDrawable;
    public NavigationItem(String text, Drawable drawable) {
        mText = text;
        mDrawable = drawable;
    }
    public String getText() {
        return mText;
    }
    public void setText(String text) {
        mText = text;
    }
    public Drawable getDrawable() {
        return mDrawable;
    }
    public void setDrawable(Drawable drawable) {
        mDrawable = drawable;
    }
}",java
"DROP DATABASE IF EXISTS employee_db;
CREATE DATABASE employee_db;
USE employee_db;
CREATE TABLE department (
	id INT NOT NULL AUTO_INCREMENT,
    name VARCHAR(30),
    PRIMARY KEY (id)
);
CREATE TABLE role (
	id INT NOT NULL AUTO_INCREMENT,
    title VARCHAR(30),
    salary DECIMAL(10,2),
    department_id INT,
    PRIMARY KEY (id)
);
CREATE TABLE employee (
	id INT NOT NULL AUTO_INCREMENT,
    first_name VARCHAR(30),
    last_name VARCHAR(30),
    role_id INT NOT NULL,
    manager_id INT,
    PRIMARY KEY (id)
);",mysql
"
function sumSquares(array) {
  return array.map((n) => n ** 2).reduce((acc, curr) => acc + curr);


}",javascript
"class Attraction < ActiveRecord::Base
    belongs_to :user
end",ruby
"SELECT COUNT(*)
FROM site AS s,
     so_user AS u1,
     tag AS t1,
     tag_question AS tq1,
     question AS q1,
     badge AS b1,
     account AS acc
WHERE s.site_id = u1.site_id
  AND s.site_id = b1.site_id
  AND s.site_id = t1.site_id
  AND s.site_id = tq1.site_id
  AND s.site_id = q1.site_id
  AND t1.id = tq1.tag_id
  AND q1.id = tq1.question_id
  AND q1.owner_user_id = u1.id
  AND acc.id = u1.account_id
  AND b1.user_id = u1.id
  AND (q1.view_count >= 100)
  AND (q1.view_count <= 100000)
  AND s.site_name = 'stackoverflow'
  AND (t1.name in ('android-linearlayout',
                   'c#',
                   'constants',
                   'deprecated',
                   'ecmascript-5',
                   'google-docs',
                   'google-glass',
                   'less',
                   'operators',
                   'release-management',
                   'windows-10-mobile',
                   'yii2-advanced-app'))
  AND (LOWER(acc.website_url) LIKE ('%in'))",mysql
"export default async function fetchLocations({ url, parser }) {
  const response = await fetch(url);
  const data = await response.json();
  return parser(data);
}",javascript
"import React from 'react'
import Icon from 'react-icon-base'
const GoColorMode = props => (
    <Icon viewBox=""0 0 40 40"" {...props}>
        <g><path d=""m5 5v30h30v-30h-30z m2.5 27.5v-25h25l-25 25z""/></g>
    </Icon>
)
export default GoColorMode",javascript
"
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for api_properties
-- ----------------------------
DROP TABLE IF EXISTS `api_properties`;
CREATE TABLE `api_properties`  (
  `id` bigint(0) NOT NULL AUTO_INCREMENT,
  `gmt_create` datetime(0) NOT NULL,
  `gmt_modified` datetime(0) NOT NULL,
  `channel_id` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL,
  `properties` varchar(10240) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `properties_id` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL,
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE INDEX `UK2g89p4h9vr0x67lf7ckvedttx`(`channel_id`, `properties_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;
SET FOREIGN_KEY_CHECKS = 1;",mysql
"module WorkForwardNola
  module Views

    class Layout < Mustache
      def title
        @title || 'Work Forward Anchorage'
      end
    end
  end
end",ruby
"package main
import ""fmt""
func main_13() {
	x := 4
	y := mySqrt(x)
	fmt.Printf(""x:%d y:%d"", x, y)
	x = 5
	y = mySqrt(x)
	fmt.Printf(""x:%d y:%d"", x, y)
	x = 100
	y = mySqrt(x)
	fmt.Printf(""x:%d y:%d"", x, y)
}
func mySqrtFail(x int) int {
	if x <= 0 {
		return 0
	}
	precision := 1
	ret := x / 2
	for {
		if ret*ret > x {
			ret = ret / 2
		} else {
			if (x - ret*ret) <= precision {
				break
			}
			ret++
		}
	}
	return ret
}
func mySqrt(x int) int {
	if x == 0 {
		return 0
	}
	approx := 0.5 * float64(x)
	for i := 0; i < 20; i++ {
		betterapprox := 0.5 * float64(approx+float64(x)/approx)
		approx = betterapprox
	}
	return int(approx)
}",go
"IF OBJECT_ID('dbo.PG_Replace_Pattern') IS NOT NULL
	DROP FUNCTION dbo.PG_Replace_Pattern
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
-- =============================================
-- Author:		e-pavlichenko
-- CREATE date: 31.05.2018
-- Alter date:	31.05.2018
-- Description:	Замена выражений LIKE на атомы регулярных выражений
-- =============================================
CREATE FUNCTION dbo.PG_Replace_Pattern
(
	@string VARCHAR(500)
)
RETURNS VARCHAR(500)
AS
BEGIN 
	SET @string = REPLACE(@string, '[_]', '\_')
	RETURN @string
END
GO",mysql
"package _0001
func twoSum(nums []int, target int) []int {
	aMap := make(map[int]int, len(nums))
	for index, value := range nums {
		y := target - value
		if v, ok := aMap[y]; ok == true {
			return []int{v, index}
		}
		aMap[value] = index
	}
	return []int{}
}",go
"package main
import (
    ""fmt""
    ""github.com/AllenDang/simhash""
)
func main() {
    s1 := ""Golang - mapping an variable length array to a string""
    s2 := ""Golang - mapping an variable length array to a struct""
    likeness := simhash.GetLikenessValue(s1, s2)
    fmt.Println(""Likeness:"", likeness)
}",go
"
create table board(
num int not null auto_increment,
id varchar(20)not null,
name varchar(20)not null,
subject varchar(100)not null,
content text not null,
regist_day varchar(30)not null,
hit int,
ip varchar(30),
primary key(num)
)default charset=UTF8;

select*from board

desc board

drop table board
select name from member where id = 1
select name from member where id=1
id,name,subject,content,regist_day,hit,ip",mysql
"import React, { useReducer } from ""react"";
export default (reducer, actions, defaultValue) => {
  const Context = React.createContext();
  const Provider = ({ children }) => {
    const [state, dispatch] = useReducer(reducer, defaultValue);
    const boundActions = {};
    for (let key in actions) {
      boundActions[key] = actions[key](dispatch);
    }
    return (
      <Context.Provider value={{ state, ...boundActions }}>
        {children}
      </Context.Provider>
    );
  };
  return { Context, Provider };
};",javascript
"

using namespace std; 

void swap(int* a, int* b) 
{ 
	int t = *a; 
	*a = *b; 
	*b = t; 
} 

int partition (int arr[], int low, int high) 
{ 
	int pivot = arr[high]; // pivot 
	int i = (low - 1); // Index of smaller element 
	for (int j = low; j <= high - 1; j++) 
	{ 

		if (arr[j] < pivot) 
		{ 
			i++; // increment index of smaller element 
			swap(&arr[i], &arr[j]); 
		} 
	} 
	swap(&arr[i + 1], &arr[high]); 
	return (i + 1); 
} 

void quickSort(int arr[], int low, int high) 
{ 
	if (low < high) 
	{ 
		
		int pi = partition(arr, low, high); 


		quickSort(arr, low, pi - 1); 
		quickSort(arr, pi + 1, high); 
	} 
} 

void printArray(int arr[], int size) 
{ 
	int i; 
	for (i = 0; i < size; i++) 
		cout << arr[i] << "" ""; 
	cout << endl; 
} 

int main() 
{ 
	int arr[] = {10, 7, 8, 9, 1, 5}; 
	int n = sizeof(arr) / sizeof(arr[0]); 
	quickSort(arr, 0, n - 1); 
	cout << ""Sorted array: \n""; 
	printArray(arr, n); 
	return 0; 
}",cpp
"if ENV['START_SIMPLECOV'].to_i == 1
  require 'simplecov'
  SimpleCov.start do
    add_filter ""#{File.basename(File.dirname(__FILE__))}/""
  end
end
require 'rspec'
begin
  require 'byebug'
rescue LoadError
  warn ""Cannot load byebug => Skipping it.""
end
require 'fakery'
RSpec.configure do |config|
  config.before(:each) do
    Typhoeus::Config.block_connection = true
  end
  config.after(:each) do
    Typhoeus::Expectation.clear
    Fakery::Registry.clear
  end
end",ruby
"
























using std::string;
void set_autoval(int n) {
  auto_val(n, a()->user());
  a()->reset_effective_sl();
  changedsl();
}",cpp
"class Address < ApplicationRecord
  belongs_to :user
  belongs_to :order, optional: true
  accepts_nested_attributes_for :order
  validates :zip_code, presence: { message: ""Please Enter Zip Code"" }, length: {is: 5, wrong_length: ""Zip Code Must Be 5 Digits""}
  validates :first_name, presence: { message: ""Please Enter First Name"" }
  validates :last_name, presence: { message: ""Please Enter Last Name"" }
  validates :address, presence: { message: ""Please Enter Address"" }
  validates :city, presence: { message: ""Please Enter City"" }
  validates :state, presence: { message: ""Please Enter State"" }
  validates :country, presence: { message: ""Please Enter Country"" }
end",ruby
"package main
import (
	""fmt""
	""sync""
)
var wg sync.WaitGroup
var chs = make([]chan int, 10)
func Add(x, y int, yy chan int) {
	defer wg.Done()
	<-yy
	z := x + y
	fmt.Println(z)
	if x+1 < len(chs) {
		chs[x+1] <- 1
	}
}
func main() {
	a := Hh{5}






	fmt.Println(a)
}
type Hh struct {
	id int
}
type number struct {
	f float32
}
type nr number",go
"var scheduler = typeof setImmediate === 'function' ? setImmediate : setTimeout;
function flushPromises() {
  return new Promise(function(resolve) {
    scheduler(resolve);
  });
}
module.exports = flushPromises;",javascript
"require 'test_helper'
class UsersIndexTest < ActionDispatch::IntegrationTest
  def setup
    @admin = users(:michael)
    @non_admin = users(:archer)
  end
  test ""index as admin including pagination and delete links"" do
    log_in_as(@admin)
    get users_path
    assert_template 'users/index'
    assert_select 'div.pagination' , count: 2
    first_page_of_users = User.paginate(page: 1)
    first_page_of_users.each do |user|
      assert_select 'a[href=?]', user_path(user), text: user.name
      unless user == @admin
        assert_select 'a[href=?]', user_path(user), text: 'delete'
      end
    end
    assert_difference 'User.count', -1 do
      delete user_path(@non_admin)
    end
  end
  test ""index as non-admin"" do
    log_in_as(@non_admin)
    get users_path
    assert_select 'a' , text: 'delete', count: 0
  end
end",ruby
"json.extract! opinion, :id, :AuthorId, :Text, :created_at, :updated_at
json.url opinion_url(opinion, format: :json)",ruby
"cask 'baiduinput' do
  version '3.4_1000e'
  sha256 'dd7a65c1eb2c1f300c96bea2bac63bbdb4a23d31a78ddbdb4f4cd5d14eba08e3'
  url ""http://shouji.baidu.com/download/baiduinput_mac_v#{version}.dmg""
  name '安装百度输入法'
  name 'Baidu Input'
  name 'BaiduIM'
  homepage 'http://wuxian.baidu.com/input/mac.html'
  license :gratis
  installer :manual => '安装百度输入法.app'
  uninstall :pkgutil  => 'com.baidu.inputmethod.*',
            :delete   => '/Library/Input Methods/BaiduIM.app'
end",ruby
"class CreateTrucks < ActiveRecord::Migration
  def change
    create_table :trucks do |t|
      t.string  :name   #G3
      t.string  :pen_name #E2
      t.string  :model    #LMTV
      t.string  :radio_NSN  # sensitive item serial number
      t.integer :odometer
      t.timestamps
    end
  end
end",ruby
"'''
Created by auto_sdk on 2020.11.25
'''
from dingtalk.api.base import RestApi
class OapiSmartdeviceBatcheventPostRequest(RestApi):
	def __init__(self,url=None):
		RestApi.__init__(self,url)
		self.device_event_vos = None
	def getHttpMethod(self):
		return 'POST'
	def getapiname(self):
		return 'dingtalk.oapi.smartdevice.batchevent.post'",python
"








namespace tensorflow {
namespace {
TEST(GraphDefBuilderTest, Version) {

  ASSERT_LT(0, TF_GRAPH_DEF_VERSION);

  GraphDefBuilder builder(GraphDefBuilder::kFailImmediately);

  Graph graph(OpRegistry::Global());
  TF_EXPECT_OK(GraphDefBuilderToGraph(builder, &graph));
  ASSERT_EQ(graph.versions().producer(), TF_GRAPH_DEF_VERSION);
  ASSERT_EQ(graph.versions().min_consumer(), TF_GRAPH_DEF_VERSION_MIN_CONSUMER);

  GraphDef graph_def;
  TF_EXPECT_OK(builder.ToGraphDef(&graph_def));
  ASSERT_EQ(graph_def.versions().producer(), TF_GRAPH_DEF_VERSION);
  ASSERT_EQ(graph_def.versions().min_consumer(),
            TF_GRAPH_DEF_VERSION_MIN_CONSUMER);
}
}  // namespace
}  // namespace tensorflow",cpp
"import { connect } from 'react-redux';
import GennyModal from './GennyModal.jsx';
function mapStateToProps(state) {
  return { sublayout: state.layouts.sublayout };
}
export default connect( mapStateToProps, null )( GennyModal );",javascript
"------------------------------
-- Archivo de base de datos --
------------------------------
DROP TABLE IF EXISTS usuarios CASCADE;
CREATE TABLE usuarios
(
    id         BIGSERIAL   PRIMARY KEY
  , login      VARCHAR(50) NOT NULL UNIQUE
                           CONSTRAINT ck_login_sin_espacios
                           CHECK (login NOT LIKE '% %')
  , password   VARCHAR(60) NOT NULL
  , created_at TIMESTAMP   NOT NULL DEFAULT current_timestamp
  ,rol         VARCHAR(60) NOT NULL
);
INSERT INTO usuarios (login, password,rol)
   VALUES ('jlcast', crypt('jlcast1988', gen_salt('bf', 10)),'mediador')
        , ('admin', crypt('admin', gen_salt('bf', 10)),'admin')
        , ('agente', crypt('agente', gen_salt('bf', 10)),'agente');",mysql
"create or replace function get_supplied_item_count( p_bpar_id in number ) return number is
  v_return number;
begin
  select count(1)
    into v_return
    from items_suppliers
   where bpar_id = p_bpar_id;
  return v_return;
end;
/",mysql
"export default (context, html) => html`
    <svg xmlns=""http://www.w3.org/2000/svg"" width=""24"" height=""24"" viewBox=""0 0 24 24""><path fill=""none"" d=""M0 0h24v24H0V0zm0 0h24v24H0V0z""/><path d=""M8 5h2v2h-.9L12 9.9V9h8v8.9l2 2V7H12V3H5.1L8 5.9zm8 6h2v2h-2zM1.3 1.8L.1 3.1 2 5v16h16l3 3 1.3-1.3-21-20.9zM6 19H4v-2h2v2zm0-4H4v-2h2v2zm0-4H4V9h2v2zm4 8H8v-2h2v2zm0-4H8v-2h2v2zm2 4v-2h2l2 2h-4z""/></svg>
`;",javascript
"


from queue import PriorityQueue
n = int(input())
g = {}
c = {str(i):0 for i in range(1,n+1)}    #children count
for i in range(1,n+1):
    k    = str(i)
    g[k] = input().split() # l[0]=weight; l[1]=no use; l[2:] parents;
    for p in g[k][2:]:
        c[p] += 1
q = PriorityQueue()
[q.put((int(g[k][0]),k)) for k in c if c[k]==0]
m = 0
i = n-1
while not q.empty():
    w,k = q.get()
    l   = i + w
    i  -= 1
    if l>m:
        m = l
    for p in g[k][2:]:
        c[p] -= 1
        if c[p]==0:
            q.put((int(g[p][0]),p))
print(m)",python
"





















namespace CuEngine::Platform
{
SystemBuilder::SystemBuilder() noexcept : m_Pimpl()
{}
SystemBuilder::SystemBuilder(SystemBuilder && other) noexcept = default;
SystemBuilder & SystemBuilder::operator=(SystemBuilder && other) noexcept = default;
SystemBuilder::~SystemBuilder() noexcept = default;
System SystemBuilder::Build() const
{
    return System(m_Pimpl->Build());
}
Impl::SystemBuilder & SystemBuilder::GetImpl() noexcept
{
    return *m_Pimpl;
}
} // namespace CuEngine::Platform",cpp
"






























void register_android_global_defaults() {
	
}",cpp
"
package com.facebook.drawee.backends.pipeline.info;
import com.facebook.imagepipeline.listener.BaseRequestListener;
import javax.annotation.Nullable;

public class ImageOriginRequestListener extends BaseRequestListener {
  private final String mControllerId;
  private final @Nullable ImageOriginListener mImageOriginLister;
  public ImageOriginRequestListener(
      String controllerId, @Nullable ImageOriginListener imageOriginLister) {
    mControllerId = controllerId;
    mImageOriginLister = imageOriginLister;
  }
  @Override
  public void onUltimateProducerReached(String requestId, String producerName, boolean successful) {
    if (mImageOriginLister != null) {
      mImageOriginLister.onImageLoaded(
          mControllerId, ImageOriginUtils.mapProducerNameToImageOrigin(producerName), successful);
    }
  }
}",java
"module Vagrant
  module Plugin
    module V2




      class Components



        attr_reader :action_hooks



        attr_reader :configs
        def initialize

          @action_hooks = Hash.new { |h, k| h[k] = [] }

          @configs = Hash.new { |h, k| h[k] = Registry.new }
        end
      end
    end
  end
end",ruby
"class CreateProducts < ActiveRecord::Migration[5.2]
  def change
    create_table :products do |t|

      t.string :name
      t.decimal :cost, precision: 6, scale: 2
      t.string :country_of_origin
      t.timestamps
    end
  end
end",ruby
"export var esmDep = true;
(function(g) {
  g.esmDep = 'esm-dep';
})(typeof window != 'undefined' ? window : global);",javascript
"{Source_to_Source}
SELECT distinct SOURCE_CODE, TARGET_CONCEPT_ID
FROM CTE_VOCAB_MAP
WHERE lower(SOURCE_VOCABULARY_ID) = 'icd10' AND lower(TARGET_VOCABULARY_ID) = 'icd10'",mysql
"
namespace application
{
    ImageUpgrader::ImageUpgrader(const char* targetName, Decryptor& decryptor)
        : targetName(targetName)
        , decryptor(decryptor)
    {}
    const char* ImageUpgrader::TargetName() const
    {
        return targetName;
    }
    Decryptor& ImageUpgrader::ImageDecryptor()
    {
        return decryptor;
    }
}",cpp
"bonsai_function u32
GetWorkerThreadCount()
{
  u32 LogicalCoreCount = PlatformGetLogicalCoreCount();
  u32 Bias = 1 + DEBUG_THREAD_COUNT_BIAS; // +1 because we already have a main thread
  if (Bias >= LogicalCoreCount)
  {
    Bias = LogicalCoreCount - 1;
  }
  u32 ThreadCount = LogicalCoreCount - Bias;
  return ThreadCount;
}
bonsai_function u32
GetTotalThreadCount()
{
  u32 Result = GetWorkerThreadCount() + 1;
  return Result;
}
inline void
SuspendWorkerThreads()
{
  TIMED_FUNCTION();
  MainThreadBlocksWorkerThreads = True;
  u32 WorkerThreadCount = GetWorkerThreadCount();
  while (WorkerThreadsWaiting < WorkerThreadCount);
  return;
}
inline void
ResumeWorkerThreads()
{
  TIMED_FUNCTION();
  MainThreadBlocksWorkerThreads = False;
  return;
}",cpp
"require 'spec_helper'
describe 'collectd_plugins::zfs_arc', :type => :class do
  context ':ensure => present' do
    let :facts do
      {:osfamily => 'FreeBSD'}
    end
    it 'Will create 10-zfs_arc.conf' do
      should contain_file('zfs_arc.load').with({
        :ensure  => 'present',
        :path    => '/usr/local/etc/collectd/10-zfs_arc.conf',
        :content => /\#\ Generated by Puppet\nLoadPlugin zfs_arc\n/,
      })
    end
  end
  context ':ensure => absent' do
    let :facts do
      {:osfamily => 'FreeBSD'}
    end
    let :params do
      {:ensure => 'absent'}
    end
    it 'Will not create 10-zfs_arc.conf' do
      should contain_file('zfs_arc.load').with({
        :ensure => 'absent',
        :path   => '/usr/local/etc/collectd/10-zfs_arc.conf',
      })
    end
  end
end",ruby
"CREATE DATABASE burgers_db;
USE burgers_db;
CREATE TABLE burgers(
    id INT AUTO_INCREMENT PRIMARY KEY,
    burger_name VARCHAR(255) NOT NULL,
    devoured BOOLEAN DEFAULT false
);",mysql
"












package fastmap
var (
	Find func([]uint64, uint64) int
)
func find(xs []uint64, v uint64) int {
	for i, x := range xs {
		if x == v {
			return i
		}
	}
	return -1
}",go
"__author__ = 'pulphix'
from app import TestApplication",python
"
package com.azureyjt.smartrest.service;
import com.azureyjt.smartrest.service.exception.NoSuchResourceException;

public interface CommonApiService {
    
    Object executeGet(String uri) throws NoSuchResourceException;
    
    String executePost(String uri, String body);
    
    String executePut(String uri, String body);
    
    String executeDelete(String uri);
}",java
"const uid = require('uid-safe').sync;
const config = require('config');
const getLanguage = require('./getLanguage');
const logger = require('./bunyan');
function generateId() {
  return uid(24);
}
exports.createSessionId = function createSessionId(req, res) {
  const id = generateId();
  const expires = new Date(Date.now() + config.get('sessionInfo.expiryPeriod'));
  logger.info('Session ID and Expiry generated');
  res.cookie('sessionId', id, {
    httpOnly: true, secure: config.get('cookieOptions.secure'), sameSite: true, expires,
  });
  res.cookie('exp', expires.toUTCString(), {
    httpOnly: true, secure: config.get('cookieOptions.secure'), sameSite: true, expires: 0,
  });
  res.locals.exp = expires.toUTCString();
  res.locals.lang = getLanguage(req.language);
  return id;
};",javascript
"











package message
import ""github.com/pingcap/tiflow/cdc/model""

type Type int

const (
	MessageTypeUnknown Type = iota
	MessageTypeCommand
	MessageTypePolymorphicEvent
	MessageTypeBarrier
	MessageTypeTick
)

type Message struct {


	Tp Type

	Command *Command

	PolymorphicEvent *model.PolymorphicEvent

	BarrierTs model.Ts
}

func PolymorphicEventMessage(event *model.PolymorphicEvent) Message {
	return Message{
		Tp:               MessageTypePolymorphicEvent,
		PolymorphicEvent: event,
	}
}

func CommandMessage(command *Command) Message {
	return Message{
		Tp:      MessageTypeCommand,
		Command: command,
	}
}

func BarrierMessage(barrierTs model.Ts) Message {
	return Message{
		Tp:        MessageTypeBarrier,
		BarrierTs: barrierTs,
	}
}


func TickMessage() Message {
	return Message{
		Tp: MessageTypeTick,
	}
}

type CommandType int
const (

	CommandTypeUnknown CommandType = iota

	CommandTypeStop
)

type Command struct {
	Tp CommandType
}",go
"from PIL import ImageChops, Image as PILImage
from http.client import HTTPConnection
from time import sleep
from traceback import format_stack, print_exc
def Tint(image, color):
    return ImageChops.blend(image, PILImage.new('RGB', image.size, color), 0.36)
def GetStatusCode(host, path=""/""):
    """""" This function retreives the status code of a website by requesting
        HEAD data from the host. This means that it only requests the headers.
        If the host cannot be reached or something else goes wrong, it returns
        None instead.
    """"""
    try:
        conn = HTTPConnection(host)
        conn.request(""HEAD"", path)
        return conn.getresponse().status
    except Exception:
        return None
def WaitOK(host, path=""/""):
    while GetStatusCode(host, path) != 200:
        sleep(5)",python
"module.exports = {
  GraphQLTodo: require('./todo'),
  GraphQLProject: require('./project')
};",javascript
"alter table application.applications
  alter column owner_id type integer using owner_id::integer;",mysql
"


namespace exemodel {
timespec_t get_clk_res(int clk_id);
timespec_t get_clk_time(int clk_id);
void set_clk_time(int clk_id, const timespec_t & tp);
template<int clk_id>
class clk_info {
public:
	static timespec_t get_res()
	{
		return get_clk_res(clk_id);
	}
	static timespec_t get_time()
	{
		return get_clk_time(clk_id);
	}
	static void set_time(const timespec_t & tp)
	{
		set_clk_time(clk_id, tp);
	}
};
typedef clk_info<CLOCK_REALTIME> rt_clk_info;
typedef clk_info<CLOCK_MONOTONIC> mono_clk_info;
}",cpp
"import pygame
import math
import glob
import os
tilesize = 128 # pixels per tile
def tiletosurface(tile):
    pass
def maptosurface(sx,sy,ex,ey,oholmap):
    pass
def main(windowsize,tilepipe,OHOLMap):
    wt = math.floor(windowsize/tilesize)
    cx,cy,first = 0,0,True
    if OHOLMap.data != {}:
       for x in OHOLMap.data:
           for y in OHOLMap.data[x]:
                if not first:
                    break
                cx,cy = x,y
                first = False
    print(""Loading sprites"")
    sprites = glob.glob(""./OneLifeData/sprites/*.tga"")
    loadedsprites = {}
    print(""Found {} sprites, loading..."".format(len(sprites)))
    for sprite in sprites:
        spriteid = os.path.basename(sprite).split(""."")[0]
        loadedsprites[spriteid] = pygame.image.load(sprite)

    tilepipe.send(""READY"")
",python
"




int MotorCtrl::MotorCw(void)
{
	MotorStop();
	delay(3);
	digitalWrite(RelayPin0, LOW);
	digitalWrite(RelayPin1, HIGH);
	return 1;
}
int MotorCtrl::MotorCcw(void)
{
	MotorStop();
	delay(3);
	digitalWrite(RelayPin0, HIGH);
	digitalWrite(RelayPin1, LOW);
	return -1;
}
int MotorCtrl::MotorStop(void)
{
	digitalWrite(RelayPin0, HIGH);
	digitalWrite(RelayPin1, HIGH);
	return 0;
}
int MotorCtrl::MotorStateCtrl(int state)
{
	if (state == 0)
	{
		MotorStop();
	}
	if (state == 1)
	{
		MotorCw();
	}
	if (state == -1)
	{
		MotorCcw();
	}
	return state;
}",cpp
"
package xmsclient
type TrashUpdateReq struct {
	Trash *TrashUpdateReqTrash `json:""trash""`
}",go
"class Solution {
public:
  int missingNumber(vector<int> &nums) {
    int n = nums.size();
    for (int i = 0; i < n; i++) {
      if (nums[i] < n && nums[i] != i) {
        int t = nums[nums[i]];
        nums[nums[i]] = nums[i];
        nums[i] = t;
        i--;
      }
    }
    for (int i = 0; i < n; i++)
      if (nums[i] != i)
        return i;
    return n;
  }
};",cpp
"module Calculated
  module AnswerApiCalls    



    def answer_for_calculator(calculator_id, params = {})
      api_call(:get, ""/calculators/#{calculator_id}/answer"", params) do |response|
        Calculated::Models::Answer.new(response)
      end
    end



    def answer_for_computation(compuation_id, params = {})
      api_call(:get, ""/computations/#{compuation_id}/answer"", params) do |response|
        Calculated::Models::Answer.new(response)
      end
    end
  end
end",ruby
"'use strict';

(function () {
    function toggleLogo() {
        logos[lastLogoIdx].classList.toggle('selected');
    }
    var logos = document.querySelectorAll('.logos img'),
        lastLogoIdx = 0;

    toggleLogo();

    setInterval(function () {
        toggleLogo();
        lastLogoIdx = (lastLogoIdx + 1) % logos.length;
        toggleLogo();
    }, 1000);
})();",javascript
"package rdb
func rdbLoadCheckModuleValue(l *Loader) error {
	var opcode uint32
	var err error
	for {
		if opcode, err = l.ReadLength(); err != nil {
			return err
		} else if opcode == rdbModuleOpcodeEof {
			break
		}
		switch opcode {
		case rdbModuleOpcodeSint:
			fallthrough
		case rdbModuleOpcodeUint:
			if _, err = l.ReadLength(); err != nil {
				return err
			}
		case rdbModuleOpcodeString:
			if _, err = l.ReadString(); err != nil {
				return err
			}
		case rdbModuleOpcodeFloat:

			if _, err = l.ReadFloat(); err != nil {
				return err
			}
		case rdbModuleOpcodeDouble:

			if _, err = l.ReadDouble(); err != nil {
				return err
			}
		}
	}
	return nil
}",go
"


















using mapnik::datasource;
using mapnik::parameters;
using mapnik::query;
using mapnik::featureset_ptr;
using mapnik::layer_descriptor;
using mapnik::coord2d;
class shape_datasource : public datasource
{
public:
    shape_datasource(parameters const& params);
    virtual ~shape_datasource();
    datasource::datasource_t type() const;
    static const char * name();
    featureset_ptr features(query const& q) const;
    featureset_ptr features_at_point(coord2d const& pt, double tol = 0) const;
    box2d<double> envelope() const;
    boost::optional<mapnik::datasource_geometry_t> get_geometry_type() const;
    layer_descriptor get_descriptor() const;
private:
    void init(shape_io& shape);
    datasource::datasource_t type_;
    std::string shape_name_;
    shape_io::shapeType shape_type_;
    long file_length_;
    box2d<double> extent_;
    bool indexed_;
    const int row_limit_;
    layer_descriptor desc_;
};
",cpp
"class AddColumnSendedAtToInvoices < ActiveRecord::Migration
  def change
    add_column :invoices, :sended_at, :datetime
    add_column :invoices, :amount, :float
  end
end",ruby
"Rails.application.routes.draw do
  mount Ahoy::Engine => ""/ahoy""
end
Ahoy::Engine.routes.draw do
  resources :visits, only: [:create]
end",ruby
"


package main
import (
	""github.com/axgle/mahonia""
	""gopkg.in/goyy/goyy.v0/util/errors""
	""gopkg.in/goyy/goyy.v0/util/strings""
)
func tagItemValue(tag, name string) string {
	return strings.Between(tag, name+`:""`, `""`)
}
func tagAttrValue(tag, name string) (string, error) {
	attributes := strings.Split(tag, ""&"")
	for _, attr := range attributes {
		pair := strings.Split(attr, ""="")
		if len(pair) != 2 {
			return """", errors.Newf(""Malformed tag: '%s'"", attr)
		}
		switch strings.ToLower(pair[0]) {
		case name:
			return pair[1], nil
		}
	}
	return """", errors.Newf(""%s was not found in tag"", name)
}
func convertUTF8(in string) string {
	enc := mahonia.NewEncoder(""gbk"")
	return enc.ConvertString(in)
}",go
"-- This file is automatically generated by LogicalPlanToSQLSuite.
SELECT a, b, sum(c) FROM parquet_t2 GROUP BY a, b GROUPING SETS (b) ORDER BY a, b
--------------------------------------------------------------------------------
SELECT `gen_attr` AS `a`, `gen_attr` AS `b`, `gen_attr` AS `sum(c)` FROM (SELECT `gen_attr` AS `gen_attr`, `gen_attr` AS `gen_attr`, sum(`gen_attr`) AS `gen_attr` FROM (SELECT `a` AS `gen_attr`, `b` AS `gen_attr`, `c` AS `gen_attr`, `d` AS `gen_attr` FROM `default`.`parquet_t2`) AS gen_subquery_0 GROUP BY `gen_attr`, `gen_attr` GROUPING SETS((`gen_attr`)) ORDER BY `gen_attr` ASC, `gen_attr` ASC) AS gen_subquery_1",mysql
"
import Loadable from 'react-loadable';
export default Loadable({
  loader: () => import('./index'),
  loading: () => null,
});",javascript
"
require 'msf/core/modules'

module Msf::Modules::Loader
end",ruby
"require 'azure_generic_resource'
class AzureMigrateProjectMachine < AzureGenericResource
  name 'azure_migrate_project_machine'
  desc 'Retrieves and verifies the settings of an Azure Migrate Project Machine.'
  example <<-EXAMPLE
    describe azure_migrate_project_machine(resource_group: 'migrate_vms', project_name: 'zoneA_migrate_project', name: 'c042be9e-3d93-42cf-917f-b92c68318ded') do
      it { should exist }
    end
  EXAMPLE
  def initialize(opts = {})
    raise ArgumentError, 'Parameters must be provided in an Hash object.' unless opts.is_a?(Hash)
    opts[:resource_provider] = specific_resource_constraint('Microsoft.Migrate/migrateProjects', opts)
    opts[:required_parameters] = %i(project_name)
    opts[:resource_path] = [opts[:project_name], 'machines'].join('/')
    super(opts, true)
  end
  def to_s
    super(AzureMigrateProjectMachine)
  end
end",ruby
"





namespace CWE401_Memory_Leak__new_int_01
{

void bad()
{
    int * data;
    data = NULL;
    
    data = new int;
    
    *data = 5;
    printIntLine(*data);
    
    ; 
}



static void goodG2B()
{
    int * data;
    data = NULL;
    
    int dataGoodBuffer;
    data = &dataGoodBuffer;
    
    *data = 5;
    printIntLine(*data);
    
    ; 
}

static void goodB2G()
{
    int * data;
    data = NULL;
    
    data = new int;
    
    *data = 5;
    printIntLine(*data);
    
    delete data;
}
void good()
{
    goodG2B();
    goodB2G();
}

} 


using namespace CWE401_Memory_Leak__new_int_01; 
int main(int argc, char * argv[])
{
    
    srand( (unsigned)time(NULL) );

    printLine(""Calling good()..."");
    good();
    printLine(""Finished good()"");


    printLine(""Calling bad()..."");
    bad();
    printLine(""Finished bad()"");

    return 0;
}
",cpp
"

namespace Layout
{
    template<typename T>
    struct PictureSizeT
    {
        T width;
        T height;
    };
    struct PictureMeta {
        const char * Name;
        const char * Id;
        const char * Colour;
        char16_t thumbnailSizes[3];
        char NameLen;
    };
    typedef PictureSizeT<char16_t> PictureSize;
    typedef PictureSizeT<double> PictureSizeDouble;
    struct Window {
        double width;
        double height;
        double scrollBar;
        double excess;
    };
    extern ""C""{
        extern void calcScaleFactors(Window w, int offset=0,bool scrollSubtracted=false );
        extern void genPicTbl();
        extern Window wnd;
    }
};
",cpp
"const redis = require('redis')
const { REDIS_CONF } = require('../conf/db.js')

const redisClient = redis.createClient(REDIS_CONF.port, REDIS_CONF.host)
redisClient.on('error', err => {
    console.error(err)
})
module.exports = redisClient",javascript
"from django.conf.urls import patterns, url
urlpatterns = patterns('appointments.views',
    url(r'^appointment/(?P<practice_id>\d+)/$', 'appointment_form', name='appointment_form'),
    url(r'^appointment/created/(?P<practice_id>\d+)/$', 'appointment_created', name='appointment_created'),
)",python
"class UsersMailer < ActionMailer::Base
  layout 'email'
  def notification_email(notification)
    @notification = notification
    old_locale = I18n.locale
    I18n.locale = @notification.user.locale if I18n.locale.to_s != @notification.user.locale.to_s # we need this if to avoid stack overflow in controller
    mail(:from => ""#{I18n.t('site.name')} <#{I18n.t('site.email.contact')}>"", :to => @notification.user.email, :subject => @notification.email_subject)
    I18n.locale = old_locale if I18n.locale.to_s != @notification.user.locale.to_s
  end
end",ruby
"






struct FPU_CPACR
{
  struct FPU_CPACRCPACRBase {} ;
  struct CPACR : public RegisterBase<0xE000ED88, 32, ReadWriteMode>
  {
    using CP = FPU_CPACR_CPACR_CP_Values<FPU_CPACR::CPACR, 20, 4, ReadWriteMode, FPU_CPACRCPACRBase> ;
    using FieldValues = FPU_CPACR_CPACR_CP_Values<FPU_CPACR::CPACR, 0, 0, NoAccess, NoAccess> ;
  } ;
  template<typename... T> 
  using CPACRPack  = Register<0xE000ED88, 32, ReadWriteMode, FPU_CPACRCPACRBase, T...> ;
} ;
",cpp
"-- script to create a table in server
-- DDL query to do so
CREATE TABLE IF NOT EXISTS force_name(
  id INT,
  name VARCHAR(256) NOT NULL
);",mysql
"


package com.intel.daal.services;

public final class CpuTypeEnable{
    private int _value;
    
    public CpuTypeEnable(int value) {
        _value = value;
    }
    
    public int getValue() {
        return _value;
    }
    private static final int _cpu_default = 0;
    private static final int _avx512_mic = 1;
    private static final int _avx512 = 2;
    private static final int _avx512_mic_e1 = 4;
    public static final CpuTypeEnable cpu_default = new CpuTypeEnable(_cpu_default);       
    public static final CpuTypeEnable avx512_mic = new CpuTypeEnable(_avx512_mic);         
    public static final CpuTypeEnable avx512 = new CpuTypeEnable(_avx512);                 
    public static final CpuTypeEnable avx512_mic_e1 = new CpuTypeEnable(_avx512_mic_e1);   
}
",java
"package s
import (
	. ""github.com/alecthomas/chroma"" // nolint
	""github.com/alecthomas/chroma/lexers/internal""
)
var SYSTEMD = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      ""SYSTEMD"",
		Aliases:   []string{""systemd""},
		Filenames: []string{""*.service""},
		MimeTypes: []string{""text/plain""},
	},
	systemdRules,
))
func systemdRules() Rules {
	return Rules{
		""root"": {
			{`\s+`, Text, nil},
			{`[;#].*`, Comment, nil},
			{`\[.*?\]$`, Keyword, nil},
			{`(.*?)(=)(.*)(\\\n)`, ByGroups(NameAttribute, Operator, LiteralString, Text), Push(""continuation"")},
			{`(.*?)(=)(.*)`, ByGroups(NameAttribute, Operator, LiteralString), nil},
		},
		""continuation"": {
			{`(.*?)(\\\n)`, ByGroups(LiteralString, Text), nil},
			{`(.*)`, LiteralString, Pop(1)},
		},
	}
}",go
"class AddCanonicalUsernameToUsers < ActiveRecord::Migration
  def change
    add_column :users, :canonical_username, :string
    User.all.each {|user| user.send(:create_canonical_username); user.save }
  end
end",ruby
"explain plan for select * from (
-- join between two subqueries
-- one of the subqueries has a window function
-- result of window function is a join column
select * from
(       
select  
        row_number() over (order by a1),
        sum(a1) over (partition by b1)
from    t1_v t1
) as sq1(b1, sum_a1)
        inner join 
(
select  a2,
        sum(a2) over(partition by b2, c2 order by a2)
from    t2_v t2
) as sq2(b2, sum_a2)
on (sq1.b1 = sq2.b2)) t limit 0;",mysql
"
from __future__ import unicode_literals
from django.db import models, migrations
import datetime
from django.utils.timezone import utc
class Migration(migrations.Migration):
    dependencies = [
        ('stocks', '0003_auto_20151129_1623'),
    ]
    operations = [
        migrations.AlterField(
            model_name='floor',
            name='floorPlayer',
            field=models.ForeignKey(to='stocks.Player', related_name='FloorPlayer'),
        ),
        migrations.AlterField(
            model_name='stock',
            name='last_updated',
            field=models.DateTimeField(default=datetime.datetime(2015, 11, 29, 22, 5, 30, 24205, tzinfo=utc)),
        ),
    ]",python
"
package ansi
import (
	""fmt""
)
const csi = ""\x1b[""
const sep = "";""

var CursorLeft = fmt.Sprintf(""%sG"", csi)

var EraseDown = fmt.Sprintf(""%sJ"", csi)

var EraseUp = fmt.Sprintf(""%s1J"", csi)

func CursorUp(count int) string {
	return fmt.Sprintf(""%s%dA"", csi, count)
}

func CursorPrevLine(count int) string {
	return fmt.Sprintf(""%s%dF"", csi, count)
}

func CursorTo(x, y int) string {
	return fmt.Sprintf(""%s%d;%dH"", csi, y+1, x+1)
}",go
"
bool CPE::IsValidBlock(uint8_t type)
{
  for (int i = BlockType::kStartOfBlockTypes; i < BlockType::kEndOfBlockTypes; ++i) {
    if (type == i)
      return true;
  }
  return false;
}
void CPE::SendExtInfo(Client* client, std::string appName, short extCount)
{
    Packet* packet = new Packet(CPE::PacketType::kExtInfo);
    packet->Write(appName);
    packet->Write(extCount);
    client->QueuePacket(packet);
}
void CPE::SendExtEntry(Client* client, std::string extName, int version)
{
    Packet* packet = new Packet(CPE::PacketType::kExtEntry);
    packet->Write(extName);
    packet->Write(version);
    client->QueuePacket(packet);
}
void CPE::SendCustomBlocks(Client* client, uint8_t support)
{
    Packet* packet = new Packet(CPE::PacketType::kCustomBlocks);
    packet->Write(support);
    client->QueuePacket(packet);
}",cpp
"package com.appleframework.jms.kafka;
import org.apache.log4j.Logger;
import com.appleframework.jms.kafka.consumer.BytesMessageConsumer;
public class KafkaMessageConsumer extends BytesMessageConsumer {
	private static Logger logger = Logger.getLogger(KafkaMessageConsumer.class.getName());
	@Override
	public void processMessage(byte[] message) {
		try {
			String object = new String(message);
			logger.error(object.toString());
		} catch (Exception e) {

		}
	}
}",java
"package platform
import (
	""errors""
	""github.com/2beens/ispend/internal/models""
)
var ErrNotFound = errors.New(""not found"")
var EmptySignal = models.Signal{}
const (
	IPAddress   = ""localhost""
	DefaultPort = ""8080""
)",go
"


package com.azure.analytics.synapse.artifacts.models;
import com.azure.core.annotation.Fluent;
import com.fasterxml.jackson.annotation.JsonProperty;
import java.util.List;

@Fluent
public final class CustomActivityReferenceObject {
    
    @JsonProperty(value = ""linkedServices"")
    private List<LinkedServiceReference> linkedServices;
    
    @JsonProperty(value = ""datasets"")
    private List<DatasetReference> datasets;
    
    public List<LinkedServiceReference> getLinkedServices() {
        return this.linkedServices;
    }
    
    public CustomActivityReferenceObject setLinkedServices(List<LinkedServiceReference> linkedServices) {
        this.linkedServices = linkedServices;
        return this;
    }
    
    public List<DatasetReference> getDatasets() {
        return this.datasets;
    }
    
    public CustomActivityReferenceObject setDatasets(List<DatasetReference> datasets) {
        this.datasets = datasets;
        return this;
    }
}",java
"

import json
import sys
import bigram

def concatString(path):
    corpus = """"
    with open(path, 'r', encoding='UTF-8') as f:
        for line in f.readlines():
            corpus += line
    return corpus
corpus = concatString(sys.argv[1])
data = json.loads(corpus)
output_path = sys.argv[2]
topics = {}
for doc in data:
    string = bigram.get_words(doc[""body""])
    topic_num = doc[""topic""]
    if topic_num not in topics:
        topics[topic_num] = []
    topics[topic_num].append(string + ""\n"")
print(""Finish traversing corpus.json"")
for topic_index in topics.keys():
    path = ""%s/%d.txt"" % (output_path, topic_index)
    with open(path, 'w', encoding='UTF-8') as f:
        f.writelines(topics[topic_index])
print(""Generated %d files."" % len(topics))",python
"
package org.lorainelab.igb.data.model.action;
import javafx.beans.property.BooleanProperty;
import javafx.beans.property.ObjectProperty;
import javafx.beans.property.StringProperty;
import javafx.scene.Node;
import javafx.scene.input.KeyCombination;

public interface IgbAction {
    ObjectProperty<KeyCombination> acceleratorProperty();
    BooleanProperty disabledProperty();
    KeyCombination getAccelerator();
    Node getGraphic();
    ObjectProperty<Node> graphicProperty();
    boolean isDisabled();
    void setAccelerator(KeyCombination value);
    void setDisabled(boolean value);
    void setGraphic(Node value);
    StringProperty textProperty();
    String getText();
    void setText(String value);
}",java
"INSERT INTO `pokemon` VALUES (12, 'Butterfree', 60, 45, 50, 90, 80, 70, 1);
INSERT INTO `pokemon` VALUES (15, 'Beedrill', 65, 90, 40, 45, 80, 75, 1);
INSERT INTO `pokemon` VALUES (18, 'Pidgeot', 83, 80, 75, 70, 70, 101, 1);
INSERT INTO `pokemon` VALUES (26, 'Raichu', 60, 90, 55, 90, 80, 110, 0);
INSERT INTO `pokemon` VALUES (28, 'Sandslash', 75, 100, 110, 45, 55, 65, 0);
INSERT INTO `pokemon` VALUES (36, 'Clefable', 95, 70, 73, 95, 90, 60, 0);
INSERT INTO `pokemon` VALUES (62, 'Poliwrath', 90, 95, 95, 70, 90, 70, 1);
INSERT INTO `pokemon` VALUES (94, 'Gengar', 60, 65, 60, 130, 75, 110, 1);
INSERT INTO `pokemon` VALUES (124, 'Jynx', 65, 50, 35, 115, 95, 95, 1);
INSERT INTO `pokemon` VALUES (139, 'Omastar', 70, 60, 125, 115, 70, 55, 1);
INSERT INTO `pokemon` VALUES (376, 'Metagross', 80, 135, 130, 95, 90, 70, 1);
INSERT INTO `pokemon` VALUES (635, 'Hydreigon', 92, 105, 90, 125, 90, 98, 1);",mysql
"""""""
:author: Thomas Delaet <thomas@delaet.org>
""""""
from velbus.modules.vmb4ry import VMB4RYModule
from velbus.modules.vmbin import VMB6INModule
from velbus.modules.vmbin import VMB7INModule",python
"const unsigned short draw_object[] PROGMEM = {
0x7ff,0xfff,
0x8257,0xda7,
0x8000,0x7ff,
0x8257,0x257,
0x87ff,0x0,
0x8da7,0x257,
0x8fff,0x7ff,
0x8da7,0xda7,
0x87ff,0xfff,
};",cpp
"
require ::File.expand_path('../config/environment',  __FILE__)
run PrimalAuth::Application",ruby
"
import deck
while(True):
    p = deck.Deck()
    p.shuffle()
    pai = p.deal(5)

    del p
    pai.sort(key=lambda x:x.figure)
    x = True
    for i in range(1, len(pai)):
        if(pai[i].suit == pai[i-1].suit and (pai[i].figure == pai[i-1].figure + 1 or pai[i].figure == 10 and pai[i-1].figure == 1)):
            continue
        else:
            x = False
            break
    if(x == True):
        for i in pai:
            print(i,end=""\t"")
        print()",python
"package com.qingchi.base.repository.user;
import com.qingchi.base.config.redis.RedisKeysConst;
import com.qingchi.base.model.user.IdentityImgDO;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
import java.util.Optional;
public interface IdentityImgRepository extends JpaRepository<IdentityImgDO, Long> {
    @CacheEvict(cacheNames = RedisKeysConst.userById, key = ""#identityImg.userId"")
    IdentityImgDO save(IdentityImgDO identityImg);
    Optional<IdentityImgDO> findFirstByUserIdAndStatusOrderByIdDesc(Integer userId, String status);
    List<IdentityImgDO> findFirst20ByOrderByIdDesc();

    List<IdentityImgDO> findFirst600ByOrderByIdDesc();
}",java
"
package org.qiyi.video.svg.transfer.service;
import android.os.IBinder;
import org.qiyi.video.svg.bean.BinderBean;

public interface IRemoteServiceTransfer {


    BinderBean getRemoteServiceBean(String serviceCanonicalName);

    void registerStubService(String serviceCanonicalName, IBinder stubBinder);
    
    void unregisterStubService(String serviceCanonicalName);
}",java
"












import re
import logging
from cmframework.apis import cmerror
class CMPluginManager(object):
    def __init__(self, plugins_path):
        self.pluginlist = {}
        self.filterdict = {}
        self.plugins_path = plugins_path

    def load_plugin(self):
        raise cmerror.CMError('Not implemented')

    def build_input(self, indata, filtername):
        search_re = re.compile(filtername)
        if isinstance(indata, dict):
            filter_data = {}
            for key, value in indata.iteritems():
                logging.debug('Matching %s against %s', key, filtername)
                if search_re.match(key):
                    filter_data[key] = value
        else:
            filter_data = []
            for key in indata:
                logging.debug('Matching %s against %s', key, filtername)
                if search_re.match(key):
                    filter_data.append(key)
        return filter_data",python
"package oos















type InstancePatchStates struct {
	InstancePatchState []InstancePatchState `json:""InstancePatchState"" xml:""InstancePatchState""`
}",go
"YMaps.Hotspots.Loader.onLoad(""heroes-307-184-9"",{""objects"":[{""data"":{""name"":""\u041a\u0435\u0440\u0447\u044c"",""Point"":{""pos"":""36.464342 45.30667""},""style"":""#hero""},""base"":new YMaps.GeoPoint(36.464342,45.30667),""geometry"":[[-10,-5,10,33]]}]});",javascript
"





















int main()
{
   std::cout << ""   Running 'V6bVCa'..."" << std::endl;
   using blazetest::mathtest::TypeA;
   using blazetest::mathtest::TypeB;
   try
   {

      using V6b = blaze::StaticVector<TypeB,6UL>;
      using VCa = blaze::CompressedVector<TypeA>;

      using CV6b = blazetest::Creator<V6b>;
      using CVCa = blazetest::Creator<VCa>;

      for( size_t i=0UL; i<=8UL; ++i ) {
         for( size_t j=0UL; j<=i; ++j ) {
            RUN_DVECSVECOUTER_OPERATION_TEST( CV6b(), CVCa( i, j ) );
         }
      }
   }
   catch( std::exception& ex ) {
      std::cerr << ""\n\n ERROR DETECTED during dense vector/sparse vector outer product:\n""
                << ex.what() << ""\n"";
      return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
}
",cpp
"const Dispatcher = require('../../../core/http/server/dispatcher')

class CreateCalculationEndpoint extends Dispatcher
{
  dispatch()
  {
    const
    calculator    = this.locator.locate('domain/aggregate/calculator'),
    calculationId = calculator.createCalculation()
    this.view.body.id = calculationId
  }
}
module.exports = CreateCalculationEndpoint",javascript
"package pfcpType
type FSEID struct {
	FSEIDvalue []byte
}",go
"class Vercel < Formula
  desc ""Command-line interface enables instant cloud deployment and local development""
  homepage ""https://vercel.com/download""
  url ""https://files.zengxs.com/Dist/vercel/vercel-21.0.1-dist.tar.xz?raw=1""
  sha256 ""c25e138aab8f8783f1b1d9cd83fbe4a865b7a55fe6b37b58fb63c7324c91fb03""
  depends_on ""node""
  def install
    libexec.install Dir[""*""]
    [""vc"", ""vercel""].each do |bin_name|
      binary = bin/bin_name
      binary.write_env_script libexec/""vercel/dist/index.js"", :NODE_PATH => libexec
    end
  end
  test do
    system ""false""
  end
end",ruby
"Pod::Spec.new do |s|
  s.name     = 'RealmLoginKit'
  s.version  = '0.1.3'
  s.license  =  { :type => 'Apache-2.0', :file => 'LICENSE' }
  s.summary  = 'A generic login view controller for apps that use the Realm Mobile Platform'
  s.homepage = 'https://realm.io'
  s.author   = { 'Realm' => 'help@realm.io' }
  s.source   = { :git => 'https://github.com/realm-demos/realm-loginkit.git', :tag => s.version.to_s }
  s.requires_arc = true
  s.platform = :ios, '9.0'
  s.default_subspec = 'Core'
  s.dependency 'Realm'
  s.dependency 'TORoundedTableView'
  s.subspec 'Core' do |core|
    core.source_files = '**/RealmLoginKit*.{swift}'
    core.exclude_files = '**/RealmLoginKit/Models/AuthenticationProvidersRealmLoginKit*.{swift}'
    aws.dependency 'AWSCognito'
    aws.dependency 'AWSCognitoIdentityProvider'
  end
end",ruby
SELECT AVG(amount) AS Media_pagamentos FROM sakila.payment;,mysql
"
FactoryGirl.define do
  factory :tag do
    name ""MyString""
  end
end",ruby
"package logging
import (
	""github.com/sirupsen/logrus""
	""testing""
)
func TestLoggers(t *testing.T) {
	Init(""logs"", ""debug"", 0)
	CLog().Debugf(""format debug clog msg [%s]"", ""test clog msg"")
	CLog().WithFields(logrus.Fields{""name"": ""clog_test"", ""type"": ""clog""}).Debugf(""format debug clog msg [%s]"", ""test clog msg"")
	VLog().Debugf(""format debug vlog msg [%s]"", ""test vlog msg"")
	VLog().WithFields(logrus.Fields{""name"": ""vlog_test"", ""type"": ""vlog""}).Debugf(""format debug vlog msg [%s]"", ""test vlog msg"")
}",go
"from suds.client import Client
from suds import WebFault
from model.project import Project
class SoapHelper:
    def __init__(self, app):
        self.app = app
    def can_login(self, username, password):
        client = Client(""http://localhost:8080/mantisbt-1.2.20/api/soap/mantisconnect.php?wsdl"")
        try:
            client.service.mc_login(username, password)
            return True
        except WebFault:
            return False
    def get_project_list(self, username, password):
        project_list = []
        client = Client(""http://localhost:8080/mantisbt-1.2.20/api/soap/mantisconnect.php?wsdl"")
        projects = client.service.mc_projects_get_user_accessible(username, password)
        for i in range(len(projects)):
            name = projects[i].name
            description = projects[i].description
            project_list.append(Project(name=name, description=description))
        return project_list",python
"INSERT INTO user_tags (user_id, name) (
	SELECT DISTINCT ON (users.id) users.id, 'editor-beta' FROM org_members INNER JOIN users ON users.auth0_id = org_members.user_id
);
INSERT INTO org_tags (org_id, name) (
	SELECT DISTINCT ON (orgs.id) orgs.id, 'editor-beta' FROM orgs
);",mysql
"
import sys
import yaml
def main():
    args = sys.argv[1:]
    file = args[0] if args else sys.stdin
    data = yaml.safe_load(file)
    join_args = data['Fn::Join']
    contents = join_args[0].join(join_args[1])
    print(contents, end='')
if __name__ == '__main__':
    sys.exit(main())",python
"package com.sample.springboot.orika.converter;
import com.sample.springboot.orika.enums.SampleEnum;
import ma.glasnost.orika.converter.BidirectionalConverter;
import ma.glasnost.orika.metadata.Type;
public class EnumsConverters {
    public static class SampleEnumToIntegerConverter extends BidirectionalConverter<SampleEnum, Integer> {
        
        @Override
        public Integer convertTo(SampleEnum source, Type<Integer> type) {
            if (null == source) {
                return null;
            }
            return source.value();
        }
        
        @Override
        public SampleEnum convertFrom(Integer source, Type<SampleEnum> type) {
            if (null == source) {
                return SampleEnum.ENUM_UNKNOWN;
            }
            return SampleEnum.valueOf(source);
        }
    }
}",java
"package com.github.tcurrie.rest.factory.it.apis;
import java.util.Set;
public interface TestApi {
    void runnable();
    void consumer(Pojo m);
    Pojo producer();
    Pojo reverse(Pojo c);
    Pojo concatenate(Pojo a, Pojo b);
    Set<Pojo> dedup(Pojo... values);
    Pojo min(Set<Pojo> values);
    int add(int a, int b);
    int sum(int... values);
    int throwsException() throws Exception;
    int throwsRuntimeException();
    String join(String[] values);
    String join(String[] values, String separator);
}",java
"CREATE TABLE foo (id serial not null, bar_id int references bar(id));
CREATE TABLE bar (id serial not null);
-- name: RightJoin :many
SELECT f.id, f.bar_id, b.id
FROM foo f
RIGHT JOIN bar b ON b.id = f.bar_id
WHERE f.id = $1;",mysql
"require ""advent_of_code_2017/day2/spreadsheet_line""
RSpec.describe AdventOfCode2017::Day2::SpreadsheetLine do
  describe ""#largest_difference"" do
    samples = {
      ""5 1 9 5"" => 8,
      ""7 5 3"" => 4,
      ""2 4 6 8"" => 6
    }
    samples.each do |input, expectation|
      it ""returns #{expectation} for #{input}"" do
        cells = input.split.map(&:to_i)
        solver = AdventOfCode2017::Day2::SpreadsheetLine.new(cells)
        expect(solver.largest_difference).to eq expectation
      end
    end
  end
  describe ""#even_division"" do
    samples = {
      ""5 9 2 8"" => 4,
      ""9 4 7 3"" => 3,
      ""3 8 6 5"" => 2
    }
    samples.each do |input, expectation|
      it ""returns #{expectation} for #{input}"" do
        cells = input.split.map(&:to_i)
        solver = AdventOfCode2017::Day2::SpreadsheetLine.new(cells)
        expect(solver.even_division).to eq expectation
      end
    end
  end
end",ruby
"package kinesis
import (
	""github.com/awslabs/goformation/v4/cloudformation/policies""
)


type Stream_StreamEncryption struct {



	EncryptionType string `json:""EncryptionType,omitempty""`



	KeyId string `json:""KeyId,omitempty""`

	AWSCloudFormationDeletionPolicy policies.DeletionPolicy `json:""-""`

	AWSCloudFormationDependsOn []string `json:""-""`

	AWSCloudFormationMetadata map[string]interface{} `json:""-""`
}

func (r *Stream_StreamEncryption) AWSCloudFormationType() string {
	return ""AWS::Kinesis::Stream.StreamEncryption""
}",go
"

require 'google/protobuf'
require 'google/api/field_behavior_pb'
require 'google/api/resource_pb'
require 'google/api/annotations_pb'
Google::Protobuf::DescriptorPool.generated_pool.build do
  add_file(""google/ads/googleads/v8/resources/hotel_group_view.proto"", :syntax => :proto3) do
    add_message ""google.ads.googleads.v8.resources.HotelGroupView"" do
      optional :resource_name, :string, 1
    end
  end
end
module Google
  module Ads
    module GoogleAds
      module V8
        module Resources
          HotelGroupView = ::Google::Protobuf::DescriptorPool.generated_pool.lookup(""google.ads.googleads.v8.resources.HotelGroupView"").msgclass
        end
      end
    end
  end
end",ruby
"package breaker
import (
	""time""
	xtime ""github.com/1024casts/snake/pkg/time""
)

type Config struct {
	SwitchOff bool // breaker switch,default off.

	K float64
	Window  xtime.Duration
	Bucket  int
	Request int64
}
func (conf *Config) fix() {
	if conf.K == 0 {
		conf.K = 1.5
	}
	if conf.Request == 0 {
		conf.Request = 100
	}
	if conf.Bucket == 0 {
		conf.Bucket = 10
	}
	if conf.Window == 0 {
		conf.Window = xtime.Duration(3 * time.Second)
	}
}",go
"const keys = require('../../config/keys');
module.exports = survey => {
  return `
    <html>
      <body>
        <div style=""text-align: center;"">
          <h3>I'd like your input!</h3>
          <p>Please answer the following question:</p>
          <p>${survey.body}</p>
          <div>
            <a href=""${keys.redirectDomain}/api/surveys/${survey.id}/yes"">Yes</a>
          </div>
          <div>
            <a href=""${keys.redirectDomain}/api/surveys/${survey.id}/no"">No</a>
          </div>
        </div>
      </body>
    </html>
  `;
};",javascript
"



namespace gp1::renderer::apis::vulkan::mesh
{
	VulkanStaticMeshData::VulkanStaticMeshData(renderer::mesh::StaticMesh* mesh)
	    : VulkanMeshData(mesh) {}
} // namespace gp1::renderer::apis::vulkan::mesh",cpp
"import tkinter
from tkinter import *
win = Tk()
sb = Spinbox(win, from_=0, to=10)
sb.pack()
win.mainloop()",python
"package com.kiuwan.importer.beans;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name=""violation"")
public class Violation {
	File file;
	Rule rule;
	public Violation() {
	}
	public Violation(File file, Rule rule) {
		this.file = file;
		this.rule = rule;
	}
	public File getFile() {
		return file;
	}
	@XmlElement
	public void setFile(File file) {
		this.file = file;
	}
	public Rule getRule() {
		return rule;
	}
	@XmlElement
	public void setRule(Rule rule) {
		this.rule = rule;
	}
}",java
"
CKEDITOR.plugins.setLang( 'specialchar', 'bg', {
	options: 'Опции за специален знак',
	title: 'Избор на специален знак',
	toolbar: 'Вмъкване на специален знак'
} );",javascript
"SELECT lcm(15, 10);
SELECT lcm(-15, 10);
SELECT lcm(15, -10);
SELECT lcm(-15, -10);
-- Implementation specific result on overflow:
SELECT ignore(lcm(256, 9223372036854775807));
SELECT ignore(lcm(256, -9223372036854775807));
SELECT ignore(lcm(-256, 9223372036854775807));
SELECT ignore(lcm(-256, -9223372036854775807));",mysql
"""""""
Third generation models implementation (VPIN)
""""""
import pandas as pd
def get_vpin(volume: pd.Series, buy_volume: pd.Series, window: int = 1) -> pd.Series:
    """"""
    Get Volume-Synchronized Probability of Informed Trading (VPIN) from bars, p. 292-293.
    :param volume: (pd.Series) bar volume
    :param buy_volume: (pd.Series) bar volume classified as buy (either tick rule, BVC or aggressor side methods applied)
    :param window: (int) estimation window
    :return: (pd.Series) VPIN series
    """"""
    sell_volume = volume - buy_volume
    volume_imbalance = abs(buy_volume - sell_volume)
    return volume_imbalance.rolling(window=window).mean() / volume",python
"

months  = (""January"",
""February"",
""March"",
""April"",
""May"",
""June"",
""July"",
""August"",
""September"",
""October"",
""November"",
""December"")
summer = months[4:7]
for month in summer:
    print(month)",python
"-- Database: derby
-- Change Parameter: constraintName=const_name
-- Change Parameter: tableName=person
ALTER TABLE person DROP CONSTRAINT const_name;",mysql
"""""""
WSGI config for hymn256 project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/3.2/howto/deployment/wsgi/
""""""
import os
from django.core.wsgi import get_wsgi_application
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'hymn256.settings')
application = get_wsgi_application()",python
"class CreateAllTables < ActiveRecord::Migration[5.1]
  def change
   create_table ""users"", force: :cascade, options: ""ENGINE=InnoDB DEFAULT CHARSET=utf8"" do |t|
      t.string ""email""
      t.datetime ""created_at"", null: false
      t.datetime ""updated_at"", null: false
      t.string ""password_digest""
      t.string ""remember_digest""
      t.boolean ""admin"", default: false
      t.string ""activation_digest""
      t.boolean ""activated"", default: false
      t.datetime ""activated_at""
      t.string ""reset_digest""
      t.datetime ""reset_sent_at""
      t.string ""name""
      t.index [""email""], name: ""index_users_on_email"", unique: true
    end
  end
end",ruby
"
Rails.application.configure do


  config.cache_classes = true




  config.eager_load = true

  config.consider_all_requests_local       = false
  config.action_controller.perform_caching = true





  config.public_file_server.enabled = ENV['RAILS_SERVE_STATIC_FILES'].present?

  config.assets.js_compressor = :uglifier


  config.assets.compile = false







  config.active_storage.service = :local








  config.log_level = :debug

  config.log_tags = [:request_id]





  config.action_mailer.perform_caching = false





  config.i18n.fallbacks = true

  config.active_support.deprecation = :notify

  config.log_formatter = ::Logger::Formatter.new



  if ENV['RAILS_LOG_TO_STDOUT'].present?
    logger           = ActiveSupport::Logger.new(STDOUT)
    logger.formatter = config.log_formatter
    config.logger    = ActiveSupport::TaggedLogging.new(logger)
  end

  config.active_record.dump_schema_after_migration = false
end",ruby
"CREATE OR REPLACE VIEW OSP$BUDGET_JUSTIFICATION ( PROPOSAL_NUMBER, VERSION_NUMBER, BUDGET_JUSTIFICATION, UPDATE_TIMESTAMP, UPDATE_USER ) 
AS select null,null,null,null,null
	from dual;",mysql
"import React from 'react';
import Button from 'material-ui/Button';
import { compose, withHandlers } from 'recompose';
import { graphql } from 'react-apollo';
import UserQuery from '../UserQuery';
import START_DRAFT_MUTATION from '../../graphql/StartDraftMutation.graphql';
const DraftStartButton = ({ league, startDraft }) => (
  <UserQuery>
    {({ user }) =>
      user && user.id === league.creator.id && league.status === 'IDLE' ? (
        <Button
          size=""large""
          variant=""raised""
          color=""primary""
          onClick={startDraft}
        >
          Start Draft
        </Button>
      ) : null
    }
  </UserQuery>
);
const enhanced = compose(
  graphql(START_DRAFT_MUTATION, { name: 'startDraftMutation' }),
  withHandlers({
    startDraft: ({ league, startDraftMutation }) => () =>
      startDraftMutation({ variables: { leagueId: league.id } }),
  })
)(DraftStartButton);
export default enhanced;",javascript
"function arePasswordsEqual(original, newPassword) {
    if (original == newPassword) {
        return true;
    }
    else {
        return false;
    }
}",javascript
"package org.firstinspires.ftc.teamcode.subsystems;
import com.qualcomm.robotcore.hardware.DcMotor;
import com.qualcomm.robotcore.hardware.DcMotorSimple;
import com.qualcomm.robotcore.util.Range;
public class FlyWheels {
    DcMotor flyWheelLeft;
    DcMotor flyWheelRight;
    public FlyWheels(DcMotor flyWheelLeft, DcMotor flyWheelRight) {
        this.flyWheelLeft = flyWheelLeft;
        this.flyWheelRight = flyWheelRight;
        flyWheelLeft.setDirection(DcMotor.Direction.FORWARD);
        flyWheelLeft.setDirection(DcMotor.Direction.FORWARD);
    }
    public void setPower(double power) {
        power = Range.clip(power, -1, 1);
        flyWheelRight.setPower(power);
        flyWheelLeft.setPower(power);
    }
    public void stop() {
        flyWheelLeft.setPower(0.0);
        flyWheelRight.setPower(0.0);
    }
}",java
"












package zipkinexporter
import (
	""github.com/open-telemetry/opentelemetry-collector/config/configmodels""
)

type Config struct {
	configmodels.ExporterSettings `mapstructure:"",squash""` // squash ensures fields are correctly decoded in embedded struct.


	URL    string `mapstructure:""url""`
	Format string `mapstructure:""format""`



	ExportResourceLabels *bool `mapstructure:""export_resource_labels""`
	DefaultServiceName string `mapstructure:""default_service_name""`
}",go
"package applicationserver
import ""github.com/mxc-foundation/lpwan-server/internal/api/client/asclient""
var pool asclient.Pool

func SetPool(p asclient.Pool) {
	pool = p
}

func Pool() asclient.Pool {
	return pool
}

func Setup() error {
	pool = asclient.NewPool()
	return nil
}",go
"package question

func removeDuplicates2(nums []int) int {

	if len(nums) < 3 {
		return len(nums)
	}

	left, right := 2, 2
	for right < len(nums) {
		if nums[left-2] != nums[right] {
			nums[left] = nums[right]
			left++
		}
		right++
	}
	return left
}",go
"workers Integer(ENV['WEB_CONCURRENCY'] || 2)
threads_count = Integer(ENV['MAX_THREADS'] || 5)
threads threads_count, threads_count
preload_app!
rackup      DefaultRackup
port        ENV['PORT']     || 3000
environment ENV['RACK_ENV'] || 'production'
on_worker_boot do


  ActiveRecord::Base.establish_connection
end",ruby
"(function(){
	var iframe = document.createElement('iframe');
	iframe.src = chrome.extension.getURL('rate.html');
	iframe.id = 'effective';
	iframe.style.zIndex = '9999999'; 
	iframe.style.width = '395px';
	iframe.style.height = '230px';
	iframe.style.top = '20px';
	iframe.style.right = '30px';
	iframe.style.position = 'fixed';
	iframe.style.border = '3px solid black';
	document.body.appendChild(iframe);
})();",javascript
"import Vue from 'vue'
import Vuex from 'vuex'
Vue.use(Vuex)
export default new Vuex.Store({
	state: {
	},
	mutations: {
		set(state, data){
			Vue.set(state, data.key, data.value)
		},
		unset(state, key){
			Vue.set(state, key, null)
		},
		list(state, key){
			Vue.set(state, '__list', key)
		}
	},
	actions: {
	}
})",javascript
"-- SQL in this file will be loaded into the database after the webinstaller
-- has been run/mimicked. This means that it will only be run/loaded if
-- skip_webinstaller=""1"" in config.cfg
-- Make sure language and opaclanguages are both set to 'en'
UPDATE systempreferences SET value = 'en' WHERE variable = 'language';
UPDATE systempreferences SET value = 'en' WHERE variable = 'opaclanguages';",mysql
"
var gutil        = require('gulp-util');
var prettyHrtime = require('pretty-hrtime');
var startTime;
module.exports = {
  start: function(filepath) {
    startTime = process.hrtime();
    gutil.log('Bundling', gutil.colors.green(filepath) + '...');
  },
  end: function(filepath) {
    var taskTime = process.hrtime(startTime);
    var prettyTime = prettyHrtime(taskTime);
    gutil.log('Bundled', gutil.colors.green(filepath), 'in', gutil.colors.magenta(prettyTime));
  }
};",javascript
"package helpers
import (
	""bytes""
	""html""
	""github.com/miekg/mmark""
	""github.com/russross/blackfriday""
	""github.com/spf13/viper""
)


type HugoHtmlRenderer struct {
	blackfriday.Renderer
}
func (renderer *HugoHtmlRenderer) BlockCode(out *bytes.Buffer, text []byte, lang string) {
	if viper.GetBool(""PygmentsCodeFences"") {
		opts := viper.GetString(""PygmentsOptions"")
		str := html.UnescapeString(string(text))
		out.WriteString(Highlight(str, lang, opts))
	} else {
		renderer.Renderer.BlockCode(out, text, lang)
	}
}


type HugoMmarkHtmlRenderer struct {
	mmark.Renderer
}
func (renderer *HugoMmarkHtmlRenderer) BlockCode(out *bytes.Buffer, text []byte, lang string, caption []byte, subfigure bool, callouts bool) {
	if viper.GetBool(""PygmentsCodeFences"") {
		str := html.UnescapeString(string(text))
		out.WriteString(Highlight(str, lang, """"))
	} else {
		renderer.Renderer.BlockCode(out, text, lang, caption, subfigure, callouts)
	}
}",go
"select title, akas
from gcp.gcp_compute_target_ssl_proxy
where name = '{{ resourceName }}';",mysql
"module HealthSeven::V2_3_1
class Nte < ::HealthSeven::Segment

  attribute :set_id_nte, Si, position: ""NTE.1""

  attribute :source_of_comment, Id, position: ""NTE.2""

  attribute :comments, Array[Ft], position: ""NTE.3"", multiple: true

  attribute :comment_type, Ce, position: ""NTE.4""
end
end",ruby
"import m from ""mithril"";
export const Settings = {
  view: ({ attrs: { actions } }) => [
    m(""h3"", ""Settings Page""),
    m(""button.btn.btn-danger"", { onclick: () => actions.settings.logout() }, ""Logout"")
  ]
};",javascript
"""""""
Module imports for templates.python.business_logic.my_project.my_app.migrations
This file is automatically generated by ./scripts/empty_pyinit.sh
DO NOT EDIT IT MANUALLY
""""""",python
"import basicHelperTests from './basic-helper';
import errorRelatedFunctionTests from './error-related';
import rulesCountersTests from './rules-counters';
describe('Common utils', () => {
	describe('Error related functions', errorRelatedFunctionTests);
	describe('Basic helpers', basicHelperTests);
	describe('Rules counters', rulesCountersTests);
});",javascript
"class Solution {
public:
    int projectionArea(vector<vector<int>>& grid) {
        int m = grid.size(), n = grid[0].size();
        int side = 0, front = 0, top = 0;
        for(int i = 0; i < m; ++i) {
            int temp = 0;
            for(int j = 0; j < n; ++j) {
                if (grid[i][j] > 0) ++top;
                if (grid[i][j] > temp) temp = grid[i][j];
            }
            side += temp;
        }
        for(int j = 0; j < n; ++j) {
            int temp = 0;
            for(int i = 0; i < m; ++i) {
                if (grid[i][j] > temp) temp = grid[i][j];
            }
            front += temp;
        }
        return side + front + top;
    }
};",cpp
"INSERT INTO portti_bundle (name, startup) 
       VALUES ('parcelinfo','{}');
UPDATE portti_bundle set startup = '{
        ""title"" : ""Parcel Info"",
        ""bundleinstancename"" : ""parcelinfo"",
        ""fi"" : ""Paikan info"",
        ""sv"" : ""parcelinfo"",
        ""en"" : ""parcelinfo"",
        ""bundlename"" : ""parcelinfo"",
        ""metadata"" : {
            ""Import-Bundle"" : {
                ""parcelinfo"" : {
                    ""bundlePath"" : ""/Oskari/packages/framework/bundle/""
                }
            }
        }
    }' WHERE name = 'parcelinfo';",mysql
"CREATE PROCEDURE SP283(OUT MYCOUNT INTEGER) SPECIFIC SP283_24563 LANGUAGE SQL NOT DETERMINISTIC READS SQL DATA NEW SAVEPOINT LEVEL BEGIN ATOMIC DECLARE MYVAR INT;SELECT COUNT(*)INTO MYCOUNT FROM TABLE300;SELECT COUNT(*)INTO MYCOUNT FROM TABLE199;SELECT COUNT(*)INTO MYCOUNT FROM TABLE89;SELECT COUNT(*)INTO MYCOUNT FROM VIEW5;SELECT COUNT(*)INTO MYCOUNT FROM VIEW12;SELECT COUNT(*)INTO MYCOUNT FROM VIEW83;END
GO",mysql
"""""""
WSGI config for tw project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/2.0/howto/deployment/wsgi/
""""""
import os
from django.core.wsgi import get_wsgi_application
os.environ.setdefault(""DJANGO_SETTINGS_MODULE"", ""tw.settings"")
application = get_wsgi_application()",python
"module Ilex
  module ArbreExt
    module HTML
      module TextNode
        def build(string)
          @content = if string.is_a? Array
                       string.join.html_safe
                     else
                       string
                     end
        end
      end
    end
  end
end",ruby
"package object
import (
	""bytes""
	""github.com/Hydrogen/src/ast""
)
type Block struct {
	Body *ast.BlockStatement
	Env  *Environment
}
func (f *Block) Type() ObjectType { return FUNCTION_OBJ }
func (f *Block) Inspect() string {
	var out bytes.Buffer
	return out.String()
}",go
"package cn.cicoding.service.impl;
import cn.cicoding.service.UserService;
import cn.cicoding.dao.UserDaoMapper;
import cn.cicoding.model.User;
import cn.cicoding.model.UserItem;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class UserServiceImpl implements UserService {
	@Autowired
	private UserDaoMapper userDao;
	public List<User> list() {
		List<User> list = userDao.list();
		return list;
	}
	public Long add(User user) {
		return userDao.addUser(user);
	}
	@Override
	public User findById(Long id) {
		return userDao.findById(id);
	}
	@Override
	public User findByName(String name) {
		return userDao.findByName(name);
	}
	@Override
	public Long clean() {
		return userDao.clean();
	}
	@Override
	public Long addUserItem(UserItem userItem) {
		return userDao.addUserItem(userItem);
	}
}",java
"
import templateMaker from '../../helpers/templateMaker';
const htmls = {
    HTML_AXIS_TICK_LINE: '<div class=""tui-chart-tick-line""' +
        ' style=""{{ positionType }}:{{ positionValue }}px;{{ sizeType }}:{{ size }}px""></div>',
    HTML_AXIS_TICK: '<div class=""tui-chart-tick"" style=""{{ cssText }}""></div>',
    HTML_AXIS_LABEL: '<div class=""tui-chart-label{{ additionalClass }}"" style=""{{ cssText }}"">' +
        '<span{{ spanCssText }}>{{ label }}</span></div>'
};
export default {
    tplTickLine: templateMaker.template(htmls.HTML_AXIS_TICK_LINE),
    tplAxisTick: templateMaker.template(htmls.HTML_AXIS_TICK),
    tplAxisLabel: templateMaker.template(htmls.HTML_AXIS_LABEL)
};",javascript
"package com.acgist.snail.context.initializer;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
import com.acgist.snail.context.NodeContext;
import com.acgist.snail.utils.Performance;
class DhtInitializerTest extends Performance {
	@Test
	void testDhtInitializer() {
		DhtInitializer.newInstance().sync();
		assertTrue(NodeContext.getInstance().nodes().size() > 0);
	}
}",java
"


using namespace AlibabaCloud::Dataworks_public;
using namespace AlibabaCloud::Dataworks_public::Model;
UpdateNodeOwnerResult::UpdateNodeOwnerResult() :
	ServiceResult()
{}
UpdateNodeOwnerResult::UpdateNodeOwnerResult(const std::string &payload) :
	ServiceResult()
{
	parse(payload);
}
UpdateNodeOwnerResult::~UpdateNodeOwnerResult()
{}
void UpdateNodeOwnerResult::parse(const std::string &payload)
{
	Json::Reader reader;
	Json::Value value;
	reader.parse(payload, value);
	setRequestId(value[""RequestId""].asString());
	if(!value[""Success""].isNull())
		success_ = value[""Success""].asString() == ""true"";
}
bool UpdateNodeOwnerResult::getSuccess()const
{
	return success_;
}",cpp
"package model
import (
	""github.com/huaweicloud/huaweicloud-sdk-go-v3/core/utils""
	""strings""
)

type ListListenerTagsRequest struct {
}
func (o ListListenerTagsRequest) String() string {
	data, err := utils.Marshal(o)
	if err != nil {
		return ""ListListenerTagsRequest struct{}""
	}
	return strings.Join([]string{""ListListenerTagsRequest"", string(data)}, "" "")
}",go
"package main
import (
	""flag""
	""log""
	""os""
	""github.com/jaypadia-frame/forked-mp4ff/mp4""
)
func main() {
	inFilePath := flag.String(""i"", """", ""Required: Path to input mp4 file"")
	outFilePath := flag.String(""o"", """", ""Required: Output filepath (without extension)"")
	flag.Parse()
	if *inFilePath == """" || *outFilePath == """" {
		flag.Usage()
		return
	}
	ifd, err := os.Open(*inFilePath)
	if err != nil {
		log.Fatalln(err)
	}
	defer ifd.Close()
	parsedMp4, err := mp4.DecodeFile(ifd)
	if err != nil {
		log.Fatal(err)
	}
	parsedMp4.Init.Moov.Mvex.Trex.TrackID = 3
	ofd, err := os.Create(*outFilePath)
	if err != nil {
		log.Fatal(err)
	}
	defer ofd.Close()
	err = parsedMp4.Encode(ofd)
	if err != nil {
		log.Fatal(err)
	}
}",go
"import csv
def ClassFactory(class_name, dictionary):
    return type(class_name, (object,), dictionary)
class CsvReader:
    def __init__(self, filepath):
        self.data = []
        with open(filepath) as csv_files:
            csv_data = csv.DictReader(csv_files, delimiter=',')
            for row in csv_data:
                self.data.append(row)
        pass
    def return_data_object(self, class_name):
        objects = []
        for row in self.data:
            objects.append(ClassFactory(class_name, row))
        return objects",python
"






using namespace Aws::CodeBuild::Model;
using namespace Aws::Utils::Json;
using namespace Aws::Utils;
using namespace Aws;
DeleteWebhookResult::DeleteWebhookResult()
{
}
DeleteWebhookResult::DeleteWebhookResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
{
  *this = result;
}
DeleteWebhookResult& DeleteWebhookResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
{
  AWS_UNREFERENCED_PARAM(result);
  return *this;
}",cpp
"-- All TAS values in File B (object class program activity) should exist in File A (appropriation)
SELECT op.row_number AS ""source_row_number"",
    op.allocation_transfer_agency AS ""source_value_allocation_transfer_agency"",
    op.agency_identifier AS ""source_value_agency_identifier"",
    op.beginning_period_of_availa AS ""source_value_beginning_period_of_availa"",
    op.ending_period_of_availabil AS ""source_value_ending_period_of_availabil"",
    op.availability_type_code AS ""source_value_availability_type_code"",
    op.main_account_code AS ""source_value_main_account_code"",
    op.sub_account_code AS ""source_value_sub_account_code"",
    op.display_tas AS ""uniqueid_TAS""
FROM object_class_program_activity AS op
WHERE op.submission_id = {0}
    AND NOT EXISTS (
        SELECT 1
        FROM appropriation AS approp
        WHERE op.account_num IS NOT DISTINCT FROM approp.account_num
            AND op.submission_id = approp.submission_id
    );",mysql
"













""""""Util import.""""""

from tensorflow_datasets.core.utils.image_utils import *
from tensorflow_datasets.core.utils.py_utils import *
from tensorflow_datasets.core.utils.tf_utils import *
from tensorflow_datasets.core.utils.tqdm_utils import *
from tensorflow_datasets.core.utils.version import Experiment
from tensorflow_datasets.core.utils.version import Version
",python
"const path = require('path')

exports.createPages = ({ graphql, boundActionCreators }) => {
  const { createPage } = boundActionCreators
  return new Promise((resolve, reject) => {
    const postTemplate = path.resolve(`src/templates/post.js`)

    resolve(
      graphql(
        `
          {
            allContentfulPost {
              edges {
                node {
                  id
                  title
                  slug
                  content {
                    content
                  }
                }
              }
            }
          }
        `
      ).then(result => {
        console.log(result)
        if (result.errors) {
          reject(result.errors)
        } else {

          result.data.allContentfulPost.edges.forEach(edge => {
            createPage({
              path: `${edge.node.slug}`,
              component: postTemplate,
              context: edge.node,
            })
          })
        }
        return
      })
    )
  })
}",javascript
"export function isRequired(report, schema, json) { // eslint-disable-line import/prefer-default-export
  const originalPath = report.path;
  if (Array.isArray(schema.required)) {
    schema.required.forEach(prop => {
      const hasValue = json[prop];
      if (!hasValue) {
        report.path = [prop]; // eslint-disable-line no-param-reassign
        report.addCustomError('IS_REQUIRED', 'Field is required', [prop], null, schema.description);
      }
    });
  }
  report.path = originalPath; // eslint-disable-line no-param-reassign
}",javascript
"
package org.jfree.chart;

public interface Effect3D {
    
    public double getXOffset();
    
    public double getYOffset();
}",java
"






namespace Fsl
{

  class MouseMoveEvent : public BasicEvent
  {
  public:
    explicit MouseMoveEvent(const BasicEvent& encodedEvent)
      : BasicEvent(encodedEvent)
    {
      if (m_type != EventType::MouseMove)
      {
        throw std::invalid_argument(""The supplied argument is of a wrong type"");
      }
    }
    MouseMoveEvent(const PxPoint2& position, const VirtualMouseButtonFlags& mouseButtonFlags);

    PxPoint2 GetPosition() const;

    VirtualMouseButtonFlags GetMouseButtonFlags() const;
  };
}
",cpp
"



namespace dart {
namespace collision {

CollisionDetector* CollisionObject::getCollisionDetector()
{
  return mCollisionDetector;
}

const CollisionDetector* CollisionObject::getCollisionDetector() const
{
  return mCollisionDetector;
}

const dynamics::ShapeFrame* CollisionObject::getShapeFrame() const
{
  return mShapeFrame;
}

dynamics::ConstShapePtr CollisionObject::getShape() const
{
  return mShapeFrame->getShape();
}

const Eigen::Isometry3d& CollisionObject::getTransform() const
{
  return mShapeFrame->getWorldTransform();
}

CollisionObject::CollisionObject(
    CollisionDetector* collisionDetector,
    const dynamics::ShapeFrame* shapeFrame)
  : mCollisionDetector(collisionDetector),
    mShapeFrame(shapeFrame)
{
  assert(mCollisionDetector);
  assert(mShapeFrame);
}
}  // namespace collision
}  // namespace dart",cpp
"import pickle 
dict1 = {'Python ':90,'Java ':95,'C++ ':85}
f = open('bin)file.dat','wb')
pickle.dump(dict1,f)
f.close()",python
"package main
import (
	""fmt""
	""io""
	""os""
	""strings""
)
func FileExists(path string) bool {
	_, err := os.Stat(path)
	return err == nil
}
func CopyFile(src, dst string) (int64, error) {
	sf, err := os.Open(src)
	if err != nil {
		return 0, err
	}
	defer sf.Close()
	df, err := os.Create(dst)
	if err != nil {
		return 0, err
	}
	defer df.Close()
	return io.Copy(df, sf)
}
func LoadConfigOrDie(file string) *Config {
	conf, err := LoadConfig(file)
	if err != nil {
		fmt.Printf(""error while loading config file: '%v'\n"", err)
		fmt.Println(""to generate a sample config file use the generate-config command"")
		os.Exit(1)
	}
	return conf
}

func IndentWith(str string, indent string) string {
	nl := ""\n""
	spl := strings.Split(str, nl)
	if spl[len(spl)-1] == """" {
		spl = spl[:len(spl)-1]
	}
	for idx, line := range spl {
		spl[idx] = indent + line
	}
	return strings.Join(spl, nl)
}",go
"



package main
import (
	""mime""
	""github.com/Go-zh/tools/present""
)
func init() {
	initTemplates(""./present/"")
	present.PlayEnabled = true
	initPlayground(""./present/"", nil)

	mime.AddExtensionType("".svg"", ""image/svg+xml"")
}",go
"package com.pepper.framework.interceptor.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Inherited
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RepeatSubmit
{
}",java
"package config
import (
	""github.com/anchore/syft/syft/source""
	""github.com/spf13/viper""
)
type fileClassification struct {
	Cataloger catalogerOptions `yaml:""cataloger"" json:""cataloger"" mapstructure:""cataloger""`
}
func (cfg fileClassification) loadDefaultValues(v *viper.Viper) {
	v.SetDefault(""file-classification.cataloger.enabled"", true)
	v.SetDefault(""file-classification.cataloger.scope"", source.SquashedScope)
}
func (cfg *fileClassification) parseConfigValues() error {
	return cfg.Cataloger.parseConfigValues()
}",go
"export default {
    namespaced: true,
    state: {},
    mutations: {},
    getters: {},
    actions: {
        updateProfile(context, user) {
            context.commit('loading_status', true, { root: true })
            axios.patch(`/api/profile/update/${user.id}`, user)
                 .then( response => {
                    context.commit('loading_status', false, { root: true })
                    context.commit('set_flashmessage', {message: 'Profile Updated Successfully', type: 'success'}, { root: true })
                 })
        }
    }
}",javascript
"
package org.bridj.objc;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
@Retention(RetentionPolicy.RUNTIME)
public @interface Selector {
    String value();
}",java
"









namespace rtt_dsxx {

using mmdevs = std::multimap<int, std::string, std::greater<>>;
using fomdev = std::pair<int, std::string>;

const std::string release();

const std::string author_list(bool const use_doxygen_formatting = false);

const std::string copyright();


std::string print_devs(size_t const maxlinelen, std::string const &line_name, mmdevs const &devs);
} // namespace rtt_dsxx

extern ""C"" void ec_release(char *release_string, size_t maxlen);



",cpp
"







namespace Avni
{ 
    void Log(char* str, int numarg , ... ) // supports only float and integer, maximum 10 nos
    {
        static char string[512];
        if(numarg)
        {
            va_list arglist;
            va_start(arglist, numarg);
            sprintf_s(str, strlen(str), string, arglist);
            va_end(arglist);
        }
        else
        {
            strcpy_s(string,(const char*)str);
        }

        OutputDebugStringA(string);
    }
}",cpp
"import { writable } from ""svelte/store"";
export const access_token = writable(undefined);
export const user = writable(undefined);
export const playlists = writable([]);
export const playingTrack = writable();
export const tournamentModes = {
  singleElimination: ""single-elimination"",
  doubleElimination: ""double-elimination""
};
export const tournamentMode = writable(tournamentModes.singleElimination);",javascript
"urlpatterns = []
handler404 = ""csrf_tests.views.csrf_token_error_handler""",python
"package de.dominikschadow.javasecurity.logging.home;
public class Login {
    private String username;
    private String password;
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
}",java
"import unittest
from code.google_search import get_people_also_ask_links
class TestGoogleSearch(unittest.TestCase):
    def setUp(self) -> None:
        pass
    def test_get_people_also_ask_links(self):
        """"""Test the get_people_also_ask_links method""""""
        test = ""principal components""
        result = get_people_also_ask_links(test)
        self.assertEqual(list, type(result))",python
"'use strict';
const tabs = require('sdk/tabs');
const chromeTabs = require('chrome-tabs-api');
exports['test '] = function(assert, done) {
    var url = 'data:text/html,' + encodeURIComponent('<title>Test</title>');
    tabs.open({
        url: url,
        onReady: function(tab) {
            assert.ok(tab, 'SDK Tab exists'); // Pre-requisite
            testSdkTab(tab);
            testSdkTab = function() {}; // Run once
        }
    });
    function testSdkTab(tab) {
        var chromeTab = chromeTabs.toChromeTab(tab);
        assert.equal(tab.url, chromeTab.url, 'Tab\'s ""url"" property must be equal');
        assert.equal(false, chromeTab.pinned, 'Tab\'s ""pinned"" property must be false');
        var ffTab = chromeTabs.toFirefoxTab(chromeTab);
        assert.equal(tab, ffTab, 'toFirefoxTab(toChromeTab(tab)) === tab');
        done();
    }
};
require('sdk/test').run(exports);",javascript
"


















int main()
{
   std::cout << ""   Running 'SDaSDa'..."" << std::endl;
   using blazetest::mathtest::TypeA;
   try
   {

      using SDa = blaze::SymmetricMatrix< blaze::DynamicMatrix<TypeA> >;

      using CSDa = blazetest::Creator<SDa>;

      for( size_t i=0UL; i<=9UL; ++i ) {
         RUN_DMATDMATADD_OPERATION_TEST( CSDa( i ), CSDa( i ) );
      }

      RUN_DMATDMATADD_OPERATION_TEST( CSDa(  67UL ), CSDa(  67UL ) );
      RUN_DMATDMATADD_OPERATION_TEST( CSDa( 128UL ), CSDa( 128UL ) );
   }
   catch( std::exception& ex ) {
      std::cerr << ""\n\n ERROR DETECTED during dense matrix/dense matrix addition:\n""
                << ex.what() << ""\n"";
      return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
}
",cpp
"alter table broadcasts
    drop subject,
    drop audience;",mysql
"Incognito::Engine.routes.draw do
  match ""#{Incognito.mount_to}/:uuid"", to: ""incognito#show"", via: :all
end",ruby
"
import paho.mqtt.client as mqtt
import json
import random
import math
import time
import ssl
config_mqtt_broker_ip = ""iot.fh-muenster.de""
config_mqtt_client_id = ""dummy-receiver-"" + str(random.randint(1000, 9999));
config_mqtt_topic     = ""sensor/60:01:94:4A:AF:7A""
ts_last_message = int(round(time.time() * 1000))

def on_connect(client, userdata, flags, rc):
	print(""Connected with result code "" + str(rc))
	client.subscribe(config_mqtt_topic)

def on_message(client, userdata, msg):
	print(msg.topic + "" "" + str(msg.payload))
mqtt_c = mqtt.Client(config_mqtt_client_id)
mqtt_c.on_connect = on_connect
mqtt_c.on_message = on_message
mqtt_c.tls_set(ca_certs=""ca.pem"")

mqtt_c.connect(config_mqtt_broker_ip, 8883, 60)
mqtt_c.loop_forever();",python
"


package timeline
import (
	""github.com/33cn/chain33/queue""
	drivers ""github.com/33cn/chain33/system/mempool""
	""github.com/33cn/chain33/types""
)
func init() {
	drivers.Reg(""timeline"", New)
}

func New(cfg *types.Mempool, sub []byte) queue.Module {
	c := drivers.NewMempool(cfg)
	var subcfg drivers.SubConfig
	types.MustDecode(sub, &subcfg)
	if subcfg.PoolCacheSize == 0 {
		subcfg.PoolCacheSize = cfg.PoolCacheSize
	}
	if subcfg.ProperFee == 0 {
		subcfg.ProperFee = cfg.MinTxFee
	}
	c.SetQueueCache(drivers.NewSimpleQueue(subcfg))
	return c
}",go
"package asset
import (
	""github.com/FnyaMing/nainaide/x/asset/internal/keeper""
	""github.com/FnyaMing/nainaide/x/asset/internal/types""
)
const (
	DefaultCodespace  = types.DefaultCodespace
	ModuleName        = types.ModuleName
	RouterKey         = types.RouterKey
	QuerierRoute      = types.QuerierRoute
	DefaultParamspace = keeper.DefaultParamspace
)
var (

	RegisterCodec = types.RegisterCodec
	NewKeeper     = keeper.NewKeeper
	NewQuerier    = keeper.NewQuerier
	NewParams     = types.NewParams

	ModuleCdc = types.ModuleCdc
	StoreKey  = types.StoreKey
)
type (
	Keeper = keeper.Keeper
	IssueMsg = types.IssueMsg
	MintMsg  = types.MintMsg
)",go
"package sorting
import (
	""testing""
)
func Test_insertionSort(t *testing.T) {
	type args struct {
		items []int
	}
	tests := []struct {
		name string
		args args
	}{
		{
			name: ""insertion sort test 1 positive 25 items"",
			args:args{items:generateSlice(25)},
		},
		{
			name: ""insertion sort test 1 positive 100 items"" ,
			args:args{items:generateSlice(100)},
		},
		{
			name: ""insertion sort test 1 positive 1000 items"" ,
			args:args{items:generateSlice(1000)},
		},
		{
			name: ""insertion sort test 1 positive 10000 items"" ,
			args:args{items:generateSlice(10000)},
		},
		{
			name: ""insertion sort test 1 positive 100000 items"" ,
			args:args{items:generateSlice(100000)},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			insertionSort(tt.args.items)
		})
	}
}
func BenchmarkInsertionTest(b *testing.B) {
		genSlice := generateSlice(b.N)
		b.StartTimer()
		insertionSort(genSlice)
}",go
"module Battle
  class Move

    class HealWeather < HealMove



      def deal_effect(user, targets)
        targets.each do |target|
          if $env.normal?
            hp = target.max_hp / 2
          elsif $env.sunny?
            hp = target.max_hp * 2 / 3
          else
            hp = target.max_hp / 4
          end
          hp = hp * 3 / 2 if pulse? && user.has_ability?(:mega_launcher)
          logic.damage_handler.heal(target, hp)
        end
      end
    end
    Move.register(:s_heal_weather, HealWeather)
  end
end",ruby
"require_relative ""../canvas_base_resolver""
require_relative ""../../types/canvas/media_track""
module LMSGraphQL
  module Resolvers
    module Canvas
      class ListMediaTracksForMediaObject < CanvasBaseResolver
        type [LMSGraphQL::Types::Canvas::CanvasMediaTrack], null: false
        argument :get_all, Boolean, required: false
        argument :media_object_id, ID, required: true
        argument :include, [String], required: false
        def resolve(media_object_id:, include: nil, get_all: false)
          result = context[:canvas_api].call(""LIST_MEDIA_TRACKS_FOR_MEDIA_OBJECT"").proxy(
            ""LIST_MEDIA_TRACKS_FOR_MEDIA_OBJECT"",
            {
              ""media_object_id"": media_object_id,
              ""include"": include            },
            nil,
            get_all,
          )
          get_all ? result : result.parsed_response
        end
      end
    end
  end
end",ruby
"CREATE TABLE nullable_table (
    id SERIAL PRIMARY KEY,
    value INTEGER
);",mysql
"select 'f?p=&APP_ID.:6:'||:app_session||':::6:P6_PRODUCT_ID,P6_BRANCH:'||p.product_id||',27:' link, 
    p.product_name||' [$'||p.list_price||']' product,
    SUM(oi.quantity * oi.unit_price) sales,
    decode(nvl(dbms_lob.getlength(p.product_image),0),0,null,
        apex_util.get_blob_file_src('P6_PRODUCT_IMAGE',p.product_id)) product_image
from demo_order_items oi,
    demo_product_info p
where oi.product_id = p.product_id
group by p.product_id, p.product_name, p.list_price,
    decode(nvl(dbms_lob.getlength(p.product_image),0),0,null,
        apex_util.get_blob_file_src('P6_PRODUCT_IMAGE',p.product_id))
order by 3 desc, 1",mysql
"



DATABASE_ENGINE = 'django.db.backends.sqlite3'
DATABASE_NAME = ':memory:'

SECRET_KEY = 'unittest'
DATABASES = {
    'default': {
        'ENGINE': DATABASE_ENGINE,
        'NAME': DATABASE_NAME,
    }
}
INSTALLED_APPS = ('django_app.adapters',)
MIDDLEWARE_CLASSES = ()",python
"var alertType = ""$var['jsalert']"";
var alerts = new Array();
alerts['csv_import_bad_filetype'] = ""$lang['lang_alerts_csv_import_bad_filetype']"";
alerts['csv_import_file_oversize'] = ""$lang['lang_alerts_csv_import_file_oversize']"";
alerts['csv_import_failed'] = ""$lang['lang_alerts_csv_import_failed']"";
alerts['csv_import_file_empty'] = ""$lang['lang_alerts_csv_import_file_empty']"";
if (alertType) {
    alert(alerts[alertType]);
}",javascript
"





ENGINE_ERROR_CODE add_failover_log(vbucket_failover_t* entries,
                                   size_t nentries,
                                   gsl::not_null<const void*> cookie) {
    ENGINE_ERROR_CODE ret;
    size_t ii;
    for (ii = 0; ii < nentries; ++ii) {
        entries[ii].uuid = htonll(entries[ii].uuid);
        entries[ii].seqno = htonll(entries[ii].seqno);
    }
    if (mcbpResponseHandlerFn(
                {},
                {},
                {reinterpret_cast<const char*>(entries),
                 (uint32_t)(nentries * sizeof(vbucket_failover_t))},
                PROTOCOL_BINARY_RAW_BYTES,
                cb::mcbp::Status::Success,
                0,
                (void*)cookie.get())) {
        ret = ENGINE_SUCCESS;
    } else {
        ret = ENGINE_ENOMEM;
    }
    for (ii = 0; ii < nentries; ++ii) {
        entries[ii].uuid = htonll(entries[ii].uuid);
        entries[ii].seqno = htonll(entries[ii].seqno);
    }
    return ret;
}",cpp
"--
-- 
-- connect to the database sample
CONNECT TO SAMPLE;
-- create the table to store the decomposed data
CREATE TABLE xdb.poemployee (empid VARCHAR(20), deptid VARCHAR(20), members XML);
-- 
-- register the schema document
REGISTER XMLSCHEMA 'http://porder.com/employee.xsd' FROM 'recemp.xsd' AS xdb.employee;
-- complete schema registration
COMPLETE XMLSCHEMA xdb.employee ENABLE DECOMPOSITION;
-- check catalog tables for information regarding registered schema.
SELECT status, decomposition, decomposition_version 
                       FROM SYSIBM.SYSXSROBJECTS 
                       where XSROBJECTNAME = 'EMPLOYEE';
-- 
-- decompose the XML document
DECOMPOSE XML DOCUMENT recemp.xml XMLSCHEMA xdb.employee VALIDATE;
-- 
-- check Decomposition result
SELECT * FROM xdb.poemployee ORDER BY empid;
-- 
-- drop the created objects
DROP XSROBJECT xdb.employee;
DROP TABLE xdb.poemployee ;
-- Reset connection
CONNECT RESET;",mysql
"












from program_helper.ast.ops import Node
from utilities.vocab_building_dictionary import DELIM
class DSymtabMod(Node):
    def __init__(self, val,
                 type_helper=None,
                 child=None, sibling=None):
        super().__init__(val, child, sibling)
        self.type_helper = type_helper if type_helper is not None else DELIM
        self.type = DSymtabMod.name()
    @staticmethod
    def name():
        return 'DSymtabMod'",python
"-- MySQL dump 10.13  Distrib 5.6.24, for Win64 (x86_64)
--
-- Host: 127.0.0.1    Database: estacionamento
-- ------------------------------------------------------
-- Server version	5.6.17
;
;
;
;
;
;
;
;
;
;
--
-- Table structure for table `status`
--
DROP TABLE IF EXISTS `status`;
;
;
CREATE TABLE `status` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `descricao` int(11) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
;
--
-- Dumping data for table `status`
--
LOCK TABLES `status` WRITE;
;
INSERT INTO `status` VALUES (1,0),(2,1);
;
UNLOCK TABLES;
;
;
;
;
;
;
;
;
-- Dump completed on 2016-06-02  9:57:58",mysql
"package com.wingsofts.byeburgernavigationview;

import android.content.Context;
import android.support.design.widget.CoordinatorLayout;
import android.support.v4.view.ViewCompat;
import android.util.AttributeSet;
import android.view.View;
import android.view.ViewConfiguration;

public class ByeBurgerTitleBehavior extends ByeBurgerBehavior {
  public ByeBurgerTitleBehavior(Context context, AttributeSet attrs) {
    super(context, attrs);
  }
  @Override public boolean layoutDependsOn(CoordinatorLayout parent, View child, View dependency) {
    if (canInit) {
      mAnimateHelper = TranslateAnimateHelper.get(child);
      canInit = false;
    }
    return super.layoutDependsOn(parent, child, dependency);
  }
  @Override protected void onNestPreScrollInit(View child) {
    if (isFirstMove) {
      isFirstMove = false;
      mAnimateHelper.setStartY(child.getY());
      mAnimateHelper.setMode(TranslateAnimateHelper.MODE_TITLE);
    }
  }
}",java
"export const TRANSLATE_INPUT = 'translate_input';
export default function (string) {
  const words = string.split(/\s+/);
  const translation = words.reduce((acc, word) => `${acc}${pigLatin(word)} `, '').trim();
  return {
    type: TRANSLATE_INPUT,
    payload: {
      original: string,
      translation,
    }
  };
}
function pigLatin(word) {
  const vowelStart = /^[aeiou].*$/;
  if (word.match(vowelStart)){
    return word + 'way';
  } else {
    return word.substr(1) + word.charAt(0) + 'ay';
  }
}",javascript
"import React, { Component } from 'react';
import {
  AppRegistry,
} from 'react-native';
import Navigation from ""./components/Navigation"";
AppRegistry.registerComponent('Grasp', () => Navigation);",javascript
"package gms.shared.mechanisms.configuration;
import static org.junit.jupiter.api.Assertions.assertAll;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import com.fasterxml.jackson.databind.ObjectMapper;
import gms.shared.mechanisms.configuration.util.ObjectSerialization;
import org.junit.jupiter.api.Test;
public class SelectorTests {
  private ObjectMapper objectMapper = ObjectSerialization.getObjectMapper();
  @Test
  public void testSerialization() throws Exception {
    final Selector<String> selectorStaIsGeres = Selector.from(""STATION"", ""geres"");
    final String json = objectMapper.writeValueAsString(selectorStaIsGeres);
    assertAll(
        () -> assertNotNull(json),
        () -> assertEquals(selectorStaIsGeres, objectMapper.readValue(json, Selector.class))
    );
  }
}",java
"

bool sphere::hit(const ray& r, float t_min, float t_max, hit_record& rec) const {
	vec3 oc = r.origin() - center;
	float a = dot(r.direction(), r.direction());
	float b = dot(oc, r.direction());
	float c = dot(oc, oc) - radius * radius;
	float discriminant = b * b - a * c;
	if (discriminant > 0) {
		float temp = (-b - sqrt(b*b - a * c)) / a;
		if (temp < t_max && temp > t_min) {
			rec.t = temp;
			rec.p = r.point_at_parameter(rec.t);
			rec.normal = (rec.p - center) / radius;
			return true;
		}
		temp = (-b + sqrt(b*b - a * c)) / a;
		if (temp < t_max && temp > t_min) {
			rec.t = temp;
			rec.p = r.point_at_parameter(rec.t);
			rec.normal = (rec.p - center) / radius;
			return true;
		}
	}
	return false;
}",cpp
"import django.http
import unittest.mock
from .. import middleware
def get_response(req):

    return django.http.HttpResponse()
def test_leaves_remote_addr_alone_if_no_real_ip():
    remote_addr = object()
    request = unittest.mock.MagicMock()
    request.META = {""REMOTE_ADDR"": remote_addr}
    middleware.XRealIPMiddleware(get_response)(request)
    assert request.META[""REMOTE_ADDR""] is remote_addr
def test_switches_out_x_real_ip_if_available():
    remote_addr = object()
    x_real_ip = object()
    request = unittest.mock.MagicMock()
    request.META = {""REMOTE_ADDR"": remote_addr, ""HTTP_X_REAL_IP"": x_real_ip}
    middleware.XRealIPMiddleware(get_response)(request)
    assert request.META[""REMOTE_ADDR""] is x_real_ip
    assert request.META[""HTTP_X_REAL_IP""] is x_real_ip",python
"CREATE OR REPLACE FUNCTION sref_system_to_srid(sref_system character varying)
  RETURNS integer AS
$BODY$
  BEGIN
    RETURN CASE lower(sref_system)
           WHEN 'osgb' THEN 27700
           WHEN 'osie' THEN 29901
           WHEN 'lugr' THEN 2169
           WHEN 'mtbqqq' THEN 4314
           WHEN 'guernsey' THEN 3108
           WHEN 'jersey' THEN 3109
           WHEN 'utm30ed50' THEN 23030
           WHEN 'utm30wgs84' THEN 32630
           ELSE sref_system :: INTEGER
           END;
  END;
  $BODY$
  LANGUAGE plpgsql VOLATILE
  COST 100;",mysql
"













package fuzz
import (
	""istio.io/istio/pilot/pkg/config/kube/crd""
)
func FuzzParseInputs(data []byte) int {
	_, _, err := crd.ParseInputs(string(data))
	if err != nil {
		return 0
	}
	return 1
}",go
"class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if (prices.size() <= 1) return 0;
        int res = 0;
        for (int i = 1; i < prices.size(); i++)
            if (prices[i] > prices[i - 1])
                res += (prices[i] - prices[i - 1]);
        return res;
    }
};",cpp
"from itertools import product
aarr = list(map(int, input().split()))
barr = list(map(int, input().split()))
print(' '.join(str(i) for i in list(product(*[aarr, barr]))))",python
"
MathJax.Hub.Insert(
  MathJax.OutputJax['HTML-CSS'].FONTDATA.FONTS['MathJax_Main-bold'],
  {
    0xA0: [0,0,250,0,0],               // NO-BREAK SPACE
    0xA8: [695,-535,575,96,478],       // DIAERESIS
    0xAC: [371,-61,767,64,702],        // NOT SIGN
    0xAF: [607,-540,575,80,494],       // MACRON
    0xB0: [702,-536,575,160,414],      // DEGREE SIGN
    0xB1: [728,35,894,64,829],         // PLUS-MINUS SIGN
    0xB4: [706,-503,575,236,460],      // ACUTE ACCENT
    0xD7: [530,28,894,168,726],        // MULTIPLICATION SIGN
    0xF7: [597,96,894,64,828]          // DIVISION SIGN
  }
);
MathJax.Ajax.loadComplete(MathJax.OutputJax[""HTML-CSS""].fontDir + ""/Main/Bold/Latin1Supplement.js"");",javascript