// ----------------------------------------------------------------------------
// -                        Open3D: www.open3d.org                            -
// ----------------------------------------------------------------------------
// The MIT License (MIT)
//
// Copyright (c) 2020 www.open3d.org
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
// ----------------------------------------------------------------------------
//

#include <vector>

#include "open3d/ml/impl/misc/NeighborSearchCommon.h"
#include "open3d/ml/pytorch/TorchHelper.h"
#include "torch/script.h"

using namespace open3d::ml::impl;

template <class T>
void FixedRadiusSearchCPU(const torch::Tensor& points,
                          const torch::Tensor& queries,
                          double radius,
                          const torch::Tensor& points_row_splits,
                          const torch::Tensor& queries_row_splits,
                          const torch::Tensor& hash_table_splits,
                          const torch::Tensor& hash_table_index,
                          const torch::Tensor& hash_table_cell_splits,
                          const Metric metric,
                          const bool ignore_query_point,
                          const bool return_distances,
                          torch::Tensor& neighbors_index,
                          torch::Tensor& neighbors_row_splits,
                          torch::Tensor& neighbors_distance);
#ifdef BUILD_CUDA_MODULE
template <class T>
void FixedRadiusSearchCUDA(const torch::Tensor& points,
                           const torch::Tensor& queries,
                           double radius,
                           const torch::Tensor& points_row_splits,
                           const torch::Tensor& queries_row_splits,
                           const torch::Tensor& hash_table_splits,
                           const torch::Tensor& hash_table_index,
                           const torch::Tensor& hash_table_cell_splits,
                           const Metric metric,
                           const bool ignore_query_point,
                           const bool return_distances,
                           torch::Tensor& neighbors_index,
                           torch::Tensor& neighbors_row_splits,
                           torch::Tensor& neighbors_distance);
#endif

std::tuple<torch::Tensor, torch::Tensor, torch::Tensor> FixedRadiusSearch(
        torch::Tensor points,
        torch::Tensor queries,
        double radius,
        torch::Tensor points_row_splits,
        torch::Tensor queries_row_splits,
        torch::Tensor hash_table_splits,
        torch::Tensor hash_table_index,
        torch::Tensor hash_table_cell_splits,
        const std::string& metric_str,
        const bool ignore_query_point,
        const bool return_distances) {
    Metric metric = L2;
    if (metric_str == "L1") {
        metric = L1;
    } else if (metric_str == "L2") {
        metric = L2;
    } else if (metric_str == "Linf") {
        metric = Linf;
    } else {
        TORCH_CHECK(false, "metric must be one of (L1, L2, Linf) but got " +
                                   metric_str);
    }
    CHECK_TYPE(points_row_splits, kInt64);
    CHECK_TYPE(queries_row_splits, kInt64);
    CHECK_TYPE(hash_table_splits, kInt32);
    CHECK_TYPE(hash_table_index, kInt32);
    CHECK_TYPE(hash_table_cell_splits, kInt32);
    CHECK_SAME_DTYPE(points, queries);
    CHECK_SAME_DEVICE_TYPE(points, queries);
    // ensure that these are on the cpu
    points_row_splits = points_row_splits.to(torch::kCPU);
    queries_row_splits = queries_row_splits.to(torch::kCPU);
    hash_table_splits = hash_table_splits.to(torch::kCPU);
    points = points.contiguous();
    queries = queries.contiguous();
    points_row_splits = points_row_splits.contiguous();
    queries_row_splits = queries_row_splits.contiguous();
    hash_table_splits = hash_table_splits.contiguous();
    hash_table_index = hash_table_index.contiguous();
    hash_table_cell_splits = hash_table_cell_splits.contiguous();

    // check input shapes
    using namespace open3d::ml::op_util;
    Dim num_points("num_points");
    Dim num_queries("num_queries");
    Dim batch_size("batch_size");
    Dim num_cells("num_cells");
    CHECK_SHAPE(points, num_points, 3);
    CHECK_SHAPE(hash_table_index, num_points);
    CHECK_SHAPE(queries, num_queries, 3);
    CHECK_SHAPE(points_row_splits, batch_size + 1);
    CHECK_SHAPE(queries_row_splits, batch_size + 1);
    CHECK_SHAPE(hash_table_splits, batch_size + 1);
    CHECK_SHAPE(hash_table_cell_splits, num_cells + 1);

    const auto& point_type = points.dtype();

    auto device = points.device().type();
    auto device_idx = points.device().index();

    torch::Tensor neighbors_index;
    torch::Tensor neighbors_row_splits = torch::empty(
            {queries.size(0) + 1},
            torch::dtype(ToTorchDtype<int64_t>()).device(device, device_idx));
    torch::Tensor neighbors_distance;

#define FN_PARAMETERS                                                      \
    points, queries, radius, points_row_splits, queries_row_splits,        \
            hash_table_splits, hash_table_index, hash_table_cell_splits,   \
            metric, ignore_query_point, return_distances, neighbors_index, \
            neighbors_row_splits, neighbors_distance

#define CALL(type, fn)                                                \
    if (CompareTorchDtype<type>(point_type)) {                        \
        fn<type>(FN_PARAMETERS);                                      \
        return std::make_tuple(neighbors_index, neighbors_row_splits, \
                               neighbors_distance);                   \
    }

    if (points.is_cuda()) {
#ifdef BUILD_CUDA_MODULE
        // pass to cuda function
        CALL(float, FixedRadiusSearchCUDA)
#else
        TORCH_CHECK(false,
                    "FixedRadiusSearch was not compiled with CUDA support")
#endif
    } else {
        CALL(float, FixedRadiusSearchCPU)
        CALL(double, FixedRadiusSearchCPU)
    }
    TORCH_CHECK(false, "FixedRadiusSearch does not support " +
                               points.toString() + " as input for points")
    return std::tuple<torch::Tensor, torch::Tensor, torch::Tensor>();
}

static auto registry = torch::RegisterOperators(
        "open3d::fixed_radius_search(Tensor points, Tensor queries, float "
        "radius, Tensor points_row_splits, Tensor queries_row_splits, Tensor "
        "hash_table_splits, Tensor hash_table_index, Tensor "
        "hash_table_cell_splits, str metric=\"L2\", bool ignore_query_point="
        "False, bool return_distances=False) -> (Tensor neighbors_index, "
        "Tensor neighbors_row_splits, Tensor neighbors_distance)",
        &FixedRadiusSearch);

{'repo_name': 'intel-isl/Open3D', 'stars': '3115', 'repo_language': 'C++', 'file_name': 'assimp.cmake', 'mime_type': 'text/plain', 'hash': 8163275870971971172, 'source_dataset': 'data'}


// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:generate go run gen.go

// Package identifier defines the contract between implementations of Encoding
// and Index by defining identifiers that uniquely identify standardized coded
// character sets (CCS) and character encoding schemes (CES), which we will
// together refer to as encodings, for which Encoding implementations provide
// converters to and from UTF-8. This package is typically only of concern to
// implementers of Indexes and Encodings.
//
// One part of the identifier is the MIB code, which is defined by IANA and
// uniquely identifies a CCS or CES. Each code is associated with data that
// references authorities, official documentation as well as aliases and MIME
// names.
//
// Not all CESs are covered by the IANA registry. The "other" string that is
// returned by ID can be used to identify other character sets or versions of
// existing ones.
//
// It is recommended that each package that provides a set of Encodings provide
// the All and Common variables to reference all supported encodings and
// commonly used subset. This allows Index implementations to include all
// available encodings without explicitly referencing or knowing about them.
package identifier

// Note: this package is internal, but could be made public if there is a need
// for writing third-party Indexes and Encodings.

// References:
// - http://source.icu-project.org/repos/icu/icu/trunk/source/data/mappings/convrtrs.txt
// - http://www.iana.org/assignments/character-sets/character-sets.xhtml
// - http://www.iana.org/assignments/ianacharset-mib/ianacharset-mib
// - http://www.ietf.org/rfc/rfc2978.txt
// - http://www.unicode.org/reports/tr22/
// - http://www.w3.org/TR/encoding/
// - https://encoding.spec.whatwg.org/
// - https://encoding.spec.whatwg.org/encodings.json
// - https://tools.ietf.org/html/rfc6657#section-5

// Interface can be implemented by Encodings to define the CCS or CES for which
// it implements conversions.
type Interface interface {
	// ID returns an encoding identifier. Exactly one of the mib and other
	// values should be non-zero.
	//
	// In the usual case it is only necessary to indicate the MIB code. The
	// other string can be used to specify encodings for which there is no MIB,
	// such as "x-mac-dingbat".
	//
	// The other string may only contain the characters a-z, A-Z, 0-9, - and _.
	ID() (mib MIB, other string)

	// NOTE: the restrictions on the encoding are to allow extending the syntax
	// with additional information such as versions, vendors and other variants.
}

// A MIB identifies an encoding. It is derived from the IANA MIB codes and adds
// some identifiers for some encodings that are not covered by the IANA
// standard.
//
// See http://www.iana.org/assignments/ianacharset-mib.
type MIB uint16

// These additional MIB types are not defined in IANA. They are added because
// they are common and defined within the text repo.
const (
	// Unofficial marks the start of encodings not registered by IANA.
	Unofficial MIB = 10000 + iota

	// Replacement is the WhatWG replacement encoding.
	Replacement

	// XUserDefined is the code for x-user-defined.
	XUserDefined

	// MacintoshCyrillic is the code for x-mac-cyrillic.
	MacintoshCyrillic
)

{'repo_name': 'checkr/codeflow', 'stars': '188', 'repo_language': 'Go', 'file_name': 'interface.go', 'mime_type': 'text/x-c', 'hash': 8128795200867875613, 'source_dataset': 'data'}


/**
 * @file test.cpp
 * @author Sina Karvandi (sina@rayanfam.com)
 * @brief test command
 * @details
 * @version 0.1
 * @date 2020-06-11
 *
 * @copyright This project is released under the GNU Public License v3.
 *
 */
#include "pch.h"

/**
 * @brief help of test command
 *
 * @return VOID
 */
VOID CommandTestHelp() {
  ShowMessages(
      "test : Test essential features of HyperDbg in current machine.\n");
  ShowMessages("syntax : \ttest [test case (hex value)\n");

  ShowMessages("\t\te.g : test\n");
  ShowMessages("\t\te.g : test 0x3\n");
}

/**
 * @brief perform test on the remote process
 *
 * @param TestCaseNum Number of test case
 * @param InvalidTestCase if true then command is invalid, if false then test
 * case is valid
 *
 * @return BOOLEAN returns true if the results was true and false if the results
 * was not ok
 */
BOOLEAN CommandTestPerformTest(UINT32 TestCaseNum, PBOOLEAN InvalidTestCase) {

  BOOLEAN ResultOfTest = FALSE;
  *InvalidTestCase = FALSE;

  switch (TestCaseNum) {
  case DEBUGGER_TEST_USER_MODE_INFINITE_LOOP_THREAD: {
    ShowMessages("[*] Test attaching to threads, stepping, detaching...\n");
    ResultOfTest = TestInfiniteLoop();
    break;
  }
  default:
    *InvalidTestCase = TRUE;
    ResultOfTest = FALSE;
    break;
  }

  return ResultOfTest;
}

/**
 * @brief test command handler
 *
 * @param SplittedCommand
 * @return VOID
 */
VOID CommandTest(vector<string> SplittedCommand) {

  BOOLEAN GetTestCase = FALSE;
  BOOLEAN TestEverything = FALSE;
  BOOLEAN WrongTestCase = FALSE;
  BOOLEAN Result = FALSE;
  UINT64 SpecialTestCase = 0;

  if (SplittedCommand.size() > 2) {
    ShowMessages("incorrect use of 'test'\n\n");
    CommandTestHelp();
    return;
  }

  //
  // Interpret command specific details (if any)
  //
  for (auto Section : SplittedCommand) {
    if (!Section.compare("test")) {
      continue;
    } else if (!GetTestCase) {

      //
      // It's probably a test case number
      //
      if (!ConvertStringToUInt64(Section, &SpecialTestCase)) {

        //
        // Unkonwn parameter
        //
        ShowMessages("Unknown parameter '%s'\n\n", Section.c_str());
        CommandTestHelp();
        return;
      } else {
        GetTestCase = TRUE;
      }
    } else {

      //
      // Unkonwn parameter
      //
      ShowMessages("Unknown parameter '%s'\n\n", Section.c_str());
      CommandTestHelp();
      return;
    }
  }

  //
  // Perform the test case
  //
  if (SpecialTestCase == DEBUGGER_TEST_ALL_COMMANDS) {

    //
    // Means to check everything
    //
    TestEverything = TRUE;
  }

  ShowMessages("---------------------------------------------------------\n");

  //
  // Means to check just one command
  //
  for (size_t i = 1; i < MAXLONG; i++) {

    if (TestEverything)
      SpecialTestCase = i;

    Result = CommandTestPerformTest(SpecialTestCase, &WrongTestCase);

    if (WrongTestCase) {
      //
      // Wrong test case
      //
      if (TestEverything) {
        break;
      } else {
        ShowMessages("Wrong test-case.\n");
      }
    } else {
      //
      // Check if this is wrong command or not
      //
      if (Result) {
        ShowMessages("\t[+] Successful\n");
      } else {
        ShowMessages("\t[-] Unsuccessful\n");
      }
    }
    if (!TestEverything) {
      break;
    }
  }

  ShowMessages("---------------------------------------------------------\n");
}

