text:
/*
  Sets up the basic audio routing, tests which audio formats are supported and parses the samples for the metronome ticks.
*/

import samples from './samples'
import {parseSamples} from './parse_audio'

let data
let masterGain
let compressor
let initialized = false

export let context = (function(){
  //console.log('init AudioContext')
  let ctx
  if(typeof window === 'object'){
    let AudioContext = window.AudioContext || window.webkitAudioContext
    if(AudioContext !== 'undefined'){
      ctx = new AudioContext()
    }
  }
  if(typeof ctx === 'undefined'){
    //@TODO: create dummy AudioContext for use in node, see: https://www.npmjs.com/package/audio-context
    context = {
      createGain: function(){
        return {
          gain: 1
        }
      },
      createOscillator: function(){},
    }
  }
  return ctx
}())

export function initAudio(){

  if(typeof context.createGainNode === 'undefined'){
    context.createGainNode = context.createGain
  }
  // check for older implementations of WebAudio
  data = {}
  let source = context.createBufferSource()
  data.legacy = false
  if(typeof source.start === 'undefined'){
    data.legacy = true
  }

  // set up the elementary audio nodes
  compressor = context.createDynamicsCompressor()
  compressor.connect(context.destination)
  masterGain = context.createGain()
  masterGain.connect(context.destination)
  masterGain.gain.value = 0.5
  initialized = true

  return new Promise((resolve, reject) => {

    parseSamples(samples).then(
      function onFulfilled(buffers){
        //console.log(buffers)
        // data.ogg = typeof buffers.emptyOgg !== 'undefined'
        // data.mp3 = typeof buffers.emptyMp3 !== 'undefined'
        data.lowtick = buffers.lowtick
        data.hightick = buffers.hightick
        if(data.ogg === false && data.mp3 === false){
          reject('No support for ogg nor mp3!')
        }else{
          resolve(data)
        }
      },
      function onRejected(){
        reject('Something went wrong while initializing Audio')
      }
    )
  })
}

let setMasterVolume = function(value: number = 0.5): void{
  if(initialized === false){
    console.warn('please call qambi.init() first')
  }else {
    setMasterVolume = function(value: number = 0.5){
      if(value > 1){
        console.info('maximal volume is 1.0, volume is set to 1.0');
      }
      value = value < 0 ? 0 : value > 1 ? 1 : value
      masterGain.gain.value = value;
    }
    setMasterVolume(value)
  }
}

let getMasterVolume = function(): void{
  if(initialized === false){
    console.warn('please call qambi.init() first')
  }else {
    getMasterVolume = function(){
      return masterGain.gain.value
    }
    return getMasterVolume()
  }
}

let getCompressionReduction = function(): void{
  if(initialized === false){
    console.warn('please call qambi.init() first')
  }else {
    getCompressionReduction = function(){
      return compressor.reduction.value
    }
    return getCompressionReduction()
  }
}

let enableMasterCompressor = function(): void{
  if(initialized === false){
    console.warn('please call qambi.init() first')
  }else {
    enableMasterCompressor = function(flag: boolean){
      if(flag){
        masterGain.disconnect(0);
        masterGain.connect(compressor);
        compressor.disconnect(0);
        compressor.connect(context.destination);
      }else{
        compressor.disconnect(0);
        masterGain.disconnect(0);
        masterGain.connect(context.destination);
      }
    }
    enableMasterCompressor()
  }
}

let configureMasterCompressor = function(cfg): void{
  /*
    readonly attribute AudioParam attack; // in Seconds
    readonly attribute AudioParam knee; // in Decibels
    readonly attribute AudioParam ratio; // unit-less
    readonly attribute AudioParam reduction; // in Decibels
    readonly attribute AudioParam release; // in Seconds
    readonly attribute AudioParam threshold; // in Decibels

    @see: http://webaudio.github.io/web-audio-api/#the-dynamicscompressornode-interface
  */
  if(initialized === false){
    console.warn('please call qambi.init() first')
  }else {
    configureMasterCompressor = function(cfg: {}){
      ({
        attack: compressor.attack = 0.003,
        knee: compressor.knee = 30,
        ratio: compressor.ratio = 12,
        reduction: compressor.reduction = 0,
        release: compressor.release = 0.250,
        threshold: compressor.threshold = -24,
      } = cfg)
    }
    configureMasterCompressor(cfg)
  }
}

export function getInitData(){
  return data
}

// this doesn't seem to be necessary anymore on iOS anymore
let unlockWebAudio = function(){
  let src = context.createOscillator()
  let gainNode = context.createGain()
  gainNode.gain.value = 0
  src.connect(gainNode)
  gainNode.connect(context.destination)
  if(typeof src.noteOn !== 'undefined'){
    src.start = src.noteOn
    src.stop = src.noteOff
  }
  src.start(0)
  src.stop(0.001)
  unlockWebAudio = function(){
    //console.log('already done')
  }
}

export {masterGain, unlockWebAudio, compressor as masterCompressor, setMasterVolume, getMasterVolume, getCompressionReduction, enableMasterCompressor, configureMasterCompressor}


text:
export enum LocationKey {
  // The light world locations
  KingsTomb,
  LightWorldSwamp,
  LinksHouse,
  SpiralCave,
  MimicCave,
  Tavern,
  ChickenHouse,
  AginahsCave,
  SahasrahlasHut,
  KakarikoWell,
  BlindsHut,
  ParadoxCave,
  BonkRocks,
  MiniMoldormCave,
  IceRodCave,
  BottleVendor,
  SahasrahlasReward,
  SickKid,
  BridgeHideout,
  EtherTablet,
  BombosTablet,
  KingZora,
  LostOldMan,
  PotionShop,
  ForestHideout,
  LumberjackTree,
  SpectacleRockCave,
  MirrorCave,
  GraveyardCliffCave,
  CheckerboardCave,
  Library,
  Mushroom,
  SpectacleRock,
  FloatingIsland,
  RaceMinigame,
  DesertWestLedge,
  LakeHyliaIsland,
  ZoraLedge,
  BuriedItem,
  SewerEscapeSideRoom,
  CastleSecretEntrance,
  CastleDungeon,
  Sanctuary,
  MadBatter,
  DwarfEscort,
  MasterSwordPedestal,
  SewerEscapeDarkRoom,
  WaterfallOfWishing,
  // The dark world locations
  BombableHut,
  CShapedHouse,
  MireHut,
  SuperBunnyCave,
  SpikeCave,
  HypeCave,
  HookshotCaveBottom,
  HookshotCaveTop,
  TreasureChestMinigame,
  StumpKid,
  PurpleChest,
  Catfish,
  HammerPegCave,
  BumperCave,
  Pyramid,
  DiggingGame,
  PyramidFairy
}

