<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/umeng_comm_content_layout"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:clickable="true"
    android:orientation="vertical">

    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="@dimen/umeng_comm_dimen_48px"
        android:layout_marginLeft="@dimen/umeng_comm_dimen_30px"
        android:layout_marginRight="@dimen/umeng_comm_dimen_30px"
        android:layout_marginTop="@dimen/umeng_comm_dimen_30px">

        <TextView
            android:id="@+id/umeng_comm_feed_item_topic"
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            android:layout_alignParentRight="true"
            android:layout_centerInParent="true"
            android:background="@drawable/umeng_comm_feed_item_topic_bg"
            android:ellipsize="end"
            android:gravity="center_vertical"
            android:maxEms="7"
            android:paddingLeft="@dimen/umeng_comm_dimen_10px"
            android:paddingRight="@dimen/umeng_comm_dimen_10px"
            android:singleLine="true"
            android:text=""
            android:textColor="@color/umeng_comm_469ef8"
            android:textSize="@dimen/umeng_comm_text_22px" />

        <!-- 头像 -->
        <com.umeng.common.ui.widgets.RoundImageView
            android:id="@+id/user_portrait_img_btn"
            android:layout_width="@dimen/umeng_comm_dimen_48px"
            android:layout_height="@dimen/umeng_comm_dimen_48px"
            android:contentDescription="@string/umeng_comm_desc"
            android:scaleType="centerCrop"
            android:src="@drawable/umeng_comm_male" />

        <LinearLayout
            android:layout_width="wrap_content"
            android:layout_height="@dimen/umeng_comm_dimen_30px"
            android:layout_centerVertical="true"
            android:layout_marginRight="@dimen/umeng_comm_dimen_14px"
            android:layout_toLeftOf="@id/umeng_comm_feed_item_topic"
            android:layout_toRightOf="@id/user_portrait_img_btn"
            android:orientation="horizontal">

            <TextView
                android:id="@+id/umeng_comm_msg_user_name"
                android:layout_width="wrap_content"
                android:layout_height="match_parent"
                android:layout_marginLeft="@dimen/umeng_comm_dimen_20px"
                android:layout_marginRight="@dimen/umeng_comm_dimen_14px"
                android:ellipsize="end"
                android:gravity="center_vertical"
                android:includeFontPadding="false"
                android:maxWidth="@dimen/umeng_comm_dimen_320px"
                android:singleLine="true"
                android:text=""
                android:textColor="@color/umeng_comm_color_99"
                android:textSize="@dimen/umeng_comm_text_24px" />

            <LinearLayout
                android:id="@+id/user_type_icon_container"
                android:layout_width="wrap_content"
                android:layout_height="match_parent"
                android:layout_centerVertical="true"
                android:orientation="horizontal" />

        </LinearLayout>

    </RelativeLayout>

    <FrameLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_marginLeft="@dimen/umeng_comm_dimen_30px"
        android:layout_marginRight="@dimen/umeng_comm_dimen_30px"
        android:layout_marginTop="@dimen/umeng_comm_dimen_20px"
        android:descendantFocusability="blocksDescendants">

        <LinearLayout
            android:id="@+id/umeng_comm_feed_detail_content_container"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical">

            <com.umeng.common.ui.emoji.EmojiTextView
                android:id="@+id/umeng_comm_msg_text"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:includeFontPadding="false"
                android:lineSpacingExtra="@dimen/umeng_comm_dimen_12px"
                android:text=""
                android:textColor="@color/umeng_comm_color_33"
                android:textSize="@dimen/umeng_comm_text_28px"
                android:visibility="visible" />

            <TextView
                android:id="@+id/umeng_comm_msg_time_tv"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:layout_centerHorizontal="true"
                android:layout_marginTop="@dimen/umeng_comm_dimen_20px"
                android:drawableLeft="@drawable/umeng_comm_simplify_time"
                android:drawablePadding="@dimen/umeng_comm_dimen_10px"
                android:includeFontPadding="false"
                android:text=""
                android:textColor="@color/umeng_comm_color_99"
                android:textSize="@dimen/umeng_comm_text_20px" />

            <LinearLayout
                android:id="@+id/umeng_comm_msg_images_gv_viewstub"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:layout_below="@id/umeng_comm_msg_text"
                android:layout_marginTop="@dimen/umeng_comm_dimen_20px"
                android:orientation="vertical"
                android:visibility="visible" />
        </LinearLayout>

        <WebView
            android:id="@+id/umeng_comm_msg_textweb"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:focusable="false"
            android:focusableInTouchMode="true"
            android:layerType="software"
            android:visibility="gone" />
    </FrameLayout>

    <LinearLayout
        android:id="@+id/umeng_comm_like_btn"
        android:layout_width="@dimen/umeng_comm_dimen_180px"
        android:layout_height="@dimen/umeng_comm_dimen_64px"
        android:layout_gravity="center_horizontal"
        android:background="@drawable/umeng_simplify_feed_detail_like_count_selector"
        android:gravity="center"
        android:orientation="horizontal">

        <ImageView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:src="@drawable/umeng_simplify_feed_detail_like_icon_selector" />

        <TextView
            android:id="@+id/umeng_comm_like_count_tv"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginLeft="@dimen/umeng_comm_dimen_18px"
            android:text=""
            android:textColor="@drawable/umeng_simplify_feed_detail_like_count_tv_selector"
            android:textSize="@dimen/umeng_comm_text_26px" />
    </LinearLayout>

    <View
        android:layout_width="match_parent"
        android:layout_height="@dimen/umeng_comm_dimen_20px"
        android:layout_marginTop="@dimen/umeng_comm_dimen_30px"
        android:background="@color/umeng_comm_color_de" />

</LinearLayout>

{'repo_name': 'donlan/Tuyi', 'stars': '143', 'repo_language': 'Java', 'file_name': 'layout.json', 'mime_type': 'text/plain', 'hash': 1650291658753709992, 'source_dataset': 'data'}


#FLM: PUA to UMS

# Version 1.0

# Description:
# Generates composite glyphs in Unicode ranges 'Miscellaneous Symbols'
# and 'Musical Symbols' (UMS) from identical glyphs in the Private
# User Area (PUA) range of a SMuFL font.

# Any preexisting glyphs in the UMS ranges are automatically skipped.

# version 1.0 does not generate glyphs in 'Medieval and
# Renaissance', 'Daseian notation' or 'Chord diagrams' ranges.

# CAUTION!
# Script will decompose any components in the reference glyphs
# prior to generating new glyphs.

# Credits:
# Knut Nergaard

print "Starting ..."

from FL import *

# List of glyphs to generate
genDict = {
'uniE260': 'uni266D',
'uniE261': 'uni266E',
'uniE262': 'uni266F',
'uniE030': 'u1D100', 'uniE031': 'u1D101', 'uniE032': 'u1D102',
'uniE033': 'u1D103', 'uniE036': 'u1D104', 'uniE038': 'u1D105',
'uniE040': 'u1D106', 'uniE041': 'u1D107', 'uniE043': 'u1D108',
'uniE045': 'u1D109', 'uniE046': 'u1D10A', 'uniE047': 'u1D10B',
'uniE048': 'u1D10C', 'uniE101': 'u1D10D', 'uniE500': 'u1D10E',
'uniE501': 'u1D10F', 'uniE4C0': 'u1D110', 'uniE4C1': 'u1D111',
'uniE4CE': 'u1D112', 'uniE4D1': 'u1D113', 'uniE000': 'u1D114',
'uniE002': 'u1D115', 'uniE010': 'u1D116', 'uniE011': 'u1D117',
'uniE012': 'u1D118', 'uniE013': 'u1D119', 'uniE014': 'u1D11A',
'uniE015': 'u1D11B', 'uniE050': 'u1D11E', 'uniE053': 'u1D11F',
'uniE052': 'u1D120', 'uniE05C': 'u1D121', 'uniE062': 'u1D122',
'uniE065': 'u1D123', 'uniE064': 'u1D124', 'uniE069': 'u1D125',
'uniE06A': 'u1D126', 'uniE263': 'u1D12A', 'uniE264': 'u1D12B',
'uniE270': 'u1D12C', 'uniE271': 'u1D12D', 'uniE272': 'u1D12E',
'uniE273': 'u1D12F', 'uniE274': 'u1D130', 'uniE275': 'u1D131',
'uniE47E': 'u1D132', 'uniE47F': 'u1D133', 'uniE08A': 'u1D134',
'uniE08B': 'u1D135', 'uniE511': 'u1D136', 'uniE51C': 'u1D137',
'uniE515': 'u1D138', 'uniE51D': 'u1D139', 'uniE4E2': 'u1D13A',
'uniE4E3': 'u1D13B', 'uniE4E4': 'u1D13C', 'uniE4E5': 'u1D13D',
'uniE4E6': 'u1D13E', 'uniE4E7': 'u1D13F', 'uniE4E8': 'u1D140',
'uniE4E9': 'u1D141', 'uniE4EA': 'u1D142', 'uniE0A9': 'u1D143',
'uniE0AF': 'u1D144', 'uniE0B3': 'u1D145', 'uniE0B8': 'u1D146',
'uniE0B9': 'u1D147', 'uniE0BD': 'u1D148', 'uniE0BE': 'u1D149',
'uniE0BF': 'u1D14A', 'uniE0C0': 'u1D14B', 'uniE0C1': 'u1D14C',
'uniE0C2': 'u1D14D', 'uniE0C6': 'u1D14E', 'uniE0C7': 'u1D14F',
'uniE0C8': 'u1D150', 'uniE0C9': 'u1D151', 'uniE0CA': 'u1D152',
'uniE0CB': 'u1D153', 'uniE0CC': 'u1D154', 'uniE0CD': 'u1D155',
'uniE0CE': 'u1D156', 'uniE0A3': 'u1D157', 'uniE0A4': 'u1D158',
'uniE0A5': 'u1D159', 'uniE120': 'u1D15A', 'uniE121': 'u1D15B',
'uniE1D0': 'u1D15C', 'uniE1D2': 'u1D15D', 'uniE1D3': 'u1D15E',
'uniE1D5': 'u1D15F', 'uniE1D7': 'u1D160', 'uniE1D9': 'u1D161',
'uniE1DB': 'u1D162', 'uniE1DD': 'u1D163', 'uniE1DF': 'u1D164',
'uniE210': 'u1D165', 'uniE211': 'u1D166', 'uniE220': 'u1D167',
'uniE221': 'u1D168', 'uniE222': 'u1D169', 'uniE225': 'u1D16A',
'uniE226': 'u1D16B', 'uniE227': 'u1D16C', 'uniE1E7': 'u1D16D',
'uniE240': 'u1D16E', 'uniE242': 'u1D16F', 'uniE244': 'u1D170',
'uniE246': 'u1D171', 'uniE248': 'u1D172', 'uniE8E0': 'u1D173',
'uniE8E1': 'u1D174', 'uniE8E2': 'u1D175', 'uniE8E3': 'u1D176',
'uniE8E4': 'u1D177', 'uniE8E5': 'u1D178', 'uniE8E6': 'u1D179',
'uniE8E7': 'u1D17A', 'uniE4A0': 'u1D17B', 'uniE4A2': 'u1D17C',
'uniE4A4': 'u1D17D', 'uniE4A6': 'u1D17E', 'uniE4AC': 'u1D17F',
'uniE4AE': 'u1D180', 'uniE4B0': 'u1D181', 'uniE4B2': 'u1D182',
'uniE634': 'u1D183', 'uniE635': 'u1D184', 'uniE5D4': 'u1D185',
'uniE5D7': 'u1D186', 'uniE5E1': 'u1D187', 'uniE5E2': 'u1D188',
'uniE5E3': 'u1D189', 'uniE5F0': 'u1D18A', 'uniE5F2': 'u1D18B',
'uniE523': 'u1D18C', 'uniE524': 'u1D18D', 'uniE525': 'u1D18E',
'uniE520': 'u1D18F', 'uniE521': 'u1D190', 'uniE522': 'u1D191',
'uniE52E': 'u1D192', 'uniE53F': 'u1D193', 'uniE560': 'u1D194',
'uniE562': 'u1D195', 'uniE566': 'u1D196', 'uniE567': 'u1D197',
'uniE568': 'u1D198', 'uniE569': 'u1D199', 'uniE56A': 'u1D19A',
'uniE594': 'u1D19B', 'uniE59D': 'u1D19C', 'uniE59E': 'u1D19D',
'uniE5A1': 'u1D19E', 'uniE5A7': 'u1D19F', 'uniE59F': 'u1D1A0',
'uniE59B': 'u1D1A1', 'uniE593': 'u1D1A2', 'uniE5A5': 'u1D1A3',
'uniE599': 'u1D1A4', 'uniE591': 'u1D1A5', 'uniE860': 'u1D1A6',
'uniE861': 'u1D1A7', 'uniE863': 'u1D1A8', 'uniE870': 'u1D1A9',
'uniE610': 'u1D1AA', 'uniE612': 'u1D1AB', 'uniE614': 'u1D1AC',
'uniE630': 'u1D1AD', 'uniE650': 'u1D1AE', 'uniE655': 'u1D1AF',
'uniE656': 'u1D1B0', 'uniE585': 'u1D1B1', 'uniE586': 'u1D1B2',
'uniE636': 'u1D1B3', 'uniE638': 'u1D1B4', 'uniE639': 'u1D1B5'}

