text:
import { Plugin } from '@ckeditor/ckeditor5-core';
import ListEditing from './listediting';

export default class TodoListEditing extends Plugin {
    static readonly pluginName: 'TodoListEditing';
    static readonly requires: [typeof ListEditing];
    init(): void;
}


text:
package kafka.utils

import java.io._
import java.nio._
import java.nio.channels._
import java.util.concurrent.locks.{Lock, ReadWriteLock}
import java.lang.management._
import java.util.{Properties, UUID}
import javax.management._
import javax.xml.bind.DatatypeConverter

import org.apache.kafka.common.protocol.SecurityProtocol

import scala.collection._
import scala.collection.mutable
import kafka.cluster.EndPoint
import org.apache.kafka.common.utils.Crc32
import org.apache.kafka.common.utils.Utils

/**
 * General helper functions!
 *
 * This is for general helper functions that aren't specific to Kafka logic. Things that should have been included in
 * the standard library etc.
 *
 * If you are making a new helper function and want to add it to this class please ensure the following:
 * 1. It has documentation
 * 2. It is the most general possible utility, not just the thing you needed in one particular place
 * 3. You have tests for it if it is nontrivial in any way
 */
object CoreUtils extends Logging {

  /**
   * Wrap the given function in a java.lang.Runnable
   * @param fun A function
   * @return A Runnable that just executes the function
   */
  def runnable(fun: => Unit): Runnable =
    new Runnable {
      def run() = fun
    }

  /**
    * Create a thread
    *
    * @param name The name of the thread
    * @param daemon Whether the thread should block JVM shutdown
    * @param fun The function to execute in the thread
    * @return The unstarted thread
    */
  def newThread(name: String, daemon: Boolean)(fun: => Unit): Thread =
    Utils.newThread(name, runnable(fun), daemon)

  /**
   * Do the given action and log any exceptions thrown without rethrowing them
   * @param log The log method to use for logging. E.g. logger.warn
   * @param action The action to execute
   */
  def swallow(log: (Object, Throwable) => Unit, action: => Unit) {
    try {
      action
    } catch {
      case e: Throwable => log(e.getMessage(), e)
    }
  }

  /**
   * Recursively delete the list of files/directories and any subfiles (if any exist)
   * @param files sequence of files to be deleted
   */
  def delete(files: Seq[String]): Unit = files.foreach(f => Utils.delete(new File(f)))

  /**
   * Register the given mbean with the platform mbean server,
   * unregistering any mbean that was there before. Note,
   * this method will not throw an exception if the registration
   * fails (since there is nothing you can do and it isn't fatal),
   * instead it just returns false indicating the registration failed.
   * @param mbean The object to register as an mbean
   * @param name The name to register this mbean with
   * @return true if the registration succeeded
   */
  def registerMBean(mbean: Object, name: String): Boolean = {
    try {
      val mbs = ManagementFactory.getPlatformMBeanServer()
      mbs synchronized {
        val objName = new ObjectName(name)
        if(mbs.isRegistered(objName))
          mbs.unregisterMBean(objName)
        mbs.registerMBean(mbean, objName)
        true
      }
    } catch {
      case e: Exception => {
        error("Failed to register Mbean " + name, e)
        false
      }
    }
  }

  /**
   * Unregister the mbean with the given name, if there is one registered
   * @param name The mbean name to unregister
   */
  def unregisterMBean(name: String) {
    val mbs = ManagementFactory.getPlatformMBeanServer()
    mbs synchronized {
      val objName = new ObjectName(name)
      if(mbs.isRegistered(objName))
        mbs.unregisterMBean(objName)
    }
  }

  /**
   * Compute the CRC32 of the byte array
   * @param bytes The array to compute the checksum for
   * @return The CRC32
   */
  def crc32(bytes: Array[Byte]): Long = crc32(bytes, 0, bytes.length)

  /**
   * Compute the CRC32 of the segment of the byte array given by the specified size and offset
   * @param bytes The bytes to checksum
   * @param offset the offset at which to begin checksumming
   * @param size the number of bytes to checksum
   * @return The CRC32
   */
  def crc32(bytes: Array[Byte], offset: Int, size: Int): Long = {
    val crc = new Crc32()
    crc.update(bytes, offset, size)
    crc.getValue()
  }

  /**
   * Read some bytes into the provided buffer, and return the number of bytes read. If the
   * channel has been closed or we get -1 on the read for any reason, throw an EOFException
   */
  def read(channel: ReadableByteChannel, buffer: ByteBuffer): Int = {
    channel.read(buffer) match {
      case -1 => throw new EOFException("Received -1 when reading from channel, socket has likely been closed.")
      case n: Int => n
    }
  }

  /**
   * This method gets comma separated values which contains key,value pairs and returns a map of
   * key value pairs. the format of allCSVal is key1:val1, key2:val2 ....
   * Also supports strings with multiple ":" such as IpV6 addresses, taking the last occurrence
   * of the ":" in the pair as the split, eg a:b:c:val1, d:e:f:val2 => a:b:c -> val1, d:e:f -> val2
   */
  def parseCsvMap(str: String): Map[String, String] = {
    val map = new mutable.HashMap[String, String]
    if ("".equals(str))
      return map
    val keyVals = str.split("\\s*,\\s*").map(s => {
      val lio = s.lastIndexOf(":")
      (s.substring(0,lio).trim, s.substring(lio + 1).trim)
    })
    keyVals.toMap
  }

  /**
   * Parse a comma separated string into a sequence of strings.
   * Whitespace surrounding the comma will be removed.
   */
  def parseCsvList(csvList: String): Seq[String] = {
    if(csvList == null || csvList.isEmpty)
      Seq.empty[String]
    else {
      csvList.split("\\s*,\\s*").filter(v => !v.equals(""))
    }
  }

  /**
   * Create an instance of the class with the given class name
   */
  def createObject[T<:AnyRef](className: String, args: AnyRef*): T = {
    val klass = Class.forName(className, true, Utils.getContextOrKafkaClassLoader()).asInstanceOf[Class[T]]
    val constructor = klass.getConstructor(args.map(_.getClass): _*)
    constructor.newInstance(args: _*)
  }

  /**
   * Create a circular (looping) iterator over a collection.
   * @param coll An iterable over the underlying collection.
   * @return A circular iterator over the collection.
   */
  def circularIterator[T](coll: Iterable[T]) =
    for (_ <- Iterator.continually(1); t <- coll) yield t

  /**
   * Replace the given string suffix with the new suffix. If the string doesn't end with the given suffix throw an exception.
   */
  def replaceSuffix(s: String, oldSuffix: String, newSuffix: String): String = {
    if(!s.endsWith(oldSuffix))
      throw new IllegalArgumentException("Expected string to end with '%s' but string is '%s'".format(oldSuffix, s))
    s.substring(0, s.length - oldSuffix.length) + newSuffix
  }

  /**
   * Read a big-endian integer from a byte array
   */
  def readInt(bytes: Array[Byte], offset: Int): Int = {
    ((bytes(offset) & 0xFF) << 24) |
    ((bytes(offset + 1) & 0xFF) << 16) |
    ((bytes(offset + 2) & 0xFF) << 8) |
    (bytes(offset + 3) & 0xFF)
  }

  /**
   * Execute the given function inside the lock
   */
  def inLock[T](lock: Lock)(fun: => T): T = {
    lock.lock()
    try {
      fun
    } finally {
      lock.unlock()
    }
  }

  def inReadLock[T](lock: ReadWriteLock)(fun: => T): T = inLock[T](lock.readLock)(fun)

  def inWriteLock[T](lock: ReadWriteLock)(fun: => T): T = inLock[T](lock.writeLock)(fun)

  //JSON strings need to be escaped based on ECMA-404 standard http://json.org
  def JSONEscapeString (s : String) : String = {
    s.map {
      case '"'  => "\\\""
      case '\\' => "\\\\"
      case '/'  => "\\/"
      case '\b' => "\\b"
      case '\f' => "\\f"
      case '\n' => "\\n"
      case '\r' => "\\r"
      case '\t' => "\\t"
      /* We'll unicode escape any control characters. These include:
       * 0x0 -> 0x1f  : ASCII Control (C0 Control Codes)
       * 0x7f         : ASCII DELETE
       * 0x80 -> 0x9f : C1 Control Codes
       *
       * Per RFC4627, section 2.5, we're not technically required to
       * encode the C1 codes, but we do to be safe.
       */
      case c if (c >= '\u0000' && c <= '\u001f') || (c >= '\u007f' && c <= '\u009f') => "\\u%04x".format(c: Int)
      case c => c
    }.mkString
  }

  /**
   * Returns a list of duplicated items
   */
  def duplicates[T](s: Traversable[T]): Iterable[T] = {
    s.groupBy(identity)
      .map { case (k, l) => (k, l.size)}
      .filter { case (_, l) => l > 1 }
      .keys
  }

  def listenerListToEndPoints(listeners: String): immutable.Map[SecurityProtocol, EndPoint] = {
    val listenerList = parseCsvList(listeners)
    listenerList.map(listener => EndPoint.createEndPoint(listener)).map(ep => ep.protocolType -> ep).toMap
  }

  def generateUuidAsBase64(): String = {
    val uuid = UUID.randomUUID()
    urlSafeBase64EncodeNoPadding(getBytesFromUuid(uuid))
  }

  def getBytesFromUuid(uuid: UUID): Array[Byte] = {
    // Extract bytes for uuid which is 128 bits (or 16 bytes) long.
    val uuidBytes = ByteBuffer.wrap(new Array[Byte](16))
    uuidBytes.putLong(uuid.getMostSignificantBits)
    uuidBytes.putLong(uuid.getLeastSignificantBits)
    uuidBytes.array
  }

  def urlSafeBase64EncodeNoPadding(data: Array[Byte]): String = {
    val base64EncodedUUID = DatatypeConverter.printBase64Binary(data)
    //Convert to URL safe variant by replacing + and / with - and _ respectively.
    val urlSafeBase64EncodedUUID = base64EncodedUUID.replace("+", "-").replace("/", "_")
    // Remove the "==" padding at the end.
    urlSafeBase64EncodedUUID.substring(0, urlSafeBase64EncodedUUID.length - 2)
  }

  def propsWith(key: String, value: String): Properties = {
    propsWith((key, value))
  }

  def propsWith(props: (String, String)*): Properties = {
    val properties = new Properties()
    props.foreach { case (k, v) => properties.put(k, v) }
    properties
  }
}

redpajama_set_name: RedPajamaGithub


text:
<?php

namespace Widop\Tests\HttpAdapter;

use Widop\HttpAdapter\StreamHttpAdapter;

/**
 * Stream http adapter test.
 *
 * @author Geoffrey Brier <geoffrey.brier@gmail.com>
 */
class StreamHttpAdapterTest extends AbstractHttpAdapterTest
{
    /**
     * {@inheritdoc}
     */
    protected function setUp()
    {
        $this->httpAdapter = new StreamHttpAdapter();
    }

    public function testName()
    {
        $this->assertSame('stream', $this->httpAdapter->getName());
    }
}


text:
<!DOCTYPE html>

        <meta charset="utf-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <title>Kamrul Hassan</title>
        <meta name="description" content="">
        <meta name="viewport" content="width=device-width, initial-scale=1">

        <link rel="stylesheet" href="css/main.css">

              <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">

              </button>

Welcome

About Me

Portfolio

Impact

Contact Me

Kamrul Hassan

Found something, found something...yes found something...Find more

About Me

Feature 1

Donec id elit non mi porta gravida at eget metus. Fusce dapibus, tellus ac cursus commodo.

Feature 2

Donec id elit non mi porta gravida at eget metus. Fusce dapibus, tellus ac cursus commodo.

Feature 3

Donec sed odio dui. Cras justo odio, dapibus ac facilisis in, egestas eget quam.

Feature 4

Donec id elit non mi porta gravida at eget metus. Fusce dapibus, tellus ac cursus commodo.

Feature 5

Donec id elit non mi porta gravida at eget metus. Fusce dapibus, tellus ac cursus commodo.

Feature 6

Donec sed odio dui. Cras justo odio, dapibus ac facilisis in, egestas eget quam.

Portfolio

 Lorem ipsum dolor sit amet, consectetur adipiscing elit. Morbi interdum justo eget lectus tempor, quis dignissim enim fermentum. Donec volutpat erat sed odio rutrum, sit amet tristique ex iaculis. Nullam eu magna placerat, malesuada ipsum et, feugiat elit. Sed iaculis mattis odio, vel accumsan nunc interdum at. Quisque ac ligula at ex hendrerit varius nec at nunc. Donec imperdiet tellus nisl. Vestibulum ornare a justo quis luctus. Proin ac felis gravida, gravida mauris volutpat, laoreet nulla. Donec convallis malesuada nibh tincidunt vehicula.