redpajama_set_name: RedPajamaGithub


text:
#import <Foundation/Foundation.h>
#if __has_include("BraintreeCore.h")
#import "BraintreeCore.h"
#else
#import <BraintreeCore/BraintreeCore.h>
#endif

NS_ASSUME_NONNULL_BEGIN

@interface BTAmericanExpressRewardsBalance : NSObject

/**
 @brief Optional. An error code when there was an issue fetching the rewards balance
 */
@property (nonatomic, nullable, copy) NSString *errorCode;

/**
 @brief Optional. An error message when there was an issue fetching the rewards balance
 */
@property (nonatomic, nullable, copy) NSString *errorMessage;

/**
 @brief Optional. The conversion rate associated with the rewards balance
 */
@property (nonatomic, nullable, copy) NSString *conversionRate;

/**
 @brief Optional. The currency amount associated with the rewards balance
 */
@property (nonatomic, nullable, copy) NSString *currencyAmount;

/**
 @brief Optional. The currency ISO code associated with the rewards balance
 */
@property (nonatomic, nullable, copy) NSString *currencyIsoCode;

/**
 @brief Optional. The request ID used when fetching the rewards balance
 */
@property (nonatomic, nullable, copy) NSString *requestId;

/**
 @brief Optional. The rewards amount associated with the rewards balance
 */
@property (nonatomic, nullable, copy) NSString *rewardsAmount;

/**
 @brief Optional. The rewards unit associated with the rewards balance
 */
@property (nonatomic, nullable, copy) NSString *rewardsUnit;

/**
 @brief Initialize with JSON from Braintree
 */
- (instancetype)initWithJSON:(BTJSON *)json;

@end

NS_ASSUME_NONNULL_END


text:
DEBUG = True
TEMPLATE_DEBUG = DEBUG

ADMINS = (
    # ('Your Name', 'your_email@example.com'),
)

MANAGERS = ADMINS

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
        'NAME': 'djangosaml',                      # Or path to database file if using sqlite3.
        'USER': 'root',                      # Not used with sqlite3.
        'PASSWORD': 'topole48',                  # Not used with sqlite3.
        'HOST': 'localhost',                      # Set to empty string for localhost. Not used with sqlite3.
        'PORT': '3306',                      # Set to empty string for default. Not used with sqlite3.
    }
}

# Local time zone for this installation. Choices can be found here:
# http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
# although not all choices may be available on all operating systems.
# On Unix systems, a value of None will cause Django to use the same
# timezone as the operating system.
# If running in a Windows environment this must be set to the same as your
# system time zone.
TIME_ZONE = 'America/Chicago'

# Language code for this installation. All choices can be found here:
# http://www.i18nguy.com/unicode/language-identifiers.html
LANGUAGE_CODE = 'en-us'

SITE_ID = 1

# If you set this to False, Django will make some optimizations so as not
# to load the internationalization machinery.
USE_I18N = True

# If you set this to False, Django will not format dates, numbers and
# calendars according to the current locale.
USE_L10N = True

# If you set this to False, Django will not use timezone-aware datetimes.
USE_TZ = True

# Absolute filesystem path to the directory that will hold user-uploaded files.
# Example: "/home/media/media.lawrence.com/media/"
MEDIA_ROOT = ''

# URL that handles the media served from MEDIA_ROOT. Make sure to use a
# trailing slash.
# Examples: "http://media.lawrence.com/media/", "http://example.com/media/"
MEDIA_URL = ''

# Absolute path to the directory static files should be collected to.
# Don't put anything in this directory yourself; store your static files
# in apps' "static/" subdirectories and in STATICFILES_DIRS.
# Example: "/home/media/media.lawrence.com/static/"
STATIC_ROOT = ''

# URL prefix for static files.
# Example: "http://media.lawrence.com/static/"
STATIC_URL = '/static/'

# Additional locations of static files
STATICFILES_DIRS = (
    # Put strings here, like "/home/html/static" or "C:/www/django/static".
    # Always use forward slashes, even on Windows.
    # Don't forget to use absolute paths, not relative paths.
)

# List of finder classes that know how to find static files in
# various locations.
STATICFILES_FINDERS = (
    'django.contrib.staticfiles.finders.FileSystemFinder',
    'django.contrib.staticfiles.finders.AppDirectoriesFinder',
#    'django.contrib.staticfiles.finders.DefaultStorageFinder',
)

# Make this unique, and don't share it with anybody.
SECRET_KEY = '-6v0pd)gqro#z3!id8!pth3%5(=%yrm1e+=%rox+w8e+3%f!b$'

# List of callables that know how to import templates from various sources.
TEMPLATE_LOADERS = (
    'django.template.loaders.filesystem.Loader',
    'django.template.loaders.app_directories.Loader',
#     'django.template.loaders.eggs.Loader',
)

MIDDLEWARE_CLASSES = (
    'django.middleware.common.CommonMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    # Uncomment the next line for simple clickjacking protection:
    # 'django.middleware.clickjacking.XFrameOptionsMiddleware',
)

ROOT_URLCONF = 'djangoSaml.urls'

# Python dotted path to the WSGI application used by Django's runserver.
WSGI_APPLICATION = 'djangoSaml.wsgi.application'

TEMPLATE_DIRS = (
    # Put strings here, like "/home/html/django_templates" or "C:/www/django/templates".
    # Always use forward slashes, even on Windows.
    # Don't forget to use absolute paths, not relative paths.
)

INSTALLED_APPS = (
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'djangosaml2',
    # Uncomment the next line to enable the admin:
    # 'django.contrib.admin',
    # Uncomment the next line to enable admin documentation:
    # 'django.contrib.admindocs',
)