# Get the Font
f = fl.font

# Check & decompose
print 'Checking for missing source glyphs ...'
for pua in genDict:
	if not f.has_key(pua):
		print pua + ' is missing';

print 'Checking for composites ...'
for g in f.glyphs:
	if g.name in genDict and len(g.components) > 0:
		g.Decompose()
		print 'Decomposing ' + g.name

def uIndex():
	if 'uni' in ums:
		return int(ums[3:], 16)
	else:
		return int(ums[1:], 16)

# Creating new glyphs
print 'creating glyphs ...'
for pua, ums in genDict.iteritems():

	puaIndx = f.FindGlyph(pua)
	puaGlyph = f.glyphs[puaIndx]
	newGlyph = Glyph()
	newGlyph.name = ums
	newGlyph.unicode = uIndex()
	newGlyph.mark = 120

	if f.has_key(ums):
		print 'Skipping prexisting glyph: ' + ums
	else:

#	Get components of PUA glyphs
		newGlyph.components.append(Component(puaIndx))

# Get metrics
		metrics = puaGlyph.GetMetrics()
		newGlyph.SetMetrics(metrics)

# Create glyphs
		f.glyphs.append(newGlyph)

fl.UpdateFont(fl.ifont)
print 'All done!'

{'repo_name': 'w3c/smufl', 'stars': '116', 'repo_language': 'HTML', 'file_name': 'generate_font_metadata.py', 'mime_type': 'text/plain', 'hash': 4635477761271063875, 'source_dataset': 'data'}