Impact

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, nulla pretium commodo ultricies

Smiling Customer1

Lorem ipsum dolor sit amet

Smiling Customers2

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, nulla

Smiling Customer3

Lorem ipsum dolor sit amet

Smiling Customer4

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin euismod, nulla pretium commodo ultricies

Smiling Customer5

Lorem ipsum dolor sit amet elit.

Smiling Customer6

Lorem ipsum dolor sit amet ... elit.

Smiling Customer7

Contact Me

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Duis rhoncus ex ante, sed auctor urna eleifend non. Integer pretium nisl et orci tincidunt, non porttitor neque pharetra. Nam ex odio, euismod sed pretium vel, facilisis non tortor. Ut consequat eros eget semper vulputate. Vivamus volutpat venenatis convallis. Ut dictum ornare ante, eget feugiat nunc ultricies quis. Nam tincidunt diam at purus rhoncus sagittis. Etiam sed quam quis risus consequat malesuada.

				 1234 Road Name, City Name, State Name

				 + (00) 012-345-6789

				  lorem@ipsum.com

Copyright © 2014 Al Nahian


text:
/***************************************************************************//**
 * @file
 * @brief EFM32WG_LETIMER register and bit field definitions
 *******************************************************************************
 * # License
 * <b>Copyright 2019 Silicon Laboratories Inc. www.silabs.com</b>
 *******************************************************************************
 *
 * SPDX-License-Identifier: Zlib
 *
 * The licensor of this software is Silicon Laboratories Inc.
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 *
 ******************************************************************************/

#if defined(__ICCARM__)
#pragma system_include       /* Treat file as system include file. */
#elif defined(__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
#pragma clang system_header  /* Treat file as system include file. */
#endif

/***************************************************************************//**
 * @addtogroup Parts
 * @{
 ******************************************************************************/
/***************************************************************************//**
 * @defgroup EFM32WG_LETIMER
 * @{
 * @brief EFM32WG_LETIMER Register Declaration
 ******************************************************************************/
typedef struct {
  __IOM uint32_t CTRL;          /**< Control Register  */
  __IOM uint32_t CMD;           /**< Command Register  */
  __IM uint32_t  STATUS;        /**< Status Register  */
  __IOM uint32_t CNT;           /**< Counter Value Register  */
  __IOM uint32_t COMP0;         /**< Compare Value Register 0  */
  __IOM uint32_t COMP1;         /**< Compare Value Register 1  */
  __IOM uint32_t REP0;          /**< Repeat Counter Register 0  */
  __IOM uint32_t REP1;          /**< Repeat Counter Register 1  */
  __IM uint32_t  IF;            /**< Interrupt Flag Register  */
  __IOM uint32_t IFS;           /**< Interrupt Flag Set Register  */
  __IOM uint32_t IFC;           /**< Interrupt Flag Clear Register  */
  __IOM uint32_t IEN;           /**< Interrupt Enable Register  */

  __IOM uint32_t FREEZE;        /**< Freeze Register  */
  __IM uint32_t  SYNCBUSY;      /**< Synchronization Busy Register  */

  uint32_t       RESERVED0[2U]; /**< Reserved for future use **/
  __IOM uint32_t ROUTE;         /**< I/O Routing Register  */
} LETIMER_TypeDef;              /**< LETIMER Register Declaration *//** @} */

/***************************************************************************//**
 * @defgroup EFM32WG_LETIMER_BitFields
 * @{
 ******************************************************************************/

/* Bit fields for LETIMER CTRL */
#define _LETIMER_CTRL_RESETVALUE             0x00000000UL                           /**< Default value for LETIMER_CTRL */
#define _LETIMER_CTRL_MASK                   0x00001FFFUL                           /**< Mask for LETIMER_CTRL */
#define _LETIMER_CTRL_REPMODE_SHIFT          0                                      /**< Shift value for LETIMER_REPMODE */
#define _LETIMER_CTRL_REPMODE_MASK           0x3UL                                  /**< Bit mask for LETIMER_REPMODE */
#define _LETIMER_CTRL_REPMODE_DEFAULT        0x00000000UL                           /**< Mode DEFAULT for LETIMER_CTRL */
#define _LETIMER_CTRL_REPMODE_FREE           0x00000000UL                           /**< Mode FREE for LETIMER_CTRL */
#define _LETIMER_CTRL_REPMODE_ONESHOT        0x00000001UL                           /**< Mode ONESHOT for LETIMER_CTRL */
#define _LETIMER_CTRL_REPMODE_BUFFERED       0x00000002UL                           /**< Mode BUFFERED for LETIMER_CTRL */
#define _LETIMER_CTRL_REPMODE_DOUBLE         0x00000003UL                           /**< Mode DOUBLE for LETIMER_CTRL */
#define LETIMER_CTRL_REPMODE_DEFAULT         (_LETIMER_CTRL_REPMODE_DEFAULT << 0)   /**< Shifted mode DEFAULT for LETIMER_CTRL */
#define LETIMER_CTRL_REPMODE_FREE            (_LETIMER_CTRL_REPMODE_FREE << 0)      /**< Shifted mode FREE for LETIMER_CTRL */
#define LETIMER_CTRL_REPMODE_ONESHOT         (_LETIMER_CTRL_REPMODE_ONESHOT << 0)   /**< Shifted mode ONESHOT for LETIMER_CTRL */
#define LETIMER_CTRL_REPMODE_BUFFERED        (_LETIMER_CTRL_REPMODE_BUFFERED << 0)  /**< Shifted mode BUFFERED for LETIMER_CTRL */
#define LETIMER_CTRL_REPMODE_DOUBLE          (_LETIMER_CTRL_REPMODE_DOUBLE << 0)    /**< Shifted mode DOUBLE for LETIMER_CTRL */
#define _LETIMER_CTRL_UFOA0_SHIFT            2                                      /**< Shift value for LETIMER_UFOA0 */
#define _LETIMER_CTRL_UFOA0_MASK             0xCUL                                  /**< Bit mask for LETIMER_UFOA0 */
#define _LETIMER_CTRL_UFOA0_DEFAULT          0x00000000UL                           /**< Mode DEFAULT for LETIMER_CTRL */
#define _LETIMER_CTRL_UFOA0_NONE             0x00000000UL                           /**< Mode NONE for LETIMER_CTRL */
#define _LETIMER_CTRL_UFOA0_TOGGLE           0x00000001UL                           /**< Mode TOGGLE for LETIMER_CTRL */
#define _LETIMER_CTRL_UFOA0_PULSE            0x00000002UL                           /**< Mode PULSE for LETIMER_CTRL */
#define _LETIMER_CTRL_UFOA0_PWM              0x00000003UL                           /**< Mode PWM for LETIMER_CTRL */
#define LETIMER_CTRL_UFOA0_DEFAULT           (_LETIMER_CTRL_UFOA0_DEFAULT << 2)     /**< Shifted mode DEFAULT for LETIMER_CTRL */
#define LETIMER_CTRL_UFOA0_NONE              (_LETIMER_CTRL_UFOA0_NONE << 2)        /**< Shifted mode NONE for LETIMER_CTRL */
#define LETIMER_CTRL_UFOA0_TOGGLE            (_LETIMER_CTRL_UFOA0_TOGGLE << 2)      /**< Shifted mode TOGGLE for LETIMER_CTRL */
#define LETIMER_CTRL_UFOA0_PULSE             (_LETIMER_CTRL_UFOA0_PULSE << 2)       /**< Shifted mode PULSE for LETIMER_CTRL */
#define LETIMER_CTRL_UFOA0_PWM               (_LETIMER_CTRL_UFOA0_PWM << 2)         /**< Shifted mode PWM for LETIMER_CTRL */
#define _LETIMER_CTRL_UFOA1_SHIFT            4                                      /**< Shift value for LETIMER_UFOA1 */
#define _LETIMER_CTRL_UFOA1_MASK             0x30UL                                 /**< Bit mask for LETIMER_UFOA1 */
#define _LETIMER_CTRL_UFOA1_DEFAULT          0x00000000UL                           /**< Mode DEFAULT for LETIMER_CTRL */
#define _LETIMER_CTRL_UFOA1_NONE             0x00000000UL                           /**< Mode NONE for LETIMER_CTRL */
#define _LETIMER_CTRL_UFOA1_TOGGLE           0x00000001UL                           /**< Mode TOGGLE for LETIMER_CTRL */
#define _LETIMER_CTRL_UFOA1_PULSE            0x00000002UL                           /**< Mode PULSE for LETIMER_CTRL */
#define _LETIMER_CTRL_UFOA1_PWM              0x00000003UL                           /**< Mode PWM for LETIMER_CTRL */
#define LETIMER_CTRL_UFOA1_DEFAULT           (_LETIMER_CTRL_UFOA1_DEFAULT << 4)     /**< Shifted mode DEFAULT for LETIMER_CTRL */
#define LETIMER_CTRL_UFOA1_NONE              (_LETIMER_CTRL_UFOA1_NONE << 4)        /**< Shifted mode NONE for LETIMER_CTRL */
#define LETIMER_CTRL_UFOA1_TOGGLE            (_LETIMER_CTRL_UFOA1_TOGGLE << 4)      /**< Shifted mode TOGGLE for LETIMER_CTRL */
#define LETIMER_CTRL_UFOA1_PULSE             (_LETIMER_CTRL_UFOA1_PULSE << 4)       /**< Shifted mode PULSE for LETIMER_CTRL */
#define LETIMER_CTRL_UFOA1_PWM               (_LETIMER_CTRL_UFOA1_PWM << 4)         /**< Shifted mode PWM for LETIMER_CTRL */
#define LETIMER_CTRL_OPOL0                   (0x1UL << 6)                           /**< Output 0 Polarity */
#define _LETIMER_CTRL_OPOL0_SHIFT            6                                      /**< Shift value for LETIMER_OPOL0 */
#define _LETIMER_CTRL_OPOL0_MASK             0x40UL                                 /**< Bit mask for LETIMER_OPOL0 */
#define _LETIMER_CTRL_OPOL0_DEFAULT          0x00000000UL                           /**< Mode DEFAULT for LETIMER_CTRL */
#define LETIMER_CTRL_OPOL0_DEFAULT           (_LETIMER_CTRL_OPOL0_DEFAULT << 6)     /**< Shifted mode DEFAULT for LETIMER_CTRL */
#define LETIMER_CTRL_OPOL1                   (0x1UL << 7)                           /**< Output 1 Polarity */
#define _LETIMER_CTRL_OPOL1_SHIFT            7                                      /**< Shift value for LETIMER_OPOL1 */
#define _LETIMER_CTRL_OPOL1_MASK             0x80UL                                 /**< Bit mask for LETIMER_OPOL1 */
#define _LETIMER_CTRL_OPOL1_DEFAULT          0x00000000UL                           /**< Mode DEFAULT for LETIMER_CTRL */
#define LETIMER_CTRL_OPOL1_DEFAULT           (_LETIMER_CTRL_OPOL1_DEFAULT << 7)     /**< Shifted mode DEFAULT for LETIMER_CTRL */
#define LETIMER_CTRL_BUFTOP                  (0x1UL << 8)                           /**< Buffered Top */
#define _LETIMER_CTRL_BUFTOP_SHIFT           8                                      /**< Shift value for LETIMER_BUFTOP */
#define _LETIMER_CTRL_BUFTOP_MASK            0x100UL                                /**< Bit mask for LETIMER_BUFTOP */
#define _LETIMER_CTRL_BUFTOP_DEFAULT         0x00000000UL                           /**< Mode DEFAULT for LETIMER_CTRL */
#define LETIMER_CTRL_BUFTOP_DEFAULT          (_LETIMER_CTRL_BUFTOP_DEFAULT << 8)    /**< Shifted mode DEFAULT for LETIMER_CTRL */
#define LETIMER_CTRL_COMP0TOP                (0x1UL << 9)                           /**< Compare Value 0 Is Top Value */
#define _LETIMER_CTRL_COMP0TOP_SHIFT         9                                      /**< Shift value for LETIMER_COMP0TOP */
#define _LETIMER_CTRL_COMP0TOP_MASK          0x200UL                                /**< Bit mask for LETIMER_COMP0TOP */
#define _LETIMER_CTRL_COMP0TOP_DEFAULT       0x00000000UL                           /**< Mode DEFAULT for LETIMER_CTRL */
#define LETIMER_CTRL_COMP0TOP_DEFAULT        (_LETIMER_CTRL_COMP0TOP_DEFAULT << 9)  /**< Shifted mode DEFAULT for LETIMER_CTRL */
#define LETIMER_CTRL_RTCC0TEN                (0x1UL << 10)                          /**< RTC Compare 0 Trigger Enable */
#define _LETIMER_CTRL_RTCC0TEN_SHIFT         10                                     /**< Shift value for LETIMER_RTCC0TEN */
#define _LETIMER_CTRL_RTCC0TEN_MASK          0x400UL                                /**< Bit mask for LETIMER_RTCC0TEN */
#define _LETIMER_CTRL_RTCC0TEN_DEFAULT       0x00000000UL                           /**< Mode DEFAULT for LETIMER_CTRL */
#define LETIMER_CTRL_RTCC0TEN_DEFAULT        (_LETIMER_CTRL_RTCC0TEN_DEFAULT << 10) /**< Shifted mode DEFAULT for LETIMER_CTRL */
#define LETIMER_CTRL_RTCC1TEN                (0x1UL << 11)                          /**< RTC Compare 1 Trigger Enable */
#define _LETIMER_CTRL_RTCC1TEN_SHIFT         11                                     /**< Shift value for LETIMER_RTCC1TEN */
#define _LETIMER_CTRL_RTCC1TEN_MASK          0x800UL                                /**< Bit mask for LETIMER_RTCC1TEN */
#define _LETIMER_CTRL_RTCC1TEN_DEFAULT       0x00000000UL                           /**< Mode DEFAULT for LETIMER_CTRL */
#define LETIMER_CTRL_RTCC1TEN_DEFAULT        (_LETIMER_CTRL_RTCC1TEN_DEFAULT << 11) /**< Shifted mode DEFAULT for LETIMER_CTRL */
#define LETIMER_CTRL_DEBUGRUN                (0x1UL << 12)                          /**< Debug Mode Run Enable */
#define _LETIMER_CTRL_DEBUGRUN_SHIFT         12                                     /**< Shift value for LETIMER_DEBUGRUN */
#define _LETIMER_CTRL_DEBUGRUN_MASK          0x1000UL                               /**< Bit mask for LETIMER_DEBUGRUN */
#define _LETIMER_CTRL_DEBUGRUN_DEFAULT       0x00000000UL                           /**< Mode DEFAULT for LETIMER_CTRL */
#define LETIMER_CTRL_DEBUGRUN_DEFAULT        (_LETIMER_CTRL_DEBUGRUN_DEFAULT << 12) /**< Shifted mode DEFAULT for LETIMER_CTRL */