# A sample logging configuration. The only tangible logging
# performed by this configuration is to send an email to
# the site admins on every HTTP 500 error when DEBUG=False.
# See http://docs.djangoproject.com/en/dev/topics/logging for
# more details on how to customize your logging configuration.
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'simple': {
            'format': '%(asctime)s %(levelname)s %(name)s %(message)s'
        },
    },
    'filters': {
        'require_debug_false': {
            '()': 'django.utils.log.RequireDebugFalse'
        }
    },
    'handlers': {
        'mail_admins': {
            'level': 'ERROR',
            'filters': ['require_debug_false'],
            'class': 'django.utils.log.AdminEmailHandler'
        },
        'default': {
            'level':'DEBUG',
            'class':'logging.handlers.RotatingFileHandler',
            'filename': '/home/ales/workspace/xlab-svn/alescernivec/trunk/projects/contrail/django-sso/djangoSaml/djangosaml.log',
            'maxBytes': 1024*1024*5, # 5 MB
            'backupCount': 5,
            'formatter':'simple',
        },
    },
    'loggers': {
        'django.request': {
            'handlers': ['mail_admins'],
            'level': 'ERROR',
            'propagate': True,
        },
	 'djangosaml2': {
	    'handlers': ['default'],
            'level': 'DEBUG',
	    'propagate': True,
        },
	 'saml2': {
         'handlers': ['default'],
            'level': 'DEBUG',
	    'propagate': True,
        },

    }
}

## SAML additions

AUTHENTICATION_BACKENDS = (
    'django.contrib.auth.backends.ModelBackend',
    'djangosaml2.backends.Saml2Backend',
)

LOGIN_URL = '/saml2/login/'

SESSION_EXPIRE_AT_BROWSER_CLOSE = True

from os import path
import saml2
BASEDIR = path.dirname(path.abspath(__file__))
SAML_CONFIG = {
  # full path to the xmlsec1 binary programm
  #'xmlsec_binary': '/usr/local/bin/xmlsec1',
  'xmlsec_binary': '/usr/local/bin/xmlsec1',

  # your entity id, usually your subdomain plus the url to the metadata view
  'entityid': 'http://localhost:8001/saml2/metadata/',

  # directory with attribute mapping
  'attribute_map_dir': path.join(BASEDIR, 'attributemaps'),

  # this block states what services we provide
  'service': {
      # we are just a lonely SP
      'sp' : {
          'name': 'Federated Django sample SP',
          'endpoints': {
              # url and binding to the assetion consumer service view
              # do not change the binding or service name
              'assertion_consumer_service': [
                  ('http://localhost:8001/saml2/acs/',
                   saml2.BINDING_HTTP_POST),
                  ],
              # url and binding to the single logout service view
              # do not change the binding or service name
              'single_logout_service': [
                  ('http://localhost:8001/saml2/ls/',
                   saml2.BINDING_HTTP_REDIRECT),
                  ],
              },

           # attributes that this project need to identify a user
          'required_attributes': ['username'],

           # attributes that may be useful to have but not required
          'optional_attributes': ['eduPersonAffiliation'],

          # in this section the list of IdPs we talk to are defined
          'idp': {
              # we do not need a WAYF service since there is
              # only an IdP defined here. This IdP should be
              # present in our metadata

              # the keys of this dictionary are entity ids
              'https://ec2-50-17-124-155.compute-1.amazonaws.com/simplesaml/saml2/idp/metadata.php': {
                  'single_sign_on_service': {
                      saml2.BINDING_HTTP_REDIRECT: 'https://ec2-50-17-124-155.compute-1.amazonaws.com/simplesaml/saml2/idp/SSOService.php',
                      },
                  'single_logout_service': {
                      saml2.BINDING_HTTP_REDIRECT: 'https://ec2-50-17-124-155.compute-1.amazonaws.com/simplesaml/saml2/idp/SingleLogoutService.php',
                      },
                  },

#              'http://0.0.0.0:9999/simplesaml/saml2/idp/metadata.php': {
#                  'single_sign_on_service': {
#                      saml2.BINDING_HTTP_REDIRECT: 'http://0.0.0.0:9999/simplesaml/saml2/idp/SSOService.php',
#                      },
#                  'single_logout_service': {
#                      saml2.BINDING_HTTP_REDIRECT: 'http://0.0.0.0:9999/simplesaml/saml2/idp/SingleLogoutService.php',
#                      },
#                  },

              },
          },
      },

  # where the remote metadata is stored
  'metadata': {
      'local': [path.join(BASEDIR, 'remote_metadata.xml')],
      },

  # set to 1 to output debugging information
  'debug': 1,

  # certificate
  'key_file': path.join(BASEDIR, 'mycert.key'),  # private part
  'cert_file': path.join(BASEDIR, 'mycert.pem'),  # public part

  # own metadata settings
  'contact_person': [
      {'given_name': 'Ales',
       'sur_name': 'Cernivec',
       'company': 'XLAB d.o.o.',
       'email_address': 'ales.cernivec@xlab.si',
       'contact_type': 'technical'},
      ],
  # you can set multilanguage information here
  'organization': {
      'name': [('Yaco Sistemas', 'es'), ('Yaco Systems', 'en')],
      'display_name': [('Yaco', 'es'), ('Yaco', 'en')],
      'url': [('http://www.yaco.es', 'es'), ('http://www.yaco.com', 'en')],
      },
  'valid_for': 24,  # how long is our metadata valid
  }


text:
struct A {
  A();
  A(const A &o);
  virtual ~A();
  int a;
};

struct B {
  B();
  int b;
  virtual B *clone(A);
};

// Converting from C* to B* requires a this adjustment.
struct C : A, B {
  C();
  int c;
  virtual C *clone(A); // expected-error {{cannot compile this non-trivial argument copy for thunk yet}}
};
B::B() {}  // force emission
C::C() {}  // force emission


text:
require 'chef/mixin/deep_merge'
require 'chef/mixin/shell_out'