{'repo_name': 'HyperDbg/HyperDbg', 'stars': '237', 'repo_language': 'C', 'file_name': 'Counters.c', 'mime_type': 'text/x-c', 'hash': 7063247158469070304, 'source_dataset': 'data'}


// Copyright IBM Corp. 2020. All Rights Reserved.
// Node module: @loopback/example-passport-login
// This file is licensed under the MIT License.
// License text available at https://opensource.org/licenses/MIT

export * from './basic';
export * from './facebook';
export * from './google';
export * from './local';
export * from './oauth2';
export * from './session';
export * from './twitter';
export * from './types';

{'repo_name': 'strongloop/loopback-next', 'stars': '2941', 'repo_language': 'TypeScript', 'file_name': 'index.js', 'mime_type': 'text/plain', 'hash': -4677520389296769505, 'source_dataset': 'data'}


/*
 * Copyright 2017 Crown Copyright
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

.EditAccount {
  width: 600px;
}

.EditAccount__set-password-button {
  width: 200px;
}

{'repo_name': 'gchq/stroom', 'stars': '329', 'repo_language': 'Java', 'file_name': 'TestTaskState.java', 'mime_type': 'text/x-c++', 'hash': 8360391416902172270, 'source_dataset': 'data'}


<?xml version="1.0" encoding="utf-8"?>
<resources>
  <integer name="translation_completeness">100</integer>
</resources>

{'repo_name': 'westnordost/StreetComplete', 'stars': '1507', 'repo_language': 'Kotlin', 'file_name': 'ic_launcher_round.xml', 'mime_type': 'text/xml', 'hash': -176229588613166086, 'source_dataset': 'data'}


initialization
initialize
	super initialize.
	matcher := RBParseTreeSearcher new.
	matcher
		matches: '`receiver `@message: ``@args'
		do: [ :node :answer |
			| class |
			((class := Smalltalk classNamed: node receiver name) notNil and: [ class isBehavior and: [ (WASlime class: class includesBehaviorNamed: #WAPresenter) and: [ (WASlime isWithinCallback: node) not ] ] ])
				ifTrue: [ answer add: node ].
			answer ]

{'repo_name': 'SeasideSt/Seaside', 'stars': '294', 'repo_language': 'Smalltalk', 'file_name': 'testStringify.st', 'mime_type': 'text/plain', 'hash': -3117871514366802512, 'source_dataset': 'data'}


# Maintainer: ArchStrike <team@archstrike.org>

buildarch=1

pkgname=ruby1.9-fivemat
_gemname=fivemat
pkgver=1.2.1
pkgrel=1
pkgdesc="Why settle for a test output format when you could have a test output fivemat?"
arch=('any')
license=('')
makedepends=('ruby1.9')
url='https://github.com/tpope/fivemat'
source=("http://rubygems.org/downloads/fivemat-$pkgver.gem")
md5sums=('385f5f4d4364aa943e30392938df7e0f')
noextract=("fivemat-$pkgver.gem")

package() {
  cd "$srcdir"
  local _gemdir="$(ruby-1.9 -rubygems -e'puts Gem.default_dir')"
  HOME=/tmp GEM_HOME="$_gemdir" GEM_PATH="$_gemdir" gem-1.9 install --ignore-dependencies --no-user-install --no-rdoc --no-ri \
  -i "${pkgdir}${_gemdir}" ${_gemname}-${pkgver}.gem
}

{'repo_name': 'ArchStrike/ArchStrike', 'stars': '374', 'repo_language': 'Shell', 'file_name': 'license.txt', 'mime_type': 'text/plain', 'hash': -2325277228972375457, 'source_dataset': 'data'}


import { Serializer } from '@edtr-io/plugin'
import { ValueJSON } from 'slate'

/** @public */
export const serializer: Serializer<NewNode[], ValueJSON> = {
  deserialize(serialized) {
    return {
      object: 'value',
      document: {
        object: 'document',
        nodes: (serialized || []).map(deserializeNode),
      },
    } as ValueJSON

    function deserializeNode(node: NewNode) {
      if (isNewElement(node)) {
        return deserializeElement(node)
      }
      return deserializeText(node)

      function deserializeElement(element: NewElement): OldElement {
        switch (element.type) {
          case 'p': {
            const oldElement: OldParagraphElement = {
              object: 'block',
              type: 'paragraph',
              nodes: element.children.map(deserializeNode),
            }
            return oldElement
          }
          case 'h': {
            const type = `@splish-me/h${element.level}` as OldHeadingElement['type']
            const oldElement: OldHeadingElement = {
              object: 'block',
              type,
              nodes: element.children.map(deserializeNode),
            }
            return oldElement
          }
          case 'a': {
            const oldElement: OldLinkElement = {
              object: 'inline',
              type: '@splish-me/a',
              data: {
                href: element.href,
              },
              nodes: element.children.map(deserializeNode),
            }
            return oldElement
          }
          case 'math': {
            if (element.inline) {
              const oldElement: OldKatexInlineElement = {
                object: 'inline',
                type: '@splish-me/katex-inline',
                data: {
                  formula: element.src,
                  inline: true,
                },
                isVoid: true,
                nodes: element.children.map(deserializeNode),
              }
              return oldElement
            }
            const oldElement: OldKatexBlockElement = {
              object: 'block',
              type: '@splish-me/katex-block',
              data: {
                formula: element.src,
                inline: false,
              },
              isVoid: true,
              nodes: element.children.map(deserializeNode),
            }
            return oldElement
          }
          case 'ordered-list': {
            const oldElement: OldOrderedListElement = {
              object: 'block',
              type: 'ordered-list',
              nodes: element.children.map(deserializeNode),
            }
            return oldElement
          }
          case 'unordered-list': {
            const oldElement: OldUnorderedListElement = {
              object: 'block',
              type: 'unordered-list',
              nodes: element.children.map(deserializeNode),
            }
            return oldElement
          }
          case 'list-item': {
            const oldElement: OldListItemElement = {
              object: 'block',
              type: 'list-item',
              nodes: element.children.map(deserializeNode),
            }
            return oldElement
          }
          case 'list-item-child': {
            const oldElement: OldListItemChildElement = {
              object: 'block',
              type: 'list-item-child',
              nodes: element.children.map(deserializeNode),
            }
            return oldElement
          }
        }
      }

      function deserializeText(text: NewText): OldText {
        const marks: OldMark[] = []
        if (text.em) {
          marks.push({ object: 'mark', type: '@splish-me/em' })
        }
        if (text.strong) {
          marks.push({ object: 'mark', type: '@splish-me/strong' })
        }
        if (text.color !== undefined) {
          marks.push({
            object: 'mark',
            type: '@splish-me/color',
            data: { colorIndex: text.color },
          })
        }

        return {
          object: 'text',
          text: text.text,
          marks: marks,
        }
      }
    }
  },
  serialize(deserialized) {
    const nodes = removeLeafs(
      deserialized && deserialized.document
        ? (deserialized.document.nodes as OldNode[])
        : []
    )
    if (!nodes) return []
    return nodes.map(serializeNode)

    function serializeNode(node: OldNode): NewNode {
      if (node.object === 'text') {
        return serializeText(node)
      }
      return serializeElement(node)

      function serializeElement(element: OldElement): NewElement {
        switch (element.type) {
          case 'paragraph': {
            const newElement: NewParagraphElement = {
              type: 'p',
              children: element.nodes.map(serializeNode),
            }
            return newElement
          }
          case '@splish-me/h1': {
            const newElement: NewHeadingElement = {
              type: 'h',
              level: 1,
              children: element.nodes.map(serializeNode),
            }
            return newElement
          }
          case '@splish-me/h2': {
            const newElement: NewHeadingElement = {
              type: 'h',
              level: 2,
              children: element.nodes.map(serializeNode),
            }
            return newElement
          }
          case '@splish-me/h3': {
            const newElement: NewHeadingElement = {
              type: 'h',
              level: 3,
              children: element.nodes.map(serializeNode),
            }
            return newElement
          }
          case '@splish-me/h4': {
            const newElement: NewHeadingElement = {
              type: 'h',
              level: 4,
              children: element.nodes.map(serializeNode),
            }
            return newElement
          }
          case '@splish-me/h5': {
            const newElement: NewHeadingElement = {
              type: 'h',
              level: 5,
              children: element.nodes.map(serializeNode),
            }
            return newElement
          }
          case '@splish-me/h6': {
            const newElement: NewHeadingElement = {
              type: 'h',
              level: 6,
              children: element.nodes.map(serializeNode),
            }
            return newElement
          }
          case '@splish-me/a': {
            const newElement: NewLinkElement = {
              type: 'a',
              href: element.data.href,
              children: element.nodes.map(serializeNode),
            }
            return newElement
          }
          case '@splish-me/katex-block': {
            const newElement: NewMathElement = {
              type: 'math',
              src: element.data.formula,
              inline: false,
              children: element.nodes.map(serializeNode),
            }
            return newElement
          }
          case '@splish-me/katex-inline': {
            const newElement: NewMathElement = {
              type: 'math',
              src: element.data.formula,
              inline: true,
              children: element.nodes.map(serializeNode),
            }
            return newElement
          }
          case 'ordered-list': {
            const newElement: NewOrderedListElement = {
              type: 'ordered-list',
              children: element.nodes.map(serializeNode),
            }
            return newElement
          }
          case 'unordered-list': {
            const newElement: NewUnorderedListElement = {
              type: 'unordered-list',
              children: element.nodes.map(serializeNode),
            }
            return newElement
          }
          case 'list-item': {
            const newElement: NewListItemElement = {
              type: 'list-item',
              children: element.nodes.map(serializeNode),
            }
            return newElement
          }
          case 'list-item-child': {
            const newElement: NewListItemChildElement = {
              type: 'list-item-child',
              children: element.nodes.map(serializeNode),
            }
            return newElement
          }
        }
      }

      function serializeText(text: OldText): NewText {
        const newText: NewText = {
          text: text.text,
        }

        const marks = text.marks || []
        marks.forEach((mark) => {
          switch (mark.type) {
            case '@splish-me/strong':
              newText.strong = true
              return
            case '@splish-me/em':
              newText.em = true
              return
            case '@splish-me/color':
              newText.color = mark.data.colorIndex
          }
        })

        return newText
      }
    }
  },
}

/** @public */
export interface NewText {
  text: string
  color?: number
  em?: boolean
  strong?: boolean
}

/** @public */
export interface NewParagraphElement {
  type: 'p'
  children: NewNode[]
}

/** @public */
export interface NewHeadingElement {
  type: 'h'
  level: 1 | 2 | 3 | 4 | 5 | 6
  children: NewNode[]
}

/** @public */
export interface NewLinkElement {
  type: 'a'
  href: string
  children: NewNode[]
}

/** @public */
export interface NewMathElement {
  type: 'math'
  src: string
  inline: boolean
  children: NewNode[]
}

/** @public */
export interface NewOrderedListElement {
  type: 'ordered-list'
  children: NewNode[]
}

/** @public */
export interface NewUnorderedListElement {
  type: 'unordered-list'
  children: NewNode[]
}

/** @public */
export interface NewListItemElement {
  type: 'list-item'
  children: NewNode[]
}

/** @public */
export interface NewListItemChildElement {
  type: 'list-item-child'
  children: NewNode[]
}

/** @public */
export type NewElement =
  | NewParagraphElement
  | NewHeadingElement
  | NewLinkElement
  | NewMathElement
  | NewOrderedListElement
  | NewUnorderedListElement
  | NewListItemElement
  | NewListItemChildElement
/** @public */
export type NewNode = NewText | NewElement

function isNewElement(node: NewNode): node is NewElement {
  return (node as NewElement).children !== undefined
}