/* Bit fields for LETIMER CMD */
#define _LETIMER_CMD_RESETVALUE              0x00000000UL                      /**< Default value for LETIMER_CMD */
#define _LETIMER_CMD_MASK                    0x0000001FUL                      /**< Mask for LETIMER_CMD */
#define LETIMER_CMD_START                    (0x1UL << 0)                      /**< Start LETIMER */
#define _LETIMER_CMD_START_SHIFT             0                                 /**< Shift value for LETIMER_START */
#define _LETIMER_CMD_START_MASK              0x1UL                             /**< Bit mask for LETIMER_START */
#define _LETIMER_CMD_START_DEFAULT           0x00000000UL                      /**< Mode DEFAULT for LETIMER_CMD */
#define LETIMER_CMD_START_DEFAULT            (_LETIMER_CMD_START_DEFAULT << 0) /**< Shifted mode DEFAULT for LETIMER_CMD */
#define LETIMER_CMD_STOP                     (0x1UL << 1)                      /**< Stop LETIMER */
#define _LETIMER_CMD_STOP_SHIFT              1                                 /**< Shift value for LETIMER_STOP */
#define _LETIMER_CMD_STOP_MASK               0x2UL                             /**< Bit mask for LETIMER_STOP */
#define _LETIMER_CMD_STOP_DEFAULT            0x00000000UL                      /**< Mode DEFAULT for LETIMER_CMD */
#define LETIMER_CMD_STOP_DEFAULT             (_LETIMER_CMD_STOP_DEFAULT << 1)  /**< Shifted mode DEFAULT for LETIMER_CMD */
#define LETIMER_CMD_CLEAR                    (0x1UL << 2)                      /**< Clear LETIMER */
#define _LETIMER_CMD_CLEAR_SHIFT             2                                 /**< Shift value for LETIMER_CLEAR */
#define _LETIMER_CMD_CLEAR_MASK              0x4UL                             /**< Bit mask for LETIMER_CLEAR */
#define _LETIMER_CMD_CLEAR_DEFAULT           0x00000000UL                      /**< Mode DEFAULT for LETIMER_CMD */
#define LETIMER_CMD_CLEAR_DEFAULT            (_LETIMER_CMD_CLEAR_DEFAULT << 2) /**< Shifted mode DEFAULT for LETIMER_CMD */
#define LETIMER_CMD_CTO0                     (0x1UL << 3)                      /**< Clear Toggle Output 0 */
#define _LETIMER_CMD_CTO0_SHIFT              3                                 /**< Shift value for LETIMER_CTO0 */
#define _LETIMER_CMD_CTO0_MASK               0x8UL                             /**< Bit mask for LETIMER_CTO0 */
#define _LETIMER_CMD_CTO0_DEFAULT            0x00000000UL                      /**< Mode DEFAULT for LETIMER_CMD */
#define LETIMER_CMD_CTO0_DEFAULT             (_LETIMER_CMD_CTO0_DEFAULT << 3)  /**< Shifted mode DEFAULT for LETIMER_CMD */
#define LETIMER_CMD_CTO1                     (0x1UL << 4)                      /**< Clear Toggle Output 1 */
#define _LETIMER_CMD_CTO1_SHIFT              4                                 /**< Shift value for LETIMER_CTO1 */
#define _LETIMER_CMD_CTO1_MASK               0x10UL                            /**< Bit mask for LETIMER_CTO1 */
#define _LETIMER_CMD_CTO1_DEFAULT            0x00000000UL                      /**< Mode DEFAULT for LETIMER_CMD */
#define LETIMER_CMD_CTO1_DEFAULT             (_LETIMER_CMD_CTO1_DEFAULT << 4)  /**< Shifted mode DEFAULT for LETIMER_CMD */

/* Bit fields for LETIMER STATUS */
#define _LETIMER_STATUS_RESETVALUE           0x00000000UL                           /**< Default value for LETIMER_STATUS */
#define _LETIMER_STATUS_MASK                 0x00000001UL                           /**< Mask for LETIMER_STATUS */
#define LETIMER_STATUS_RUNNING               (0x1UL << 0)                           /**< LETIMER Running */
#define _LETIMER_STATUS_RUNNING_SHIFT        0                                      /**< Shift value for LETIMER_RUNNING */
#define _LETIMER_STATUS_RUNNING_MASK         0x1UL                                  /**< Bit mask for LETIMER_RUNNING */
#define _LETIMER_STATUS_RUNNING_DEFAULT      0x00000000UL                           /**< Mode DEFAULT for LETIMER_STATUS */
#define LETIMER_STATUS_RUNNING_DEFAULT       (_LETIMER_STATUS_RUNNING_DEFAULT << 0) /**< Shifted mode DEFAULT for LETIMER_STATUS */

/* Bit fields for LETIMER CNT */
#define _LETIMER_CNT_RESETVALUE              0x00000000UL                    /**< Default value for LETIMER_CNT */
#define _LETIMER_CNT_MASK                    0x0000FFFFUL                    /**< Mask for LETIMER_CNT */
#define _LETIMER_CNT_CNT_SHIFT               0                               /**< Shift value for LETIMER_CNT */
#define _LETIMER_CNT_CNT_MASK                0xFFFFUL                        /**< Bit mask for LETIMER_CNT */
#define _LETIMER_CNT_CNT_DEFAULT             0x00000000UL                    /**< Mode DEFAULT for LETIMER_CNT */
#define LETIMER_CNT_CNT_DEFAULT              (_LETIMER_CNT_CNT_DEFAULT << 0) /**< Shifted mode DEFAULT for LETIMER_CNT */

/* Bit fields for LETIMER COMP0 */
#define _LETIMER_COMP0_RESETVALUE            0x00000000UL                        /**< Default value for LETIMER_COMP0 */
#define _LETIMER_COMP0_MASK                  0x0000FFFFUL                        /**< Mask for LETIMER_COMP0 */
#define _LETIMER_COMP0_COMP0_SHIFT           0                                   /**< Shift value for LETIMER_COMP0 */
#define _LETIMER_COMP0_COMP0_MASK            0xFFFFUL                            /**< Bit mask for LETIMER_COMP0 */
#define _LETIMER_COMP0_COMP0_DEFAULT         0x00000000UL                        /**< Mode DEFAULT for LETIMER_COMP0 */
#define LETIMER_COMP0_COMP0_DEFAULT          (_LETIMER_COMP0_COMP0_DEFAULT << 0) /**< Shifted mode DEFAULT for LETIMER_COMP0 */

/* Bit fields for LETIMER COMP1 */
#define _LETIMER_COMP1_RESETVALUE            0x00000000UL                        /**< Default value for LETIMER_COMP1 */
#define _LETIMER_COMP1_MASK                  0x0000FFFFUL                        /**< Mask for LETIMER_COMP1 */
#define _LETIMER_COMP1_COMP1_SHIFT           0                                   /**< Shift value for LETIMER_COMP1 */
#define _LETIMER_COMP1_COMP1_MASK            0xFFFFUL                            /**< Bit mask for LETIMER_COMP1 */
#define _LETIMER_COMP1_COMP1_DEFAULT         0x00000000UL                        /**< Mode DEFAULT for LETIMER_COMP1 */
#define LETIMER_COMP1_COMP1_DEFAULT          (_LETIMER_COMP1_COMP1_DEFAULT << 0) /**< Shifted mode DEFAULT for LETIMER_COMP1 */

/* Bit fields for LETIMER REP0 */
#define _LETIMER_REP0_RESETVALUE             0x00000000UL                      /**< Default value for LETIMER_REP0 */
#define _LETIMER_REP0_MASK                   0x000000FFUL                      /**< Mask for LETIMER_REP0 */
#define _LETIMER_REP0_REP0_SHIFT             0                                 /**< Shift value for LETIMER_REP0 */
#define _LETIMER_REP0_REP0_MASK              0xFFUL                            /**< Bit mask for LETIMER_REP0 */
#define _LETIMER_REP0_REP0_DEFAULT           0x00000000UL                      /**< Mode DEFAULT for LETIMER_REP0 */
#define LETIMER_REP0_REP0_DEFAULT            (_LETIMER_REP0_REP0_DEFAULT << 0) /**< Shifted mode DEFAULT for LETIMER_REP0 */

/* Bit fields for LETIMER REP1 */
#define _LETIMER_REP1_RESETVALUE             0x00000000UL                      /**< Default value for LETIMER_REP1 */
#define _LETIMER_REP1_MASK                   0x000000FFUL                      /**< Mask for LETIMER_REP1 */
#define _LETIMER_REP1_REP1_SHIFT             0                                 /**< Shift value for LETIMER_REP1 */
#define _LETIMER_REP1_REP1_MASK              0xFFUL                            /**< Bit mask for LETIMER_REP1 */
#define _LETIMER_REP1_REP1_DEFAULT           0x00000000UL                      /**< Mode DEFAULT for LETIMER_REP1 */
#define LETIMER_REP1_REP1_DEFAULT            (_LETIMER_REP1_REP1_DEFAULT << 0) /**< Shifted mode DEFAULT for LETIMER_REP1 */