class Chef
  class Knife
    class ScribeAdjust < Chef::Knife

      include Chef::Mixin::DeepMerge
      include Chef::Mixin::ShellOut

      deps do
        require_relative 'scribe_hire'
        require_relative 'scribe_copy'
      end

      TEMPLATE_HASH = { "author_name" => "",
        "author_email" => "",
        "description" => "",
        "adjustments" => []
      }

      ENVIRONMENT_ADJUSTMENT_TEMPLATE = {
        "action" => "merge",
        "type" => "environment",
        "search" => "name:my_environment_name",
        "adjustment" => { "default_attributes" => { },
          "override_attributes" => { },
          "cookbook_versions" => { }
        }
      }

      ROLE_ADJUSTMENT_TEMPLATE = {
        "action" => "merge",
        "type" => "role",
        "search" => "name:my_role_name",
        "adjustment" => { "default_attributes" => { },
          "override_attributes" => { },
          "run_list" => [ ]
        }
      }

      NODE_ADJUSTMENT_TEMPLATE = {
        "action" => "merge",
        "type" => "node",
        "search" => "name:my_node_name",
        "adjustment" => { "normal" => { },
          "run_list" => [ ],
        }
      }

      banner "knife scribe adjust FILE [FILE..]"

      option :generate,
      :short => "-g",
      :long  => "--generate",
      :description => "generate adjustment templates"

      option :document,
      :short => "-d",
      :long  => "--document",
      :description => "document with copy copy"

      option :dryrun,
      :long  => "--dryrun",
      :description => "do a test run"

      option :type,
      :short => "-t TYPE",
      :long  => "--type TYPE",
      :description => "generate adjustment templates [environemnt|node|role]",
      :default => "environment"

      option :chronicle_path,
      :short => "-p PATH",
      :long => "--chronicle-path PATH",
      :description => "Path to the directory where the chronicle should be located",
      :default => nil

      option :remote_name,
      :long => "--remote-name REMOTE_NAME",
      :description => "Name of the remote chronicle repository",
      :default => nil

      option :remote_url,
      :short => "-r REMOTE_URL",
      :long => "--remote-url REMOTE_URL",
      :description => "Url of the remote chronicle repository",
      :default => nil

      option :branch,
      :long => "--branch BRANCH_NAME",
      :description => "Name of the branch you want to use",
      :default => nil

      alias_method :action_merge, :merge
      alias_method :action_hash_only_merge, :hash_only_merge if respond_to?(:hash_only_merge)

      def changes
        @changes ||= {}
      end

      def descriptions
        @descriptions ||= []
      end

      def errors
        @errors ||= []
      end

      def run
        if @name_args[0].nil?
          show_usage
          ui.fatal("At least one adjustment file needs to be specified!")
          exit 1
        end
        if config[:generate] == true
          @name_args.each { |filename| generate_template(filename) }
        else
          parse_adjustments
        end
      end

      def generate_templates

      end

      def parse_adjustments
        @name_args.each do |filename|
          errors.push({ "name" => filename, "general" => nil, "adjustments" => {} })
          parse_adjustment_file(filename)
        end
        if errors?
          print_errors
          exit 1 unless config[:dryrun]
        end
        if config[:dryrun]
          diff
        else
          if config[:document] == true
            hire
            record_state
          end
          write_adjustments
          record_state(descriptions.join("\n").strip) if config[:document] == true
        end
      end

      def generate_template(filename)
        unless ["environment", "role", "node"].include?(config[:type])
          ui.fatal("Incorrect adjustment type! Only 'node', 'environment' or 'role' allowed.")
          exit 1
        end
        TEMPLATE_HASH["adjustments"] = [self.class.class_eval(config[:type].upcase + "_ADJUSTMENT_TEMPLATE")]
        File.open(filename, "w") { |file| file.write(JSON.pretty_generate(TEMPLATE_HASH)) }
      end

      def parse_adjustment_file(filename)
        if !File.exists?(filename)
          errors.last["general"] = "File does not exist!"
        else
          begin
            adjustment_file = File.open(filename, "r") { |file| JSON.load(file) }
            if adjustment_file_valid? adjustment_file
              adjustment_file["adjustments"].each_with_index do |adjustment, index|
                apply_adjustment(adjustment) if adjustment_valid?(adjustment, index)
              end
            end
            if adjustment_file["adjustments"].length > errors.last["adjustments"].length
              description = adjustment_file["description"]
              description += "[with errors]" if errors.last["adjustments"].size > 0
              descriptions.push(description)
            end
          rescue JSON::ParserError
            errors.last["general"] = "Malformed JSON!"
          end
        end
      end

      def apply_adjustment(adjustment)
        query = adjustment["search"].include?(":") ? adjustment["search"] : "name:" + adjustment["search"]
        Chef::Search::Query.new.search(adjustment["type"], query ) do |result|
          key = result.class.name.downcase + ":" + result.name
          prepared_hash = prepare_adjustment_subject(key, result)
          changes[key].store("adjusted", send(("action_" + adjustment["action"]).to_sym, prepared_hash, adjustment["adjustment"]))
        end
      end

      def prepare_adjustment_subject(key, chef_object)
        prepared_hash = prepare_object_hash(chef_object)
        if changes.has_key? key
          prepared_hash = changes[key]["adjusted"]
        else
          changes.store(key, { "original" => prepared_hash })
        end
        prepared_hash
      end

      def prepare_object_hash(chef_object)
        prepared_hash = chef_object.to_hash
        if prepared_hash["chef_type"] == "node"
          prepared_hash.reject! { |key, value| !(["name","chef_type","chef_environment","run_list"].include? key) }
          prepared_hash.merge!({ "normal" => chef_object.normal_attrs })
        end
        prepared_hash
      end

      def write_adjustments
        changes.values.each do |change|
          Chef.const_get(change["adjusted"]["chef_type"].capitalize).json_create(change["adjusted"]).save
        end
      end

      def adjustment_file_valid? adjustment_file
        unless adjustment_file.kind_of?(Hash)
          errors.last["general"] = "Adjustment file must contain a JSON hash!"
          return false
        end

        unless adjustment_file["adjustments"].kind_of?(Array)
          errors.last["general"] = "Adjustment file must contain an array of adjustments!"
          return false
        end
        true
      end

      def adjustment_valid?(adjustment, index)
        unless adjustment.kind_of?(Hash)
          errors.last["adjustments"].store(index,"Adjustment must be a JSON hash!")
          return false
        end

        ["action", "type", "search", "adjustment"].each do |required_key|
          unless adjustment.has_key?(required_key)
            errors.last["adjustments"].store(index, "Adjustment hash must contain " + required_key + "!")
            return false
          end
        end

        unless respond_to?("action_" + adjustment["action"])
          errors.last["adjustments"].store(index, "Incorrect action!")
          return false
        end
        true
      end

      def hire
        hired_scribe = Chef::Knife::ScribeHire.new
        [:chronicle_path, :remote_url, :remote_name].each { |key| hired_scribe.config[key] = config[key] }
        hired_scribe.run
      end

      def record_state(message = nil)
        if @copyist.nil?
          @copyist = Chef::Knife::ScribeCopy.new
          [:chronicle_path, :remote_name, :branch].each { |key| @copyist.config[key] = config[key] }
        end
        @copyist.config[:message] = message
        @copyist.run
      end

      def errors?
        errors.each { |err| return true if !err["general"].nil? || (err["adjustments"].size > 0) }
        false
      end

      def print_errors
        ui.error("ERRORS OCCURED:")
        errors.each do |err|
          ui.error(err["name"]) if !err["general"].nil? || (err["adjustments"].size > 0)
          ui.error("\t" + err["general"]) if !err["general"].nil?
          err["adjustments"].each { |num, adj_err| ui.error("\t[Adjustment #{num}]: #{adj_err}") }
        end
      end

      def action_overwrite(base, overwrite_with)
        if base.kind_of?(Hash) && overwrite_with.kind_of?(Hash)
          base.merge(overwrite_with)
        elsif overwrite_with.nil?
          base
        else
          overwrite_with
        end
      end
    end

    def deep_delete(delete_from, delete_spec)
      deep_delete!(delete_from.dup, delete_spec.dup)
    end

    alias_method :action_delete, :deep_delete

    def deep_delete!(delete_from, delete_spec)
      if delete_from.kind_of?(Hash) || delete_from.kind_of?(Array)
        if delete_spec.kind_of?(Array)
          delete_spec.each { |item| deep_delete!(delete_from, item) }
        elsif delete_spec.kind_of?(Hash)
          delete_spec.each { |key,item| deep_delete!(delete_from[key], item) }
        else
          delete_from.kind_of?(Array) ? delete_from.delete_at(delete_spec) : delete_from.delete(delete_spec)
        end
      end
      delete_from
    end

    def diff
      original_file = Tempfile.new("original")
      adjusted_file = Tempfile.new("adjusted")
      begin
        changes.each do |key, change|
          ui.info("[#{key}]")
          original_file.write(JSON.pretty_generate(change["original"]))
          adjusted_file.write(JSON.pretty_generate(change["adjusted"]))
          original_file.rewind
          adjusted_file.rewind
          diff_output = shell_out("diff -L original -L adjusted -u #{original_file.path} #{adjusted_file.path}")
          ui.info(diff_output.stdout)
        end
      ensure
        original_file.close
        original_file.unlink
        adjusted_file.close
        adjusted_file.unlink
      end
    end
  end