% Generated by roxygen2: do not edit by hand
% Please edit documentation in R/catboost.R
\name{catboost.get_feature_importance}
\alias{catboost.get_feature_importance}
\title{Calculate the feature importances}
\usage{
catboost.get_feature_importance(model, pool = NULL,
  type = "FeatureImportance", thread_count = -1, fstr_type = NULL)
}
\arguments{
\item{model}{The model obtained as the result of training.

Default value: Required argument}

\item{pool}{The input dataset.

The feature importance for the training dataset is calculated if this argument is not specified.

Default value: NULL}

\item{type}{The feature importance type.

Possible values:
\itemize{
  \item 'PredictionValuesChange'

    Calculate score for every feature.

  \item 'LossFunctionChange'

    Calculate score for every feature for groupwise model.

  \item 'FeatureImportance'

    'LossFunctionChange' in case of groupwise model and 'PredictionValuesChange' otherwise.

  \item 'Interaction'

    Calculate pairwise score between every feature.

  \item 'ShapValues'

    Calculate SHAP Values for every object.

}

Default value: 'FeatureImportance'}

\item{thread_count}{The number of threads to use when applying the model. If -1, then the number of threads is set to the number of CPU cores.

Allows you to optimize the speed of execution. This parameter doesn't affect results.

Default value: -1}

\item{fstr_type}{Deprecated parameter, use 'type' instead.}
}
\description{
Calculate the feature importances (see \url{https://catboost.ai/docs/concepts/fstr.html#fstr})
(Regular feature importance, ShapValues, and Feature interaction strength).
}
\seealso{
\url{https://catboost.ai/docs/features/feature-importances-calculation.html}
}

{'repo_name': 'catboost/catboost', 'stars': '5254', 'repo_language': 'C++', 'file_name': 'lz4_12.cpp', 'mime_type': 'text/x-c', 'hash': 8912213378675507113, 'source_dataset': 'data'}


'use strict';
angular.module("ngLocale", [], ["$provide", function($provide) {
var PLURAL_CATEGORY = {ZERO: "zero", ONE: "one", TWO: "two", FEW: "few", MANY: "many", OTHER: "other"};
function getDecimals(n) {
  n = n + '';
  var i = n.indexOf('.');
  return (i == -1) ? 0 : n.length - i - 1;
}

function getVF(n, opt_precision) {
  var v = opt_precision;

  if (undefined === v) {
    v = Math.min(getDecimals(n), 3);
  }

  var base = Math.pow(10, v);
  var f = ((n * base) | 0) % base;
  return {v: v, f: f};
}

$provide.value("$locale", {
  "DATETIME_FORMATS": {
    "AMPMS": [
      "\u0f66\u0f94\u0f0b\u0f46\u0f0b",
      "\u0f55\u0fb1\u0f72\u0f0b\u0f46\u0f0b"
    ],
    "DAY": [
      "\u0f42\u0f5f\u0f60\u0f0b\u0f5f\u0fb3\u0f0b\u0f56\u0f0b",
      "\u0f42\u0f5f\u0f60\u0f0b\u0f58\u0f72\u0f42\u0f0b\u0f51\u0f58\u0f62\u0f0b",
      "\u0f42\u0f5f\u0f60\u0f0b\u0f63\u0fb7\u0f42\u0f0b\u0f54\u0f0b",
      "\u0f42\u0f5f\u0f60\u0f0b\u0f55\u0f74\u0f62\u0f0b\u0f56\u0f74\u0f0b",
      "\u0f42\u0f5f\u0f60\u0f0b\u0f54\u0f0b\u0f66\u0f44\u0f66\u0f0b",
      "\u0f42\u0f5f\u0f60\u0f0b\u0f66\u0fa4\u0f7a\u0f53\u0f0b\u0f54\u0f0b",
      "\u0f42\u0f5f\u0f60\u0f0b\u0f49\u0f72\u0f0b\u0f58\u0f0b"
    ],
    "ERANAMES": [
      "BCE",
      "CE"
    ],
    "ERAS": [
      "BCE",
      "CE"
    ],
    "FIRSTDAYOFWEEK": 6,
    "MONTH": [
      "\u0f5f\u0fb3\u0f0b\u0f51\u0f44\u0f54\u0f0b",
      "\u0f5f\u0fb3\u0f0b\u0f42\u0f49\u0f72\u0f66\u0f0b\u0f54\u0f0b",
      "\u0f5f\u0fb3\u0f0b\u0f42\u0f66\u0f74\u0f58\u0f0b\u0f54\u0f0b",
      "\u0f5f\u0fb3\u0f0b\u0f56\u0f5e\u0f72\u0f0b\u0f54\u0f0b",
      "\u0f5f\u0fb3\u0f0b\u0f63\u0f94\u0f0b\u0f54\u0f0b",
      "\u0f5f\u0fb3\u0f0b\u0f51\u0fb2\u0f74\u0f42\u0f0b\u0f54",
      "\u0f5f\u0fb3\u0f0b\u0f56\u0f51\u0f74\u0f53\u0f0b\u0f54\u0f0b",
      "\u0f5f\u0fb3\u0f0b\u0f56\u0f62\u0f92\u0fb1\u0f51\u0f0b\u0f54\u0f0b",
      "\u0f5f\u0fb3\u0f0b\u0f51\u0f42\u0f74\u0f0b\u0f54\u0f0b",
      "\u0f5f\u0fb3\u0f0b\u0f56\u0f45\u0f74\u0f0b\u0f54\u0f0b",
      "\u0f5f\u0fb3\u0f0b\u0f56\u0f45\u0f74\u0f0b\u0f42\u0f45\u0f72\u0f42\u0f0b\u0f54\u0f0b",
      "\u0f5f\u0fb3\u0f0b\u0f56\u0f45\u0f74\u0f0b\u0f42\u0f49\u0f72\u0f66\u0f0b\u0f54\u0f0b"
    ],
    "SHORTDAY": [
      "\u0f5f\u0fb3\u0f0b",
      "\u0f58\u0f72\u0f62\u0f0b",
      "\u0f63\u0fb7\u0f42\u0f0b",
      "\u0f55\u0f74\u0f62\u0f0b",
      "\u0f66\u0f44\u0f66\u0f0b",
      "\u0f66\u0fa4\u0f7a\u0f53\u0f0b",
      "\u0f49\u0f72\u0f0b"
    ],
    "SHORTMONTH": [
      "\u0f21",
      "\u0f22",
      "\u0f23",
      "\u0f24",
      "\u0f25",
      "\u0f26",
      "\u0f27",
      "\u0f28",
      "\u0f29",
      "\u0f21\u0f20",
      "\u0f21\u0f21",
      "12"
    ],
    "STANDALONEMONTH": [
      "\u0f66\u0fa4\u0fb1\u0f72\u0f0b\u0f5f\u0fb3\u0f0b\u0f51\u0f44\u0f54\u0f0b",
      "\u0f66\u0fa4\u0fb1\u0f72\u0f0b\u0f5f\u0fb3\u0f0b\u0f42\u0f49\u0f72\u0f66\u0f0b\u0f54\u0f0b",
      "\u0f66\u0fa4\u0fb1\u0f72\u0f0b\u0f5f\u0fb3\u0f0b\u0f42\u0f66\u0f74\u0f58\u0f0b\u0f54\u0f0b",
      "\u0f66\u0fa4\u0fb1\u0f72\u0f0b\u0f5f\u0fb3\u0f0b\u0f56\u0f5e\u0f72\u0f0b\u0f54",
      "\u0f66\u0fa4\u0fb1\u0f72\u0f0b\u0f5f\u0fb3\u0f0b\u0f63\u0f94\u0f0b\u0f54\u0f0b",
      "\u0f66\u0fa4\u0fb1\u0f72\u0f0b\u0f5f\u0fb3\u0f0b\u0f51\u0fb2\u0f74\u0f42\u0f0b\u0f54",
      "\u0f66\u0fa4\u0fb1\u0f72\u0f0b\u0f5f\u0fb3\u0f0b\u0f56\u0f51\u0f74\u0f53\u0f0b\u0f54\u0f0b",
      "\u0f66\u0fa4\u0fb1\u0f72\u0f0b\u0f5f\u0fb3\u0f0b\u0f56\u0f62\u0f92\u0fb1\u0f51\u0f0b\u0f54\u0f0b",
      "\u0f66\u0fa4\u0fb1\u0f72\u0f0b\u0f5f\u0fb3\u0f0b\u0f51\u0f42\u0f74\u0f0b\u0f54\u0f0b",
      "\u0f66\u0fa4\u0fb1\u0f72\u0f0b\u0f5f\u0fb3\u0f0b\u0f56\u0f45\u0f74\u0f0b\u0f54\u0f0b",
      "\u0f66\u0fa4\u0fb1\u0f72\u0f0b\u0f5f\u0fb3\u0f0b\u0f56\u0f45\u0f74\u0f0b\u0f42\u0f45\u0f72\u0f42\u0f0b\u0f54\u0f0b",
      "\u0f66\u0fa4\u0fb1\u0f72\u0f0b\u0f5f\u0fb3\u0f0b\u0f56\u0f45\u0f74\u0f0b\u0f42\u0f49\u0f72\u0f66\u0f0b\u0f54\u0f0b"
    ],
    "WEEKENDRANGE": [
      5,
      6
    ],
    "fullDate": "EEEE, \u0f66\u0fa4\u0fb1\u0f72\u0f0b\u0f63\u0f7c\u0f0by MMMM \u0f5a\u0f7a\u0f66\u0f0bdd",
    "longDate": "\u0f66\u0fa4\u0fb1\u0f72\u0f0b\u0f63\u0f7c\u0f0by MMMM \u0f5a\u0f7a\u0f66\u0f0b dd",
    "medium": "\u0f66\u0fa4\u0fb1\u0f72\u0f0b\u0f63\u0f7c\u0f0by \u0f5f\u0fb3\u0f0bMMM \u0f5a\u0f7a\u0f66\u0f0bdd \u0f46\u0f74\u0f0b\u0f5a\u0f7c\u0f51\u0f0bh:mm:ss a",
    "mediumDate": "\u0f66\u0fa4\u0fb1\u0f72\u0f0b\u0f63\u0f7c\u0f0by \u0f5f\u0fb3\u0f0bMMM \u0f5a\u0f7a\u0f66\u0f0bdd",
    "mediumTime": "\u0f46\u0f74\u0f0b\u0f5a\u0f7c\u0f51\u0f0bh:mm:ss a",
    "short": "y-MM-dd \u0f46\u0f74\u0f0b\u0f5a\u0f7c\u0f51\u0f0b h \u0f66\u0f90\u0f62\u0f0b\u0f58\u0f0b mm a",
    "shortDate": "y-MM-dd",
    "shortTime": "\u0f46\u0f74\u0f0b\u0f5a\u0f7c\u0f51\u0f0b h \u0f66\u0f90\u0f62\u0f0b\u0f58\u0f0b mm a"
  },
  "NUMBER_FORMATS": {
    "CURRENCY_SYM": "Nu.",
    "DECIMAL_SEP": ".",
    "GROUP_SEP": ",",
    "PATTERNS": [
      {
        "gSize": 2,
        "lgSize": 3,
        "maxFrac": 3,
        "minFrac": 0,
        "minInt": 1,
        "negPre": "-",
        "negSuf": "",
        "posPre": "",
        "posSuf": ""
      },
      {
        "gSize": 2,
        "lgSize": 3,
        "maxFrac": 2,
        "minFrac": 2,
        "minInt": 1,
        "negPre": "-\u00a4",
        "negSuf": "",
        "posPre": "\u00a4",
        "posSuf": ""
      }
    ]
  },
  "id": "dz-bt",
  "localeID": "dz_BT",
  "pluralCat": function(n, opt_precision) {  var i = n | 0;  var vf = getVF(n, opt_precision);  if (i == 1 && vf.v == 0) {    return PLURAL_CATEGORY.ONE;  }  return PLURAL_CATEGORY.OTHER;}
});
}]);

{'repo_name': 'aspnetboilerplate/aspnetboilerplate-templates', 'stars': '120', 'repo_language': 'JavaScript', 'file_name': 'AssemblyInfo.cs', 'mime_type': 'text/plain', 'hash': -6196067726907597646, 'source_dataset': 'data'}


@charset "UTF-8";
:root{
    /* Transition
  -------------------------- */
    /* Colors
  -------------------------- */
    /* Link
  -------------------------- */
    /* Border
  -------------------------- */
    /* Box-shadow
  -------------------------- */
    /* Fill
  -------------------------- */
    /* Font
  -------------------------- */
    /* Size
  -------------------------- */
    /* z-index
  -------------------------- */
    /* Disable base
  -------------------------- */
    /* Icon
  -------------------------- */
    /* Checkbox
  -------------------------- */
    /* Radio
  -------------------------- */
    /* Select
  -------------------------- */
    /* Alert
  -------------------------- */
    /* Message Box
  -------------------------- */
    /* Message
  -------------------------- */
    /* Notification
  -------------------------- */
    /* Input
  -------------------------- */
    /* Cascader
  -------------------------- */
    /* Group
  -------------------------- */
    /* Tab
  -------------------------- */
    /* Button
  -------------------------- */
    /* cascader
  -------------------------- */
    /* Switch
 -------------------------- */
    /* Dialog
 -------------------------- */
    /* Table
 -------------------------- */
    /* Pagination
 -------------------------- */
    /* Popover
 -------------------------- */
    /* Tooltip
  -------------------------- */
    /* Tag
  -------------------------- */
    /* Dropdown
  -------------------------- */
    /* Badge
  -------------------------- */
    /* Card
  --------------------------*/
    /* Slider
  --------------------------*/
    /* Steps
  --------------------------*/
    /* Menu
  --------------------------*/
    /* Rate
  --------------------------*/
    /* DatePicker
  --------------------------*/
    /* Loading
  --------------------------*/
    /* Scrollbar
  --------------------------*/
    /* Carousel
  --------------------------*/
    /* Collapse
  --------------------------*/
    /* Transfer
  --------------------------*/
}

.el-button{
    display: inline-block;
    line-height: 1;
    white-space: nowrap;
    cursor: pointer;
    background: #fff;
    border: 1px solid rgb(191, 203, 217);
    border-color: #c4c4c4;
    color: rgb(31, 45, 61);
    -webkit-appearance: none;
    text-align: center;
    box-sizing: border-box;
    outline: none;
    margin: 0;
    -moz-user-select: none;
    -webkit-user-select: none;
    -ms-user-select: none;
    padding: 10px 15px;
    font-size: 14px;
    border-radius: 4px;
}

.el-button + .el-button{
    margin-left: 10px;
}

.el-button:hover, .el-button:focus{
    color: #20a0ff;
    border-color: #20a0ff;
}

.el-button:active{
    color: rgb(29, 144, 230);
    border-color: rgb(29, 144, 230);
    outline: none;
}

.el-button::-moz-focus-inner{
    border: 0;
}

.el-button [class*="el-icon-"]{}

.el-button [class*="el-icon-"] + span{
    margin-left: 5px;
}

.el-button.is-loading{
    position: relative;
    pointer-events: none;
}

.el-button.is-loading:before{
    pointer-events: none;
    content: '';
    position: absolute;
    left: -1px;
    top: -1px;
    right: -1px;
    bottom: -1px;
    border-radius: inherit;
    background-color: rgba(255,255,255,.35);
}

.el-button.is-disabled{}

.el-button.is-disabled, .el-button.is-disabled:hover, .el-button.is-disabled:focus{
    color: rgb(191, 203, 217);
    cursor: not-allowed;
    background-image: none;
    background-color: rgb(238, 241, 246);
    border-color: rgb(209, 219, 229);
}

.el-button.is-disabled.el-button--text{
    background-color: transparent;
}

.el-button.is-disabled.is-plain{}

.el-button.is-disabled.is-plain, .el-button.is-disabled.is-plain:hover, .el-button.is-disabled.is-plain:focus{
    background-color: #fff;
    border-color: rgb(209, 219, 229);
    color: rgb(191, 203, 217);
}

.el-button.is-active{
    color: rgb(29, 144, 230);
    border-color: rgb(29, 144, 230);
}

.el-button.is-plain{}

.el-button.is-plain:hover, .el-button.is-plain:focus{
    background: #fff;
    border-color: #20a0ff;
    color: #20a0ff;
}

.el-button.is-plain:active{
    background: #fff;
    border-color: rgb(29, 144, 230);
    color: rgb(29, 144, 230);
    outline: none;
}

.el-button--primary{
    color: #fff;
    background-color: #20a0ff;
    border-color: #20a0ff;
}

.el-button--primary:hover, .el-button--primary:focus{
    background: rgb(77, 179, 255);
    border-color: rgb(77, 179, 255);
    color: #fff;
}

.el-button--primary:active{
    background: rgb(29, 144, 230);
    border-color: rgb(29, 144, 230);
    color: #fff;
    outline: none;
}

.el-button--primary.is-active{
    background: rgb(29, 144, 230);
    border-color: rgb(29, 144, 230);
    color: #fff;
}

.el-button--primary.is-plain{
    background: #fff;
    border: 1px solid rgb(191, 203, 217);
    color: rgb(31, 45, 61);
}

.el-button--primary.is-plain:hover, .el-button--primary.is-plain:focus{
    background: #fff;
    border-color: #20a0ff;
    color: #20a0ff;
}

.el-button--primary.is-plain:active{
    background: #fff;
    border-color: rgb(29, 144, 230);
    color: rgb(29, 144, 230);
    outline: none;
}

.el-button--success{
    color: #fff;
    background-color: #13ce66;
    border-color: #13ce66;
}

.el-button--success:hover, .el-button--success:focus{
    background: rgb(66, 216, 133);
    border-color: rgb(66, 216, 133);
    color: #fff;
}

.el-button--success:active{
    background: rgb(17, 185, 92);
    border-color: rgb(17, 185, 92);
    color: #fff;
    outline: none;
}

.el-button--success.is-active{
    background: rgb(17, 185, 92);
    border-color: rgb(17, 185, 92);
    color: #fff;
}

.el-button--success.is-plain{
    background: #fff;
    border: 1px solid rgb(191, 203, 217);
    color: rgb(31, 45, 61);
}

.el-button--success.is-plain:hover, .el-button--success.is-plain:focus{
    background: #fff;
    border-color: #13ce66;
    color: #13ce66;
}

.el-button--success.is-plain:active{
    background: #fff;
    border-color: rgb(17, 185, 92);
    color: rgb(17, 185, 92);
    outline: none;
}

.el-button--warning{
    color: #fff;
    background-color: #f7ba2a;
    border-color: #f7ba2a;
}

.el-button--warning:hover, .el-button--warning:focus{
    background: rgb(249, 200, 85);
    border-color: rgb(249, 200, 85);
    color: #fff;
}

.el-button--warning:active{
    background: rgb(222, 167, 38);
    border-color: rgb(222, 167, 38);
    color: #fff;
    outline: none;
}

.el-button--warning.is-active{
    background: rgb(222, 167, 38);
    border-color: rgb(222, 167, 38);
    color: #fff;
}

.el-button--warning.is-plain{
    background: #fff;
    border: 1px solid rgb(191, 203, 217);
    color: rgb(31, 45, 61);
}

.el-button--warning.is-plain:hover, .el-button--warning.is-plain:focus{
    background: #fff;
    border-color: #f7ba2a;
    color: #f7ba2a;
}

.el-button--warning.is-plain:active{
    background: #fff;
    border-color: rgb(222, 167, 38);
    color: rgb(222, 167, 38);
    outline: none;
}

.el-button--danger{
    color: #fff;
    background-color: #ff4949;
    border-color: #ff4949;
}

.el-button--danger:hover, .el-button--danger:focus{
    background: rgb(255, 109, 109);
    border-color: rgb(255, 109, 109);
    color: #fff;
}

.el-button--danger:active{
    background: rgb(230, 66, 66);
    border-color: rgb(230, 66, 66);
    color: #fff;
    outline: none;
}

.el-button--danger.is-active{
    background: rgb(230, 66, 66);
    border-color: rgb(230, 66, 66);
    color: #fff;
}

.el-button--danger.is-plain{
    background: #fff;
    border: 1px solid rgb(191, 203, 217);
    color: rgb(31, 45, 61);
}

.el-button--danger.is-plain:hover, .el-button--danger.is-plain:focus{
    background: #fff;
    border-color: #ff4949;
    color: #ff4949;
}

.el-button--danger.is-plain:active{
    background: #fff;
    border-color: rgb(230, 66, 66);
    color: rgb(230, 66, 66);
    outline: none;
}

.el-button--info{
    color: #fff;
    background-color: #50bfff;
    border-color: #50bfff;
}

.el-button--info:hover, .el-button--info:focus{
    background: rgb(115, 204, 255);
    border-color: rgb(115, 204, 255);
    color: #fff;
}

.el-button--info:active{
    background: rgb(72, 172, 230);
    border-color: rgb(72, 172, 230);
    color: #fff;
    outline: none;
}

.el-button--info.is-active{
    background: rgb(72, 172, 230);
    border-color: rgb(72, 172, 230);
    color: #fff;
}

.el-button--info.is-plain{
    background: #fff;
    border: 1px solid rgb(191, 203, 217);
    color: rgb(31, 45, 61);
}

.el-button--info.is-plain:hover, .el-button--info.is-plain:focus{
    background: #fff;
    border-color: #50bfff;
    color: #50bfff;
}

.el-button--info.is-plain:active{
    background: #fff;
    border-color: rgb(72, 172, 230);
    color: rgb(72, 172, 230);
    outline: none;
}

.el-button--large{
    padding: 11px 19px;
    font-size: 16px;
    border-radius: 4px;
}

.el-button--small{
    padding: 7px 9px;
    font-size: 12px;
    border-radius: 4px;
}

.el-button--mini{
    padding: 4px 4px;
    font-size: 12px;
    border-radius: 4px;
}

.el-button--text{
    border: none;
    color: #20a0ff;
    background: transparent;
    padding-left: 0;
    padding-right: 0;
}

.el-button--text:hover, .el-button--text:focus{
    color: rgb(77, 179, 255);
}

.el-button--text:active{
    color: rgb(29, 144, 230);
}

.el-button-group{
    display: inline-block;
    vertical-align: middle;
}

.el-button-group:before, .el-button-group:after{
    display: table;
    content: "";
}

.el-button-group:after{
    clear: both;
}

.el-button-group .el-button--primary{}

.el-button-group .el-button--primary:first-child{
    border-right-color: rgba(255, 255, 255, 0.5);
}

.el-button-group .el-button--primary:last-child{
    border-left-color: rgba(255, 255, 255, 0.5);
}

.el-button-group .el-button--primary:not(:first-child):not(:last-child){
    border-left-color: rgba(255, 255, 255, 0.5);
    border-right-color: rgba(255, 255, 255, 0.5);
}

.el-button-group .el-button--success{}

.el-button-group .el-button--success:first-child{
    border-right-color: rgba(255, 255, 255, 0.5);
}

.el-button-group .el-button--success:last-child{
    border-left-color: rgba(255, 255, 255, 0.5);
}

.el-button-group .el-button--success:not(:first-child):not(:last-child){
    border-left-color: rgba(255, 255, 255, 0.5);
    border-right-color: rgba(255, 255, 255, 0.5);
}

.el-button-group .el-button--warning{}

.el-button-group .el-button--warning:first-child{
    border-right-color: rgba(255, 255, 255, 0.5);
}

.el-button-group .el-button--warning:last-child{
    border-left-color: rgba(255, 255, 255, 0.5);
}

.el-button-group .el-button--warning:not(:first-child):not(:last-child){
    border-left-color: rgba(255, 255, 255, 0.5);
    border-right-color: rgba(255, 255, 255, 0.5);
}

.el-button-group .el-button--danger{}

.el-button-group .el-button--danger:first-child{
    border-right-color: rgba(255, 255, 255, 0.5);
}

.el-button-group .el-button--danger:last-child{
    border-left-color: rgba(255, 255, 255, 0.5);
}

.el-button-group .el-button--danger:not(:first-child):not(:last-child){
    border-left-color: rgba(255, 255, 255, 0.5);
    border-right-color: rgba(255, 255, 255, 0.5);
}

.el-button-group .el-button--info{}

.el-button-group .el-button--info:first-child{
    border-right-color: rgba(255, 255, 255, 0.5);
}

.el-button-group .el-button--info:last-child{
    border-left-color: rgba(255, 255, 255, 0.5);
}

.el-button-group .el-button--info:not(:first-child):not(:last-child){
    border-left-color: rgba(255, 255, 255, 0.5);
    border-right-color: rgba(255, 255, 255, 0.5);
}

.el-button-group .el-button{
    float: left;
    position: relative;
}

.el-button-group .el-button + .el-button{
    margin-left: 0;
}

.el-button-group .el-button:first-child{
    border-top-right-radius: 0;
    border-bottom-right-radius: 0;
}

.el-button-group .el-button:last-child{
    border-top-left-radius: 0;
    border-bottom-left-radius: 0;
}

.el-button-group .el-button:not(:first-child):not(:last-child){
    border-radius: 0;
}

.el-button-group .el-button:not(:last-child){
    margin-right: -1px;
}

.el-button-group .el-button:hover, .el-button-group .el-button:focus, .el-button-group .el-button:active{
    z-index: 1;
}

.el-button-group .el-button.is-active{
    z-index: 1;
}
:root{
    /* Transition
  -------------------------- */
    /* Colors
  -------------------------- */
    /* Link
  -------------------------- */
    /* Border
  -------------------------- */
    /* Box-shadow
  -------------------------- */
    /* Fill
  -------------------------- */
    /* Font
  -------------------------- */
    /* Size
  -------------------------- */
    /* z-index
  -------------------------- */
    /* Disable base
  -------------------------- */
    /* Icon
  -------------------------- */
    /* Checkbox
  -------------------------- */
    /* Radio
  -------------------------- */
    /* Select
  -------------------------- */
    /* Alert
  -------------------------- */
    /* Message Box
  -------------------------- */
    /* Message
  -------------------------- */
    /* Notification
  -------------------------- */
    /* Input
  -------------------------- */
    /* Cascader
  -------------------------- */
    /* Group
  -------------------------- */
    /* Tab
  -------------------------- */
    /* Button
  -------------------------- */
    /* cascader
  -------------------------- */
    /* Switch
 -------------------------- */
    /* Dialog
 -------------------------- */
    /* Table
 -------------------------- */
    /* Pagination
 -------------------------- */
    /* Popover
 -------------------------- */
    /* Tooltip
  -------------------------- */
    /* Tag
  -------------------------- */
    /* Dropdown
  -------------------------- */
    /* Badge
  -------------------------- */
    /* Card
  --------------------------*/
    /* Slider
  --------------------------*/
    /* Steps
  --------------------------*/
    /* Menu
  --------------------------*/
    /* Rate
  --------------------------*/
    /* DatePicker
  --------------------------*/
    /* Loading
  --------------------------*/
    /* Scrollbar
  --------------------------*/
    /* Carousel
  --------------------------*/
    /* Collapse
  --------------------------*/
    /* Transfer
  --------------------------*/
}

{'repo_name': 'leer0911/myVueTest', 'stars': '128', 'repo_language': 'CSS', 'file_name': 'settings.json', 'mime_type': 'text/plain', 'hash': -1161756888640509984, 'source_dataset': 'data'}


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<title></title>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta name="generator" content="Doxygen 1.8.5">
<link rel="stylesheet" type="text/css" href="search.css"/>

Loading...

Searching...

No Matches

{'repo_name': 'pvbrowser/pvb', 'stars': '187', 'repo_language': 'C++', 'file_name': 'rlsvgcat.pro', 'mime_type': 'text/plain', 'hash': 7827454250875413200, 'source_dataset': 'data'}


# LeapFrog Pollux Platform: Kernel Configuration
## Contents
## Summary
## Prerequisites
* LeapFrog_Pollux_Platform:_Build_Environment
## Software Needed
* LeapFrog_Pollux_Platform:_Source_Code
## Using Preexisting Config
## Make Menuconfig
## Manual Config Editing

{'repo_name': 'tinyclub/elinux', 'stars': '170', 'repo_language': 'Shell', 'file_name': 'Tims_Notes_on_ARM_memory_allocation.md', 'mime_type': 'text/plain', 'hash': -6763244441714853353, 'source_dataset': 'data'}


// SPDX-License-Identifier: GPL-2.0-only
/*
 * LED driver for Marvell 88PM860x
 *
 * Copyright (C) 2009 Marvell International Ltd.
 *	Haojian Zhuang <haojian.zhuang@marvell.com>
 */

#include <linux/kernel.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/i2c.h>
#include <linux/leds.h>
#include <linux/slab.h>
#include <linux/mfd/88pm860x.h>
#include <linux/module.h>

#define LED_PWM_MASK		(0x1F)
#define LED_CURRENT_MASK	(0x07 << 5)

#define LED_BLINK_MASK		(0x7F)

#define LED_ON_CONTINUOUS	(0x0F << 3)

#define LED1_BLINK_EN		(1 << 1)
#define LED2_BLINK_EN		(1 << 2)

struct pm860x_led {
	struct led_classdev cdev;
	struct i2c_client *i2c;
	struct pm860x_chip *chip;
	struct mutex lock;
	char name[MFD_NAME_SIZE];

	int port;
	int iset;
	unsigned char brightness;
	unsigned char current_brightness;

	int reg_control;
	int reg_blink;
	int blink_mask;
};

static int led_power_set(struct pm860x_chip *chip, int port, int on)
{
	int ret = -EINVAL;

	switch (port) {
	case 0:
	case 1:
	case 2:
		ret = on ? pm8606_osc_enable(chip, RGB1_ENABLE) :
			pm8606_osc_disable(chip, RGB1_ENABLE);
		break;
	case 3:
	case 4:
	case 5:
		ret = on ? pm8606_osc_enable(chip, RGB2_ENABLE) :
			pm8606_osc_disable(chip, RGB2_ENABLE);
		break;
	}
	return ret;
}

static int pm860x_led_set(struct led_classdev *cdev,
			   enum led_brightness value)
{
	struct pm860x_led *led = container_of(cdev, struct pm860x_led, cdev);
	struct pm860x_chip *chip;
	unsigned char buf[3];
	int ret;

	chip = led->chip;
	mutex_lock(&led->lock);
	led->brightness = value >> 3;

	if ((led->current_brightness == 0) && led->brightness) {
		led_power_set(chip, led->port, 1);
		if (led->iset) {
			pm860x_set_bits(led->i2c, led->reg_control,
					LED_CURRENT_MASK, led->iset);
		}
		pm860x_set_bits(led->i2c, led->reg_blink,
				LED_BLINK_MASK, LED_ON_CONTINUOUS);
		pm860x_set_bits(led->i2c, PM8606_WLED3B, led->blink_mask,
				led->blink_mask);
	}
	pm860x_set_bits(led->i2c, led->reg_control, LED_PWM_MASK,
			led->brightness);

	if (led->brightness == 0) {
		pm860x_bulk_read(led->i2c, led->reg_control, 3, buf);
		ret = buf[0] & LED_PWM_MASK;
		ret |= buf[1] & LED_PWM_MASK;
		ret |= buf[2] & LED_PWM_MASK;
		if (ret == 0) {
			/* unset current since no led is lighting */
			pm860x_set_bits(led->i2c, led->reg_control,
					LED_CURRENT_MASK, 0);
			pm860x_set_bits(led->i2c, PM8606_WLED3B,
					led->blink_mask, 0);
			led_power_set(chip, led->port, 0);
		}
	}
	led->current_brightness = led->brightness;
	dev_dbg(chip->dev, "Update LED. (reg:%d, brightness:%d)\n",
		led->reg_control, led->brightness);
	mutex_unlock(&led->lock);

	return 0;
}

#ifdef CONFIG_OF
static int pm860x_led_dt_init(struct platform_device *pdev,
			      struct pm860x_led *data)
{
	struct device_node *nproot, *np;
	int iset = 0;

	if (!pdev->dev.parent->of_node)
		return -ENODEV;
	nproot = of_get_child_by_name(pdev->dev.parent->of_node, "leds");
	if (!nproot) {
		dev_err(&pdev->dev, "failed to find leds node\n");
		return -ENODEV;
	}
	for_each_child_of_node(nproot, np) {
		if (of_node_name_eq(np, data->name)) {
			of_property_read_u32(np, "marvell,88pm860x-iset",
					     &iset);
			data->iset = PM8606_LED_CURRENT(iset);
			of_node_put(np);
			break;
		}
	}
	of_node_put(nproot);
	return 0;
}
#else
#define pm860x_led_dt_init(x, y)	(-1)
#endif

static int pm860x_led_probe(struct platform_device *pdev)
{
	struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent);
	struct pm860x_led_pdata *pdata = dev_get_platdata(&pdev->dev);
	struct pm860x_led *data;
	struct resource *res;
	int ret = 0;

	data = devm_kzalloc(&pdev->dev, sizeof(struct pm860x_led), GFP_KERNEL);
	if (data == NULL)
		return -ENOMEM;
	res = platform_get_resource_byname(pdev, IORESOURCE_REG, "control");
	if (!res) {
		dev_err(&pdev->dev, "No REG resource for control\n");
		return -ENXIO;
	}
	data->reg_control = res->start;
	res = platform_get_resource_byname(pdev, IORESOURCE_REG, "blink");
	if (!res) {
		dev_err(&pdev->dev, "No REG resource for blink\n");
		return -ENXIO;
	}
	data->reg_blink = res->start;
	memset(data->name, 0, MFD_NAME_SIZE);
	switch (pdev->id) {
	case 0:
		data->blink_mask = LED1_BLINK_EN;
		sprintf(data->name, "led0-red");
		break;
	case 1:
		data->blink_mask = LED1_BLINK_EN;
		sprintf(data->name, "led0-green");
		break;
	case 2:
		data->blink_mask = LED1_BLINK_EN;
		sprintf(data->name, "led0-blue");
		break;
	case 3:
		data->blink_mask = LED2_BLINK_EN;
		sprintf(data->name, "led1-red");
		break;
	case 4:
		data->blink_mask = LED2_BLINK_EN;
		sprintf(data->name, "led1-green");
		break;
	case 5:
		data->blink_mask = LED2_BLINK_EN;
		sprintf(data->name, "led1-blue");
		break;
	}
	data->chip = chip;
	data->i2c = (chip->id == CHIP_PM8606) ? chip->client : chip->companion;
	data->port = pdev->id;
	if (pm860x_led_dt_init(pdev, data))
		if (pdata)
			data->iset = pdata->iset;

	data->current_brightness = 0;
	data->cdev.name = data->name;
	data->cdev.brightness_set_blocking = pm860x_led_set;
	mutex_init(&data->lock);

	ret = devm_led_classdev_register(chip->dev, &data->cdev);
	if (ret < 0) {
		dev_err(&pdev->dev, "Failed to register LED: %d\n", ret);
		return ret;
	}
	pm860x_led_set(&data->cdev, 0);
	return 0;
}

static struct platform_driver pm860x_led_driver = {
	.driver	= {
		.name	= "88pm860x-led",
	},
	.probe	= pm860x_led_probe,
};

module_platform_driver(pm860x_led_driver);

MODULE_DESCRIPTION("LED driver for Marvell PM860x");
MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:88pm860x-led");

{'repo_name': 'RadeonOpenCompute/ROCK-Kernel-Driver', 'stars': '135', 'repo_language': 'C', 'file_name': 'pinctrl-zx.c', 'mime_type': 'text/x-c', 'hash': 3935192134429126653, 'source_dataset': 'data'}


// RUN: %clang_cc1 -triple i686-pc-linux -std=c++11 -fblocks %s -verify

void block_capture_errors() {
  __block int var; // expected-note 2{{'var' declared here}}
  (void)[var] { }; // expected-error{{__block variable 'var' cannot be captured in a lambda}}

  (void)[=] { var = 17; }; // expected-error{{__block variable 'var' cannot be captured in a lambda}}
}

void conversion_to_block(int captured) {
  int (^b1)(int) = [=](int x) { return x + captured; };

  const auto lambda = [=](int x) { return x + captured; };
  int (^b2)(int) = lambda;
}

template<typename T>
class ConstCopyConstructorBoom {
public:
  ConstCopyConstructorBoom(ConstCopyConstructorBoom&);

  ConstCopyConstructorBoom(const ConstCopyConstructorBoom&) {
    T *ptr = 1; // expected-error{{cannot initialize a variable of type 'float *' with an rvalue of type 'int'}}
  }

  void foo() const;
};

void conversion_to_block_init(ConstCopyConstructorBoom<int> boom,
                              ConstCopyConstructorBoom<float> boom2) {
  const auto& lambda1([=] { boom.foo(); }); // okay

  const auto& lambda2([=] { boom2.foo(); }); // expected-note{{in instantiation of member function}}
  void (^block)(void) = lambda2;
}

void nesting() {
  int array[7]; // expected-note 2{{'array' declared here}}
  [=] () mutable {
    [&] {
      ^ {
        int i = array[2];
        i += array[3];
      }();
    }();
  }();

  [&] {
    [=] () mutable {
      ^ {
        int i = array[2]; // expected-error{{cannot refer to declaration with an array type inside block}}
        i += array[3];
      }();
    }();

    [=] () mutable {
      ^ {
        int i = 0;
        i += array[3]; // expected-error{{cannot refer to declaration with an array type inside block}}
      }();
    }();
  }();
}

namespace overloading {
  void bool_conversion() {
    if ([](){}) {
    }

    bool b = []{};
    b = (bool)[]{};
  }

  void conversions() {
    int (*fp)(int) = [](int x) { return x + 1; };
    fp = [](int x) { return x + 1; };

    typedef int (*func_ptr)(int);
    fp = (func_ptr)[](int x) { return x + 1; };

    int (^bp)(int) = [](int x) { return x + 1; };
    bp = [](int x) { return x + 1; };

    typedef int (^block_ptr)(int);
    bp = (block_ptr)[](int x) { return x + 1; };
  }

  int &accept_lambda_conv(int (*fp)(int));
  float &accept_lambda_conv(int (^bp)(int));

  void call_with_lambda() {
    int &ir = accept_lambda_conv([](int x) { return x + 1; });
  }

  template<typename T> using id = T;

  auto a = [](){};
  struct C : decltype(a) {
    using decltype(a)::operator id<void(*)()>;
  private:
    using decltype(a)::operator id<void(^)()>;
  } extern c;

  struct D : decltype(a) {
    using decltype(a)::operator id<void(^)()>;
  private:
    using decltype(a)::operator id<void(*)()>; // expected-note {{here}}
  } extern d;

  bool r1 = c;
  bool r2 = d; // expected-error {{private}}
}

namespace PR13117 {
  struct A {
    template<typename ... Args> static void f(Args...);

    template<typename ... Args> static void f1()
    {
      (void)^(Args args) { // expected-error{{block contains unexpanded parameter pack 'Args'}}
      };
    }

    template<typename ... Args> static void f2()
    {
      // FIXME: Allow this.
      f(
        ^(Args args) // expected-error{{block contains unexpanded parameter pack 'Args'}}
        { }
        ... // expected-error{{pack expansion does not contain any unexpanded parameter packs}}
      );
    }

    template<typename ... Args> static void f3()
    {
      (void)[](Args args) { // expected-error{{expression contains unexpanded parameter pack 'Args'}}
      };
    }

    template<typename ... Args> static void f4()
    {
      f([](Args args) { } ...);
    }
  };

  void g() {
    A::f1<int, int>();
    A::f2<int, int>();
  }
}

{'repo_name': 'llvm-mirror/clang', 'stars': '2759', 'repo_language': 'C++', 'file_name': '__init__.py', 'mime_type': 'text/plain', 'hash': 1481131251020609726, 'source_dataset': 'data'}


#region License

// Copyright (c) 2013, ClearCanvas Inc.
// All rights reserved.
// http://www.clearcanvas.ca
//
// This file is part of the ClearCanvas RIS/PACS open source project.
//
// The ClearCanvas RIS/PACS open source project is free software: you can
// redistribute it and/or modify it under the terms of the GNU General Public
// License as published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// The ClearCanvas RIS/PACS open source project is distributed in the hope that it
// will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
// Public License for more details.
//
// You should have received a copy of the GNU General Public License along with
// the ClearCanvas RIS/PACS open source project.  If not, see
// <http://www.gnu.org/licenses/>.

#endregion

using System;
using System.Collections.Generic;

namespace ClearCanvas.Dicom.Iod.FunctionalGroups
{
	/// <summary>
	/// MR Echo Functional Group Macro
	/// </summary>
	/// <remarks>As defined in the DICOM Standard 2011, Part 3, Section C.8.13.5.4 (Table C.8-91)</remarks>
	public class MrEchoFunctionalGroup : FunctionalGroupMacro
	{
		/// <summary>
		/// Initializes a new instance of the <see cref="MrEchoFunctionalGroup"/> class.
		/// </summary>
		public MrEchoFunctionalGroup() {}

		/// <summary>
		/// Initializes a new instance of the <see cref="MrEchoFunctionalGroup"/> class.
		/// </summary>
		/// <param name="dicomSequenceItem">The DICOM sequence item.</param>
		public MrEchoFunctionalGroup(DicomSequenceItem dicomSequenceItem)
			: base(dicomSequenceItem) {}

		public override IEnumerable<uint> DefinedTags
		{
			get { yield return DicomTags.MrEchoSequence; }
		}

		public override IEnumerable<uint> NestedTags
		{
			get { yield return DicomTags.EffectiveEchoTime; }
		}

		public override void InitializeAttributes() {}

		/// <summary>
		/// Gets or sets the value of MrEchoSequence in the underlying collection. Type 1.
		/// </summary>
		public MrEchoSequenceItem MrEchoSequence
		{
			get
			{
				var dicomAttribute = DicomAttributeProvider[DicomTags.MrEchoSequence];
				if (dicomAttribute.IsNull || dicomAttribute.IsEmpty)
					return null;
				return new MrEchoSequenceItem(((DicomSequenceItem[]) dicomAttribute.Values)[0]);
			}
			set
			{
				var dicomAttribute = DicomAttributeProvider[DicomTags.MrEchoSequence];
				if (value == null)
				{
					const string msg = "MrEchoSequence is Type 1 Required.";
					throw new ArgumentNullException("value", msg);
				}
				dicomAttribute.Values = new[] {value.DicomSequenceItem};
			}
		}

		/// <summary>
		/// Creates the MrEchoSequence in the underlying collection. Type 1.
		/// </summary>
		public MrEchoSequenceItem CreateMrEchoSequence()
		{
			var dicomAttribute = DicomAttributeProvider[DicomTags.MrEchoSequence];
			if (dicomAttribute.IsNull || dicomAttribute.IsEmpty)
			{
				var dicomSequenceItem = new DicomSequenceItem();
				dicomAttribute.Values = new[] {dicomSequenceItem};
				var sequenceType = new MrEchoSequenceItem(dicomSequenceItem);
				return sequenceType;
			}
			return new MrEchoSequenceItem(((DicomSequenceItem[]) dicomAttribute.Values)[0]);
		}
	}

	/// <summary>
	/// MR Echo Sequence Item
	/// </summary>
	/// <remarks>As defined in the DICOM Standard 2011, Part 3, Section C.8.13.5.4 (Table C.8-91)</remarks>
	public class MrEchoSequenceItem : SequenceIodBase
	{
		/// <summary>
		/// Initializes a new instance of the <see cref="MrEchoSequenceItem"/> class.
		/// </summary>
		public MrEchoSequenceItem() {}

		/// <summary>
		/// Initializes a new instance of the <see cref="MrEchoSequenceItem"/> class.
		/// </summary>
		/// <param name="dicomSequenceItem">The DICOM sequence item.</param>
		public MrEchoSequenceItem(DicomSequenceItem dicomSequenceItem)
			: base(dicomSequenceItem) {}

		/// <summary>
		/// Gets or sets the value of EffectiveEchoTime in the underlying collection. Type 1C.
		/// </summary>
		public double? EffectiveEchoTime
		{
			get
			{
				double result;
				if (DicomAttributeProvider[DicomTags.EffectiveEchoTime].TryGetFloat64(0, out result))
					return result;
				return null;
			}
			set
			{
				if (!value.HasValue)
				{
					DicomAttributeProvider[DicomTags.EffectiveEchoTime] = null;
					return;
				}
				DicomAttributeProvider[DicomTags.EffectiveEchoTime].SetFloat64(0, value.Value);
			}
		}
	}
}

{'repo_name': 'ClearCanvas/ClearCanvas', 'stars': '318', 'repo_language': 'C#', 'file_name': 'AssemblyInfo.cs', 'mime_type': 'text/plain', 'hash': -7792805847197566506, 'source_dataset': 'data'}


Date: Tue, 18 Sep 2001 00:38:37 -0500 (CDT)
From: Chris Lattner <sabre@nondot.org>
To: Vikram S. Adve <vadve@cs.uiuc.edu>
Subject: Idea for a simple, useful link time optimization

In C++ programs, exceptions suck, and here's why:

1. In virtually all function calls, you must assume that the function
   throws an exception, unless it is defined as 'nothrow'.  This means
   that every function call has to have code to invoke dtors on objects
   locally if one is thrown by the function.  Most functions don't throw
   exceptions, so this code is dead [with all the bad effects of dead
   code, including icache pollution].
2. Declaring a function nothrow causes catch blocks to be added to every
   call that isnot  provably nothrow.  This makes them very slow.
3. Extra extraneous exception edges reduce the opportunity for code
   motion.
4. EH is typically implemented with large lookup tables.  Ours is going to
   be much smaller (than the "standard" way of doing it) to start with,
   but eliminating it entirely would be nice. :)
5. It is physically impossible to correctly put (accurate, correct)
   exception specifications on generic, templated code.  But it is trivial
   to analyze instantiations of said code.
6. Most large C++ programs throw few exceptions.  Most well designed
   programs only throw exceptions in specific planned portions of the
   code.

Given our _planned_ model of handling exceptions, all of this would be
pretty trivial to eliminate through some pretty simplistic interprocedural
analysis.  The DCE factor alone could probably be pretty significant.  The
extra code motion opportunities could also be exploited though...

Additionally, this optimization can be implemented in a straight forward
conservative manner, allowing libraries to be optimized or individual
files even (if there are leaf functions visible in the translation unit
that are called).

I think it's a reasonable optimization that hasn't really been addressed
(because assembly is way too low level for this), and could have decent
payoffs... without being a overly complex optimization.

After I wrote all of that, I found this page that is talking about
basically the same thing I just wrote, except that it is translation unit
at a time, tree based approach:
http://www.ocston.org/~jls/ehopt.html

but is very useful from "expected gain" and references perspective.  Note
that their compiler is apparently unable to inline functions that use
exceptions, so there numbers are pretty worthless... also our results
would (hopefully) be better because it's interprocedural...

What do you think?

-Chris

{'repo_name': 'NetBSD/src', 'stars': '261', 'repo_language': 'None', 'file_name': 'config.h', 'mime_type': 'text/plain', 'hash': -7540866802974849483, 'source_dataset': 'data'}


// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.vcs.log.util

import org.junit.Assert.assertEquals
import org.junit.Test

class StopWatchTestCase {
  @Test
  fun testEvenMinutes() {
    assertEquals("1m", StopWatch.formatTime(60000))
  }

  @Test
  fun testEvenSeconds() {
    assertEquals("1m 5s", StopWatch.formatTime(65000))
  }

  @Test
  fun testUnEvenSeconds() {
    assertEquals("1m 5.100s", StopWatch.formatTime(65100))
  }
}

{'repo_name': 'JetBrains/intellij-community', 'stars': '10177', 'repo_language': 'None', 'file_name': 'ProjectSetRequestHandler.coffee', 'mime_type': 'text/plain', 'hash': -4569371931830509044, 'source_dataset': 'data'}


package errors

import (
	"net/http"
	"sort"

	"github.com/go-ozzo/ozzo-validation"
)

type validationError struct {
	Field string `json:"field"`
	Error string `json:"error"`
}

// InternalServerError creates a new API error representing an internal server error (HTTP 500)
func InternalServerError(err error) *APIError {
	return NewHTTPError(http.StatusInternalServerError, "INTERNAL_SERVER_ERROR", Params{"error": err.Error()})
}

// NotFound creates a new API error representing a resource-not-found error (HTTP 404)
func NotFound(resource string) *APIError {
	return NewHTTPError(http.StatusNotFound, "NOT_FOUND", Params{"resource": resource})
}

// Unauthorized creates a new API error representing an authentication failure (HTTP 401)
func Unauthorized(err string) *APIError {
	return NewHTTPError(http.StatusUnauthorized, "UNAUTHORIZED", Params{"error": err})
}

// InvalidData converts a data validation error into an API error (HTTP 400)
func InvalidData(errs validation.Errors) *APIError {
	result := []validationError{}
	fields := []string{}
	for field := range errs {
		fields = append(fields, field)
	}
	sort.Strings(fields)
	for _, field := range fields {
		err := errs[field]
		result = append(result, validationError{
			Field: field,
			Error: err.Error(),
		})
	}

	err := NewHTTPError(http.StatusBadRequest, "INVALID_DATA", nil)
	err.Details = result

	return err
}

{'repo_name': 'ProofSuite/amp-matching-engine', 'stars': '124', 'repo_language': 'Go', 'file_name': 'server.go', 'mime_type': 'text/plain', 'hash': 8192564259114154918, 'source_dataset': 'data'}


/*
 *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#ifndef KIS_ANIMATION_IMPORTER_TEST_H
#define KIS_ANIMATION_IMPORTER_TEST_H

#include <QTest>

class KisAnimationImporterTest : public QObject {
    Q_OBJECT

private Q_SLOTS:
    void testImport();
};

#endif

{'repo_name': 'KDE/krita', 'stars': '2337', 'repo_language': 'C++', 'file_name': 'filestest.h', 'mime_type': 'text/x-c++', 'hash': -4271166277435693642, 'source_dataset': 'data'}


package com.googlecode.totallylazy.parser;

import com.googlecode.totallylazy.Segment;

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

import static com.googlecode.totallylazy.parser.Success.success;

class ManyParser<A> implements Parser<List<A>> {
    private final Parser<? extends A> parser;

    private ManyParser(Parser<? extends A> parser) {
        this.parser = parser;
    }

    static <A> ManyParser<A> many(Parser<? extends A> parser) {
        return new ManyParser<A>(parser);
    }

    public Result<List<A>> parse(Segment<Character> characters) {
        Segment<Character> segment = characters;
        List<A> list = new ArrayList<A>();

        while (!segment.isEmpty()) {
            Result<? extends A> result = parser.parse(segment);
            if (result instanceof Failure) break;
            list.add(result.value());
            segment = result.remainder();
        }
        return success(list, segment);
    }

    @Override
    public String toString() {
        return String.format("many %s", parser);
    }
}

{'repo_name': 'bodar/totallylazy', 'stars': '247', 'repo_language': 'Java', 'file_name': 'config.yml', 'mime_type': 'text/plain', 'hash': 7502960762427909536, 'source_dataset': 'data'}


// <auto-generated>
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for
// license information.
//
// Code generated by Microsoft (R) AutoRest Code Generator.
// Changes may cause incorrect behavior and will be lost if the code is
// regenerated.
// </auto-generated>

namespace Microsoft.Azure.Management.WebSites
{
    using Microsoft.Rest;
    using Microsoft.Rest.Azure;
    using Models;
    using System.Collections;
    using System.Collections.Generic;
    using System.Threading;
    using System.Threading.Tasks;

    /// <summary>
    /// CertificateRegistrationProviderOperations operations.
    /// </summary>
    public partial interface ICertificateRegistrationProviderOperations
    {
        /// <summary>
        /// Implements Csm operations Api to exposes the list of available Csm
        /// Apis under the resource provider
        /// </summary>
        /// <remarks>
        /// Description for Implements Csm operations Api to exposes the list
        /// of available Csm Apis under the resource provider
        /// </remarks>
        /// <param name='customHeaders'>
        /// The headers that will be added to request.
        /// </param>
        /// <param name='cancellationToken'>
        /// The cancellation token.
        /// </param>
        /// <exception cref="DefaultErrorResponseException">
        /// Thrown when the operation returned an invalid status code
        /// </exception>
        /// <exception cref="Microsoft.Rest.SerializationException">
        /// Thrown when unable to deserialize the response
        /// </exception>
        /// <exception cref="Microsoft.Rest.ValidationException">
        /// Thrown when a required parameter is null
        /// </exception>
        Task<AzureOperationResponse<IPage<CsmOperationDescription>>> ListOperationsWithHttpMessagesAsync(Dictionary<string, List<string>> customHeaders = null, CancellationToken cancellationToken = default(CancellationToken));
        /// <summary>
        /// Implements Csm operations Api to exposes the list of available Csm
        /// Apis under the resource provider
        /// </summary>
        /// <remarks>
        /// Description for Implements Csm operations Api to exposes the list
        /// of available Csm Apis under the resource provider
        /// </remarks>
        /// <param name='nextPageLink'>
        /// The NextLink from the previous successful call to List operation.
        /// </param>
        /// <param name='customHeaders'>
        /// The headers that will be added to request.
        /// </param>
        /// <param name='cancellationToken'>
        /// The cancellation token.
        /// </param>
        /// <exception cref="DefaultErrorResponseException">
        /// Thrown when the operation returned an invalid status code
        /// </exception>
        /// <exception cref="Microsoft.Rest.SerializationException">
        /// Thrown when unable to deserialize the response
        /// </exception>
        /// <exception cref="Microsoft.Rest.ValidationException">
        /// Thrown when a required parameter is null
        /// </exception>
        Task<AzureOperationResponse<IPage<CsmOperationDescription>>> ListOperationsNextWithHttpMessagesAsync(string nextPageLink, Dictionary<string, List<string>> customHeaders = null, CancellationToken cancellationToken = default(CancellationToken));
    }
}

{'repo_name': 'Azure/azure-sdk-for-net', 'stars': '1841', 'repo_language': 'C#', 'file_name': 'NetworkSecurityGroupsDeleteOperation.cs', 'mime_type': 'text/plain', 'hash': -4318435990503682910, 'source_dataset': 'data'}


export default {
  today: 'วันนี้',
  now: 'ตอนนี้',
  backToToday: 'กลับไปยังวันนี้',
  ok: 'ตกลง',
  clear: 'ลบล้าง',
  month: 'เดือน',
  year: 'ปี',
  timeSelect: 'เลือกเวลา',
  dateSelect: 'เลือกวัน',
  monthSelect: 'เลือกเดือน',
  yearSelect: 'เลือกปี',
  decadeSelect: 'เลือกทศวรรษ',
  yearFormat: 'YYYY',
  dateFormat: 'D/M/YYYY',
  dayFormat: 'D',
  dateTimeFormat: 'D/M/YYYY HH:mm:ss',
  monthBeforeYear: true,
  previousMonth: 'เดือนก่อนหน้า (PageUp)',
  nextMonth: 'เดือนถัดไป (PageDown)',
  previousYear: 'ปีก่อนหน้า (Control + left)',
  nextYear: 'ปีถัดไป (Control + right)',
  previousDecade: 'ทศวรรษก่อนหน้า',
  nextDecade: 'ทศวรรษถัดไป',
  previousCentury: 'ศตวรรษก่อนหน้า',
  nextCentury: 'ศตวรรษถัดไป',
};

{'repo_name': 'choerodon/choerodon-ui', 'stars': '133', 'repo_language': 'TypeScript', 'file_name': 'config.yml', 'mime_type': 'text/plain', 'hash': 2928204801380590566, 'source_dataset': 'data'}


<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2" android:background="@color/h4" android:layout_width="match_parent" android:layout_height="wrap_content">
    <LinearLayout android:orientation="vertical" android:id="@+id/eg1" android:background="@color/h4" android:layout_width="match_parent" android:layout_height="wrap_content"/>
    <ImageView android:id="@+id/eg2" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginRight="15dp" android:src="@drawable/be3" android:layout_alignParentRight="true" android:layout_centerVertical="true"/>
    <TextView android:textSize="16dp" android:textColor="@color/a69" android:id="@+id/eg3" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginRight="25dp" android:layout_marginBottom="22dp" android:text="3/4" android:layout_alignParentRight="true" android:layout_alignParentBottom="true"/>
</RelativeLayout>

{'repo_name': 'HelloHuDi/AndroidReverseNotes', 'stars': '116', 'repo_language': 'Smali', 'file_name': 'v.java', 'mime_type': 'text/x-java', 'hash': -4345465496176893778, 'source_dataset': 'data'}


//
//  AppDelegate.m
//  利用Runtime自定义控制器POP手势动画
//
//  Created by yifan on 15/9/29.
//  Copyright © 2015年 黄成都. All rights reserved.
//

#import "AppDelegate.h"

@interface AppDelegate ()

@end

@implementation AppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    // Override point for customization after application launch.
    return YES;
}

- (void)applicationWillResignActive:(UIApplication *)application {
    // Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state.
    // Use this method to pause ongoing tasks, disable timers, and throttle down OpenGL ES frame rates. Games should use this method to pause the game.
}

- (void)applicationDidEnterBackground:(UIApplication *)application {
    // Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later.
    // If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits.
}

- (void)applicationWillEnterForeground:(UIApplication *)application {
    // Called as part of the transition from the background to the inactive state; here you can undo many of the changes made on entering the background.
}

- (void)applicationDidBecomeActive:(UIApplication *)application {
    // Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface.
}

- (void)applicationWillTerminate:(UIApplication *)application {
    // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.
}

@end

{'repo_name': 'huang303513/iOSKeyPointExploration', 'stars': '655', 'repo_language': 'Objective-C', 'file_name': 'Info.plist', 'mime_type': 'text/xml', 'hash': -5200002028247329851, 'source_dataset': 'data'}


set(SRC_CPP_FILES
)

set(INTERNAL_CPP_FILES
  mitkPluginActivator.cpp
  QmitkDataManagerLightView.cpp
)

set(MOC_H_FILES
  src/internal/QmitkDataManagerLightView.h
  src/internal/mitkPluginActivator.h
)

set(CPP_FILES )

set(CACHED_RESOURCE_FILES
  plugin.xml
  resources/DataManagerLight.png
)

set(QRC_FILES
  resources/DataManagerLight.qrc
)

foreach(file ${SRC_CPP_FILES})
  set(CPP_FILES ${CPP_FILES} src/${file})
endforeach(file ${SRC_CPP_FILES})

foreach(file ${INTERNAL_CPP_FILES})
  set(CPP_FILES ${CPP_FILES} src/internal/${file})
endforeach(file ${INTERNAL_CPP_FILES})

{'repo_name': 'MITK/MITK', 'stars': '322', 'repo_language': 'C++', 'file_name': 'Overview.dox', 'mime_type': 'text/html', 'hash': 1491652133373328692, 'source_dataset': 'data'}


/*! \file common.h
 *  \brief Auto-generated file. Do not modify.
 *  \author Georgi Gerganov
 */

#pragma once

// the main js module
constexpr auto kImGuiWS_js = R"js(

var imgui_ws = {
    canvas: null,
    gl: null,

    shader_program: null,
    vertex_buffer: null,
    index_buffer: null,

    attribute_location_tex: null,
    attribute_location_proj_mtx: null,
    attribute_location_position: null,
    attribute_location_uv: null,
    attribute_location_color: null,

    device_pixel_ratio: window.device_pixel_ratio || 1,

    tex_font_id: null,
    tex_font_abuf: null,

    n_draw_lists: null,
    draw_lists_abuf: {},

    io: {
        mouse_x: 0.0,
        mouse_y: 0.0,

        want_capture_mouse: true,
        want_capture_keyboard: true,
    },

    init: function(canvas_name) {
        this.canvas = document.getElementById(canvas_name);

        var onkeyup = this.canvas_on_keyup.bind(this);
        var onkeydown = this.canvas_on_keydown.bind(this);
        var onkeypress = this.canvas_on_keypress.bind(this);
        var onpointermove = this.canvas_on_pointermove.bind(this);
        var onpointerdown = this.canvas_on_pointerdown.bind(this);
        var onpointerup = this.canvas_on_pointerup.bind(this);
        var onwheel = this.canvas_on_wheel.bind(this);
        var ontouch = this.canvas_on_touch.bind(this);

        //this.canvas.style.touchAction = 'none'; // Disable browser handling of all panning and zooming gestures.
        //this.canvas.addEventListener('blur', this.canvas_on_blur);

        this.canvas.addEventListener('keyup', onkeyup, true);
        this.canvas.addEventListener('keydown', onkeydown, true);
        this.canvas.addEventListener('keypress', onkeypress, true);

        this.canvas.addEventListener('pointermove', onpointermove);
        this.canvas.addEventListener('mousemove', onpointermove);

        this.canvas.addEventListener('pointerdown', onpointerdown);
        this.canvas.addEventListener('mousedown', onpointerdown);

        this.canvas.addEventListener('pointerup', onpointerup);
        this.canvas.addEventListener('mouseup', onpointerup);

        this.canvas.addEventListener('contextmenu', function(event) { event.preventDefault(); });
        this.canvas.addEventListener('wheel', onwheel, false);

        this.canvas.addEventListener('touchstart', ontouch);
        this.canvas.addEventListener('touchmove', ontouch);
        this.canvas.addEventListener('touchend', ontouch);
        this.canvas.addEventListener('touchcancel', ontouch);

        this.gl = this.canvas.getContext('webgl');

        this.vertex_buffer = this.gl.createBuffer();
        this.index_buffer = this.gl.createBuffer();

        var vertex_shader_source = [
            'precision mediump float;' +
            'uniform mat4 ProjMtx;' +
            'attribute vec2 Position;' +
            'attribute vec2 UV;' +
            'attribute vec4 Color;' +
            'varying vec2 Frag_UV;' +
            'varying vec4 Frag_Color;' +
            'void main(void) {' +
            '	Frag_UV = UV;' +
            '	Frag_Color = Color;' +
            '   gl_Position = ProjMtx * vec4(Position, 0, 1);' +
            '}'
        ];

        var vertex_shader = this.gl.createShader(this.gl.VERTEX_SHADER);
        this.gl.shaderSource(vertex_shader, vertex_shader_source);
        this.gl.compileShader(vertex_shader);

        var fragment_shader_source = [
            'precision mediump float;' +
            'uniform sampler2D Texture;' +
            'varying vec2 Frag_UV;' +
            'varying vec4 Frag_Color;' +
            'void main() {' +
            '	gl_FragColor = Frag_Color * texture2D(Texture, Frag_UV.st);' +
            '}'
        ];

        var fragment_shader = this.gl.createShader(this.gl.FRAGMENT_SHADER);
        this.gl.shaderSource(fragment_shader, fragment_shader_source);
        this.gl.compileShader(fragment_shader);

        this.shader_program = this.gl.createProgram();
        this.gl.attachShader(this.shader_program, vertex_shader);
        this.gl.attachShader(this.shader_program, fragment_shader);
        this.gl.linkProgram(this.shader_program);

        this.attribute_location_tex      = this.gl.getUniformLocation(this.shader_program,   "Texture");
        this.attribute_location_proj_mtx = this.gl.getUniformLocation(this.shader_program,   "ProjMtx");
        this.attribute_location_position = this.gl.getAttribLocation(this.shader_program,    "Position");
        this.attribute_location_uv       = this.gl.getAttribLocation(this.shader_program,    "UV");
        this.attribute_location_color    = this.gl.getAttribLocation(this.shader_program,    "Color");

        this.gl.enable(this.gl.BLEND);
        this.gl.blendEquation(this.gl.FUNC_ADD);
        this.gl.blendFunc(this.gl.SRC_ALPHA, this.gl.ONE_MINUS_SRC_ALPHA);
        this.gl.disable(this.gl.CULL_FACE);
        this.gl.disable(this.gl.DEPTH_TEST);
        this.gl.viewport(0, 0, this.canvas.width, this.canvas.height);

        var clip_off_x = 0.0;
        var clip_off_y = 0.0;

        const L = clip_off_x;
        const R = clip_off_x + this.canvas.width;
        const T = clip_off_y;
        const B = clip_off_y + this.canvas.height;

        const ortho_projection = new Float32Array([
            2.0 / (R - L), 0.0, 0.0, 0.0,
            0.0, 2.0 / (T - B), 0.0, 0.0,
            0.0, 0.0, -1.0, 0.0,
            (R + L) / (L - R), (T + B) / (B - T), 0.0, 1.0,
        ]);
        this.gl.useProgram(this.shader_program);
        this.gl.uniform1i(this.attribute_location_tex, 0);
        this.gl.uniformMatrix4fv(this.attribute_location_proj_mtx, false, ortho_projection);

        this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.vertex_buffer);
        this.gl.bindBuffer(this.gl.ELEMENT_ARRAY_BUFFER, this.index_buffer);

        this.gl.enableVertexAttribArray(this.attribute_location_position);
        this.gl.enableVertexAttribArray(this.attribute_location_uv);
        this.gl.enableVertexAttribArray(this.attribute_location_color);
        this.gl.vertexAttribPointer(this.attribute_location_position, 2, this.gl.FLOAT,         false, 5*4, 0);
        this.gl.vertexAttribPointer(this.attribute_location_uv,       2, this.gl.FLOAT,         false, 5*4, 2*4);
        this.gl.vertexAttribPointer(this.attribute_location_color,    4, this.gl.UNSIGNED_BYTE, true,  5*4, 4*4);
    },

    incppect_tex_font: function(incppect) {
        if (this.tex_font_abuf === null || this.tex_font_abuf.byteLength < 1) {
            this.tex_font_abuf = incppect.get_abuf('imgui.textures[%d]', 1);
        } else if (this.tex_font_id === null) {
            imgui_ws.init_font(this.tex_font_abuf);
        }
    },

    init_font: function(tex_font_abuf) {
        var tex_font_uint8 = new Uint8Array(tex_font_abuf);
        var tex_font_int32 = new Int32Array(tex_font_abuf);

        const width = tex_font_int32[2];
        const height = tex_font_int32[3];

        var pixels = new Uint8Array(4*width*height);
        for (var i = 0; i < width*height; ++i) {
            pixels[4*i + 3] = tex_font_uint8[16 + i];
            pixels[4*i + 2] = 0xFF;
            pixels[4*i + 1] = 0xFF;
            pixels[4*i + 0] = 0xFF;
        }

        this.tex_font_id = this.gl.createTexture();
        this.gl.bindTexture(this.gl.TEXTURE_2D, this.tex_font_id);
        this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MIN_FILTER, this.gl.LINEAR);
        this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MAG_FILTER, this.gl.LINEAR);
        //this.gl.pixelStorei(gl.UNPACK_ROW_LENGTH); // WebGL2
        this.gl.texImage2D(this.gl.TEXTURE_2D, 0, this.gl.RGBA, width, height, 0, this.gl.RGBA, this.gl.UNSIGNED_BYTE, pixels);
    },

    incppect_draw_lists: function(incppect) {
        this.n_draw_lists = incppect.get_int32('imgui.n_draw_lists');
        if (this.n_draw_lists < 1) return;

        for (var i = 0; i < this.n_draw_lists; ++i) {
            this.draw_lists_abuf[i] = incppect.get_abuf('imgui.draw_list[%d]', i);
        }
    },

    render: function(n_draw_lists, draw_lists_abuf) {
        if (typeof n_draw_lists === "undefined" && typeof draw_lists_abuf === "undefined") {
            if (this.n_draw_lists === null) return;
            if (this.draw_lists_abuf === null) return;

            this.render(this.n_draw_lists, this.draw_lists_abuf);

            return;
        }

        var clip_off_x = 0.0;
        var clip_off_y = 0.0;

        this.gl.enable(this.gl.SCISSOR_TEST);

        for (var i_list = 0; i_list < n_draw_lists; ++i_list) {
            if (draw_lists_abuf[i_list].byteLength < 1) continue;

            var draw_data_offset = 0;

            var p = new Float32Array(draw_lists_abuf[i_list], draw_data_offset, 2);
            var offset_x = p[0]; draw_data_offset += 4;
            var offset_y = p[1]; draw_data_offset += 4;

            p = new Uint32Array(draw_lists_abuf[i_list], draw_data_offset, 1);
            var n_vertices = p[0]; draw_data_offset += 4;

            var av = new Float32Array(draw_lists_abuf[i_list], draw_data_offset, 5*n_vertices);

            for (var k = 0; k < n_vertices; ++k) {
                av[5*k + 0] += offset_x;
                av[5*k + 1] += offset_y;
            }

            this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.vertex_buffer);
            this.gl.bufferData(this.gl.ARRAY_BUFFER, av, this.gl.STREAM_DRAW);

            for (var k = 0; k < n_vertices; ++k) {
                av[5*k + 0] -= offset_x;
                av[5*k + 1] -= offset_y;
            }

            draw_data_offset += 5*4*n_vertices;

            p = new Uint32Array(draw_lists_abuf[i_list], draw_data_offset, 1);
            var n_indices = p[0]; draw_data_offset += 4;

            var ai = new Uint16Array(draw_lists_abuf[i_list], draw_data_offset, n_indices);
            this.gl.bindBuffer(this.gl.ELEMENT_ARRAY_BUFFER, this.index_buffer);
            this.gl.bufferData(this.gl.ELEMENT_ARRAY_BUFFER, ai, this.gl.STREAM_DRAW);
            draw_data_offset += 2*n_indices;

            p = new Uint32Array(draw_lists_abuf[i_list], draw_data_offset, 1);
            var n_cmd = p[0]; draw_data_offset += 4;

            for (var i_cmd = 0; i_cmd < n_cmd; ++i_cmd) {
                var pi = new Uint32Array(draw_lists_abuf[i_list], draw_data_offset, 4);
                var n_elements = pi[0]; draw_data_offset += 4;
                var texture_id = pi[1]; draw_data_offset += 4;
                var offset_vtx = pi[2]; draw_data_offset += 4;
                var offset_idx = pi[3]; draw_data_offset += 4;

                var pf = new Float32Array(draw_lists_abuf[i_list], draw_data_offset, 4);
                var clip_x = pf[0] - clip_off_x; draw_data_offset += 4;
                var clip_y = pf[1] - clip_off_y; draw_data_offset += 4;
                var clip_z = pf[2] - clip_off_x; draw_data_offset += 4;
                var clip_w = pf[3] - clip_off_y; draw_data_offset += 4;

                if (clip_x < this.canvas.width && clip_y < this.canvas.height && clip_z >= 0.0 && clip_w >= 0.0) {
                    this.gl.scissor(clip_x, this.canvas.height - clip_w, clip_z - clip_x, clip_w - clip_y);
                    // todo : temp hack
                    if (texture_id == 1) {
                        this.gl.activeTexture(this.gl.TEXTURE0);
                        this.gl.bindTexture(this.gl.TEXTURE_2D, this.tex_font_id);
                    }
                    this.gl.drawElements(this.gl.TRIANGLES, n_elements, this.gl.UNSIGNED_SHORT, 2*offset_idx);
                }
            }
        }

        this.gl.disable(this.gl.SCISSOR_TEST);
    },

    canvas_on_keyup: function(event) {},
    canvas_on_keydown: function(event) {},
    canvas_on_keypress: function(event) {},
    canvas_on_pointermove: function(event) {},
    canvas_on_pointerdown: function(event) {},
    canvas_on_pointerup: function(event) {},
    canvas_on_wheel: function(event) {},
    canvas_on_touch: function(event) {},

    set_incppect_handlers: function(incppect) {
        this.canvas_on_keyup = function(event) {
            incppect.send('6 ' + event.keyCode);
        };

        this.canvas_on_keydown = function(event) {
            incppect.send('5 ' + event.keyCode);
        };

        this.canvas_on_keypress = function(event) {
            incppect.send('4 ' + event.keyCode);

            if (this.io.want_capture_mouse) {
                event.preventDefault();
            }
        };

        this.canvas_on_pointermove = function(event) {
            this.io.mouse_x = event.offsetX * this.device_pixel_ratio;
            this.io.mouse_y = event.offsetY * this.device_pixel_ratio;

            incppect.send('0 ' + this.io.mouse_x + ' ' + this.io.mouse_y);

            if (this.io.want_capture_keyboard) {
                event.preventDefault();
            }
        };

        this.canvas_on_pointerdown = function(event) {
            this.io.mouse_x = event.offsetX * this.device_pixel_ratio;
            this.io.mouse_y = event.offsetY * this.device_pixel_ratio;

            incppect.send('1 ' + event.button + ' ' + this.io.mouse_x + ' ' + this.io.mouse_y);
        };

        this.canvas_on_pointerup = function(event) {
            incppect.send('2 ' + event.button + ' ' + this.io.mouse_x + ' ' + this.io.mouse_y);

            if (this.io.want_capture_mouse) {
                event.preventDefault();
            }
        };

        this.canvas_on_wheel = function(event) {
            let scale = 1.0;
            switch (event.deltaMode) {
                case event.DOM_DELTA_PIXEL:
                    scale = 0.01;
                    break;
                case event.DOM_DELTA_LINE:
                    scale = 0.2;
                    break;
                case event.DOM_DELTA_PAGE:
                    scale = 1.0;
                    break;
            }

            var wheel_x =  event.deltaX * scale;
            var wheel_y = -event.deltaY * scale;

            incppect.send('3 ' + wheel_x + ' ' + wheel_y);

            if (this.io.want_capture_mouse) {
                event.preventDefault();
            }
        };

        this.canvas_on_touch = function (event) {
            if (event.touches.length > 1) {
                return;
            }

            var touches = event.changedTouches,
                first = touches[0],
                type = "";

            switch(event.type) {
                case "touchstart": type = "mousedown"; break;
                case "touchmove":  type = "mousemove"; break;
                case "touchend":   type = "mouseup";   break;
                default:           return;
            }

            // initMouseEvent(type, canBubble, cancelable, view, clickCount,
            //                screenX, screenY, clientX, clientY, ctrlKey,
            //                altKey, shiftKey, metaKey, button, relatedTarget);

            var simulatedEvent = document.createEvent("MouseEvent");
            simulatedEvent.initMouseEvent(type, true, true, window, 1, first.screenX, first.screenY, first.clientX, first.clientY, false, false, false, false, 0/*left*/, null);

            first.target.dispatchEvent(simulatedEvent);
            event.preventDefault();
        };
    },

}

)js";