/* Bit fields for LETIMER IF */
#define _LETIMER_IF_RESETVALUE               0x00000000UL                     /**< Default value for LETIMER_IF */
#define _LETIMER_IF_MASK                     0x0000001FUL                     /**< Mask for LETIMER_IF */
#define LETIMER_IF_COMP0                     (0x1UL << 0)                     /**< Compare Match 0 Interrupt Flag */
#define _LETIMER_IF_COMP0_SHIFT              0                                /**< Shift value for LETIMER_COMP0 */
#define _LETIMER_IF_COMP0_MASK               0x1UL                            /**< Bit mask for LETIMER_COMP0 */
#define _LETIMER_IF_COMP0_DEFAULT            0x00000000UL                     /**< Mode DEFAULT for LETIMER_IF */
#define LETIMER_IF_COMP0_DEFAULT             (_LETIMER_IF_COMP0_DEFAULT << 0) /**< Shifted mode DEFAULT for LETIMER_IF */
#define LETIMER_IF_COMP1                     (0x1UL << 1)                     /**< Compare Match 1 Interrupt Flag */
#define _LETIMER_IF_COMP1_SHIFT              1                                /**< Shift value for LETIMER_COMP1 */
#define _LETIMER_IF_COMP1_MASK               0x2UL                            /**< Bit mask for LETIMER_COMP1 */
#define _LETIMER_IF_COMP1_DEFAULT            0x00000000UL                     /**< Mode DEFAULT for LETIMER_IF */
#define LETIMER_IF_COMP1_DEFAULT             (_LETIMER_IF_COMP1_DEFAULT << 1) /**< Shifted mode DEFAULT for LETIMER_IF */
#define LETIMER_IF_UF                        (0x1UL << 2)                     /**< Underflow Interrupt Flag */
#define _LETIMER_IF_UF_SHIFT                 2                                /**< Shift value for LETIMER_UF */
#define _LETIMER_IF_UF_MASK                  0x4UL                            /**< Bit mask for LETIMER_UF */
#define _LETIMER_IF_UF_DEFAULT               0x00000000UL                     /**< Mode DEFAULT for LETIMER_IF */
#define LETIMER_IF_UF_DEFAULT                (_LETIMER_IF_UF_DEFAULT << 2)    /**< Shifted mode DEFAULT for LETIMER_IF */
#define LETIMER_IF_REP0                      (0x1UL << 3)                     /**< Repeat Counter 0 Interrupt Flag */
#define _LETIMER_IF_REP0_SHIFT               3                                /**< Shift value for LETIMER_REP0 */
#define _LETIMER_IF_REP0_MASK                0x8UL                            /**< Bit mask for LETIMER_REP0 */
#define _LETIMER_IF_REP0_DEFAULT             0x00000000UL                     /**< Mode DEFAULT for LETIMER_IF */
#define LETIMER_IF_REP0_DEFAULT              (_LETIMER_IF_REP0_DEFAULT << 3)  /**< Shifted mode DEFAULT for LETIMER_IF */
#define LETIMER_IF_REP1                      (0x1UL << 4)                     /**< Repeat Counter 1 Interrupt Flag */
#define _LETIMER_IF_REP1_SHIFT               4                                /**< Shift value for LETIMER_REP1 */
#define _LETIMER_IF_REP1_MASK                0x10UL                           /**< Bit mask for LETIMER_REP1 */
#define _LETIMER_IF_REP1_DEFAULT             0x00000000UL                     /**< Mode DEFAULT for LETIMER_IF */
#define LETIMER_IF_REP1_DEFAULT              (_LETIMER_IF_REP1_DEFAULT << 4)  /**< Shifted mode DEFAULT for LETIMER_IF */

/* Bit fields for LETIMER IFS */
#define _LETIMER_IFS_RESETVALUE              0x00000000UL                      /**< Default value for LETIMER_IFS */
#define _LETIMER_IFS_MASK                    0x0000001FUL                      /**< Mask for LETIMER_IFS */
#define LETIMER_IFS_COMP0                    (0x1UL << 0)                      /**< Set Compare Match 0 Interrupt Flag */
#define _LETIMER_IFS_COMP0_SHIFT             0                                 /**< Shift value for LETIMER_COMP0 */
#define _LETIMER_IFS_COMP0_MASK              0x1UL                             /**< Bit mask for LETIMER_COMP0 */
#define _LETIMER_IFS_COMP0_DEFAULT           0x00000000UL                      /**< Mode DEFAULT for LETIMER_IFS */
#define LETIMER_IFS_COMP0_DEFAULT            (_LETIMER_IFS_COMP0_DEFAULT << 0) /**< Shifted mode DEFAULT for LETIMER_IFS */
#define LETIMER_IFS_COMP1                    (0x1UL << 1)                      /**< Set Compare Match 1 Interrupt Flag */
#define _LETIMER_IFS_COMP1_SHIFT             1                                 /**< Shift value for LETIMER_COMP1 */
#define _LETIMER_IFS_COMP1_MASK              0x2UL                             /**< Bit mask for LETIMER_COMP1 */
#define _LETIMER_IFS_COMP1_DEFAULT           0x00000000UL                      /**< Mode DEFAULT for LETIMER_IFS */
#define LETIMER_IFS_COMP1_DEFAULT            (_LETIMER_IFS_COMP1_DEFAULT << 1) /**< Shifted mode DEFAULT for LETIMER_IFS */
#define LETIMER_IFS_UF                       (0x1UL << 2)                      /**< Set Underflow Interrupt Flag */
#define _LETIMER_IFS_UF_SHIFT                2                                 /**< Shift value for LETIMER_UF */
#define _LETIMER_IFS_UF_MASK                 0x4UL                             /**< Bit mask for LETIMER_UF */
#define _LETIMER_IFS_UF_DEFAULT              0x00000000UL                      /**< Mode DEFAULT for LETIMER_IFS */
#define LETIMER_IFS_UF_DEFAULT               (_LETIMER_IFS_UF_DEFAULT << 2)    /**< Shifted mode DEFAULT for LETIMER_IFS */
#define LETIMER_IFS_REP0                     (0x1UL << 3)                      /**< Set Repeat Counter 0 Interrupt Flag */
#define _LETIMER_IFS_REP0_SHIFT              3                                 /**< Shift value for LETIMER_REP0 */
#define _LETIMER_IFS_REP0_MASK               0x8UL                             /**< Bit mask for LETIMER_REP0 */
#define _LETIMER_IFS_REP0_DEFAULT            0x00000000UL                      /**< Mode DEFAULT for LETIMER_IFS */
#define LETIMER_IFS_REP0_DEFAULT             (_LETIMER_IFS_REP0_DEFAULT << 3)  /**< Shifted mode DEFAULT for LETIMER_IFS */
#define LETIMER_IFS_REP1                     (0x1UL << 4)                      /**< Set Repeat Counter 1 Interrupt Flag */
#define _LETIMER_IFS_REP1_SHIFT              4                                 /**< Shift value for LETIMER_REP1 */
#define _LETIMER_IFS_REP1_MASK               0x10UL                            /**< Bit mask for LETIMER_REP1 */
#define _LETIMER_IFS_REP1_DEFAULT            0x00000000UL                      /**< Mode DEFAULT for LETIMER_IFS */
#define LETIMER_IFS_REP1_DEFAULT             (_LETIMER_IFS_REP1_DEFAULT << 4)  /**< Shifted mode DEFAULT for LETIMER_IFS */

/* Bit fields for LETIMER IFC */
#define _LETIMER_IFC_RESETVALUE              0x00000000UL                      /**< Default value for LETIMER_IFC */
#define _LETIMER_IFC_MASK                    0x0000001FUL                      /**< Mask for LETIMER_IFC */
#define LETIMER_IFC_COMP0                    (0x1UL << 0)                      /**< Clear Compare Match 0 Interrupt Flag */
#define _LETIMER_IFC_COMP0_SHIFT             0                                 /**< Shift value for LETIMER_COMP0 */
#define _LETIMER_IFC_COMP0_MASK              0x1UL                             /**< Bit mask for LETIMER_COMP0 */
#define _LETIMER_IFC_COMP0_DEFAULT           0x00000000UL                      /**< Mode DEFAULT for LETIMER_IFC */
#define LETIMER_IFC_COMP0_DEFAULT            (_LETIMER_IFC_COMP0_DEFAULT << 0) /**< Shifted mode DEFAULT for LETIMER_IFC */
#define LETIMER_IFC_COMP1                    (0x1UL << 1)                      /**< Clear Compare Match 1 Interrupt Flag */
#define _LETIMER_IFC_COMP1_SHIFT             1                                 /**< Shift value for LETIMER_COMP1 */
#define _LETIMER_IFC_COMP1_MASK              0x2UL                             /**< Bit mask for LETIMER_COMP1 */
#define _LETIMER_IFC_COMP1_DEFAULT           0x00000000UL                      /**< Mode DEFAULT for LETIMER_IFC */
#define LETIMER_IFC_COMP1_DEFAULT            (_LETIMER_IFC_COMP1_DEFAULT << 1) /**< Shifted mode DEFAULT for LETIMER_IFC */
#define LETIMER_IFC_UF                       (0x1UL << 2)                      /**< Clear Underflow Interrupt Flag */
#define _LETIMER_IFC_UF_SHIFT                2                                 /**< Shift value for LETIMER_UF */
#define _LETIMER_IFC_UF_MASK                 0x4UL                             /**< Bit mask for LETIMER_UF */
#define _LETIMER_IFC_UF_DEFAULT              0x00000000UL                      /**< Mode DEFAULT for LETIMER_IFC */
#define LETIMER_IFC_UF_DEFAULT               (_LETIMER_IFC_UF_DEFAULT << 2)    /**< Shifted mode DEFAULT for LETIMER_IFC */
#define LETIMER_IFC_REP0                     (0x1UL << 3)                      /**< Clear Repeat Counter 0 Interrupt Flag */
#define _LETIMER_IFC_REP0_SHIFT              3                                 /**< Shift value for LETIMER_REP0 */
#define _LETIMER_IFC_REP0_MASK               0x8UL                             /**< Bit mask for LETIMER_REP0 */
#define _LETIMER_IFC_REP0_DEFAULT            0x00000000UL                      /**< Mode DEFAULT for LETIMER_IFC */
#define LETIMER_IFC_REP0_DEFAULT             (_LETIMER_IFC_REP0_DEFAULT << 3)  /**< Shifted mode DEFAULT for LETIMER_IFC */
#define LETIMER_IFC_REP1                     (0x1UL << 4)                      /**< Clear Repeat Counter 1 Interrupt Flag */
#define _LETIMER_IFC_REP1_SHIFT              4                                 /**< Shift value for LETIMER_REP1 */
#define _LETIMER_IFC_REP1_MASK               0x10UL                            /**< Bit mask for LETIMER_REP1 */
#define _LETIMER_IFC_REP1_DEFAULT            0x00000000UL                      /**< Mode DEFAULT for LETIMER_IFC */
#define LETIMER_IFC_REP1_DEFAULT             (_LETIMER_IFC_REP1_DEFAULT << 4)  /**< Shifted mode DEFAULT for LETIMER_IFC */

/* Bit fields for LETIMER IEN */
#define _LETIMER_IEN_RESETVALUE              0x00000000UL                      /**< Default value for LETIMER_IEN */
#define _LETIMER_IEN_MASK                    0x0000001FUL                      /**< Mask for LETIMER_IEN */
#define LETIMER_IEN_COMP0                    (0x1UL << 0)                      /**< Compare Match 0 Interrupt Enable */
#define _LETIMER_IEN_COMP0_SHIFT             0                                 /**< Shift value for LETIMER_COMP0 */
#define _LETIMER_IEN_COMP0_MASK              0x1UL                             /**< Bit mask for LETIMER_COMP0 */
#define _LETIMER_IEN_COMP0_DEFAULT           0x00000000UL                      /**< Mode DEFAULT for LETIMER_IEN */
#define LETIMER_IEN_COMP0_DEFAULT            (_LETIMER_IEN_COMP0_DEFAULT << 0) /**< Shifted mode DEFAULT for LETIMER_IEN */
#define LETIMER_IEN_COMP1                    (0x1UL << 1)                      /**< Compare Match 1 Interrupt Enable */
#define _LETIMER_IEN_COMP1_SHIFT             1                                 /**< Shift value for LETIMER_COMP1 */
#define _LETIMER_IEN_COMP1_MASK              0x2UL                             /**< Bit mask for LETIMER_COMP1 */
#define _LETIMER_IEN_COMP1_DEFAULT           0x00000000UL                      /**< Mode DEFAULT for LETIMER_IEN */
#define LETIMER_IEN_COMP1_DEFAULT            (_LETIMER_IEN_COMP1_DEFAULT << 1) /**< Shifted mode DEFAULT for LETIMER_IEN */
#define LETIMER_IEN_UF                       (0x1UL << 2)                      /**< Underflow Interrupt Enable */
#define _LETIMER_IEN_UF_SHIFT                2                                 /**< Shift value for LETIMER_UF */
#define _LETIMER_IEN_UF_MASK                 0x4UL                             /**< Bit mask for LETIMER_UF */
#define _LETIMER_IEN_UF_DEFAULT              0x00000000UL                      /**< Mode DEFAULT for LETIMER_IEN */
#define LETIMER_IEN_UF_DEFAULT               (_LETIMER_IEN_UF_DEFAULT << 2)    /**< Shifted mode DEFAULT for LETIMER_IEN */
#define LETIMER_IEN_REP0                     (0x1UL << 3)                      /**< Repeat Counter 0 Interrupt Enable */
#define _LETIMER_IEN_REP0_SHIFT              3                                 /**< Shift value for LETIMER_REP0 */
#define _LETIMER_IEN_REP0_MASK               0x8UL                             /**< Bit mask for LETIMER_REP0 */
#define _LETIMER_IEN_REP0_DEFAULT            0x00000000UL                      /**< Mode DEFAULT for LETIMER_IEN */
#define LETIMER_IEN_REP0_DEFAULT             (_LETIMER_IEN_REP0_DEFAULT << 3)  /**< Shifted mode DEFAULT for LETIMER_IEN */
#define LETIMER_IEN_REP1                     (0x1UL << 4)                      /**< Repeat Counter 1 Interrupt Enable */
#define _LETIMER_IEN_REP1_SHIFT              4                                 /**< Shift value for LETIMER_REP1 */
#define _LETIMER_IEN_REP1_MASK               0x10UL                            /**< Bit mask for LETIMER_REP1 */
#define _LETIMER_IEN_REP1_DEFAULT            0x00000000UL                      /**< Mode DEFAULT for LETIMER_IEN */
#define LETIMER_IEN_REP1_DEFAULT             (_LETIMER_IEN_REP1_DEFAULT << 4)  /**< Shifted mode DEFAULT for LETIMER_IEN */