end


text:
CHANGELOG
=========

3.2.0
-----

 * Mappings with a colon that is not followed by a space are deprecated and
   will lead to a `ParseException` in Symfony 4.0.

 * Added support for parsing PHP constants:

   ```php
   Yaml::parse('!php/const:PHP_INT_MAX', Yaml::PARSE_CONSTANT);
   ```

 * Support for silently ignoring duplicate keys in YAML has been deprecated and
   will lead to a `ParseException` in Symfony 4.0.

3.1.0
-----

 * Strings that are not UTF-8 encoded will be dumped as base64 encoded binary
   data.

 * Added support for dumping multi line strings as literal blocks.

 * Added support for parsing base64 encoded binary data when they are tagged
   with the `!!binary` tag.

 * Added support for parsing timestamps as `\DateTime` objects:

   ```php
   Yaml::parse('2001-12-15 21:59:43.10 -5', Yaml::PARSE_DATETIME);
   ```

 * `\DateTime` and `\DateTimeImmutable` objects are dumped as YAML timestamps.

 * Deprecated usage of `%` at the beginning of an unquoted string.

 * Added support for customizing the YAML parser behavior through an optional bit field:

   ```php
   Yaml::parse('{ "foo": "bar", "fiz": "cat" }', Yaml::PARSE_EXCEPTION_ON_INVALID_TYPE | Yaml::PARSE_OBJECT | Yaml::PARSE_OBJECT_FOR_MAP);
   ```

 * Added support for customizing the dumped YAML string through an optional bit field:

   ```php
   Yaml::dump(array('foo' => new A(), 'bar' => 1), 0, 0, Yaml::DUMP_EXCEPTION_ON_INVALID_TYPE | Yaml::DUMP_OBJECT);
   ```

3.0.0
-----

 * Yaml::parse() now throws an exception when a blackslash is not escaped
   in double-quoted strings