/** @public */
export interface OldStrongMark {
  object: 'mark'
  type: '@splish-me/strong'
}

/** @public */
export interface OldEmphasizeMark {
  object: 'mark'
  type: '@splish-me/em'
}

/** @public */
export interface OldColorMark {
  object: 'mark'
  type: '@splish-me/color'
  data: { colorIndex: number }
}

/** @public */
export type OldMark = OldStrongMark | OldEmphasizeMark | OldColorMark

/** @public */
export interface OldText {
  object: 'text'
  text: string
  marks?: OldMark[]
}

/** @public */
export interface OldParagraphElement {
  object: 'block'
  type: 'paragraph'
  nodes: OldNode[]
}

/** @public */
export interface OldHeadingElement {
  object: 'block'
  type:
    | '@splish-me/h1'
    | '@splish-me/h2'
    | '@splish-me/h3'
    | '@splish-me/h4'
    | '@splish-me/h5'
    | '@splish-me/h6'
  nodes: OldNode[]
}

/** @public */
export interface OldLinkElement {
  object: 'inline'
  type: '@splish-me/a'
  data: {
    href: string
  }
  nodes: OldNode[]
}

/** @public */
export interface OldKatexInlineElement {
  object: 'inline'
  type: '@splish-me/katex-inline'
  data: {
    formula: string
    inline: true
  }
  isVoid: true
  nodes: OldNode[]
}

/** @public */
export interface OldKatexBlockElement {
  object: 'block'
  type: '@splish-me/katex-block'
  data: {
    formula: string
    inline: false
  }
  isVoid: true
  nodes: OldNode[]
}

/** @public */
export interface OldOrderedListElement {
  object: 'block'
  type: 'ordered-list'
  nodes: OldNode[]
}

/** @public */
export interface OldUnorderedListElement {
  object: 'block'
  type: 'unordered-list'
  nodes: OldNode[]
}

/** @public */
export interface OldListItemElement {
  object: 'block'
  type: 'list-item'
  nodes: OldNode[]
}

/** @public */
export interface OldListItemChildElement {
  object: 'block'
  type: 'list-item-child'
  nodes: OldNode[]
}

/** @public */
export type OldElement =
  | OldParagraphElement
  | OldHeadingElement
  | OldLinkElement
  | OldKatexInlineElement
  | OldKatexBlockElement
  | OldOrderedListElement
  | OldUnorderedListElement
  | OldListItemElement
  | OldListItemChildElement
/** @public */
export type OldNode = OldText | OldElement

// eslint-disable-next-line @typescript-eslint/no-explicit-any
function removeLeafs(nodes: any[]) {
  if (!nodes) {
    return []
  }
  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
  const cleanedNodes: any[] = nodes.reduce((acc, node) => {
    /* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-return */
    if (node.leaves) {
      // we don't need the node itself, as we expect it to be a text node
      return [
        ...acc,
        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-call
        ...node.leaves.map((leave: any) => ({
          ...leave,
          object: 'text',
        })),
      ]
    } else {
      const cleanedNode = node.nodes
        ? {
            ...node,
            nodes: removeLeafs(node.nodes),
          }
        : node
      return [...acc, cleanedNode]
    }
    /* eslint-enable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-return */
  }, [])
  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
  return cleanedNodes
}

{'repo_name': 'edtr-io/edtr-io', 'stars': '601', 'repo_language': 'TypeScript', 'file_name': 'default-document-editor.api.md', 'mime_type': 'text/x-java', 'hash': -1082187750033165595, 'source_dataset': 'data'}


name := "cqrs-akka"

organization := "net.debasishg"

version := "0.1"

crossScalaVersions := Seq("2.9.1", "2.9.0", "2.8.1", "2.8.0")

// resolvers ++= Seq("Twitter Repository" at "http://maven.twttr.com", "Akka Repository" at "http://akka.io/repository")

resolvers ++= Seq("Akka Repository" at "http://repo.typesafe.com/typesafe/releases/")

libraryDependencies <++= scalaVersion { scalaVersion =>
  // Helper for dynamic version switching based on scalaVersion
  val scalatestVersion: String => String = Map(("2.8.0" -> "1.3.1.RC2"), ("2.8.1" -> "1.5.1")) getOrElse (_, "1.6.1")
  // The dependencies with proper scope
  Seq(
    "org.scala-lang.plugins"         % "continuations"   % scalaVersion,
    "net.debasishg"                 %% "redisclient"     % "2.4.2",
    "net.debasishg"                 %% "sjson"           % "0.15",
    "org.slf4j"                      % "slf4j-api"       % "1.6.1",
    "org.slf4j"                      % "slf4j-log4j12"   % "1.6.1"            % "provided",
    "log4j"                          % "log4j"           % "1.2.16"           % "provided",
    "junit"                          % "junit"           % "4.8.1"            % "test",
    "org.scalatest"                 %% "scalatest"       % "1.6.1"            % "test",
    "org.scalaz"                    %% "scalaz-core"     % "6.0.3",
    "com.typesafe.akka"              % "akka-actor"      % "2.0",
    "com.typesafe.akka"              % "akka-testkit"    % "2.0",
    "ch.qos.logback"                 % "logback-classic" % "0.9.28"           % "runtime"
  )
}

autoCompilerPlugins := true

addCompilerPlugin("org.scala-lang.plugins" % "continuations" % "2.9.1")

scalacOptions ++= Seq("-encoding", "UTF-8", "-deprecation", "-Xcheckinit", "-P:continuations:enable")

// TODO: Enable this with SBT 0.10.2 (See: https://github.com/harrah/xsbt/issues/147)
// scaladocOptions <++= (name, version) map { (name, ver) =>
//  Seq("-doc-title", name, "-doc-version", ver)
//}

parallelExecution in Test := false

publishTo := Some("Scala-Tools Nexus Repository for Releases" at "http://nexus.scala-tools.org/content/repositories/releases")

credentials += Credentials(Path.userHome / ".ivy2" / ".credentials")

{'repo_name': 'debasishg/cqrs-akka', 'stars': '110', 'repo_language': 'Scala', 'file_name': 'build.properties', 'mime_type': 'text/plain', 'hash': 6368320858436381396, 'source_dataset': 'data'}


.ct-label {
  fill: rgba(0, 0, 0, 0.4);
  color: rgba(0, 0, 0, 0.4);
  font-size: 0.75rem;
  line-height: 1; }

.ct-chart-line .ct-label,
.ct-chart-bar .ct-label {
  display: block;
  display: -webkit-box;
  display: -moz-box;
  display: -ms-flexbox;
  display: -webkit-flex;
  display: flex; }

.ct-chart-pie .ct-label,
.ct-chart-donut .ct-label {
  dominant-baseline: central; }

.ct-label.ct-horizontal.ct-start {
  -webkit-box-align: flex-end;
  -webkit-align-items: flex-end;
  -ms-flex-align: flex-end;
  align-items: flex-end;
  -webkit-box-pack: flex-start;
  -webkit-justify-content: flex-start;
  -ms-flex-pack: flex-start;
  justify-content: flex-start;
  text-align: left;
  text-anchor: start; }

.ct-label.ct-horizontal.ct-end {
  -webkit-box-align: flex-start;
  -webkit-align-items: flex-start;
  -ms-flex-align: flex-start;
  align-items: flex-start;
  -webkit-box-pack: flex-start;
  -webkit-justify-content: flex-start;
  -ms-flex-pack: flex-start;
  justify-content: flex-start;
  text-align: left;
  text-anchor: start; }

.ct-label.ct-vertical.ct-start {
  -webkit-box-align: flex-end;
  -webkit-align-items: flex-end;
  -ms-flex-align: flex-end;
  align-items: flex-end;
  -webkit-box-pack: flex-end;
  -webkit-justify-content: flex-end;
  -ms-flex-pack: flex-end;
  justify-content: flex-end;
  text-align: right;
  text-anchor: end; }

.ct-label.ct-vertical.ct-end {
  -webkit-box-align: flex-end;
  -webkit-align-items: flex-end;
  -ms-flex-align: flex-end;
  align-items: flex-end;
  -webkit-box-pack: flex-start;
  -webkit-justify-content: flex-start;
  -ms-flex-pack: flex-start;
  justify-content: flex-start;
  text-align: left;
  text-anchor: start; }

.ct-chart-bar .ct-label.ct-horizontal.ct-start {
  -webkit-box-align: flex-end;
  -webkit-align-items: flex-end;
  -ms-flex-align: flex-end;
  align-items: flex-end;
  -webkit-box-pack: center;
  -webkit-justify-content: center;
  -ms-flex-pack: center;
  justify-content: center;
  text-align: center;
  text-anchor: start; }

.ct-chart-bar .ct-label.ct-horizontal.ct-end {
  -webkit-box-align: flex-start;
  -webkit-align-items: flex-start;
  -ms-flex-align: flex-start;
  align-items: flex-start;
  -webkit-box-pack: center;
  -webkit-justify-content: center;
  -ms-flex-pack: center;
  justify-content: center;
  text-align: center;
  text-anchor: start; }

.ct-chart-bar.ct-horizontal-bars .ct-label.ct-horizontal.ct-start {
  -webkit-box-align: flex-end;
  -webkit-align-items: flex-end;
  -ms-flex-align: flex-end;
  align-items: flex-end;
  -webkit-box-pack: flex-start;
  -webkit-justify-content: flex-start;
  -ms-flex-pack: flex-start;
  justify-content: flex-start;
  text-align: left;
  text-anchor: start; }

.ct-chart-bar.ct-horizontal-bars .ct-label.ct-horizontal.ct-end {
  -webkit-box-align: flex-start;
  -webkit-align-items: flex-start;
  -ms-flex-align: flex-start;
  align-items: flex-start;
  -webkit-box-pack: flex-start;
  -webkit-justify-content: flex-start;
  -ms-flex-pack: flex-start;
  justify-content: flex-start;
  text-align: left;
  text-anchor: start; }

.ct-chart-bar.ct-horizontal-bars .ct-label.ct-vertical.ct-start {
  -webkit-box-align: center;
  -webkit-align-items: center;
  -ms-flex-align: center;
  align-items: center;
  -webkit-box-pack: flex-end;
  -webkit-justify-content: flex-end;
  -ms-flex-pack: flex-end;
  justify-content: flex-end;
  text-align: right;
  text-anchor: end; }

.ct-chart-bar.ct-horizontal-bars .ct-label.ct-vertical.ct-end {
  -webkit-box-align: center;
  -webkit-align-items: center;
  -ms-flex-align: center;
  align-items: center;
  -webkit-box-pack: flex-start;
  -webkit-justify-content: flex-start;
  -ms-flex-pack: flex-start;
  justify-content: flex-start;
  text-align: left;
  text-anchor: end; }

.ct-grid {
  stroke: rgba(0, 0, 0, 0.2);
  stroke-width: 1px;
  stroke-dasharray: 2px; }

.ct-grid-background {
  fill: none; }

.ct-point {
  stroke-width: 10px;
  stroke-linecap: round; }

.ct-line {
  fill: none;
  stroke-width: 4px; }

.ct-area {
  stroke: none;
  fill-opacity: 0.1; }

.ct-bar {
  fill: none;
  stroke-width: 10px; }

.ct-slice-donut {
  fill: none;
  stroke-width: 60px; }