/* Bit fields for LETIMER FREEZE */
#define _LETIMER_FREEZE_RESETVALUE           0x00000000UL                             /**< Default value for LETIMER_FREEZE */
#define _LETIMER_FREEZE_MASK                 0x00000001UL                             /**< Mask for LETIMER_FREEZE */
#define LETIMER_FREEZE_REGFREEZE             (0x1UL << 0)                             /**< Register Update Freeze */
#define _LETIMER_FREEZE_REGFREEZE_SHIFT      0                                        /**< Shift value for LETIMER_REGFREEZE */
#define _LETIMER_FREEZE_REGFREEZE_MASK       0x1UL                                    /**< Bit mask for LETIMER_REGFREEZE */
#define _LETIMER_FREEZE_REGFREEZE_DEFAULT    0x00000000UL                             /**< Mode DEFAULT for LETIMER_FREEZE */
#define _LETIMER_FREEZE_REGFREEZE_UPDATE     0x00000000UL                             /**< Mode UPDATE for LETIMER_FREEZE */
#define _LETIMER_FREEZE_REGFREEZE_FREEZE     0x00000001UL                             /**< Mode FREEZE for LETIMER_FREEZE */
#define LETIMER_FREEZE_REGFREEZE_DEFAULT     (_LETIMER_FREEZE_REGFREEZE_DEFAULT << 0) /**< Shifted mode DEFAULT for LETIMER_FREEZE */
#define LETIMER_FREEZE_REGFREEZE_UPDATE      (_LETIMER_FREEZE_REGFREEZE_UPDATE << 0)  /**< Shifted mode UPDATE for LETIMER_FREEZE */
#define LETIMER_FREEZE_REGFREEZE_FREEZE      (_LETIMER_FREEZE_REGFREEZE_FREEZE << 0)  /**< Shifted mode FREEZE for LETIMER_FREEZE */

/* Bit fields for LETIMER SYNCBUSY */
#define _LETIMER_SYNCBUSY_RESETVALUE         0x00000000UL                           /**< Default value for LETIMER_SYNCBUSY */
#define _LETIMER_SYNCBUSY_MASK               0x0000003FUL                           /**< Mask for LETIMER_SYNCBUSY */
#define LETIMER_SYNCBUSY_CTRL                (0x1UL << 0)                           /**< CTRL Register Busy */
#define _LETIMER_SYNCBUSY_CTRL_SHIFT         0                                      /**< Shift value for LETIMER_CTRL */
#define _LETIMER_SYNCBUSY_CTRL_MASK          0x1UL                                  /**< Bit mask for LETIMER_CTRL */
#define _LETIMER_SYNCBUSY_CTRL_DEFAULT       0x00000000UL                           /**< Mode DEFAULT for LETIMER_SYNCBUSY */
#define LETIMER_SYNCBUSY_CTRL_DEFAULT        (_LETIMER_SYNCBUSY_CTRL_DEFAULT << 0)  /**< Shifted mode DEFAULT for LETIMER_SYNCBUSY */
#define LETIMER_SYNCBUSY_CMD                 (0x1UL << 1)                           /**< CMD Register Busy */
#define _LETIMER_SYNCBUSY_CMD_SHIFT          1                                      /**< Shift value for LETIMER_CMD */
#define _LETIMER_SYNCBUSY_CMD_MASK           0x2UL                                  /**< Bit mask for LETIMER_CMD */
#define _LETIMER_SYNCBUSY_CMD_DEFAULT        0x00000000UL                           /**< Mode DEFAULT for LETIMER_SYNCBUSY */
#define LETIMER_SYNCBUSY_CMD_DEFAULT         (_LETIMER_SYNCBUSY_CMD_DEFAULT << 1)   /**< Shifted mode DEFAULT for LETIMER_SYNCBUSY */
#define LETIMER_SYNCBUSY_COMP0               (0x1UL << 2)                           /**< COMP0 Register Busy */
#define _LETIMER_SYNCBUSY_COMP0_SHIFT        2                                      /**< Shift value for LETIMER_COMP0 */
#define _LETIMER_SYNCBUSY_COMP0_MASK         0x4UL                                  /**< Bit mask for LETIMER_COMP0 */
#define _LETIMER_SYNCBUSY_COMP0_DEFAULT      0x00000000UL                           /**< Mode DEFAULT for LETIMER_SYNCBUSY */
#define LETIMER_SYNCBUSY_COMP0_DEFAULT       (_LETIMER_SYNCBUSY_COMP0_DEFAULT << 2) /**< Shifted mode DEFAULT for LETIMER_SYNCBUSY */
#define LETIMER_SYNCBUSY_COMP1               (0x1UL << 3)                           /**< COMP1 Register Busy */
#define _LETIMER_SYNCBUSY_COMP1_SHIFT        3                                      /**< Shift value for LETIMER_COMP1 */
#define _LETIMER_SYNCBUSY_COMP1_MASK         0x8UL                                  /**< Bit mask for LETIMER_COMP1 */
#define _LETIMER_SYNCBUSY_COMP1_DEFAULT      0x00000000UL                           /**< Mode DEFAULT for LETIMER_SYNCBUSY */
#define LETIMER_SYNCBUSY_COMP1_DEFAULT       (_LETIMER_SYNCBUSY_COMP1_DEFAULT << 3) /**< Shifted mode DEFAULT for LETIMER_SYNCBUSY */
#define LETIMER_SYNCBUSY_REP0                (0x1UL << 4)                           /**< REP0 Register Busy */
#define _LETIMER_SYNCBUSY_REP0_SHIFT         4                                      /**< Shift value for LETIMER_REP0 */
#define _LETIMER_SYNCBUSY_REP0_MASK          0x10UL                                 /**< Bit mask for LETIMER_REP0 */
#define _LETIMER_SYNCBUSY_REP0_DEFAULT       0x00000000UL                           /**< Mode DEFAULT for LETIMER_SYNCBUSY */
#define LETIMER_SYNCBUSY_REP0_DEFAULT        (_LETIMER_SYNCBUSY_REP0_DEFAULT << 4)  /**< Shifted mode DEFAULT for LETIMER_SYNCBUSY */
#define LETIMER_SYNCBUSY_REP1                (0x1UL << 5)                           /**< REP1 Register Busy */
#define _LETIMER_SYNCBUSY_REP1_SHIFT         5                                      /**< Shift value for LETIMER_REP1 */
#define _LETIMER_SYNCBUSY_REP1_MASK          0x20UL                                 /**< Bit mask for LETIMER_REP1 */
#define _LETIMER_SYNCBUSY_REP1_DEFAULT       0x00000000UL                           /**< Mode DEFAULT for LETIMER_SYNCBUSY */
#define LETIMER_SYNCBUSY_REP1_DEFAULT        (_LETIMER_SYNCBUSY_REP1_DEFAULT << 5)  /**< Shifted mode DEFAULT for LETIMER_SYNCBUSY */

/* Bit fields for LETIMER ROUTE */
#define _LETIMER_ROUTE_RESETVALUE            0x00000000UL                           /**< Default value for LETIMER_ROUTE */
#define _LETIMER_ROUTE_MASK                  0x00000703UL                           /**< Mask for LETIMER_ROUTE */
#define LETIMER_ROUTE_OUT0PEN                (0x1UL << 0)                           /**< Output 0 Pin Enable */
#define _LETIMER_ROUTE_OUT0PEN_SHIFT         0                                      /**< Shift value for LETIMER_OUT0PEN */
#define _LETIMER_ROUTE_OUT0PEN_MASK          0x1UL                                  /**< Bit mask for LETIMER_OUT0PEN */
#define _LETIMER_ROUTE_OUT0PEN_DEFAULT       0x00000000UL                           /**< Mode DEFAULT for LETIMER_ROUTE */
#define LETIMER_ROUTE_OUT0PEN_DEFAULT        (_LETIMER_ROUTE_OUT0PEN_DEFAULT << 0)  /**< Shifted mode DEFAULT for LETIMER_ROUTE */
#define LETIMER_ROUTE_OUT1PEN                (0x1UL << 1)                           /**< Output 1 Pin Enable */
#define _LETIMER_ROUTE_OUT1PEN_SHIFT         1                                      /**< Shift value for LETIMER_OUT1PEN */
#define _LETIMER_ROUTE_OUT1PEN_MASK          0x2UL                                  /**< Bit mask for LETIMER_OUT1PEN */
#define _LETIMER_ROUTE_OUT1PEN_DEFAULT       0x00000000UL                           /**< Mode DEFAULT for LETIMER_ROUTE */
#define LETIMER_ROUTE_OUT1PEN_DEFAULT        (_LETIMER_ROUTE_OUT1PEN_DEFAULT << 1)  /**< Shifted mode DEFAULT for LETIMER_ROUTE */
#define _LETIMER_ROUTE_LOCATION_SHIFT        8                                      /**< Shift value for LETIMER_LOCATION */
#define _LETIMER_ROUTE_LOCATION_MASK         0x700UL                                /**< Bit mask for LETIMER_LOCATION */
#define _LETIMER_ROUTE_LOCATION_LOC0         0x00000000UL                           /**< Mode LOC0 for LETIMER_ROUTE */
#define _LETIMER_ROUTE_LOCATION_DEFAULT      0x00000000UL                           /**< Mode DEFAULT for LETIMER_ROUTE */
#define _LETIMER_ROUTE_LOCATION_LOC1         0x00000001UL                           /**< Mode LOC1 for LETIMER_ROUTE */
#define _LETIMER_ROUTE_LOCATION_LOC2         0x00000002UL                           /**< Mode LOC2 for LETIMER_ROUTE */
#define _LETIMER_ROUTE_LOCATION_LOC3         0x00000003UL                           /**< Mode LOC3 for LETIMER_ROUTE */
#define LETIMER_ROUTE_LOCATION_LOC0          (_LETIMER_ROUTE_LOCATION_LOC0 << 8)    /**< Shifted mode LOC0 for LETIMER_ROUTE */
#define LETIMER_ROUTE_LOCATION_DEFAULT       (_LETIMER_ROUTE_LOCATION_DEFAULT << 8) /**< Shifted mode DEFAULT for LETIMER_ROUTE */
#define LETIMER_ROUTE_LOCATION_LOC1          (_LETIMER_ROUTE_LOCATION_LOC1 << 8)    /**< Shifted mode LOC1 for LETIMER_ROUTE */
#define LETIMER_ROUTE_LOCATION_LOC2          (_LETIMER_ROUTE_LOCATION_LOC2 << 8)    /**< Shifted mode LOC2 for LETIMER_ROUTE */
#define LETIMER_ROUTE_LOCATION_LOC3          (_LETIMER_ROUTE_LOCATION_LOC3 << 8)    /**< Shifted mode LOC3 for LETIMER_ROUTE */

/** @} End of group EFM32WG_LETIMER */
/** @} End of group Parts */


text:
var ValueParser = require('./lib/value-expr-parser').parser,
    stringHash = require('string-hash');

var docs = require('../documentation');
var type_values = require('../type_values');
var expressions = {};

function addExpression(property) {
    if (property !== null && property.source !== "") {
        expressions[property.source] = true;
    }
}

function expand(expression) {
    var result = "";
    var expandedValue = expression;

    while (expandedValue !== result) {
        result = expandedValue;
        expandedValue = result.replace(/<([-_a-zA-Z]+)>/g, function(typeRef, typeName) {
            if (type_values.hasOwnProperty(typeName)) {
                return "[" + type_values[typeName] + "]";
            }
            else {
                console.error("ERROR: unknown type-ref '%s'", typeRef);
                return typeRef;
            }
        });
    }

    return result;
}