2.8.0
-----

 * Deprecated usage of a colon in an unquoted mapping value
 * Deprecated usage of @, \`, | and > at the beginning of an unquoted string
 * When surrounding strings with double-quotes, you must now escape `\` characters. Not
   escaping those characters (when surrounded by double-quotes) is deprecated.

   Before:

   ```yml
   class: "Foo\Var"
   ```

   After:

   ```yml
   class: "Foo\\Var"
   ```

2.1.0
-----

 * Yaml::parse() does not evaluate loaded files as PHP files by default
   anymore (call Yaml::enablePhpParsing() to get back the old behavior)


text:
<?php

// Language: Slovak (SK)
// Author: Branislav Pírek, www.piri.sk
// Last Updated: 01/09/2014

$file_lang_name = "Slovak (SK)";
$file_lang_default = 0; // 1 for default, 0 for not

$lang_title_ended = "Spojenie ukončené";
$lang_title_errors = "Došlo k chybe";

$lang_session_expired = "Vaše spojenie vypršalo";
$lang_ip_conflict = "Vaša IP adresa je v rozpore s inou pripojenou IP adresou";

$lang_btn_login = "Prihlásiť";
$lang_ftp_host = "FTP Hostiteľ";
$lang_port = "Port";
$lang_passive_mode = "Pasívny režim (predvolené)";
$lang_username = "Meno užívateľa";
$lang_password = "Heslo";
$lang_ftp_ssl = "Pripojiť sa cez SSL (ak je to možné)";
$lang_adv_interface = "Rozšírené rozhranie";
$lang_save_login = "Uložiť prihlasovacie údaje";
$lang_language = "Jazyk";
$lang_skin = "Grafická schéma";
$lang_ip_check = "Uzamknúť toto spojenie s vašou IP";

$lang_skins_empty = "[skins] priečinok je prázdny!";
$lang_skins_locked = "[skins] priečinok je blokovaný!";
$lang_skins_missing = "[skins] priečinok neexistuje!";

$lang_missing_fields = "Chyba! Prosím, vyplňte všetky označené polia";
$lang_max_logins = "Prekročili ste povolený počet pokusov o prihlásenie a účet bol zablokovaný. Skúste to znovu o [n] minút";
$lang_cant_connect = "Chyba! Nie je možné sa pripojiť k FTP serveru";
$lang_cant_authenticate = "Chyba! Nie je možné overiť prihlasovacie údaje";
$lang_ip_conflict = "Bol zistený konflikt IP adries";

$lang_table_name = "Názov";
$lang_table_size = "Veľkosť";
$lang_table_date = "Dátum";
$lang_table_time = "Čas";
$lang_table_user = "Užívateľ";
$lang_table_group = "Skupina";
$lang_table_perms = "Oprávnenia";

$lang_size_b = "B";
$lang_size_kb = "kB";
$lang_size_mb = "MB";
$lang_size_gb = "GB";
$lang_size_tb = "TB";

$lang_btn_sendlink = "Odoslať odkaz";
$lang_btn_dl = "Stiahnuť";
$lang_btn_refresh = "Obnoviť";
$lang_btn_cut = "Vystrihnúť";
$lang_btn_copy = "Kopírovať";
$lang_btn_paste = "Prilepiť";
$lang_btn_rename = "Premenovať";
$lang_btn_delete = "Odstrániť";
$lang_btn_chmod = "Oprávnenia";
$lang_btn_logout = "Odhlísiť";
$lang_btn_save = "Uložiť";
$lang_btn_close = "Zavrieť";
$lang_btn_cancel = "Zrušiť";
$lang_btn_ok = "OK";
$lang_btn_new_folder = "Nový priečinok";
$lang_btn_new_file = "Nový súbor";
$lang_btn_upload_file = "Nahrať súbor";
$lang_btn_upload_files = "Nahrať súbory";
$lang_btn_upload_repeat = "Opakovať nahrávanie";
$lang_btn_upload_folder = "Nahrať priečinok";

$lang_info_host = "Hostiteľ";
$lang_info_user = "Užívateľ";
$lang_info_upload_limit = "Maximálna veľkosť";
$lang_info_drag_drop = "Sem môžete priamo presunúť súbory potiahnutím myškou";

$lang_xfer_file = "Súbor";
$lang_xfer_size = "Veľkosť";
$lang_xfer_progress = "Stav";
$lang_xfer_elapsed = "Uplynulý čas";
$lang_xfer_uploaded = "Nahrané";
$lang_xfer_rate = "Rýchlosť prenosu";
$lang_xfer_remain = "Zostávajúci čas";

$lang_move_conflict = "Cieľový priečinok je podpriečinkom zdrojového priečinka";
$lang_cant_rename = "Nie je možné premenovať súbor [file]";
$lang_cant_delete = "Nie je možné odstrániť súbor [file]";

$lang_folder_exists = "Priečinok [folder] už existuje";
$lang_folder_doesnt_exist = "Priečinok [folder] neexistuje";
$lang_folder_cant_move = "Priečinok [folder] nie je možné presunúť";
$lang_folder_cant_delete = "Priečinok [folder] nie je možné odstrániť";
$lang_folder_cant_access = "Priečinok [folder] nie je možné otvoriť";
$lang_folder_cant_make = "Priečinok [folder] nie je možné vytvoriť";

$lang_file_exists = "Súbor [file] už existuje";
$lang_file_doesnt_exist = "Súbor [file] neexistuje";
$lang_file_cant_move = "Súbor [file] nie je možné presunúť";
$lang_file_cant_make = "Súbor [file] nie je možné vytvoriť";

$lang_server_error_down = "Chyba servera pri sťahovaní súboru [file]";
$lang_server_error_up = "Chyba servera pri nahrávaní súboru [file]";
$lang_browser_error_up = "Chyba prehliadača pri nahrávaní súboru [file]";
$lang_file_size_error = "Súbor je väčší ako stanovený limit";
$lang_file_size_copy_error = "Súbor [file] je väčší ako stanovený limit";

$lang_folder_cant_chmod = "Nie je možné zmeniť oprávnenia [perms] priečinka [folder]";
$lang_file_cant_chmod = "Nie je možné zmeniť oprávnenia [perms] súboru [file]";
$lang_chmod_max_777 = "Parameter nemôže byť väčší ako 777";
$lang_chmod_owner = "Oprávnenia vlastníka";
$lang_chmod_group = "Skupinové oprávnenia";
$lang_chmod_public = "Globálne oprávnenia";
$lang_chmod_manual = "Manuálne";
$lang_chmod_read = "Čitanie";
$lang_chmod_write = "Zápis";
$lang_chmod_exe = "Vykonávať";
$lang_chmod_no_support = "Váš PHP server nepodporuje funkciu ftp_chmod";

$lang_title_rename = "Premenovať súbory";
$lang_title_chmod = "Zmeniť atribúty súboru";
$lang_title_edit_file = "Editácia";
$lang_title_new_file = "Nový súbor";
$lang_title_new_folder = "Nový priečinok";
$lang_new_folder_name = "Zadajte nový názov priečinka...";
$lang_new_file_name = "Zadajte nový názov súboru...";
$lang_template = "Šablóna";
$lang_no_template = "Žiadna šablóna";

$lang_no_xmlhttp = "Váš prehliadač nepodporuje XMLHTTP!";
$lang_support_drop = "Podporované";
$lang_no_support_drop = "Nepodporované";
$lang_transfer_pending = "V poradí";
$lang_transferring_to_ftp = "Odosielanie na FTP server...";
$lang_no_file_selected = "Kliknite na PREHĽADÁVAŤ a vyberte súbor pre nahranie!";
$lang_none_selected = "Musíte vybrať aspoň jeden súbor alebo priečinok!";
$lang_context_open = "Otvoriť";
$lang_context_download = "Stiahnuť";
$lang_context_edit = "Upraviť";
$lang_context_cut = "Vystrihnúť";
$lang_context_copy = "Kopírovať";
$lang_context_paste = "Prilepiť";
$lang_context_rename = "Premenovať";
$lang_context_delete = "Odstrániť";
$lang_context_chmod = "Oprávnenia";

// Translation required (start)
$lang_title_fetch_file = "Fetch File";
$lang_fetch_no_file = "The URL does not contain a file name.";
$lang_fetch_not_found = "No file could be found at this address.";
$lang_btn_fetch = "Fetch";
$lang_btn_fetch_file = "Fetch File";
// Translation required (end)

?>


text:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.meteogroup.jbrotli</groupId>
  <artifactId>jbrotli-examples-spring-boot</artifactId>
  <version>0.6.0-SNAPSHOT</version>

  <properties>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

    <version.jbrotli.native>0.6.0-SNAPSHOT</version.jbrotli.native>
  </properties>

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.3.3.RELEASE</version>
    <relativePath/>
  </parent>

  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.meteogroup.jbrotli</groupId>
      <artifactId>jbrotli-servlet</artifactId>
      <version>${version.jbrotli.native}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.testng</groupId>
      <artifactId>testng</artifactId>
      <version>6.9.10</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.assertj</groupId>
      <artifactId>assertj-core</artifactId>
      <version>2.2.0</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <repositories>
    <repository>
      <id>bintray-nitram509-jbrotli</id>
      <url>https://api.bintray.com/maven/nitram509/jbrotli/jbrotli</url>
    </repository>
  </repositories>

</project>


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<meta http-equiv="content-type" content="text/html; charset=ISO-8859-1">
<meta name="description" content="TickIt - A powerful open source ticketing system for computer repair shops">
<meta name="keywords" content="Ticketing, Computer Repair">
<meta name="author" content="Adam Jimerson">
<link rel="stylesheet" type="text/css" href="default.css" media="screen">
<title>TickIt Documentation</title>

		TickIt - Computer Repair Ticketing System

		Home
		Download
		Documentation

Removing a Computer/Customer

There are two ways for removing a computer and customer from the
				system, the first way is done through the "checkout" process and the
				second is done just by removing it.  Both ways will be discussed,
				as to why both would be needed and how to use them, in this chapter.

Removing a system through by checking it out

Once a repair is complete and the customer has come to pick up the
				machine it will need to be checked out of the system this will thus
				print out a receipt, two copies will actually be made one for the
				customer and the other for our records, as well as remove both computer
				and customer entries for that system from the database.

				      TickIt

				Version v2.1.0, Copyright 2009-2011 Shimazu Labs

				----------------------------

				Main Menu, To make a selection specify the number for that action

				1. Add New Computer to Database

				2. Edit Computer Status in Database

				3. Look up Computer Information

				4. List All Repair Requests

				5. Customer Checkout

				6. Check Computer Status

				7. Add a Comment

				8. Add a Donation Amount

				9. Quit

				Action: 6

						    Please scan barcode to login: xxxxxxxxxxxxxx

						    Welcome John Wayne

						    ID: 3

						    Press Enter To Continer

						    Please Scan System Barcode:
				000-000000

				      Customer Name: John Smith

				Computer: Dell Optiplex 500

				Removing 000-000000 from active repair requests...

				... Done

Removing a system without checking it out

This is more of a backup just in case a system for any reasons needs
				to be removed from the database without printing a receipt, IE
				testing/training purposes and can only be done from the TickItAdmin program.

				      Please scan barcode to login: xxxxxxxxxxxxxx

					      Welcome John Wayne

					      ID: 3

					      Press Enter To Contine

					      TickIt Admin System

					      Version v1.0.0, Copyright 2009-2011 Shimazu Labs

					      -------------------------------------------------------

					      Tech Management

					      ____________________

					      1. Add New Tech to TickIt

					      2. List Detailed Information on a Tech

					      3. List All Techs

					      4. Add a Tech Review

					      5. Remove a TEch from TickIt

					      System Management

					      __________________

					      6. Remove a Repair Request

					      Reports

					      _________

					      7. Generate Tech Review

					      8. Generate Monthly Repair Request

					      9. Generate Monthly Donation Amount

					      10. Generate Yearly Repair Request

					      11. Generate Yearly Donation Amount

					      Other Options

					      ______________

					      12. End of Year System Reset

					      13. Quit

				Action: 6

				      Please Scan System Barcode:
				000-000000

				Delete Completed

				Press Enter To Continue

Documentation Navigation

Back: Chapter 3.4

Main Menu

Next: Chapter 3.6

				© 2009-2010 Shimazu Labs. Valid CSS & XHTML.
				Template design by Arcsin

Content is available under GNU Free Documentation License 1.3


text:
<raphael-rect [leftCorner]="rectLeftCorner" [width]="width" [height]="height" [radius]="options.radius"
              [stroke]="options.stroke" [strokeWidth]="options.strokeWidth"
              [fillColors]="options.fillColors" [fillOpacity]="options.fillOpacity"></raphael-rect>
<diagram-tooltip [data]="data"></diagram-tooltip>


text:
The TempoDB Ruby API Client makes calls to the [TempoDB API](http://tempo-db.com/api/).  The module is available as a gem.

```
gem build tempodb.gemspec
gem install tempodb-1.0.0.gem
```

[![Build Status](https://travis-ci.org/tempodb/tempodb-ruby.png?branch=master)](https://travis-ci.org/tempodb/tempodb-ruby)

# Quickstart

```ruby
require 'tempodb'