.ct-series-a .ct-point, .ct-series-a .ct-line, .ct-series-a .ct-bar, .ct-series-a .ct-slice-donut {
  stroke: #d70206; }

.ct-series-a .ct-slice-pie, .ct-series-a .ct-slice-donut-solid, .ct-series-a .ct-area {
  fill: #d70206; }

.ct-series-b .ct-point, .ct-series-b .ct-line, .ct-series-b .ct-bar, .ct-series-b .ct-slice-donut {
  stroke: #f05b4f; }

.ct-series-b .ct-slice-pie, .ct-series-b .ct-slice-donut-solid, .ct-series-b .ct-area {
  fill: #f05b4f; }

.ct-series-c .ct-point, .ct-series-c .ct-line, .ct-series-c .ct-bar, .ct-series-c .ct-slice-donut {
  stroke: #f4c63d; }

.ct-series-c .ct-slice-pie, .ct-series-c .ct-slice-donut-solid, .ct-series-c .ct-area {
  fill: #f4c63d; }

.ct-series-d .ct-point, .ct-series-d .ct-line, .ct-series-d .ct-bar, .ct-series-d .ct-slice-donut {
  stroke: #d17905; }

.ct-series-d .ct-slice-pie, .ct-series-d .ct-slice-donut-solid, .ct-series-d .ct-area {
  fill: #d17905; }

.ct-series-e .ct-point, .ct-series-e .ct-line, .ct-series-e .ct-bar, .ct-series-e .ct-slice-donut {
  stroke: #453d3f; }

.ct-series-e .ct-slice-pie, .ct-series-e .ct-slice-donut-solid, .ct-series-e .ct-area {
  fill: #453d3f; }

.ct-series-f .ct-point, .ct-series-f .ct-line, .ct-series-f .ct-bar, .ct-series-f .ct-slice-donut {
  stroke: #59922b; }

.ct-series-f .ct-slice-pie, .ct-series-f .ct-slice-donut-solid, .ct-series-f .ct-area {
  fill: #59922b; }

.ct-series-g .ct-point, .ct-series-g .ct-line, .ct-series-g .ct-bar, .ct-series-g .ct-slice-donut {
  stroke: #0544d3; }

.ct-series-g .ct-slice-pie, .ct-series-g .ct-slice-donut-solid, .ct-series-g .ct-area {
  fill: #0544d3; }

.ct-series-h .ct-point, .ct-series-h .ct-line, .ct-series-h .ct-bar, .ct-series-h .ct-slice-donut {
  stroke: #6b0392; }

.ct-series-h .ct-slice-pie, .ct-series-h .ct-slice-donut-solid, .ct-series-h .ct-area {
  fill: #6b0392; }

.ct-series-i .ct-point, .ct-series-i .ct-line, .ct-series-i .ct-bar, .ct-series-i .ct-slice-donut {
  stroke: #f05b4f; }

.ct-series-i .ct-slice-pie, .ct-series-i .ct-slice-donut-solid, .ct-series-i .ct-area {
  fill: #f05b4f; }

.ct-series-j .ct-point, .ct-series-j .ct-line, .ct-series-j .ct-bar, .ct-series-j .ct-slice-donut {
  stroke: #dda458; }

.ct-series-j .ct-slice-pie, .ct-series-j .ct-slice-donut-solid, .ct-series-j .ct-area {
  fill: #dda458; }

.ct-series-k .ct-point, .ct-series-k .ct-line, .ct-series-k .ct-bar, .ct-series-k .ct-slice-donut {
  stroke: #eacf7d; }

.ct-series-k .ct-slice-pie, .ct-series-k .ct-slice-donut-solid, .ct-series-k .ct-area {
  fill: #eacf7d; }

.ct-series-l .ct-point, .ct-series-l .ct-line, .ct-series-l .ct-bar, .ct-series-l .ct-slice-donut {
  stroke: #86797d; }

.ct-series-l .ct-slice-pie, .ct-series-l .ct-slice-donut-solid, .ct-series-l .ct-area {
  fill: #86797d; }

.ct-series-m .ct-point, .ct-series-m .ct-line, .ct-series-m .ct-bar, .ct-series-m .ct-slice-donut {
  stroke: #b2c326; }

.ct-series-m .ct-slice-pie, .ct-series-m .ct-slice-donut-solid, .ct-series-m .ct-area {
  fill: #b2c326; }

.ct-series-n .ct-point, .ct-series-n .ct-line, .ct-series-n .ct-bar, .ct-series-n .ct-slice-donut {
  stroke: #6188e2; }

.ct-series-n .ct-slice-pie, .ct-series-n .ct-slice-donut-solid, .ct-series-n .ct-area {
  fill: #6188e2; }

.ct-series-o .ct-point, .ct-series-o .ct-line, .ct-series-o .ct-bar, .ct-series-o .ct-slice-donut {
  stroke: #a748ca; }

.ct-series-o .ct-slice-pie, .ct-series-o .ct-slice-donut-solid, .ct-series-o .ct-area {
  fill: #a748ca; }

.ct-square {
  display: block;
  position: relative;
  width: 100%; }
  .ct-square:before {
    display: block;
    float: left;
    content: "";
    width: 0;
    height: 0;
    padding-bottom: 100%; }
  .ct-square:after {
    content: "";
    display: table;
    clear: both; }
  .ct-square > svg {
    display: block;
    position: absolute;
    top: 0;
    left: 0; }

.ct-minor-second {
  display: block;
  position: relative;
  width: 100%; }
  .ct-minor-second:before {
    display: block;
    float: left;
    content: "";
    width: 0;
    height: 0;
    padding-bottom: 93.75%; }
  .ct-minor-second:after {
    content: "";
    display: table;
    clear: both; }
  .ct-minor-second > svg {
    display: block;
    position: absolute;
    top: 0;
    left: 0; }

.ct-major-second {
  display: block;
  position: relative;
  width: 100%; }
  .ct-major-second:before {
    display: block;
    float: left;
    content: "";
    width: 0;
    height: 0;
    padding-bottom: 88.8888888889%; }
  .ct-major-second:after {
    content: "";
    display: table;
    clear: both; }
  .ct-major-second > svg {
    display: block;
    position: absolute;
    top: 0;
    left: 0; }

.ct-minor-third {
  display: block;
  position: relative;
  width: 100%; }
  .ct-minor-third:before {
    display: block;
    float: left;
    content: "";
    width: 0;
    height: 0;
    padding-bottom: 83.3333333333%; }
  .ct-minor-third:after {
    content: "";
    display: table;
    clear: both; }
  .ct-minor-third > svg {
    display: block;
    position: absolute;
    top: 0;
    left: 0; }

.ct-major-third {
  display: block;
  position: relative;
  width: 100%; }
  .ct-major-third:before {
    display: block;
    float: left;
    content: "";
    width: 0;
    height: 0;
    padding-bottom: 80%; }
  .ct-major-third:after {
    content: "";
    display: table;
    clear: both; }
  .ct-major-third > svg {
    display: block;
    position: absolute;
    top: 0;
    left: 0; }

.ct-perfect-fourth {
  display: block;
  position: relative;
  width: 100%; }
  .ct-perfect-fourth:before {
    display: block;
    float: left;
    content: "";
    width: 0;
    height: 0;
    padding-bottom: 75%; }
  .ct-perfect-fourth:after {
    content: "";
    display: table;
    clear: both; }
  .ct-perfect-fourth > svg {
    display: block;
    position: absolute;
    top: 0;
    left: 0; }

.ct-perfect-fifth {
  display: block;
  position: relative;
  width: 100%; }
  .ct-perfect-fifth:before {
    display: block;
    float: left;
    content: "";
    width: 0;
    height: 0;
    padding-bottom: 66.6666666667%; }
  .ct-perfect-fifth:after {
    content: "";
    display: table;
    clear: both; }
  .ct-perfect-fifth > svg {
    display: block;
    position: absolute;
    top: 0;
    left: 0; }

.ct-minor-sixth {
  display: block;
  position: relative;
  width: 100%; }
  .ct-minor-sixth:before {
    display: block;
    float: left;
    content: "";
    width: 0;
    height: 0;
    padding-bottom: 62.5%; }
  .ct-minor-sixth:after {
    content: "";
    display: table;
    clear: both; }
  .ct-minor-sixth > svg {
    display: block;
    position: absolute;
    top: 0;
    left: 0; }

.ct-golden-section {
  display: block;
  position: relative;
  width: 100%; }
  .ct-golden-section:before {
    display: block;
    float: left;
    content: "";
    width: 0;
    height: 0;
    padding-bottom: 61.804697157%; }
  .ct-golden-section:after {
    content: "";
    display: table;
    clear: both; }
  .ct-golden-section > svg {
    display: block;
    position: absolute;
    top: 0;
    left: 0; }

.ct-major-sixth {
  display: block;
  position: relative;
  width: 100%; }
  .ct-major-sixth:before {
    display: block;
    float: left;
    content: "";
    width: 0;
    height: 0;
    padding-bottom: 60%; }
  .ct-major-sixth:after {
    content: "";
    display: table;
    clear: both; }
  .ct-major-sixth > svg {
    display: block;
    position: absolute;
    top: 0;
    left: 0; }

.ct-minor-seventh {
  display: block;
  position: relative;
  width: 100%; }
  .ct-minor-seventh:before {
    display: block;
    float: left;
    content: "";
    width: 0;
    height: 0;
    padding-bottom: 56.25%; }
  .ct-minor-seventh:after {
    content: "";
    display: table;
    clear: both; }
  .ct-minor-seventh > svg {
    display: block;
    position: absolute;
    top: 0;
    left: 0; }

.ct-major-seventh {
  display: block;
  position: relative;
  width: 100%; }
  .ct-major-seventh:before {
    display: block;
    float: left;
    content: "";
    width: 0;
    height: 0;
    padding-bottom: 53.3333333333%; }
  .ct-major-seventh:after {
    content: "";
    display: table;
    clear: both; }
  .ct-major-seventh > svg {
    display: block;
    position: absolute;
    top: 0;
    left: 0; }

.ct-octave {
  display: block;
  position: relative;
  width: 100%; }
  .ct-octave:before {
    display: block;
    float: left;
    content: "";
    width: 0;
    height: 0;
    padding-bottom: 50%; }
  .ct-octave:after {
    content: "";
    display: table;
    clear: both; }
  .ct-octave > svg {
    display: block;
    position: absolute;
    top: 0;
    left: 0; }

.ct-major-tenth {
  display: block;
  position: relative;
  width: 100%; }
  .ct-major-tenth:before {
    display: block;
    float: left;
    content: "";
    width: 0;
    height: 0;
    padding-bottom: 40%; }
  .ct-major-tenth:after {
    content: "";
    display: table;
    clear: both; }
  .ct-major-tenth > svg {
    display: block;
    position: absolute;
    top: 0;
    left: 0; }

.ct-major-eleventh {
  display: block;
  position: relative;
  width: 100%; }
  .ct-major-eleventh:before {
    display: block;
    float: left;
    content: "";
    width: 0;
    height: 0;
    padding-bottom: 37.5%; }
  .ct-major-eleventh:after {
    content: "";
    display: table;
    clear: both; }
  .ct-major-eleventh > svg {
    display: block;
    position: absolute;
    top: 0;
    left: 0; }

.ct-major-twelfth {
  display: block;
  position: relative;
  width: 100%; }
  .ct-major-twelfth:before {
    display: block;
    float: left;
    content: "";
    width: 0;
    height: 0;
    padding-bottom: 33.3333333333%; }
  .ct-major-twelfth:after {
    content: "";
    display: table;
    clear: both; }
  .ct-major-twelfth > svg {
    display: block;
    position: absolute;
    top: 0;
    left: 0; }

.ct-double-octave {
  display: block;
  position: relative;
  width: 100%; }
  .ct-double-octave:before {
    display: block;
    float: left;
    content: "";
    width: 0;
    height: 0;
    padding-bottom: 25%; }
  .ct-double-octave:after {
    content: "";
    display: table;
    clear: both; }
  .ct-double-octave > svg {
    display: block;
    position: absolute;
    top: 0;
    left: 0; }

/*# sourceMappingURL=chartist.css.map */

{'repo_name': 'gitcoinco/codefund', 'stars': '138', 'repo_language': 'CSS', 'file_name': 'layout_view_test.exs', 'mime_type': 'text/plain', 'hash': 3454555251820665868, 'source_dataset': 'data'}


/*
Template Name: Material Pro Admin
Author: Themedesigner
Email: niravjoshi87@gmail.com
File: js
*/
(function (global, factory) {
  if (typeof define === "function" && define.amd) {
    define(['jquery'], factory);
  } else if (typeof exports !== "undefined") {
    factory(require('jquery'));
  } else {
    var mod = {
      exports: {}
    };
    factory(global.jquery);
    global.metisMenu = mod.exports;
  }
})(this, function (_jquery) {
  'use strict';

  var _jquery2 = _interopRequireDefault(_jquery);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
    return typeof obj;
  } : function (obj) {
    return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
  };

  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  var Util = function ($) {
    var transition = false;

    var TransitionEndEvent = {
      WebkitTransition: 'webkitTransitionEnd',
      MozTransition: 'transitionend',
      OTransition: 'oTransitionEnd otransitionend',
      transition: 'transitionend'
    };

    function getSpecialTransitionEndEvent() {
      return {
        bindType: transition.end,
        delegateType: transition.end,
        handle: function handle(event) {
          if ($(event.target).is(this)) {
            return event.handleObj.handler.apply(this, arguments);
          }
          return undefined;
        }
      };
    }

    function transitionEndTest() {
      if (window.QUnit) {
        return false;
      }

      var el = document.createElement('mm');

      for (var name in TransitionEndEvent) {
        if (el.style[name] !== undefined) {
          return {
            end: TransitionEndEvent[name]
          };
        }
      }

      return false;
    }

    function transitionEndEmulator(duration) {
      var _this2 = this;

      var called = false;

      $(this).one(Util.TRANSITION_END, function () {
        called = true;
      });

      setTimeout(function () {
        if (!called) {
          Util.triggerTransitionEnd(_this2);
        }
      }, duration);

      return this;
    }

    function setTransitionEndSupport() {
      transition = transitionEndTest();
      $.fn.emulateTransitionEnd = transitionEndEmulator;

      if (Util.supportsTransitionEnd()) {
        $.event.special[Util.TRANSITION_END] = getSpecialTransitionEndEvent();
      }
    }

    var Util = {
      TRANSITION_END: 'mmTransitionEnd',

      triggerTransitionEnd: function triggerTransitionEnd(element) {
        $(element).trigger(transition.end);
      },
      supportsTransitionEnd: function supportsTransitionEnd() {
        return Boolean(transition);
      }
    };

    setTransitionEndSupport();

    return Util;
  }(jQuery);

  var MetisMenu = function ($) {

    var NAME = 'metisMenu';
    var DATA_KEY = 'metisMenu';
    var EVENT_KEY = '.' + DATA_KEY;
    var DATA_API_KEY = '.data-api';
    var JQUERY_NO_CONFLICT = $.fn[NAME];
    var TRANSITION_DURATION = 350;

    var Default = {
      toggle: true,
      preventDefault: true,
      activeClass: 'active',
      collapseClass: 'collapse',
      collapseInClass: 'in',
      collapsingClass: 'collapsing',
      triggerElement: 'a',
      parentTrigger: 'li',
      subMenu: 'ul'
    };

    var Event = {
      SHOW: 'show' + EVENT_KEY,
      SHOWN: 'shown' + EVENT_KEY,
      HIDE: 'hide' + EVENT_KEY,
      HIDDEN: 'hidden' + EVENT_KEY,
      CLICK_DATA_API: 'click' + EVENT_KEY + DATA_API_KEY
    };

    var MetisMenu = function () {
      function MetisMenu(element, config) {
        _classCallCheck(this, MetisMenu);

        this._element = element;
        this._config = this._getConfig(config);
        this._transitioning = null;

        this.init();
      }

      MetisMenu.prototype.init = function init() {
        var self = this;
        $(this._element).find(this._config.parentTrigger + '.' + this._config.activeClass).has(this._config.subMenu).children(this._config.subMenu).attr('aria-expanded', true).addClass(this._config.collapseClass + ' ' + this._config.collapseInClass);

        $(this._element).find(this._config.parentTrigger).not('.' + this._config.activeClass).has(this._config.subMenu).children(this._config.subMenu).attr('aria-expanded', false).addClass(this._config.collapseClass);

        $(this._element).find(this._config.parentTrigger).has(this._config.subMenu).children(this._config.triggerElement).on(Event.CLICK_DATA_API, function (e) {
          var _this = $(this);
          var _parent = _this.parent(self._config.parentTrigger);
          var _siblings = _parent.siblings(self._config.parentTrigger).children(self._config.triggerElement);
          var _list = _parent.children(self._config.subMenu);
          if (self._config.preventDefault) {
            e.preventDefault();
          }
          if (_this.attr('aria-disabled') === 'true') {
            return;
          }
          if (_parent.hasClass(self._config.activeClass)) {
            _this.attr('aria-expanded', false);
            self._hide(_list);
          } else {
            self._show(_list);
            _this.attr('aria-expanded', true);
            if (self._config.toggle) {
              _siblings.attr('aria-expanded', false);
            }
          }

          if (self._config.onTransitionStart) {
            self._config.onTransitionStart(e);
          }
        });
      };

      MetisMenu.prototype._show = function _show(element) {
        if (this._transitioning || $(element).hasClass(this._config.collapsingClass)) {
          return;
        }
        var _this = this;
        var _el = $(element);

        var startEvent = $.Event(Event.SHOW);
        _el.trigger(startEvent);

        if (startEvent.isDefaultPrevented()) {
          return;
        }

        _el.parent(this._config.parentTrigger).addClass(this._config.activeClass);

        if (this._config.toggle) {
          this._hide(_el.parent(this._config.parentTrigger).siblings().children(this._config.subMenu + '.' + this._config.collapseInClass).attr('aria-expanded', false));
        }

        _el.removeClass(this._config.collapseClass).addClass(this._config.collapsingClass).height(0);

        this.setTransitioning(true);

        var complete = function complete() {

          _el.removeClass(_this._config.collapsingClass).addClass(_this._config.collapseClass + ' ' + _this._config.collapseInClass).height('').attr('aria-expanded', true);

          _this.setTransitioning(false);

          _el.trigger(Event.SHOWN);
        };

        if (!Util.supportsTransitionEnd()) {
          complete();
          return;
        }

        _el.height(_el[0].scrollHeight).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION);
      };

      MetisMenu.prototype._hide = function _hide(element) {

        if (this._transitioning || !$(element).hasClass(this._config.collapseInClass)) {
          return;
        }
        var _this = this;
        var _el = $(element);

        var startEvent = $.Event(Event.HIDE);
        _el.trigger(startEvent);

        if (startEvent.isDefaultPrevented()) {
          return;
        }

        _el.parent(this._config.parentTrigger).removeClass(this._config.activeClass);
        _el.height(_el.height())[0].offsetHeight;

        _el.addClass(this._config.collapsingClass).removeClass(this._config.collapseClass).removeClass(this._config.collapseInClass);

        this.setTransitioning(true);

        var complete = function complete() {
          if (_this._transitioning && _this._config.onTransitionEnd) {
            _this._config.onTransitionEnd();
          }

          _this.setTransitioning(false);
          _el.trigger(Event.HIDDEN);

          _el.removeClass(_this._config.collapsingClass).addClass(_this._config.collapseClass).attr('aria-expanded', false);
        };

        if (!Util.supportsTransitionEnd()) {
          complete();
          return;
        }

        _el.height() == 0 || _el.css('display') == 'none' ? complete() : _el.height(0).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION);
      };

      MetisMenu.prototype.setTransitioning = function setTransitioning(isTransitioning) {
        this._transitioning = isTransitioning;
      };

      MetisMenu.prototype.dispose = function dispose() {
        $.removeData(this._element, DATA_KEY);

        $(this._element).find(this._config.parentTrigger).has(this._config.subMenu).children(this._config.triggerElement).off('click');

        this._transitioning = null;
        this._config = null;
        this._element = null;
      };

      MetisMenu.prototype._getConfig = function _getConfig(config) {
        config = $.extend({}, Default, config);
        return config;
      };

      MetisMenu._jQueryInterface = function _jQueryInterface(config) {
        return this.each(function () {
          var $this = $(this);
          var data = $this.data(DATA_KEY);
          var _config = $.extend({}, Default, $this.data(), (typeof config === 'undefined' ? 'undefined' : _typeof(config)) === 'object' && config);

          if (!data && /dispose/.test(config)) {
            this.dispose();
          }

          if (!data) {
            data = new MetisMenu(this, _config);
            $this.data(DATA_KEY, data);
          }

          if (typeof config === 'string') {
            if (data[config] === undefined) {
              throw new Error('No method named "' + config + '"');
            }
            data[config]();
          }
        });
      };

      return MetisMenu;
    }();

    /**
     * ------------------------------------------------------------------------
     * jQuery
     * ------------------------------------------------------------------------
     */

    $.fn[NAME] = MetisMenu._jQueryInterface;
    $.fn[NAME].Constructor = MetisMenu;
    $.fn[NAME].noConflict = function () {
      $.fn[NAME] = JQUERY_NO_CONFLICT;
      return MetisMenu._jQueryInterface;
    };
    return MetisMenu;
  }(jQuery);
});

{'repo_name': 'kyokidG/html-templates', 'stars': '141', 'repo_language': 'HTML', 'file_name': 'main.js', 'mime_type': 'text/html', 'hash': -5476495803707645505, 'source_dataset': 'data'}


<sect1 id="zend.mail.smtp-authentication">
  <title>Uwierzytelnianie SMTP</title>

  <para>Klasa Zend_Mail obsługuje uwierzytelnianie SMTP, które
  może być aktywowane przez przekazanie parametru 'auth' w tablicy
  konfiguracyjnej do konstruktora klasy Zend_Mail_Transport_Smtp.
  Dostępnymi wbudowanymi metodami uwierzytelniania są metody PLAIN, LOGIN oraz
  CRAM-MD5. Wszystkie wymagają wartości 'username' oraz 'password' w tablicy
  konfiguracyjnej.</para>

  <example id="zend.mail.smtp-authentication.example-1">
    <title>Aktywowanie uwierzytelniania w klasie Zend_Mail_Transport_Smtp</title>

    <programlisting role="php"><![CDATA[
$config = array('auth' => 'login',
                'username' => 'myusername',
                'password' => 'password');

$transport = new Zend_Mail_Transport_Smtp('mail.server.com', $config);

$mail = new Zend_Mail();
$mail->setBodyText('To jest treść wiadomości e-mail.');
$mail->setFrom('sender@test.com', 'Nadawca');
$mail->addTo('recipient@test.com', 'Adresat');
$mail->setSubject('Testowy temat');
$mail->send($transport);
]]>
    </programlisting>
  </example>

  <note>
    <title>Typy uwierzytelniania</title>

    <para>
        Nie znaczenia czy nazwę typu uwierzytelniania podamy używając wielkich
        czy małych liter, ale podajemy ją bez znaków interpunkcyjnych. Np. aby
        użyć adaptera CRAM-MD5 powinieneś przekazać parametr 'auth' => 'crammd5'
        do konstruktora klasy Zend_Mail_Transport_Smtp.
    </para>
  </note>
</sect1>

{'repo_name': 'zendframework/zf1', 'stars': '351', 'repo_language': 'PHP', 'file_name': 'demo.php', 'mime_type': 'text/x-php', 'hash': 5530519673673791823, 'source_dataset': 'data'}


# -*- coding: utf-8 -*-

import codecs
import json
import random as rnd
import numpy as np
from collections import Counter, defaultdict
from itertools import chain, count
from six import string_types

import torch
import torchtext.data
import torchtext.vocab

UNK_WORD = '<unk>'
UNK = 0
PAD_WORD = '<blank>'
PAD = 1
BOS_WORD = '<s>'
EOS_WORD = '</s>'
SPLIT_WORD = '<|>'
special_token_list = [UNK_WORD, PAD_WORD, BOS_WORD, EOS_WORD, SPLIT_WORD]

def __getstate__(self):
    return dict(self.__dict__, stoi=dict(self.stoi))

def __setstate__(self, state):
    self.__dict__.update(state)
    self.stoi = defaultdict(lambda: 0, self.stoi)

torchtext.vocab.Vocab.__getstate__ = __getstate__
torchtext.vocab.Vocab.__setstate__ = __setstate__

def merge_vocabs(vocabs, vocab_size=None):
    """
    Merge individual vocabularies (assumed to be generated from disjoint
    documents) into a larger vocabulary.

    Args:
        vocabs: `torchtext.vocab.Vocab` vocabularies to be merged
        vocab_size: `int` the final vocabulary size. `None` for no limit.
    Return:
        `torchtext.vocab.Vocab`
    """
    merged = sum([vocab.freqs for vocab in vocabs], Counter())
    return torchtext.vocab.Vocab(merged,
                                 specials=list(special_token_list),
                                 max_size=vocab_size)

def join_dicts(*args):
    """
    args: dictionaries with disjoint keys
    returns: a single dictionary that has the union of these keys
    """
    return dict(chain(*[d.items() for d in args]))

class OrderedIterator(torchtext.data.Iterator):
    def create_batches(self):
        if self.train:
            self.batches = torchtext.data.pool(
                self.data(), self.batch_size,
                self.sort_key, self.batch_size_fn,
                random_shuffler=self.random_shuffler)
        else:
            self.batches = []
            for b in torchtext.data.batch(self.data(), self.batch_size,
                                          self.batch_size_fn):
                self.batches.append(sorted(b, key=self.sort_key))

def read_anno_json(anno_path):
    with codecs.open(anno_path, "r", "utf-8") as corpus_file:
        js_list = [json.loads(line) for line in corpus_file]
        for js in js_list:
            cond_list = list(enumerate(js['query']['conds']))
            # sort by (op, orginal index)
            # cond_list.sort(key=lambda x: (x[1][1], x[0]))
            cond_list.sort(key=lambda x: x[1][1])
            js['query']['conds'] = [x[1] for x in cond_list]
    return js_list

class TableDataset(torchtext.data.Dataset):
    """Defines a dataset for machine translation."""

    @staticmethod
    def sort_key(ex):
        "Sort in reverse size order"
        return -len(ex.src)

    def __init__(self, anno, fields, opt, filter_ex, **kwargs):
        """
        Create a TranslationDataset given paths and fields.

        anno: location of annotated data / js_list
        filter_ex: False - keep all the examples for evaluation (should not have filtered examples); True - filter examples with unmatched spans;
        """
        if isinstance(anno, string_types):
            js_list = read_anno_json(anno)
        else:
            js_list = anno

        src_data = self._read_annotated_file(
            opt, js_list, 'question', filter_ex)
        src_examples = self._construct_examples(src_data, 'src')

        ent_data = self._read_annotated_file(opt, js_list, 'ent', filter_ex)
        ent_examples = self._construct_examples(ent_data, 'ent')

        agg_data = self._read_annotated_file(opt, js_list, 'agg', filter_ex)
        agg_examples = self._construct_examples(agg_data, 'agg')

        sel_data = self._read_annotated_file(opt, js_list, 'sel', filter_ex)
        sel_examples = self._construct_examples(sel_data, 'sel')

        tbl_data = self._read_annotated_file(opt, js_list, 'tbl', filter_ex)
        tbl_examples = self._construct_examples(tbl_data, 'tbl')

        tbl_split_data = self._read_annotated_file(
            opt, js_list, 'tbl_split', filter_ex)
        tbl_split_examples = self._construct_examples(
            tbl_split_data, 'tbl_split')

        tbl_mask_data = self._read_annotated_file(
            opt, js_list, 'tbl_mask', filter_ex)
        tbl_mask_examples = self._construct_examples(
            tbl_mask_data, 'tbl_mask')

        lay_data = self._read_annotated_file(opt, js_list, 'lay', filter_ex)
        lay_examples = self._construct_examples(lay_data, 'lay')

        cond_op_data = self._read_annotated_file(
            opt, js_list, 'cond_op', filter_ex)
        cond_op_examples = self._construct_examples(cond_op_data, 'cond_op')

        cond_col_data = list(
            self._read_annotated_file(opt, js_list, 'cond_col', filter_ex))
        cond_col_examples = self._construct_examples(cond_col_data, 'cond_col')
        cond_col_loss_examples = self._construct_examples(
            cond_col_data, 'cond_col_loss')

        def _map_to_sublist_index(d_list, idx):
            return [([it[idx] for it in d] if (d is not None) else None) for d in d_list]
        span_data = list(self._read_annotated_file(
            opt, js_list, 'cond_span', filter_ex))
        span_l_examples = self._construct_examples(
            _map_to_sublist_index(span_data, 0), 'cond_span_l')
        span_r_examples = self._construct_examples(
            _map_to_sublist_index(span_data, 1), 'cond_span_r')
        span_l_loss_examples = self._construct_examples(
            _map_to_sublist_index(span_data, 0), 'cond_span_l_loss')
        span_r_loss_examples = self._construct_examples(
            _map_to_sublist_index(span_data, 1), 'cond_span_r_loss')

        # examples: one for each src line or (src, tgt) line pair.
        examples = [join_dicts(*it) for it in zip(src_examples, ent_examples, agg_examples, sel_examples, lay_examples, tbl_examples, tbl_split_examples, tbl_mask_examples,
                                                  cond_op_examples, cond_col_examples, span_l_examples, span_r_examples, cond_col_loss_examples, span_l_loss_examples, span_r_loss_examples)]
        # the examples should not contain None
        len_before_filter = len(examples)
        examples = list(filter(lambda x: all(
            (v is not None for k, v in x.items())), examples))
        len_after_filter = len(examples)
        num_filter = len_before_filter - len_after_filter
        # if num_filter > 0:
        #     print('Filter #examples (with None): {} / {} = {:.2%}'.format(num_filter,
        #                                                                   len_before_filter, num_filter / len_before_filter))

        len_lay_list = []
        len_tgt_list = []
        for ex in examples:
            has_agg = 0 if int(ex['agg']) == 0 else 1
            if len(ex['cond_op']) == 0:
                len_lay_list.append(0)
                len_tgt_list.append(1 + has_agg + 1)
            else:
                len_lay = len(ex['cond_op']) * 2
                len_lay_list.append(len_lay)
                len_tgt_list.append(
                    1 + has_agg + 1 + len_lay + len(ex['cond_op']) * 2)

        # Peek at the first to see which fields are used.
        ex = examples[0]
        keys = ex.keys()
        fields = [(k, fields[k])
                  for k in (list(keys) + ["indices"])]

        def construct_final(examples):
            for i, ex in enumerate(examples):
                yield torchtext.data.Example.fromlist(
                    [ex[k] for k in keys] + [i],
                    fields)

        def filter_pred(example):
            return True

        super(TableDataset, self).__init__(
            construct_final(examples), fields, filter_pred)

    def _read_annotated_file(self, opt, js_list, field, filter_ex):
        """
        path: location of a src or tgt file
        truncate: maximum sequence length (0 for unlimited)
        """
        if field in ('sel', 'agg'):
            lines = (line['query'][field] for line in js_list)
        elif field in ('ent',):
            lines = (line['question']['ent'] for line in js_list)
        elif field in ('tbl',):
            def _tbl(line):
                tk_list = [SPLIT_WORD]
                tk_split = '\t' + SPLIT_WORD + '\t'
                tk_list.extend(tk_split.join(
                    ['\t'.join(col['words']) for col in line['table']['header']]).strip().split('\t'))
                tk_list.append(SPLIT_WORD)
                return tk_list
            lines = (_tbl(line) for line in js_list)
        elif field in ('tbl_split',):
            def _cum_length_for_split(line):
                len_list = [len(col['words'])
                            for col in line['table']['header']]
                r = [0]
                for i in range(len(len_list)):
                    r.append(r[-1] + len_list[i] + 1)
                return r
            lines = (_cum_length_for_split(line) for line in js_list)
        elif field in ('tbl_mask',):
            lines = ([0 for col in line['table']['header']]
                     for line in js_list)
        elif field in ('lay',):
            def _lay(where_list):
                return ' '.join([str(op) for col, op, cond in where_list])
            lines = (_lay(line['query']['conds'])
                     for line in js_list)
        elif field in ('cond_op',):
            lines = ([str(op) for col, op, cond in line['query']['conds']]
                     for line in js_list)
        elif field in ('cond_col',):
            lines = ([col for col, op, cond in line['query']['conds']]
                     for line in js_list)
        elif field in ('cond_span',):
            def _find_span(q_list, where_list):
                r_list = []
                for col, op, cond in where_list:
                    tk_list = cond['words']
                    # find exact match first
                    if len(tk_list) <= len(q_list):
                        match_list = []
                        for st in range(0, len(q_list) - len(tk_list) + 1):
                            if q_list[st:st + len(tk_list)] == tk_list:
                                match_list.append((st, st + len(tk_list) - 1))
                        if len(match_list) > 0:
                            r_list.append(rnd.choice(match_list))
                            continue
                        elif (opt is not None) and opt.span_exact_match:
                            return None
                        else:
                            # do not have exact match, then fuzzy match (w/o considering order)
                            for len_span in range(len(tk_list), len(tk_list) + 2):
                                for st in range(0, len(q_list) - len_span + 1):
                                    if set(tk_list) <= set(q_list[st:st + len_span]):
                                        match_list.append(
                                            (st, st + len_span - 1))
                                if len(match_list) > 0:
                                    # match spans that are as short as possible
                                    break
                            if len(match_list) > 0:
                                r_list.append(rnd.choice(match_list))
                            else:
                                return None
                    else:
                        return None
                return r_list

            def _span(q_list, where_list, filter_ex):
                r_list = _find_span(q_list, where_list)
                if (not filter_ex) and (r_list is None):
                    r_list = []
                    for col, op, cond in where_list:
                        r_list.append((0, 0))
                return r_list
            lines = (_span(line['question']['words'], line['query']
                           ['conds'], filter_ex) for line in js_list)
        elif field in ('cond_mask',):
            lines = ([0 for col, op, cond in line['query']['conds']]
                     for line in js_list)
        else:
            lines = (line[field]['words'] for line in js_list)
        for line in lines:
            yield line

    def _construct_examples(self, lines, side):
        for words in lines:
            example_dict = {side: words}
            yield example_dict

    def __getstate__(self):
        return self.__dict__

    def __setstate__(self, d):
        self.__dict__.update(d)

    def __reduce_ex__(self, proto):
        "This is a hack. Something is broken with torch pickle."
        return super(TableDataset, self).__reduce_ex__()

    @staticmethod
    def load_fields(vocab):
        vocab = dict(vocab)
        fields = TableDataset.get_fields()
        for k, v in vocab.items():
            # Hack. Can't pickle defaultdict :(
            v.stoi = defaultdict(lambda: 0, v.stoi)
            fields[k].vocab = v
        return fields

    @staticmethod
    def save_vocab(fields):
        vocab = []
        for k, f in fields.items():
            if 'vocab' in f.__dict__:
                f.vocab.stoi = dict(f.vocab.stoi)
                vocab.append((k, f.vocab))
        return vocab

    @staticmethod
    def get_fields():
        fields = {}
        fields["src"] = torchtext.data.Field(
            pad_token=PAD_WORD, include_lengths=True)
        fields["ent"] = torchtext.data.Field(
            pad_token=PAD_WORD, include_lengths=False)
        fields["agg"] = torchtext.data.Field(
            sequential=False, use_vocab=False, batch_first=True)
        fields["sel"] = torchtext.data.Field(
            sequential=False, use_vocab=False, batch_first=True)
        fields["tbl"] = torchtext.data.Field(
            pad_token=PAD_WORD, include_lengths=True)
        fields["tbl_split"] = torchtext.data.Field(
            use_vocab=False, pad_token=0)
        fields["tbl_mask"] = torchtext.data.Field(
            use_vocab=False, tensor_type=torch.ByteTensor, batch_first=True, pad_token=1)
        fields["lay"] = torchtext.data.Field(
            sequential=False, batch_first=True)
        fields["cond_op"] = torchtext.data.Field(
            include_lengths=True, pad_token=PAD_WORD)
        fields["cond_col"] = torchtext.data.Field(
            use_vocab=False, include_lengths=False, pad_token=0)
        fields["cond_span_l"] = torchtext.data.Field(
            use_vocab=False, include_lengths=False, pad_token=0)
        fields["cond_span_r"] = torchtext.data.Field(
            use_vocab=False, include_lengths=False, pad_token=0)
        fields["cond_col_loss"] = torchtext.data.Field(
            use_vocab=False, include_lengths=False, pad_token=-1)
        fields["cond_span_l_loss"] = torchtext.data.Field(
            use_vocab=False, include_lengths=False, pad_token=-1)
        fields["cond_span_r_loss"] = torchtext.data.Field(
            use_vocab=False, include_lengths=False, pad_token=-1)
        fields["indices"] = torchtext.data.Field(
            use_vocab=False, sequential=False)
        return fields

    @staticmethod
    def build_vocab(train, dev, test, opt):
        fields = train.fields

        merge_list = []
        merge_name_list = ('src', 'tbl')
        for split in (dev, test, train,):
            for merge_name_it in merge_name_list:
                fields[merge_name_it].build_vocab(
                    split, max_size=opt.src_vocab_size, min_freq=0)
                merge_list.append(fields[merge_name_it].vocab)
        # build vocabulary only based on the training set
        fields["ent"].build_vocab(
            train, max_size=opt.src_vocab_size, min_freq=0)
        fields["lay"].build_vocab(
            train, max_size=opt.src_vocab_size, min_freq=0)
        fields["cond_op"].build_vocab(
            train, max_size=opt.src_vocab_size, min_freq=0)

        # need to know all the words to filter the pretrained word embeddings
        merged_vocab = merge_vocabs(merge_list, vocab_size=opt.src_vocab_size)
        for merge_name_it in merge_name_list:
            fields[merge_name_it].vocab = merged_vocab

{'repo_name': 'donglixp/coarse2fine', 'stars': '144', 'repo_language': 'Python', 'file_name': 'UtilClass.py', 'mime_type': 'text/x-python', 'hash': 5040420102849071559, 'source_dataset': 'data'}


// Copyright 2020 the Deno authors. All rights reserved. MIT license.
use super::Context;
use super::LintRule;
use std::sync::Arc;
use swc_ecmascript::ast::{
  ArrayPat, Expr, Ident, Lit, ObjectPat, Pat, TsAsExpr, TsLit, TsType,
  TsTypeAssertion, VarDecl,
};
use swc_ecmascript::visit::Node;
use swc_ecmascript::visit::Visit;

pub struct PreferAsConst;

impl LintRule for PreferAsConst {
  fn new() -> Box<Self> {
    Box::new(PreferAsConst)
  }

  fn code(&self) -> &'static str {
    "prefer-as-const"
  }

  fn lint_module(
    &self,
    context: Arc<Context>,
    module: &swc_ecmascript::ast::Module,
  ) {
    let mut visitor = PreferAsConstVisitor::new(context);
    visitor.visit_module(module, module);
  }
}

struct PreferAsConstVisitor {
  context: Arc<Context>,
}

impl PreferAsConstVisitor {
  fn new(context: Arc<Context>) -> Self {
    Self { context }
  }

  fn add_diagnostic_helper(&self, span: swc_common::Span) {
    self.context.add_diagnostic(
      span,
      "prefer-as-const",
      "strict equality between type and value is not allowed",
    );
  }

  fn compare(&self, type_ann: &TsType, expr: &Expr, span: swc_common::Span) {
    if let TsType::TsLitType(lit_type) = &*type_ann {
      if let Expr::Lit(expr_lit) = &*expr {
        match (expr_lit, &lit_type.lit) {
          (Lit::Str(value_literal), TsLit::Str(type_literal)) => {
            if value_literal.value == type_literal.value {
              self.add_diagnostic_helper(span)
            }
          }
          (Lit::Num(value_literal), TsLit::Number(type_literal)) => {
            let error = 0.01f64;
            if (value_literal.value - type_literal.value).abs() < error {
              self.add_diagnostic_helper(span)
            }
          }
          _ => return,
        }
      }
    }
  }
}

impl Visit for PreferAsConstVisitor {
  fn visit_ts_as_expr(&mut self, as_expr: &TsAsExpr, _parent: &dyn Node) {
    self.compare(&as_expr.type_ann, &as_expr.expr, as_expr.span);
  }

  fn visit_ts_type_assertion(
    &mut self,
    type_assertion: &TsTypeAssertion,
    _parent: &dyn Node,
  ) {
    self.compare(
      &type_assertion.type_ann,
      &type_assertion.expr,
      type_assertion.span,
    );
  }

  fn visit_var_decl(&mut self, var_decl: &VarDecl, _parent: &dyn Node) {
    if let Some(init) = &var_decl.decls[0].init {
      match &**init {
        Expr::TsAs(as_expr) => {
          self.visit_ts_as_expr(&as_expr, _parent);
          return;
        }
        Expr::Object(object) => {
          self.visit_object_lit(&object, _parent);
          return;
        }
        Expr::TsTypeAssertion(type_assert) => {
          self.visit_ts_type_assertion(&type_assert, _parent);
          return;
        }
        _ => {}
      }

      if let Pat::Array(ArrayPat { type_ann, .. })
      | Pat::Object(ObjectPat { type_ann, .. })
      | Pat::Ident(Ident { type_ann, .. }) = &var_decl.decls[0].name
      {
        if let Some(swc_ecmascript::ast::TsTypeAnn { type_ann, .. }) = &type_ann
        {
          self.compare(type_ann, &init, var_decl.span);
        }
      }
    }
  }
}

#[cfg(test)]
mod tests {
  use super::*;
  use crate::test_util::*;

  #[test]
  fn prefer_as_const_valid() {
    assert_lint_ok::<PreferAsConst>(
      r#"
      let foo = "baz" as const;
      let foo = 1 as const;
      let foo = { bar: "baz" as const };
      let foo = { bar: 1 as const };
      let foo = { bar: "baz" };
      let foo = { bar: 2 };
      let foo = <bar>"bar";
      let foo = <string>"bar";
      let foo = "bar" as string;
      let foo = `bar` as `bar`;
      let foo = `bar` as `foo`;
      let foo = `bar` as "bar";
      let foo: string = "bar";
      let foo: number = 1;
      let foo: "bar" = baz;
      let foo = "bar";

      class foo {
        bar: "baz" = "baz";
      }
      class foo {
        bar = "baz";
      }
      let foo: "bar";
      let foo = { bar };
      let foo: "baz" = "baz" as const;
      "#,
    );
  }

  #[test]
  fn prefer_as_const_invalid() {
    assert_lint_err::<PreferAsConst>(
      r#"let foo = { bar: "baz" as "baz" };"#,
      17,
    );
    assert_lint_err::<PreferAsConst>(r#"let foo = { bar: 1 as 1 };"#, 17);
    assert_lint_err::<PreferAsConst>(r#"let [x]: "bar" = "bar";"#, 0);
    assert_lint_err::<PreferAsConst>(r#"let {x}: "bar" = "bar";"#, 0);
    assert_lint_err::<PreferAsConst>(r#"let foo: "bar" = "bar";"#, 0);
    assert_lint_err::<PreferAsConst>(r#"let foo: 2 = 2;"#, 0);
    assert_lint_err::<PreferAsConst>(r#"let foo: "bar" = "bar" as "bar";"#, 17);
    assert_lint_err::<PreferAsConst>(r#"let foo = <"bar">"bar";"#, 10);
    assert_lint_err::<PreferAsConst>(r#"let foo = <4>4;"#, 10);
    assert_lint_err::<PreferAsConst>(r#"let foo = "bar" as "bar";"#, 10);
    assert_lint_err::<PreferAsConst>(r#"let foo = 5 as 5;"#, 10);
  }
}

{'repo_name': 'denoland/deno_lint', 'stars': '406', 'repo_language': 'Rust', 'file_name': 'main.rs', 'mime_type': 'text/x-c', 'hash': 3749285079198473913, 'source_dataset': 'data'}


<?xml version="1.0" encoding="UTF-8"?>
<!--
  ~ Copyright (c) 2010-2017 Evolveum and contributors
  ~
  ~ This work is dual-licensed under the Apache License 2.0
  ~ and European Union Public License. See LICENSE file for details.
  -->

<resource oid="ef2bc95b-76e0-59e2-86d6-3d4f02d3ffff"
          xmlns="http://midpoint.evolveum.com/xml/ns/public/common/common-3"
          xmlns:c="http://midpoint.evolveum.com/xml/ns/public/common/common-3"
          xmlns:t="http://prism.evolveum.com/xml/ns/public/types-3"
          xmlns:ri="http://midpoint.evolveum.com/xml/ns/public/resource/instance/ef2bc95b-76e0-59e2-86d6-3d4f02d3ffff"
          xmlns:cap="http://midpoint.evolveum.com/xml/ns/public/resource/capabilities-3"
          xmlns:q="http://prism.evolveum.com/xml/ns/public/query-3"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xmlns:icfc="http://midpoint.evolveum.com/xml/ns/public/connector/icf-1/connector-schema-3"
          xmlns:icfs="http://midpoint.evolveum.com/xml/ns/public/connector/icf-1/resource-schema-3"
          xmlns:mr="http://prism.evolveum.com/xml/ns/public/matching-rule-3">

    <name>Embedded Test OpenDJ</name>
    <!-- NOTE: The connector OID will get dynamically replaced in the integration tests -->
    <connectorRef oid="ef2bc95b-76e0-59e2-86d6-3d4f02d3eedd"/>
    <connectorConfiguration xmlns:icfcldap="http://midpoint.evolveum.com/xml/ns/public/connector/icf-1/bundle/com.evolveum.polygon.connector-ldap/com.evolveum.polygon.connector.ldap.LdapConnector">

        <icfc:configurationProperties>
            <icfcldap:port>10389</icfcldap:port>
            <icfcldap:host>localhost</icfcldap:host>
            <icfcldap:baseContext>dc=example,dc=com</icfcldap:baseContext>
            <icfcldap:bindDn>cn=directory manager</icfcldap:bindDn>
            <icfcldap:bindPassword><t:clearValue>secret</t:clearValue></icfcldap:bindPassword>
            <icfcldap:pagingStrategy>auto</icfcldap:pagingStrategy>
            <icfcldap:vlvSortAttribute>entryUUID</icfcldap:vlvSortAttribute>
             <icfcldap:operationalAttributes>ds-pwp-account-disabled</icfcldap:operationalAttributes>
        </icfc:configurationProperties>

        <icfc:connectorPoolConfiguration>
            <icfc:minEvictableIdleTimeMillis>120000</icfc:minEvictableIdleTimeMillis>
            <icfc:minIdle>1</icfc:minIdle>
            <icfc:maxIdle>10</icfc:maxIdle>
            <icfc:maxObjects>10</icfc:maxObjects>
            <icfc:maxWait>150000</icfc:maxWait>
        </icfc:connectorPoolConfiguration>

        <icfc:producerBufferSize>100</icfc:producerBufferSize>

        <icfc:timeouts>
                <icfc:create>-1</icfc:create>
                <icfc:get>-1</icfc:get>
                <icfc:update>-1</icfc:update>
                <icfc:delete>-1</icfc:delete>
                <icfc:test>-1</icfc:test>
                <icfc:scriptOnConnector>-1</icfc:scriptOnConnector>
                <icfc:scriptOnResource>-1</icfc:scriptOnResource>
                <icfc:authentication>-1</icfc:authentication>
                <icfc:search>-1</icfc:search>
                <icfc:validate>-1</icfc:validate>
                <icfc:sync>-1</icfc:sync>
                <icfc:schema>-1</icfc:schema>
            </icfc:timeouts>

            <icfc:resultsHandlerConfiguration>
                <icfc:enableFilteredResultsHandler>false</icfc:enableFilteredResultsHandler>
            </icfc:resultsHandlerConfiguration>

    </connectorConfiguration>

    <namespace>http://midpoint.evolveum.com/xml/ns/public/resource/instance/ef2bc95b-76e0-59e2-86d6-3d4f02d3ffff</namespace>

    <!-- Schema is not present. Schema should be generated by provisioning on the first use of this resource. -->

    <schemaHandling>

        <objectType>
            <kind>account</kind>
            <intent>default</intent>
            <displayName>Default Account</displayName>
            <default>true</default>
            <objectClass>ri:inetOrgPerson</objectClass>
            <attribute>
                <ref>ri:dn</ref>
                <matchingRule>mr:stringIgnoreCase</matchingRule>
            </attribute>
            <association>
                <ref>ri:group</ref>
                <displayName>LDAP Group Membership</displayName>
                <kind>entitlement</kind>
                <intent>ldapGroup</intent>
                <direction>objectToSubject</direction>
                <associationAttribute>ri:uniqueMember</associationAttribute>
                <valueAttribute>ri:dn</valueAttribute>
                <explicitReferentialIntegrity>true</explicitReferentialIntegrity>
            </association>
               <protected>
                   <filter>
                       <q:equal>
                           <q:matching>http://prism.evolveum.com/xml/ns/public/matching-rule-3#distinguishedName</q:matching>
                        <q:path>attributes/ri:dn</q:path>
                        <!-- WilDCapiTaLIzaTioN and spacing makes sure that this is matched properly -->
                        <q:value>uid=cAlyPSo, ou=PeoPle,    DC=example,dc=COM</q:value>
                    </q:equal>
                </filter>
            </protected>
            <configuredCapabilities>
                <cap:pagedSearch>
                    <cap:defaultSortField>ri:uid</cap:defaultSortField>
                </cap:pagedSearch>
                <cap:countObjects>
                    <cap:simulate>sequentialSearch</cap:simulate>
                </cap:countObjects>
            </configuredCapabilities>
        </objectType>

        <objectType>
            <kind>entitlement</kind>
            <intent>ldapGroup</intent>
            <displayName>LDAP Group</displayName>
            <objectClass>ri:groupOfUniqueNames</objectClass>
            <attribute>
                <ref>ri:uniqueMember</ref>
                <matchingRule>mr:stringIgnoreCase</matchingRule>
            </attribute>
        </objectType>

    </schemaHandling>

    <capabilities>
        <configured>
            <cap:activation>
                <cap:status>
                    <cap:attribute>ri:ds-pwp-account-disabled</cap:attribute>
                    <cap:enableValue/>
                    <cap:disableValue>true</cap:disableValue>
                </cap:status>
            </cap:activation>
            <!--
            <cap:credentials>
                <cap:password/>
            </cap:credentials>
            <cap:liveSync/>
            <cap:testConnection/>
            -->
            <cap:update>
                <cap:enabled>false</cap:enabled>
            </cap:update>
        </configured>
    </capabilities>

</resource>

{'repo_name': 'Evolveum/midpoint', 'stars': '208', 'repo_language': 'Java', 'file_name': 'TestAuditServiceImpl.java', 'mime_type': 'text/x-java', 'hash': 7136017683216270423, 'source_dataset': 'data'}


#ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_CLANG_HPP_INCLUDED
#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_CLANG_HPP_INCLUDED

// MS compatible compilers support #pragma once

#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif

//  detail/sp_counted_base_clang.hpp - __c11 clang intrinsics
//
//  Copyright (c) 2007, 2013, 2015 Peter Dimov
//
//  Distributed under the Boost Software License, Version 1.0.
//  See accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt

#include <boost/detail/sp_typeinfo.hpp>
#include <boost/cstdint.hpp>

namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost
{

namespace detail
{

typedef _Atomic( mars_boost::int_least32_t ) atomic_int_least32_t;

inline void atomic_increment( atomic_int_least32_t * pw )
{
    __c11_atomic_fetch_add( pw, 1, __ATOMIC_RELAXED );
}

inline mars_boost::int_least32_t atomic_decrement( atomic_int_least32_t * pw )
{
    return __c11_atomic_fetch_sub( pw, 1, __ATOMIC_ACQ_REL );
}

inline mars_boost::int_least32_t atomic_conditional_increment( atomic_int_least32_t * pw )
{
    // long r = *pw;
    // if( r != 0 ) ++*pw;
    // return r;

    mars_boost::int_least32_t r = __c11_atomic_load( pw, __ATOMIC_RELAXED );

    for( ;; )
    {
        if( r == 0 )
        {
            return r;
        }

        if( __c11_atomic_compare_exchange_weak( pw, &r, r + 1, __ATOMIC_RELAXED, __ATOMIC_RELAXED ) )
        {
            return r;
        }
    }
}

class sp_counted_base
{
private:

    sp_counted_base( sp_counted_base const & );
    sp_counted_base & operator= ( sp_counted_base const & );

    atomic_int_least32_t use_count_;	// #shared
    atomic_int_least32_t weak_count_;	// #weak + (#shared != 0)

public:

    sp_counted_base()
    {
        __c11_atomic_init( &use_count_, 1 );
        __c11_atomic_init( &weak_count_, 1 );
    }

    virtual ~sp_counted_base() // nothrow
    {
    }

    // dispose() is called when use_count_ drops to zero, to release
    // the resources managed by *this.

    virtual void dispose() = 0; // nothrow

    // destroy() is called when weak_count_ drops to zero.

    virtual void destroy() // nothrow
    {
        delete this;
    }

    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
    virtual void * get_untyped_deleter() = 0;

    void add_ref_copy()
    {
        atomic_increment( &use_count_ );
    }

    bool add_ref_lock() // true on success
    {
        return atomic_conditional_increment( &use_count_ ) != 0;
    }

    void release() // nothrow
    {
        if( atomic_decrement( &use_count_ ) == 1 )
        {
            dispose();
            weak_release();
        }
    }

    void weak_add_ref() // nothrow
    {
        atomic_increment( &weak_count_ );
    }

    void weak_release() // nothrow
    {
        if( atomic_decrement( &weak_count_ ) == 1 )
        {
            destroy();
        }
    }

    long use_count() const // nothrow
    {
        return __c11_atomic_load( const_cast< atomic_int_least32_t* >( &use_count_ ), __ATOMIC_ACQUIRE );
    }
};

} // namespace detail

} // namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost

#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_CLANG_HPP_INCLUDED

{'repo_name': 'bingwin/MicroChat', 'stars': '203', 'repo_language': 'C++', 'file_name': 'UIRichEdit.h', 'mime_type': 'text/x-c++', 'hash': -7800253862834182508, 'source_dataset': 'data'}


#ifndef Py_METAGRAMMAR_H
#define Py_METAGRAMMAR_H
#ifdef __cplusplus
extern "C" {
#endif

#define MSTART 256
#define RULE 257
#define RHS 258
#define ALT 259
#define ITEM 260
#define ATOM 261

#ifdef __cplusplus
}
#endif
#endif /* !Py_METAGRAMMAR_H */

{'repo_name': 'bendmorris/static-python', 'stars': '159', 'repo_language': 'Python', 'file_name': 'wininst-7.1.vcproj', 'mime_type': 'text/xml', 'hash': -8001179477561190892, 'source_dataset': 'data'}


10423951	processed_pseudogene	8556	131543	25031005	25031529	-1	9461042	havana	\N	1	11366479	ENSG00000237444	1	2009-05-19 09:47:17	2009-05-19 09:47:17
10423952	lincRNA	8556	131543	25055535	25069906	1	9461053	havana	\N	1	11366480	ENSG00000244278	1	2009-08-05 14:27:16	2009-08-05 14:27:16
10423953	lincRNA	8556	131543	25095022	25103670	1	9461064	havana	\N	1	11366482	ENSG00000232512	6	2009-05-19 09:47:17	2015-06-01 18:57:05
10423954	misc_RNA	8561	131543	25101132	25101415	1	9461079	ensembl	RNA, 7SK small nuclear pseudogene 236 [Source:HGNC Symbol;Acc:HGNC:45960]	1	11366483	ENSG00000274662	1	2014-06-09 10:49:07	2014-06-09 10:49:07
10423955	lincRNA	8556	131543	25127469	25135247	1	9461088	havana	\N	1	11366484	ENSG00000223870	1	2009-05-19 09:47:17	2009-05-19 09:47:17
10423956	lincRNA	8556	131543	25169431	25333825	-1	9461100	havana	\N	1	11366485	ENSG00000222042	1	2008-10-31 20:15:39	2008-10-31 20:15:39
10423957	rRNA	8561	131543	25202207	25202315	1	9461109	ensembl	RNA, 5S ribosomal pseudogene 489 [Source:HGNC Symbol;Acc:HGNC:43389]	1	11366486	ENSG00000238627	1	2010-03-19 11:01:35	2010-03-19 11:01:35
10423958	miRNA	8561	131543	25339005	25339099	1	9461114	ensembl	\N	1	11366487	ENSG00000238660	1	2010-03-19 11:02:24	2010-03-19 11:02:24
10423959	processed_pseudogene	8556	131543	25361821	25362431	1	9461121	havana	ribosomal protein L13a pseudogene 7 [Source:HGNC Symbol;Acc:HGNC:23755]	1	11366488	ENSG00000213885	3	2007-09-07 00:01:32	2011-02-14 13:38:37
10423960	TEC	8556	131543	25371827	25372043	1	9461132	havana	\N	1	11366489	ENSG00000279534	1	2014-08-13 17:29:05	2014-08-13 17:29:05
10423961	lincRNA	8556	131543	25385820	25431701	-1	9461144	havana	long intergenic non-protein coding RNA 158 [Source:HGNC Symbol;Acc:HGNC:1283]	1	11366491	ENSG00000185433	8	2008-04-29 11:17:41	2015-06-01 18:57:05
10423962	miRNA	8561	131543	25454736	25454842	1	9461172	ensembl	\N	1	11366494	ENSG00000275053	1	2014-06-09 10:49:07	2014-06-09 10:49:07
10423963	lincRNA	8556	131543	25515473	25518338	-1	9461179	havana	\N	1	11366495	ENSG00000229962	1	2009-05-19 09:47:17	2009-05-19 09:47:17
10423964	lincRNA	8556	131543	25561909	25575168	1	9461192	havana	MIR155 host gene [Source:HGNC Symbol;Acc:HGNC:35460]	1	11366496	ENSG00000234883	3	2009-05-19 09:47:17	2014-06-09 10:49:07
10423965	miRNA	8561	131543	25573980	25574044	1	9461205	ensembl	microRNA 155 [Source:HGNC Symbol;Acc:HGNC:31542]	1	11366497	ENSG00000275402	1	2014-06-09 10:49:07	2014-06-09 10:49:07
10423966	antisense	8556	131543	25582770	25583326	-1	9461215	havana	\N	1	11366498	ENSG00000260583	1	2011-11-11 09:57:43	2011-11-11 09:57:43
10423967	protein_coding	8566	131543	25585656	25607517	-1	9461229	ensembl_havana	mitochondrial ribosomal protein L39 [Source:HGNC Symbol;Acc:HGNC:14027]	1	11366500	ENSG00000154719	13	2008-04-29 11:17:41	2015-06-01 18:57:05
10423968	protein_coding	8566	131543	25639272	25717562	1	9461314	ensembl_havana	junctional adhesion molecule 2 [Source:HGNC Symbol;Acc:HGNC:14686]	1	11366502	ENSG00000154721	14	2008-04-29 11:17:41	2015-06-01 18:57:05
10423969	processed_pseudogene	8556	131543	25643489	25644216	1	9461411	havana	RNA guanylyltransferase and 5'-phosphatase pseudogene 1 [Source:HGNC Symbol;Acc:HGNC:39652]	1	11366509	ENSG00000237731	1	2009-05-19 09:47:17	2009-05-19 09:47:17
10423970	processed_pseudogene	8556	131543	25692180	25692554	1	9461422	havana	ferredoxin 1 pseudogene 2 [Source:HGNC Symbol;Acc:HGNC:3641]	1	11366510	ENSG00000227054	1	2009-05-19 09:47:17	2009-05-19 09:47:17
10423971	protein_coding	8566	131543	25716503	25735673	-1	9461436	ensembl_havana	ATP synthase, H+ transporting, mitochondrial Fo complex subunit F6 [Source:HGNC Symbol;Acc:HGNC:847]	1	11366514	ENSG00000154723	12	2008-04-29 11:17:41	2015-06-01 18:57:05
10423972	protein_coding	8566	131543	25734570	25772460	1	9461581	ensembl_havana	GA binding protein transcription factor alpha subunit [Source:HGNC Symbol;Acc:HGNC:4071]	1	11366519	ENSG00000154727	10	2008-04-29 11:17:41	2015-06-01 18:57:05
10423973	processed_pseudogene	8556	131543	25762938	25763333	-1	9461671	havana	LLP homolog, long-term synaptic facilitation (Aplysia) pseudogene 2 [Source:HGNC Symbol;Acc:HGNC:50492]	1	11366522	ENSG00000235514	1	2009-05-19 09:47:17	2009-05-19 09:47:17
10423974	protein_coding	8566	131543	25880550	26171128	-1	9461686	ensembl_havana	amyloid beta (A4) precursor protein [Source:HGNC Symbol;Acc:HGNC:620]	1	11366523	ENSG00000142192	20	2008-04-29 11:17:41	2015-06-01 18:57:05
10423975	processed_transcript	8556	131543	25928754	25942686	1	9462270	havana	\N	1	11366545	ENSG00000233783	7	2009-05-19 09:47:17	2015-06-01 18:57:05
10423976	snRNA	8561	131543	25943044	25943145	-1	9462312	ensembl	RNA, U6 small nuclear 123, pseudogene [Source:HGNC Symbol;Acc:HGNC:47086]	1	11366547	ENSG00000251972	1	2010-03-19 10:58:51	2010-03-19 10:58:51
10423977	protein_coding	8566	131543	43772512	43776445	-1	9462325	ensembl_havana	cystatin B [Source:HGNC Symbol;Acc:HGNC:2482]	1	11366548	ENSG00000160213	5	2008-04-29 11:17:41	2009-08-05 14:27:16
10423660	LRG_gene	8405	2006216187	5004	7714	1	8478870	LRG database	cystatin B [Source:HGNC Symbol;Acc:HGNC:2482]	1	11366113	LRG_485	1	2015-10-23 09:25:52	2015-10-23 09:25:52

{'repo_name': 'Ensembl/ensembl-vep', 'stars': '216', 'repo_language': 'Perl', 'file_name': 'trigger-dependent-build.sh', 'mime_type': 'text/x-shellscript', 'hash': 5335371816430374824, 'source_dataset': 'data'}


/* SPDX-License-Identifier: GPL-2.0 */
#ifndef __USBAUDIO_DEBUG_H
#define __USBAUDIO_DEBUG_H

/*
 * h/w constraints
 */

#ifdef HW_CONST_DEBUG
#define hwc_debug(fmt, args...) printk(KERN_DEBUG fmt, ##args)
#else
#define hwc_debug(fmt, args...) do { } while(0)
#endif

#endif /* __USBAUDIO_DEBUG_H */

{'repo_name': 'multipath-tcp/mptcp', 'stars': '660', 'repo_language': 'C', 'file_name': 'iwl-devtrace.c', 'mime_type': 'text/x-c', 'hash': -4409271008713383058, 'source_dataset': 'data'}