function parse(expression) {
    try {
        return ValueParser.parse(expression);
    }
    catch(e) {
        console.error("Error parsing '%s'\n", expression);
        console.error(e);

        return null;
    }
}

// collect styler type expressions

Object.keys(docs.stylers).forEach(function(stylerName) {
    var styler = docs.stylers[stylerName];

    Object.keys(styler.properties).forEach(function(propertyName) {
        addExpression(styler.properties[propertyName]);
    });
});

// collect control type expressions

Object.keys(docs.controls).forEach(function(controlName) {
    var control = docs.controls[controlName];

    Object.keys(control.properties).forEach(function(propertyName) {
        addExpression(control.properties[propertyName]);
    });
});

// collection type expressions

Object.keys(type_values).forEach(function(valueName) {
    expressions[type_values[valueName]] = true;
});

// create aggregate

var result = {};

Object.keys(expressions).sort().forEach(function(expression) {
    var minified = expression.replace(/\s+/g, "");
    var expansion = expand(expression);

    result[minified] = {
        source: expression,
        expansion: expansion,
        hash: stringHash(minified),
        ast: parse(expansion)
    };
});

console.log(JSON.stringify(result, null, 2));


text:
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = require("tslib");
var utils = tslib_1.__importStar(require("./utils"));
var anonymousFunc = /(<anonymous>|Function):(\d+):(\d+)/;
/**
 * This is a centralized class of any error that could be thrown internally (mostly by the parser).
 * Besides standard .message it keeps some additional data like a path to the file where the error
 * occurred along with line and column numbers.
 *
 * @class
 * @extends Error
 * @type {module.LessError}
 *
 * @prop {string} type
 * @prop {string} filename
 * @prop {number} index
 * @prop {number} line
 * @prop {number} column
 * @prop {number} callLine
 * @prop {number} callExtract
 * @prop {string[]} extract
 *
 * @param {Object} e              - An error object to wrap around or just a descriptive object
 * @param {Object} fileContentMap - An object with file contents in 'contents' property (like importManager) @todo - move to fileManager?
 * @param {string} [currentFilename]
 */
var LessError = function (e, fileContentMap, currentFilename) {
    Error.call(this);
    var filename = e.filename || currentFilename;
    this.message = e.message;
    this.stack = e.stack;
    if (fileContentMap && filename) {
        var input = fileContentMap.contents[filename];
        var loc = utils.getLocation(e.index, input);
        var line = loc.line;
        var col = loc.column;
        var callLine = e.call && utils.getLocation(e.call, input).line;
        var lines = input ? input.split('\n') : '';
        this.type = e.type || 'Syntax';
        this.filename = filename;
        this.index = e.index;
        this.line = typeof line === 'number' ? line + 1 : null;
        this.column = col;
        if (!this.line && this.stack) {
            var found = this.stack.match(anonymousFunc);
            /**
             * We have to figure out how this environment stringifies anonymous functions
             * so we can correctly map plugin errors.
             *
             * Note, in Node 8, the output of anonymous funcs varied based on parameters
             * being present or not, so we inject dummy params.
             */
            var func = new Function('a', 'throw new Error()');
            var lineAdjust = 0;
            try {
                func();
            }
            catch (e) {
                var match = e.stack.match(anonymousFunc);
                var line = parseInt(match[2]);
                lineAdjust = 1 - line;
            }
            if (found) {
                if (found[2]) {
                    this.line = parseInt(found[2]) + lineAdjust;
                }
                if (found[3]) {
                    this.column = parseInt(found[3]);
                }
            }
        }
        this.callLine = callLine + 1;
        this.callExtract = lines[callLine];
        this.extract = [
            lines[this.line - 2],
            lines[this.line - 1],
            lines[this.line]
        ];
    }
};
if (typeof Object.create === 'undefined') {
    var F = function () { };
    F.prototype = Error.prototype;
    LessError.prototype = new F();
}
else {
    LessError.prototype = Object.create(Error.prototype);
}
LessError.prototype.constructor = LessError;
/**
 * An overridden version of the default Object.prototype.toString
 * which uses additional information to create a helpful message.
 *
 * @param {Object} options
 * @returns {string}
 */
LessError.prototype.toString = function (options) {
    options = options || {};
    var message = '';
    var extract = this.extract || [];
    var error = [];
    var stylize = function (str) { return str; };
    if (options.stylize) {
        var type = typeof options.stylize;
        if (type !== 'function') {
            throw Error("options.stylize should be a function, got a " + type + "!");
        }
        stylize = options.stylize;
    }
    if (this.line !== null) {
        if (typeof extract[0] === 'string') {
            error.push(stylize(this.line - 1 + " " + extract[0], 'grey'));
        }
        if (typeof extract[1] === 'string') {
            var errorTxt = this.line + " ";
            if (extract[1]) {
                errorTxt += extract[1].slice(0, this.column) +
                    stylize(stylize(stylize(extract[1].substr(this.column, 1), 'bold') +
                        extract[1].slice(this.column + 1), 'red'), 'inverse');
            }
            error.push(errorTxt);
        }
        if (typeof extract[2] === 'string') {
            error.push(stylize(this.line + 1 + " " + extract[2], 'grey'));
        }
        error = error.join('\n') + stylize('', 'reset') + "\n";
    }
    message += stylize(this.type + "Error: " + this.message, 'red');
    if (this.filename) {
        message += stylize(' in ', 'red') + this.filename;
    }
    if (this.line) {
        message += stylize(" on line " + this.line + ", column " + (this.column + 1) + ":", 'grey');
    }
    message += "\n" + error;
    if (this.callLine) {
        message += stylize('from ', 'red') + (this.filename || '') + "/n";
        message += stylize(this.callLine, 'grey') + " " + this.callExtract + "/n";
    }
    return message;
};
exports.default = LessError;
//# sourceMappingURL=less-error.js.map


text:
<?xml version="1.0" encoding="UTF-8"?>

		<item value="800" key="DIALOG_WIDTH"/>
		<item value=", com.altera.sbtgui.launch.hardware.Nios2HardwareLaunchConfiguration, " key="org.eclipse.debug.ui.EXPANDED_NODES"/>
		<item value="640" key="DIALOG_HEIGHT"/>
		<item value="237" key="org.eclipse.debug.ui.DIALOG_SASH_WEIGHTS_1"/>
		<item value="1|Microsoft YaHei UI|9.0|0|WINDOWS|1|-12|0|0|0|400|0|0|0|1|0|0|0|0|Microsoft YaHei UI" key="DIALOG_FONT_NAME"/>
		<item value="762" key="org.eclipse.debug.ui.DIALOG_SASH_WEIGHTS_2"/>


text:
package se.west.second.gnat;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;

@XmlAccessorType(XmlAccessType.FIELD)
public class SecondFoo {

    // Internal state
    private String secondBar;
}


text:
shared_examples 'a request error' do
  context 'API' do
    let(:response_body) { "{\"error\": {\"text\": \"error message\", \"id\": \"INTERNAL_ERROR\"}}" }
    let(:bad_response)  { double('response', status: 400, body: response_body) }

    it 'should raise an error' do
      client.stub_chain(:connection, :get).and_return(bad_response)
      expect { request }.to raise_error(Yelp::Error::InternalError)
    end
  end
end


text:
package org.tinyj.lava;

/**
 * A function maps its argument to a result.
 *

 * This is the exception declaring version of {@link java.util.function.Function}
 *

 * While not strictly required it usually is expected that subsequent
 * invocations with the same argument yield equal results.
 *

 * This is a functional interface whose functional method is
 * {@link #checkedApply}.
 *
 * @param <X> the function's argument type
 * @param <R> the function's result type
 * @param <E> upper limit of thrown exception types
 */
@FunctionalInterface
public interface LavaFunction<X, R, E extends Exception> {

  /**
   * Apply the function to an argument
   *
   * @param x argument to map
   * @return the function's result
   */
  R checkedApply(X x) throws E;

  /**
   * Safely casts between different {@link LavaFunction} parametrization
   *
   * @param <X> accepted argument type
   * @param <R> required result type
   * @param <E> required exception limit
   * @param function function to adopt
   * @return {@code function} casted to the compatible parametrization {@link LavaFunction}{@code <X, R, E>}
   */
  @SuppressWarnings("unchecked")
  static <X, R, E extends Exception>
  LavaFunction<X, R, E> castDown(LavaFunction<? super X, ? extends R, ? extends E> function) {
    return (LavaFunction<X, R, E>) function;
  }
}


text:
"use strict";
Error.stackTraceLimit = 1/0;
const Assert = require("assert").strict;
require("../../tree.js").toggleDebugMode();

const ParseExternal = require("../../parse-external.js");
const Tree = require("../../tree.js");
const Lang = require("../../lang");
const State = require("../state.js");
const Completion = require("../completion.js");
const Scope = require("../scope");
const Visit = require("./index.js");

Visit.initializeTest(
  [
    require("./other.js"),
    require("./pattern.js"),
    require("./closure.js"),
    require("./class.js"),
    require("./expression.js"),
    require("./link-statement.js"),
    require("./hoisted-statement.js"),
    require("./statement.js"),
    require("./block.js")]);