client = TempoDB::Client.new('database_id', 'api_key', 'api_secret')
client.create_series("temp-1')
client.list_series
```

# Usage

For more example usage, please see the [TempoDB API documentation](http://tempo-db.com/docs/api/), which includes Ruby client examples for all endpoints.

There is also a [generated RDoc API documentation](http://tempo-db.com/rdoc) which you can use as a reference.


text:
package net.minidev.ovh.api.cloud.billingview;

import java.util.Date;

/**
 * MonthlyInstanceDetail
 */
public class OvhMonthlyInstanceDetail {
	/**
	 * Instance ID
	 *
	 * canBeNull && readOnly
	 */
	public String instanceId;

	/**
	 * Total price
	 *
	 * canBeNull && readOnly
	 */
	public Double totalPrice;

	/**
	 * Monthly instance activation
	 *
	 * canBeNull && readOnly
	 */
	public Date activation;
}


text:
module HubSync

  autoload :Version, 'hubsync/version'

end


text:
(function () {
    "use strict";

    angular
        .module("Bookly")
        .factory("MessageService", ["FIREBASE_URI", "$firebaseArray", "locker", "BookService",
            function(FIREBASE_URI, $firebaseArray, locker, BookService) {
                var ref = new Firebase(FIREBASE_URI);
                var timeStamp = Firebase.ServerValue.TIMESTAMP;
                var sender = locker.get("currentUser");
                var senderId = locker.get("user");
                var service = this;

                var userMessages = $firebaseArray(ref.child("users").child(senderId).child("messages"));

                service.requestBook = function(id, book) {

                    var message = {
                        type: "request",
                        sent: timeStamp,
                        title: book.title,
                        author: book.author,
                        id: book.$id,
                        requestedBy: sender,
                        requesterId: senderId
                    };

                    var messages = $firebaseArray(ref.child("users").child(id).child("messages"));
                    return messages.$add(message)

                };

                service.denyRequest = function(book, requesterId) {
                    var message = {
                        sent: timeStamp,
                        type: "deny",
                        sender: sender,
                        book: book,
                        body: ("Your request for " + book + " was denied by " + sender)
                    };

                    var messages = $firebaseArray(ref.child("users").child(requesterId).child("messages"));
                    return messages.$add(message);
                };

                service.approveRequest = function (book, requesterId, index) {
                    var message = {
                        sent: timeStamp,
                        type: "approve",
                        sender: sender,
                        book: book,
                        body: ("Your request for " + book + " was approved by " + sender)
                    };

                    var messages = $firebaseArray(ref.child("users").child(requesterId).child("messages"));
                    messages.$add(message)
                        .then(function() {
                            BookService.updateAvailability(index);
                        });

                };

                service.removeMessage = function (index) {
                    var item = userMessages[index];
                    userMessages.$remove(item)
                        .then(function() {

                        });
                };

                service.getMessages = function() {
                    //$firebaseArray(ref.child("users").child(locker.get("user")).child("messages")).$loaded();
                    return userMessages;
                };

                return service;
        }]);
}());


text:
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE OverloadedStrings #-}
module Main (main) where

import Common

import qualified GitHub
import qualified GitHub.Endpoints.Organizations.Teams as GitHub

main :: IO ()
main = do
  args <- getArgs
  result <- case args of
              [team_id, username, token] ->
                GitHub.teamMembershipInfoFor' (Just $ GitHub.OAuth $ fromString token) (GitHub.mkTeamId $ read team_id) (GitHub.mkOwnerName $ fromString username)
              [team_id, username]        ->
                GitHub.teamMembershipInfoFor (GitHub.mkTeamId $ read team_id) (GitHub.mkOwnerName $ fromString username)
              _                          ->
                error "usage: TeamMembershipInfoFor <team_id> <username> [token]"
  case result of
    Left err   -> putStrLn $ "Error: " <> tshow err
    Right team -> putStrLn $ tshow team


text:
layout: post
title: Bari su Open Street Map
date: 2013-11-24
categories:
- OpenStreetMap
tags:
- #openstreetmap
- #bari
status: publish
type: post
published: true
author: Simone Cortesi
email: simone@cortesi.com
twitter:
linkedin:
---

Le mappe con cui ci orientiamo ci dicono davvero come è fatto il territorio? Nell'immagine qui sotto potete osservare una parte della città di Bari in diverse versioni, dove vengono messe in evidenza diverse caratteristiche.

In alto a sinistra la foto satellitare mostra la foto aerea di Bari Vecchia.

In alto a destra la versione standard di OpenStreetMap. In basso a sinistra la versione standard di Google Maps, in basso a destra, invece, una seconda versione OpenStreetMap, costruita a partire dagli stessi dati, ma completamente diversa per aspetto.

OpenStreetMap è una mappa fatta dalle persone, per le persone, senza nessun controllo da parte dell'amministrazione pubblica. Chiunque può aggiungere modifiche migliorative alla mappa.

E' libera, nel senso che ognuno è libero di scaricare i dati sorgenti e di utilizzarli in maniera creativa, senza alcun limite alla fantasia. Molte mappe che normalmente consideriamo libere, in realtà non lo sono, non hai diritto ad esempio di scaricare i dati di Google Maps e di utilìzzarli all'interno di un progetto aziendale, non hai diritto di aggiungere i dati mancanti o di correggere quelli errati.

Questo è un esempio di come si possono inserire dati non previsti dalle amministrazioni, come ad esempio i parcheggi abusivi della citta di Bari.


text: ./play.sh | python strategypy/consolefe.py


text:
class Flower{
    String whatsYourName() {
        return "I have many names and types.";
    }
}

class Jasmine extends Flower{
    @Override
    String whatsYourName() {
        return "Jasmine";
    }
}

class Lily extends Flower{
    @Override
    String whatsYourName() {
        return "Lily";
    }
}

class Lotus extends Flower{
    @Override
    String whatsYourName() {
        return "Lotus";
    }
}

class State{
    Flower yourNationalFlower() {
        return new Flower();
    }
}

class WestBengal extends State{
    @Override
    Flower yourNationalFlower() {
        return new Jasmine();
    }
}

class Karnataka extends State{
    @Override
    Flower yourNationalFlower() {
        return new Lotus();
    }
}

class AndhraPradesh extends State{
    @Override
    Flower yourNationalFlower() {
        return new Lily();
    }
}