{'repo_name': 'ggerganov/imgui-ws', 'stars': '124', 'repo_language': 'C++', 'file_name': 'imgui-draw-data-compressor.h', 'mime_type': 'text/x-c++', 'hash': 3856348379730431010, 'source_dataset': 'data'}


/*
 * Module provides interfaces for turning on and off different parts of the
 * networking stack.
 *
 * @author Stephen Dawson-Haggerty <stevedh@cs.berkeley.edu>
 * @author Brad Campbell <bradjc@umich.edu>
 */

module IPStackControlP {
  provides {
    interface SplitControl;
  }
  uses {
    interface StdControl;
    interface StdControl as RoutingControl;
    interface SplitControl as SubSplitControl;
    interface StdControl as NeighborDiscoveryControl;
    interface IPAddress;
  }
} implementation {

  // Keep track of whether the BLIP stack has been started (using SplitControl)
  bool blip_started = FALSE;

  command error_t SplitControl.start() {
    if (blip_started) return EALREADY;
    return call SubSplitControl.start();
  }

  event void SubSplitControl.startDone(error_t error) {
    if (error == SUCCESS) {
      blip_started = TRUE;
      call StdControl.start();
    }

    call NeighborDiscoveryControl.start();

#if RPL_ADDR_AUTOCONF
    // If we are using the routing layer to get our full address, then
    // we must start the routing layer immediately.
    call RoutingControl.start();
#else
    // Otherwise, check to see if we have a global address before starting
    // the routing layer.
    {
      struct in6_addr addr;
      // if we have a global address, we can start any routing protocols now.
      if (call IPAddress.getGlobalAddr(&addr)) {
        call RoutingControl.start();
      }
    }
#endif

    signal SplitControl.startDone(error);
  }

  command error_t SplitControl.stop() {
    call StdControl.stop();
    call RoutingControl.stop();

    return call SubSplitControl.stop();
  }

  event void SubSplitControl.stopDone(error_t error) {
    if (error == SUCCESS) {
      blip_started = FALSE;
    }
    signal SplitControl.stopDone(error);
  }

  event void IPAddress.changed(bool valid) {
    if (valid) {
      call RoutingControl.start();
    } else {
      call RoutingControl.stop();
    }
  }

 default command error_t StdControl.start() { return SUCCESS; }
 default command error_t StdControl.stop() { return SUCCESS; }
 default command error_t RoutingControl.start() { return SUCCESS; }
 default command error_t RoutingControl.stop() { return SUCCESS; }

}