State.runSession({nodes:[], serials:new Map(), evals:{__proto__:null}}, () => {

  // // PROGRAM >> Empty //
  // Lang.match(
  //   Visit.visitProgram(
  //     Scope.RootScope({strict:true}),
  //     ParseExternal(
  //       ``,
  //       {source:"script"}),
  //     {source:"script"}),
  //   Lang.parseProgram(`{
  //     let $this;
  //     $this = #aran.globalObjectRecord;
  //     completion void 0; }`),
  //   Assert);

  // PROGRAM >> Module //
  Lang.match(
    Visit.visitProgram(
      Scope.RootScope({strict:true}),
      ParseExternal(
        `
          !i;
          export function f () { 123; };
          import * as i from "source";`,
        {source:"module"}),
      {source:"module"}),
    Lang.parseProgram(`
      module;
      export f;
      import * from "source";
      {
        let $this, $f, _prototype;
        (
          $f = void 0,
          export f $f);
        $this = #aran.globalObjectRecord;
        (
          $f = (
            _prototype = {__proto__:#Object.prototype},
            ${Lang.generate(
              Visit.visitClosure(
                Scope.RootScope({strict:true}),
                ParseExternal(`(function f () { 123; })`).body[0].expression,
                {prototype:Scope.TestBox("_prototype")}))}),
          export f $f);
        !import * from "source";
        completion void 0; }`),
    Assert);

  // PROGRAM >> Eval (global) //
  Lang.match(
    Visit.visitProgram(
      Scope.RootScope({strict:true}),
      ParseExternal(`
        123;
        foo: bar: function f () { 456; };
        789;`),
      {source:null}),
    Lang.parseProgram(`
      eval;
      {
        let $this, $f, _completion, _prototype;
        $f = void 0;
        _completion = void 0;
        $this = #aran.globalObjectRecord;
        $f = (
          _prototype = {__proto__:#Object.prototype},
          ${Lang.generate(
            Visit.visitClosure(
              Scope.RootScope({strict:true}),
              ParseExternal(`(function f () { 456; })`).body[0].expression,
              {prototype:Scope.TestBox("_prototype")}))});
        123;
        _completion = 789;
        completion _completion; }`),
    Assert);

  // PROGRAM >> Eval (Local) //
  Lang.match(
    Visit.visitProgram(
      Scope.RootScope({strict:true}),
      ParseExternal(`
        123;`),
      {source:["$x", "$y"]}),
    Lang.parseProgram(`
      eval §$x §$y;
      {
        let _completion;
        _completion = void 0;
        _completion = 123;
        completion _completion; }`),
    Assert);

  // PROGRAM >> Script //
  Lang.match(
    Visit.visitProgram(
      Scope.RootScope(),
      ParseExternal(`
        "use strict";
        123;
        debugger;`),
      {source:"script"}),
    Lang.parseProgram(`
      script;
      {
        let $this, _completion;
        _completion = void 0;
        $this = #aran.globalObjectRecord;
        "use strict";
        _completion = 123;
        debugger;
        completion _completion; }`),
    Assert);

  // Block >> node.type === BlockStatement && Hoisting //
  Lang.match(
    Visit.visitProgram(
      Scope.RootScope({strict:true}),
      ParseExternal(`{
        123;
        function f () { 456; } }`),
      {source:null}),
    Lang.parseProgram(`
      eval;
      {
        let $this, $f, _completion;
        $f = void 0;
        _completion = void 0;
        $this = #aran.globalObjectRecord;
        {
          let _prototype;
          $f = (
            _prototype = {__proto__:#Object.prototype},
            ${Lang.generate(
              Visit.visitClosure(
                Scope.RootScope({strict:true}),
                ParseExternal(`(function f () { 456; })`).body[0].expression,
                {prototype:Scope.TestBox("_prototype")}))});
          _completion = 123;
          completion void 0; }
        completion _completion; }`),
    Assert);

  // Block >> node.type !== BlockStatement && context.with !== null //
  Lang.match(
    Visit.visitProgram(
      Scope.RootScope(),
      ParseExternal(`with (123) 456;`),
      {source:"script"}),
    Lang.parseProgram(`
      script;
      {
        let $this, _completion, _frame;
        _completion = void 0;
        $this = #aran.globalObjectRecord;
        _completion = void 0;
        _frame = 123;
        _frame = (
          (
            (_frame === null) ?
            true :
            (_frame === void 0)) ?
          throw new #TypeError("Cannot convert undefined or null to object") :
          #Object(_frame));
        {
          _completion = 456;
          completion void 0; }
        completion _completion; }`),
    Assert);

  // Block >> reset === true //
  Lang.match(
    Visit.visitProgram(
      Scope.RootScope(),
      ParseExternal(`try { 123; } catch { 456; }`),
      {source:"script"}),
    Lang.parseProgram(`
      script;
      {
        let $this, _completion;
        _completion = void 0;
        $this = #aran.globalObjectRecord;
        _completion = void 0;
        try {
          _completion = 123;
          completion void 0; }
        catch {
          _completion = void 0;
          _completion = 456;
          completion void 0; }
        finally {
          completion void 0; }
        completion _completion; }`),
    Assert);

  // CLOSURE_BODY >> node.type !== "BlockStatement" //
  Lang.match(
    Visit.visitClosureBody(
      Scope.RootScope(),
      ParseExternal(`123;`).body[0].expression,
      {bindings:[]}),
    Lang.parseBlock(`{
      return 123;
      completion void 0; }`),
    Assert);

  // CLOSURE_BODY >> dynamic //
    Lang.match(
      Visit.visitClosureBody(
        Scope.RootScope(),
        ParseExternal(`eval(123);`).body[0].expression,
        {bindings:[]}),
      Lang.parseBlock(`{
        let _frame, _eval;
        _frame = {__proto__:null};
        return (
          _eval = (
            #Reflect.has(_frame, "eval") ?
            #Reflect.get(_frame, "eval") :
             throw new #ReferenceError("Cannot read from missing variable eval")),
          (
            (_eval === #eval) ?
            eval §_frame §_eval 123 :
            _eval(123)));
        completion void 0; }`),
      Assert);

  // CLOSURE_BODY >> bindings //
    Lang.match(
      Visit.visitClosureBody(
        Scope.RootScope(),
        ParseExternal(`{ var x = 123, y = 456; function f () { 789 } }`).body[0],
        {
          bindings: [
            {
              identifier: "x",
              box: Scope.PrimitiveBox("x-value")},
            {
              identifier: "y",
              box: Scope.PrimitiveBox("y-value")}]}),
      Lang.parseBlock(`{
        let $x, $y, $f, _prototype;
        $x = void 0;
        $y = void 0;
        $f = void 0;
        $x = "x-value";
        $y = "y-value";
        $f = (
          _prototype = {__proto__:#Object.prototype},
          ${Lang.generate(
            Visit.visitClosure(
              Scope.RootScope(),
              ParseExternal(`(function f () { 789; })`).body[0].expression,
              {prototype:Scope.TestBox("_prototype")}))});
        $x = 123;
        $y = 456;
        completion void 0; }`),
      Assert);

  // SWITCH //
  Lang.match(
    Visit.visitProgram(
      Scope.RootScope({strict:true}),
      ParseExternal(
        `
          switch (!1) {
            case 2:
              3;
              let x = 4;
              function f () { 5; }
            default:
              x;
              6; }`),
      {source:null}),
    Lang.parseProgram(`
      eval;
      {
        let $this, $f, _completion, _discriminant, _matched;
        $f = void 0;
        _completion = void 0;
        $this = #aran.globalObjectRecord;
        _completion = void 0;
        _discriminant = !1;
        _matched = false;
        $: {
          let $x, _x, _prototype;
          _x = false;
          $f = (
            _prototype = {__proto__:#Object.prototype},
            ${Lang.generate(
              Visit.visitClosure(
                Scope.RootScope({strict:true}),
                ParseExternal(`(function f () { 5; })`).body[0].expression,
                {prototype:Scope.TestBox("_prototype")}))});
          if (
            (
              _matched ?
              true :
              (
                (_discriminant === 2) ?
                (
                  _matched = true,
                  true) :
                false)))
            {
              3;
              ($x = 4, _x = true);
              completion void 0; } else
            {
              completion void 0; }
          _matched = true;
          {
            (
              _x ?
              $x :
              throw new #ReferenceError("Cannot read from non-initialized static variable named x"));
            _completion = 6;
            completion void 0; }
          completion void 0; }
        completion _completion; }`),
    Assert);

});


text:
"""
Helper methods for database operations.

Each function takes a database cursor as its first parameter. The caller is responsible for
ensuring the proper transaction semantics are preserved and lock starvation is minimized.

"""

from collections import Counter

from ob2.util.time import now_str
from ob2.util.assignments import get_assignment_name_set
from ob2.util.build_constants import QUEUED
from ob2.util.config_data import get_repo_type
from ob2.util.group_constants import ACCEPTED

def get_next_autoincrementing_value(c, option_name):
    c.execute('''SELECT value FROM options WHERE key = ?''', [option_name])
    results = c.fetchall()
    if not results:
        next_value = 1
        c.execute('''INSERT INTO options (key, value) VALUES (?, ?)''', [option_name,
                                                                         str(next_value)])
    else:
        (current_value,), = results
        next_value = int(current_value) + 1
        c.execute('''UPDATE options SET value = ? WHERE key = ?''', [str(next_value),
                                                                     option_name])
    return next_value

def get_repo_owners(c, repo_name):
    """
    Given the name of a repository, return the list of users (user id's) that own the repository.
    An empty list may be returned if no users match.

    """
    repo_type = get_repo_type(repo_name)
    if repo_type == "group":
        c.execute('''SELECT users.id
                     FROM groupsusers LEFT JOIN users ON groupsusers.user = users.id
                     WHERE groupsusers.`group` = ?''', [repo_name])
        return [user_id for user_id, in c.fetchall()]
    elif repo_type == "personal":
        c.execute('''SELECT id FROM users WHERE login = ? LIMIT 1''', [repo_name])
        try:
            id, = c.fetchone()
            return [id]
        except TypeError:
            return []

def get_groups(c, user_id):
    c.execute('''SELECT `group` FROM groupsusers WHERE user = ?''', [user_id])
    return [group for group, in c.fetchall()]

def get_grouplimit(c, user_id):
    c.execute('''SELECT grouplimit FROM users WHERE id = ?''', [user_id])
    try:
        grouplimit, = c.fetchone()
        return grouplimit
    except TypeError:
        pass

def modify_grouplimit(c, user_id, modification=-1):
    c.execute("UPDATE users SET grouplimit = grouplimit + ? WHERE id = ?", [modification, user_id])

def finalize_group_if_ready(c, invitation_id):
    c.execute('''SELECT users.id, users.name, users.email, users.github, invitations.status
                 FROM invitations LEFT JOIN users ON invitations.user = users.id
                 WHERE invitations.invitation_id = ?''', [invitation_id])
    members = c.fetchall()
    for _, _, _, _, status in members:
        if status != ACCEPTED:
            return None, []
    for _, _, _, github, _ in members:
        if not github:
            raise RuntimeError("finalize_group_if_ready: Group finalized with unregistered student")
    c.execute("DELETE FROM invitations WHERE invitation_id = ?", [invitation_id])
    group_number = get_next_autoincrementing_value(c, "group_next_group_number")
    group_name = "group%d" % (group_number)
    for user, _, _, _, _ in members:
        c.execute("INSERT INTO groupsusers (user, `group`) VALUES (?, ?)", [user, group_name])
    group_members = [(user_id, name, email, github) for user_id, name, email, github, _ in members]
    return group_name, group_members

def get_user_by_id(c, user_id):
    c.execute('''SELECT id, name, sid, login, github, email FROM users
                 WHERE id = ?''', [user_id])
    return c.fetchone()

def get_users_by_ids(c, user_ids):
    c.execute('''SELECT id, name, sid, login, github, email FROM users
                 WHERE id IN (%s)''' % (",".join(["?"] * len(user_ids))), user_ids)
    return {row[0]: row for row in c.fetchall()}

def get_user_by_github(c, github):
    c.execute('''SELECT id, name, sid, login, github, email FROM users
                 WHERE github = ?''', [github])
    return c.fetchone()

def get_user_by_login(c, login):
    c.execute('''SELECT id, name, sid, login, github, email FROM users
                 WHERE login = ?''', [login])
    return c.fetchone()

def get_user_by_student_id(c, sid):
    c.execute('''SELECT id, name, sid, login, github, email FROM users
                 WHERE sid = ?''', [sid])
    return c.fetchone()

def get_users_by_identifier(c, identifier):
    """
    Looks up a list of users based on an identifier, for the enter-grades script. If the identifier
    is ambiguous (see get_valid_ambiguous_identifiers), then the behavior of this function is
    undefined.

    Always returns a list (but it may be empty).

    """
    for field in ("login", "sid", "name"):
        c.execute("SELECT id, name, sid, login, github, email FROM users WHERE %s = ?" % field,
                  [identifier])
        user = c.fetchone()
        if user:
            return [user]
    c.execute('''SELECT id, name, sid, login, github, email
                 FROM groupsusers LEFT JOIN users ON groupsusers.user = users.id
                 WHERE `group` = ?''', [identifier])
    return c.fetchall()

def get_valid_ambiguous_identifiers(c):
    c.execute("SELECT sid, login, name FROM users")
    identifiers_counter = Counter([identifier for user in c.fetchall()
                                   for identifier in user if identifier])
    c.execute("SELECT distinct `group` FROM groupsusers")
    identifiers_counter.update([group for group, in c.fetchall() if group])
    get_key = lambda(key, count): key
    get_count = lambda(key, count): count
    valid_identifiers = map(get_key, filter(lambda i: get_count(i) == 1,
                                            identifiers_counter.viewitems()))
    ambiguous_identifiers = map(get_key, filter(lambda i: get_count(i) > 1,
                                                identifiers_counter.viewitems()))
    return valid_identifiers, ambiguous_identifiers

def get_super(c, user_id):
    c.execute("SELECT super FROM users WHERE id = ?", [user_id])
    try:
        super_, = c.fetchone()
        return super_
    except TypeError:
        pass

def get_photo(c, user_id):
    c.execute("SELECT photo FROM users WHERE id = ?", [user_id])
    try:
        photo, = c.fetchone()
        return buffer(photo)
    except TypeError:
        pass

def create_build(c, job_name, source, commit, message):
    build_number = get_next_autoincrementing_value(c, "dockergrader_last_build_number")
    build_name = "%s-build-%d" % (job_name, build_number)
    c.execute('''INSERT INTO builds (build_name, source, `commit`, message, job, status, score,
                 started, updated, log) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
              [build_name, source, commit, message, job_name, QUEUED, 0.0, now_str(),
               now_str(), None])
    return build_name

def assign_grade_batch(c, users, assignment, score, slipunits, transaction_name, description,
                       source, manual=False, dont_lower=False):
    """
    Assigns a new grade to one or more students. Also supports assigning slip units. You can use
    the special value `None` for score and/or slipunits to use the current value. If the dont_lower
    flag is True, then anybody in `users` who currently has a higher grade will be removed from
    the operation (and slip days will not be adjusted either).

    Returns a list of user ids whose grades were affected (will always be a subset of users).

    """
    if assignment not in get_assignment_name_set():
        raise ValueError("Assignment %s is not known" % assignment)
    if not users:
        return []
    if score is None and slipunits is None:
        return []
    timestamp = now_str()

    if dont_lower:
        if score is None:
            # It makes no sense to do this.
            raise ValueError("You can not use both dont_lower=True and have a score of None, if " +
                             "slipunits is not None.")

        # This comparison (old score vs new score) MUST be done in Sqlite in order for the result
        # to be correct. Sqlite will round the floating point number in the same way it did when
        # the original result was inserted, and the two values will be equal. Converting this to a
        # float in another language may produce undesirable effects.
        c.execute('''SELECT user FROM grades
                     WHERE assignment = ? AND score >= ? AND user IN (%s)''' %
                  (','.join(['?'] * len(users))), [assignment, score] + users)
        users = list(set(users) - {user for user, in c.fetchall()})
        if not users:
            return []

    c.execute('''SELECT users.id FROM grades LEFT JOIN users
                 ON grades.user = users.id WHERE grades.assignment = ? AND users.id IN (%s)''' %
              (','.join(["?"] * len(users))), [assignment] + users)
    for user in list(set(users) - {user for user, in c.fetchall()}):
        # Insert dummy values first, and we will update them later
        c.execute('''INSERT INTO grades (user, assignment) VALUES (?, ?)''',
                  [user, assignment])

    c.execute('''UPDATE grades SET updated = ?, manual = ?
                 WHERE assignment = ? AND user IN (%s)''' % (','.join(['?'] * len(users))),
              [timestamp, int(manual), assignment] + users)

    if score is not None:
        c.execute('''UPDATE grades SET score = ?
                     WHERE assignment = ? AND user IN (%s)''' % (','.join(['?'] * len(users))),
                  [score, assignment] + users)

    if slipunits is not None:
        c.execute('''UPDATE grades SET slipunits = ?
                     WHERE assignment = ? AND user IN (%s)''' % (','.join(['?'] * len(users))),
                  [slipunits, assignment] + users)

    c.execute('''INSERT INTO gradeslog (transaction_name, description, source, updated, user,
                                        assignment, score, slipunits)
                 VALUES %s''' % (','.join(['(?,?,?,?,?,?,?,?)'] * len(users))),
              [field for entry in [[transaction_name, description, source, timestamp, user,
                                    assignment, score, slipunits]
                                   for user in users] for field in entry])
    return users


text:
    <java-class-file name="D:\Experiments\Analisi di Sopravvivenza\Progetto16715\ProgettiDaAnalizzare\jhotdraw\JHotDraw 7.4.1\JHotDraw 7.4.1\Source\jhotdraw7\src\main\java\org\jhotdraw\draw\handle\AbstractHandle.java">
        <package-decl name="org.jhotdraw.draw.handle"/>
        <class name="AbstractHandle" visibility="public" abstract="true">
            <constructor visibility="public" name="AbstractHandle">
            </constructor>
            <method name="getHandlesize" visibility="protected">
            </method>
            <method name="addHandleListener" visibility="public">
            </method>
            <method name="removeHandleListener" visibility="public">
            </method>
            <method name="getOwner" visibility="public">
            </method>
            <method name="setView" visibility="public">
            </method>
            <method name="getView" visibility="public">
            </method>
            <method name="getEditor" visibility="public">
            </method>
            <method name="fireAreaInvalidated" visibility="protected">
            </method>
            <method name="fireUndoableEditHappened" visibility="protected">
            </method>
            <method name="fireHandleRequestRemove" visibility="protected">
            </method>
            <method name="fireHandleRequestSecondaryHandles" visibility="protected">
            </method>
            <method name="draw" visibility="public">
            </method>
            <method name="drawCircle" visibility="protected">
            </method>
            <method name="drawRectangle" visibility="protected">
            </method>
            <method name="drawDiamond" visibility="protected">
            </method>
            <method name="contains" visibility="public">
            </method>
            <method name="invalidate" visibility="public">
            </method>
            <method name="dispose" visibility="public">
            </method>
            <method name="areaInvalidated" visibility="public">
            </method>
            <method name="figureAdded" visibility="public">
            </method>
            <method name="figureRemoved" visibility="public">
            </method>
            <method name="figureRequestRemove" visibility="public">
            </method>
            <method name="figureChanged" visibility="public">
            </method>
            <method name="getCursor" visibility="public">
            </method>
            <method name="isCombinableWith" visibility="public">
            </method>
            <method name="keyTyped" visibility="public">
            </method>
            <method name="keyReleased" visibility="public">
            </method>
            <method name="keyPressed" visibility="public">
            </method>
            <method name="getBounds" visibility="public" final="true">
            </method>
            <method name="getDrawingArea" visibility="public">
            </method>
            <method name="basicGetBounds" visibility="protected" abstract="true">
            </method>
            <method name="updateBounds" visibility="protected">
            </method>
            <method name="trackDoubleClick" visibility="public">
            </method>
            <method name="attributeChanged" visibility="public">
            </method>
            <method name="viewTransformChanged" visibility="public">
            </method>
            <method name="createSecondaryHandles" visibility="public">
            </method>
            <method name="getToolTipText" visibility="public">
            </method>
            <method name="setToolTipText" visibility="public">
            </method>
            <method name="figureHandlesChanged" visibility="public">
            </method>
        </class>
    </java-class-file>


text:
using System.Collections.Generic;
using System.Collections.ObjectModel;

namespace NAntScriptBuilder
{
    /// <summary>
    /// Defaults for building an nant script
    /// </summary>
    public static class Defaults
    {
        public static readonly ReadOnlyCollection<string> Includes;
        public static readonly Dictionary<string,string> SystemReferences;

        static Defaults()
        {
            var defIncludes = new List<string>();
            // default includes per nant docs:
            // http://nant.sourceforge.net/release/latest/help/tasks/script.html
            defIncludes.Add("System");
            defIncludes.Add("System.Collections");
            defIncludes.Add("System.IO");
            defIncludes.Add("System.Text");
            defIncludes.Add("NAnt.Core");
            defIncludes.Add("NAnt.Core.Attributes");
            Includes = new ReadOnlyCollection<string>(defIncludes);

            // just a list of known System imports that need a reference to the dll
            // this list is definitely not complete, but for what I need right now it works
            SystemReferences = new Dictionary<string, string>();
            SystemReferences.Add("System.Xml", "System.Xml.dll");
            SystemReferences.Add("System.Configuration", "System.configuration.dll");
        }
    }

    /// <summary>
    /// Extension Methods
    /// </summary>
    public static class Ext
    {
        /// <summary>
        /// simple util function to determine if a string has any data
        /// </summary>
        /// <param name="s"></param>
        /// <returns></returns>
        public static bool IsNotEmpty(this string s)
        {
            return !string.IsNullOrEmpty(s.Trim());
        }
    }
}


text:
add_library( dutils_img_filter_neon STATIC

	"by_edge/by_edge.h"
	"by_edge/by_edge_internal.h"
	"by_edge/by8_edge_neonv8_v0.cpp"

	"transform/fcc1x_packed/fcc1x_packed_to_fcc.h"
	"transform/fcc1x_packed/fcc1x_packed_to_fcc8_neon_v0.cpp"
	"transform/fcc1x_packed/fcc1x_packed_to_fcc16_neon_v0.cpp"

	"transform/fcc1x_packed/transform_fcc1x_to_fcc8.h"
	"transform/fcc1x_packed/transform_fcc1x_to_fcc8_neon.cpp"

	"filter/whitebalance/wb_apply.h"
	"filter/whitebalance/wb_apply_neon.cpp"
	"filter/whitebalance/wb_apply_by8_neon.cpp"
	"filter/whitebalance/wb_apply_by16_neon.cpp"

	"transform/mono_to_bgr/transform_mono_to_bgr_neon.cpp"

	"transform/fcc8_fcc16/transform_fcc8_fcc16_neon_v0.cpp"
)

target_link_libraries( dutils_img_filter_neon
PUBLIC
	dutils_img::dutils_img_filter_c
PRIVATE
	dutils_img::project_options
	dutils_img::project_warnings
)

if( ${CMAKE_SYSTEM_PROCESSOR} MATCHES "aarch64" )

elseif( ${CMAKE_SYSTEM_PROCESSOR} MATCHES "arm" )

target_compile_options( dutils_img_filter_neon PUBLIC -mfpu=neon-vfpv4 )	# This is needed as a minimum for building this neon code in arm32 mode

endif()

add_library( dutils_img::img_filter_optimized ALIAS dutils_img_filter_neon )


text:
[bits 16]
push 0		; 6A 00 - equivalent to push byte 0
push byte 0	; 6A 00
push word 0	; 6A 00 - optimized
push dword 0	; 66 68 00000000
push strict byte 0	; 6A 00
push strict word 0	; 68 0000
push strict dword 0	; 66 68 00000000
push 128	; 68 8000 - doesn't fit in byte, equivalent to push word 128
push byte 128	; 6A 80 - warning (signed overflow)
push word 128	; 68 8000
push dword 128	; 66 68 80000000
push strict byte 128	; 6A 80 - warning (signed overflow)
push strict word 128	; 68 8000
push strict dword 128	; 66 68 80000000

[bits 32]
push 0		; 6A 00 - equivalent to push byte 0
push byte 0	; 6A 00
push word 0	; 66 68 0000
push dword 0	; 6A 00 - optimized
push strict byte 0	; 6A 00
push strict word 0	; 66 68 0000
push strict dword 0	; 68 00000000
push 128	; 68 80000000 - doesn't fit in byte -> push dword 128
push byte 128	; 6A 80 - warning (signed overflow)
push word 128	; 66 6A 8000
push dword 128	; 6A 80000000
push strict byte 128	; 6A 80 - warning (signed overflow)
push strict word 128	; 66 6A 8000
push strict dword 128	; 6A 80000000

[bits 64]
push 0		; same as bits 32 output
push byte 0
push word 0
push dword 0	; optimized to byte
push strict byte 0
push strict word 0
push strict dword 0
push 128
push byte 128	; warning
push word 128
push dword 128
push strict byte 128	; warning
push strict word 128
push strict dword 128


text:
<?php
/**
 * Created by IntelliJ IDEA.
 * User: Maxim
 * Date: 20/08/13
 * Time: 11:30
 * To change this template use File | Settings | File Templates.
 */

namespace Maxim\Module\TicketBundle\Routing;
use Symfony\Component\Config\Loader\Loader;
use Symfony\Component\Routing\RouteCollection;
use Symfony\Component\Config\Loader\LoaderInterface;
use Symfony\Component\Config\Loader\LoaderResolverInterface;
use Symfony\Component\Config\FileLocator;
use Symfony\Component\Routing\Loader\YamlFileLoader;
use Symfony\Component\Finder\Finder;
class RouteLoader extends Loader implements LoaderInterface {

    private $loaded = false;

    public function load($resource, $type = null)
    {
        if (true === $this->loaded) {
            throw new \RuntimeException('Do not add this loader twice');
        }

        $collection = new RouteCollection();

        $resource = __DIR__ . '/../Resources/config';
        $locator    = new FileLocator($resource);
        $loader     = new YamlFileLoader($locator);

        $collection->addCollection($loader->load('routing.yml'));
        $collection->addCollection($loader->load('routing_admin.yml'));

        $this->loaded = true;

        return $collection;
    }

    public function supports($resource, $type = null)
    {
        return 'module' === $type;
    }

    public function reload()
    {
        $this->loaded = false;
    }

    public function getResolver()
    {
    }
    public function setResolver(LoaderResolverInterface $resolver)
    {
        // irrelevant to us, since we don't need a resolver
    }
}


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

package org.chromium.chromecast.shell;

import android.content.Context;

import org.chromium.base.Log;
import org.chromium.base.annotations.CalledByNative;
import org.chromium.base.annotations.JNINamespace;
import org.chromium.chromecast.base.ChromecastConfigAndroid;

/**
 * JNI wrapper class for accessing CastCrashHandler.
 */
@JNINamespace("chromecast")
public final class CastCrashHandler {
    private static final String TAG = "cr.CastCrashHandler";

    @CalledByNative
    public static void initializeUploader(Context context, String crashDumpPath,
            boolean uploadCrashToStaging) {
        CastCrashUploader uploader = new CastCrashUploader(crashDumpPath, uploadCrashToStaging);
        if (ChromecastConfigAndroid.canSendUsageStats(context)) {
            uploader.startPeriodicUpload();
        } else {
            Log.d(TAG, "Removing crash dumps instead of uploading");
            uploader.removeCrashDumps();
        }
    }
}


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
null

#### Original name
Lecidea shliidenii var. shliidenii

### Remarks
null


text:
package com.digits.sdk.android;

import android.content.Context;

import com.twitter.sdk.android.core.Callback;
import com.twitter.sdk.android.core.TwitterException;

import java.lang.ref.WeakReference;

import io.fabric.sdk.android.Fabric;

public abstract class DigitsCallback<T> extends Callback<T> {
    final DigitsController controller;
    private final WeakReference<Context> context;

    DigitsCallback(Context context, DigitsController controller) {

        this.context = new WeakReference<>(context);
        this.controller = controller;
    }

    @Override
    public void failure(TwitterException exception) {
        final DigitsException digitsException = DigitsException.create(controller.getErrors(),
                exception);
        Fabric.getLogger().e(Digits.TAG, "HTTP Error: " + exception.getMessage() + ", API Error: " +
                "" + digitsException.getErrorCode() + ", User Message: " + digitsException
                .getMessage());
        controller.handleError(context.get(), digitsException);
    }
}