{'repo_name': 'tinyos/tinyos-main', 'stars': '1052', 'repo_language': 'nesC', 'file_name': 'UartControl.nc', 'mime_type': 'text/plain', 'hash': 4440832123417009575, 'source_dataset': 'data'}


Lorem ipsum           {@id=lorem}
=================================

Dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor
incididunt ut labore et dolore magna aliqua.

* Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris
    nisi ut aliquip ex ea commodo consequat.{@class=first_item}

* Duis aute irure dolor in reprehenderit in voluptate velit esse
    cillum dolore eu fugiat nulla pariatur2. Excepteur sint occaecat
    cupidatat non proident, sunt in culpa qui officia deserunt mollit
    anim id est laborum.

Duis aute **irure{@type=term}** dolor in reprehenderit in voluptate
velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint
occaecat cupidatat non proident, sunt in culpa qui officia deserunt
mollit anim id est laborum.

{'repo_name': 'cloudera/hue', 'stars': '4253', 'repo_language': 'Python', 'file_name': 'index.txt', 'mime_type': 'text/plain', 'hash': -4455071742900466832, 'source_dataset': 'data'}


<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="http://www.opentravel.org/OTA/2003/05" targetNamespace="http://www.opentravel.org/OTA/2003/05" elementFormDefault="qualified" version="1.007" id="OTA2007B">
	<xs:include schemaLocation="OTA_HotelCommonTypes.xsd"/>

	<xs:annotation>
		<xs:documentation xml:lang="en">All Schema files in the OTA specification are made available according to the terms defined by the OTA License Agreement at http://www.opentravel.org/ota_downloads_form.cfm</xs:documentation>
	</xs:annotation>
	<xs:element name="OTA_HotelInvSyncRQ">
		<xs:complexType>
			<xs:sequence>
				<xs:element name="UniqueID" type="UniqueID_Type" minOccurs="0"/>
				<xs:element name="Adjustments" minOccurs="0">
					<xs:complexType>
						<xs:complexContent>
							<xs:extension base="AdjustmentsType">
								<xs:attributeGroup ref="HotelReferenceGroup"/>
							</xs:extension>
						</xs:complexContent>
					</xs:complexType>
				</xs:element>
			</xs:sequence>
			<xs:attributeGroup ref="OTA_PayloadStdAttributes"/>
		</xs:complexType>
	</xs:element>
</xs:schema>

{'repo_name': 'goetas/xsd2php', 'stars': '150', 'repo_language': 'PHP', 'file_name': 'OTA_AuthorizationRS.xsd', 'mime_type': 'text/xml', 'hash': 8906471547423661863, 'source_dataset': 'data'}