text:
import os

import numpy as np

import pytest

from spotlight.evaluation import precision_recall_score, sequence_precision_recall_score
from spotlight.cross_validation import random_train_test_split, user_based_train_test_split
from spotlight.datasets import movielens
from spotlight.factorization.implicit import ImplicitFactorizationModel
from spotlight.sequence.implicit import ImplicitSequenceModel

RANDOM_STATE = np.random.RandomState(42)
CUDA = bool(os.environ.get('SPOTLIGHT_CUDA', False))
# Acceptable variation in specific test runs
EPSILON = .005

@pytest.fixture(scope='module')
def data_implicit_factorization():

    interactions = movielens.get_movielens_dataset('100K')

    train, test = random_train_test_split(interactions,
                                          random_state=RANDOM_STATE)

    model = ImplicitFactorizationModel(loss='bpr',
                                       n_iter=1,
                                       batch_size=1024,
                                       learning_rate=1e-2,
                                       l2=1e-6,
                                       random_state=RANDOM_STATE,
                                       use_cuda=CUDA)
    model.fit(train)

    return train, test, model

@pytest.fixture(scope='module')
def data_implicit_sequence():

    max_sequence_length = 200
    min_sequence_length = 20
    step_size = 200

    interactions = movielens.get_movielens_dataset('100K')

    train, test = user_based_train_test_split(interactions,
                                              random_state=RANDOM_STATE)

    train = train.to_sequence(max_sequence_length=max_sequence_length,
                              min_sequence_length=min_sequence_length,
                              step_size=step_size)

    test = test.to_sequence(max_sequence_length=max_sequence_length,
                            min_sequence_length=min_sequence_length,
                            step_size=step_size)

    model = ImplicitSequenceModel(loss='adaptive_hinge',
                                  representation='lstm',
                                  batch_size=8,
                                  learning_rate=1e-2,
                                  l2=1e-3,
                                  n_iter=2,
                                  use_cuda=CUDA,
                                  random_state=RANDOM_STATE)

    model.fit(train, verbose=True)

    return train, test, model

@pytest.mark.parametrize('k', [10])
def test_sequence_precision_recall(data_implicit_sequence, k):

    (train, test, model) = data_implicit_sequence

    precision, recall = sequence_precision_recall_score(model, test, k)
    precision = precision.mean()
    recall = recall.mean()

    # with respect to the hyper-parameters specified in data_implicit_sequence
    expected_precision = 0.064
    expected_recall = 0.064

    # true_pos/(true_pos + false_pos) == true_pos/(true_pos + false_neg)
    # because num_predictions is set equal to num_targets in sequence_precision_recall_score
    assert precision == recall
    assert expected_precision - EPSILON < precision and precision < expected_precision + EPSILON
    assert expected_recall - EPSILON < recall and recall < expected_recall + EPSILON

@pytest.mark.parametrize('k', [
    1,
    [1, 1],
    [1, 1, 1]
])
def test_precision_recall(data_implicit_factorization, k):

    (train, test, model) = data_implicit_factorization

    interactions = movielens.get_movielens_dataset('100K')
    train, test = random_train_test_split(interactions,
                                          random_state=RANDOM_STATE)

    precision, recall = precision_recall_score(model, test, train, k=k)

    assert precision.shape == recall.shape

    if not isinstance(k, list):
        assert len(precision.shape) == 1
    else:
        assert precision.shape[1] == len(k)


text:
package dockershim

import (
	"fmt"
	"strings"
	"sync/atomic"
	"time"

	dockertypes "github.com/docker/engine-api/types"
	dockerfilters "github.com/docker/engine-api/types/filters"
	"github.com/golang/glog"

	"k8s.io/apimachinery/pkg/util/sets"
	"k8s.io/apimachinery/pkg/util/wait"
	runtimeapi "k8s.io/kubernetes/pkg/kubelet/apis/cri/v1alpha1"
	kubecontainer "k8s.io/kubernetes/pkg/kubelet/container"
	"k8s.io/kubernetes/pkg/kubelet/dockershim/libdocker"
	"k8s.io/kubernetes/pkg/kubelet/leaky"
)

// These are labels used by kuberuntime. Ideally, we should not rely on kuberuntime implementation
// detail in dockershim. However, we need these labels for legacy container (containers created by
// kubernetes 1.4 and 1.5) support.
// TODO(random-liu): Remove this file and related code in kubernetes 1.8.
const (
	podDeletionGracePeriodLabel    = "io.kubernetes.pod.deletionGracePeriod"
	podTerminationGracePeriodLabel = "io.kubernetes.pod.terminationGracePeriod"

	containerHashLabel                     = "io.kubernetes.container.hash"
	containerRestartCountLabel             = "io.kubernetes.container.restartCount"
	containerTerminationMessagePathLabel   = "io.kubernetes.container.terminationMessagePath"
	containerTerminationMessagePolicyLabel = "io.kubernetes.container.terminationMessagePolicy"
	containerPreStopHandlerLabel           = "io.kubernetes.container.preStopHandler"
	containerPortsLabel                    = "io.kubernetes.container.ports"
)

// NOTE that we can't handle the following dockershim internal labels, so they will be empty:
// * containerLogPathLabelKey ("io.kubernetes.container.logpath"): RemoveContainer will ignore
// the label if it's empty.
// * sandboxIDLabelKey ("io.kubernetes.sandbox.id"): This is used in 2 places:
//   * filter.PodSandboxId: The filter is not used in kuberuntime now.
//   * runtimeapi.Container.PodSandboxId: toRuntimeAPIContainer retrieves PodSandboxId from the
//   label. The field is used in kuberuntime sandbox garbage collection. Missing this may cause
//   pod sandbox to be removed before its containers are removed.

// convertLegacyNameAndLabels converts legacy name and labels into dockershim name and labels.
// The function can be used to either legacy infra container or regular container.
// NOTE that legacy infra container doesn't have restart count label, so the returned attempt for
// sandbox will always be 0. The sandbox attempt is only used to generate new sandbox name, and
// there is no naming conflict between legacy and new containers/sandboxes, so it should be fine.
func convertLegacyNameAndLabels(names []string, labels map[string]string) ([]string, map[string]string, error) {
	if len(names) == 0 {
		return nil, nil, fmt.Errorf("unexpected empty name")
	}

	// Generate new dockershim name.
	m, _, err := libdocker.ParseDockerName(names[0])
	if err != nil {
		return nil, nil, err
	}
	sandboxName, sandboxNamespace, err := kubecontainer.ParsePodFullName(m.PodFullName)
	if err != nil {
		return nil, nil, err
	}
	newNames := []string{strings.Join([]string{
		kubePrefix,                         // 0
		m.ContainerName,                    // 1: container name
		sandboxName,                        // 2: sandbox name
		sandboxNamespace,                   // 3: sandbox namesapce
		string(m.PodUID),                   // 4: sandbox uid
		labels[containerRestartCountLabel], // 5
	}, nameDelimiter)}

	// Generate new labels.
	legacyAnnotations := sets.NewString(
		containerHashLabel,
		containerRestartCountLabel,
		containerTerminationMessagePathLabel,
		containerTerminationMessagePolicyLabel,
		containerPreStopHandlerLabel,
		containerPortsLabel,
	)
	newLabels := map[string]string{}
	for k, v := range labels {
		if legacyAnnotations.Has(k) {
			// Add annotation prefix for all legacy labels which should be annotations in dockershim.
			newLabels[fmt.Sprintf("%s%s", annotationPrefix, k)] = v
		} else {
			newLabels[k] = v
		}
	}
	// Add containerTypeLabelKey indicating the container is sandbox or application container.
	if m.ContainerName == leaky.PodInfraContainerName {
		newLabels[containerTypeLabelKey] = containerTypeLabelSandbox
	} else {
		newLabels[containerTypeLabelKey] = containerTypeLabelContainer
	}
	return newNames, newLabels, nil
}

// legacyCleanupCheckInterval is the interval legacyCleanupCheck is performed.
const legacyCleanupCheckInterval = 10 * time.Second

// LegacyCleanupInit initializes the legacy cleanup flag. If necessary, it will starts a goroutine
// which periodically checks legacy cleanup until it finishes.
func (ds *dockerService) LegacyCleanupInit() {
	// If there is no legacy container/sandbox, just return.
	if clean, _ := ds.checkLegacyCleanup(); clean {
		return
	}
	// Or else start the cleanup routine.
	go wait.PollInfinite(legacyCleanupCheckInterval, ds.checkLegacyCleanup)
}

// checkLegacyCleanup lists legacy containers/sandboxes, if no legacy containers/sandboxes are found,
// mark the legacy cleanup flag as done.
func (ds *dockerService) checkLegacyCleanup() (bool, error) {
	// Always do legacy cleanup when list fails.
	sandboxes, err := ds.ListLegacyPodSandbox(nil)
	if err != nil {
		glog.Errorf("Failed to list legacy pod sandboxes: %v", err)
		return false, nil
	}
	containers, err := ds.ListLegacyContainers(nil)
	if err != nil {
		glog.Errorf("Failed to list legacy containers: %v", err)
		return false, nil
	}
	if len(sandboxes) != 0 || len(containers) != 0 {
		glog.V(4).Infof("Found legacy sandboxes %+v, legacy containers %+v, continue legacy cleanup",
			sandboxes, containers)
		return false, nil
	}
	ds.legacyCleanup.MarkDone()
	glog.V(2).Infof("No legacy containers found, stop performing legacy cleanup.")
	return true, nil
}

// ListLegacyPodSandbox only lists all legacy pod sandboxes.
func (ds *dockerService) ListLegacyPodSandbox(filter *runtimeapi.PodSandboxFilter) ([]*runtimeapi.PodSandbox, error) {
	// By default, list all containers whether they are running or not.
	opts := dockertypes.ContainerListOptions{All: true, Filter: dockerfilters.NewArgs()}
	filterOutReadySandboxes := false
	f := newDockerFilter(&opts.Filter)
	if filter != nil {
		if filter.Id != "" {
			f.Add("id", filter.Id)
		}
		if filter.State != nil {
			if filter.GetState().State == runtimeapi.PodSandboxState_SANDBOX_READY {
				// Only list running containers.
				opts.All = false
			} else {
				// runtimeapi.PodSandboxState_SANDBOX_NOTREADY can mean the
				// container is in any of the non-running state (e.g., created,
				// exited). We can't tell docker to filter out running
				// containers directly, so we'll need to filter them out
				// ourselves after getting the results.
				filterOutReadySandboxes = true
			}
		}
		if filter.LabelSelector != nil {
			for k, v := range filter.LabelSelector {
				f.AddLabel(k, v)
			}
		}
	}
	containers, err := ds.client.ListContainers(opts)
	if err != nil {
		return nil, err
	}

	// Convert docker containers to runtime api sandboxes.
	result := []*runtimeapi.PodSandbox{}
	for i := range containers {
		c := containers[i]
		// Skip new containers with containerTypeLabelKey label.
		if _, ok := c.Labels[containerTypeLabelKey]; ok {
			continue
		}
		// If the container has no containerTypeLabelKey label, treat it as a legacy container.
		c.Names, c.Labels, err = convertLegacyNameAndLabels(c.Names, c.Labels)
		if err != nil {
			glog.V(4).Infof("Unable to convert legacy container %+v: %v", c, err)
			continue
		}
		if c.Labels[containerTypeLabelKey] != containerTypeLabelSandbox {
			continue
		}
		converted, err := containerToRuntimeAPISandbox(&c)
		if err != nil {
			glog.V(4).Infof("Unable to convert docker to runtime API sandbox %+v: %v", c, err)
			continue
		}
		if filterOutReadySandboxes && converted.State == runtimeapi.PodSandboxState_SANDBOX_READY {
			continue
		}
		result = append(result, converted)
	}
	return result, nil
}

// ListLegacyPodSandbox only lists all legacy containers.
func (ds *dockerService) ListLegacyContainers(filter *runtimeapi.ContainerFilter) ([]*runtimeapi.Container, error) {
	opts := dockertypes.ContainerListOptions{All: true, Filter: dockerfilters.NewArgs()}
	f := newDockerFilter(&opts.Filter)

	if filter != nil {
		if filter.Id != "" {
			f.Add("id", filter.Id)
		}
		if filter.State != nil {
			f.Add("status", toDockerContainerStatus(filter.GetState().State))
		}
		// NOTE: Legacy container doesn't have sandboxIDLabelKey label, so we can't filter with
		// it. Fortunately, PodSandboxId is not used in kuberuntime now.
		if filter.LabelSelector != nil {
			for k, v := range filter.LabelSelector {
				f.AddLabel(k, v)
			}
		}
	}
	containers, err := ds.client.ListContainers(opts)
	if err != nil {
		return nil, err
	}

	// Convert docker to runtime api containers.
	result := []*runtimeapi.Container{}
	for i := range containers {
		c := containers[i]
		// Skip new containers with containerTypeLabelKey label.
		if _, ok := c.Labels[containerTypeLabelKey]; ok {
			continue
		}
		// If the container has no containerTypeLabelKey label, treat it as a legacy container.
		c.Names, c.Labels, err = convertLegacyNameAndLabels(c.Names, c.Labels)
		if err != nil {
			glog.V(4).Infof("Unable to convert legacy container %+v: %v", c, err)
			continue
		}
		if c.Labels[containerTypeLabelKey] != containerTypeLabelContainer {
			continue
		}
		converted, err := toRuntimeAPIContainer(&c)
		if err != nil {
			glog.V(4).Infof("Unable to convert docker container to runtime API container %+v: %v", c, err)
			continue
		}
		result = append(result, converted)
	}
	return result, nil
}

// legacyCleanupFlag is the flag indicating whether legacy cleanup is done.
type legacyCleanupFlag struct {
	done int32
}

// Done checks whether legacy cleanup is done.
func (f *legacyCleanupFlag) Done() bool {
	return atomic.LoadInt32(&f.done) == 1
}

// MarkDone sets legacy cleanup as done.
func (f *legacyCleanupFlag) MarkDone() {
	atomic.StoreInt32(&f.done, 1)
}

redpajama_set_name: RedPajamaGithub


text:
var currentTag = null
var currentNote = null
var notes = {}

module.exports = {
  init: function init () {
    if (!localStorage.notes) {
      notes = {
        Example: [
          {
            name: 'Example',
            content: 'Example'
          }
        ]
      }
      this.writeData()
    } else {
      this.readData()
    }
  },
  readData: function () {
    notes = JSON.parse(localStorage.notes)
  },
  writeData: function () {
    localStorage.notes = JSON.stringify(notes)
  },
  // Get all notes of current tag
  getNotes: function () {
    if (currentTag) {
      return notes[currentTag]
    }
    return null
  },
  // Get all tags
  getTags: function () {
    return Object.keys(notes)
  },
  // Given name and content of a new note
  addNote: function (name, content) {
    if (name === '') {
      alert('Title can\'t be empty')
    }
    var note = {
      name: name,
      content: content
    }
    notes[currentTag].push(note)
    this.writeData()
    this.setCurrentNote(note)
  },
  removeNote: function (note) {
    var arr = notes[currentTag]
    var flag = this.isCurrentNote(note)
    arr.splice(arr.indexOf(note), 1)
    if (flag) {
      currentNote = null
    }
    this.writeData()
  },
  updateNote: function (name, content) {
    if (name === '') {
      alert('Title can\'t be empty')
    }
    currentNote.name = name
    currentNote.content = content
    this.writeData()
  },
  // Given tag name of a new tag
  addTag: function (tag) {
    if (notes[tag]) {
      alert('This tag exists!')
    } else {
      notes[tag] = []
    }
    this.writeData()
  },
  removeTag: function (tag) {
    var flag = this.isCurrentTag(tag)
    delete notes[tag]
    if (flag) {
      currentTag = null
    }
    this.writeData()
  },
  updateTag: function (tag, value) {
    if (!value) {
      alert("Can't be empty!")
    } else if (tag === value) {
      return
    } else if (notes[value]) {
      alert('This tag exists!')
    } else {
      var flag = this.isCurrentTag(tag)
      // Is this OK ?
      notes[value] = notes[tag]
      delete notes[tag]
      if (flag) {
        this.setCurrentTag(value)
      }
    }
    this.writeData()
  },
  getCurrentTag: function () {
    return currentTag
  },
  getCurrentNote: function () {
    return currentNote
  },
  setCurrentTag: function (tag) {
    currentTag = tag
  },
  setCurrentNote: function (note) {
    currentNote = note
  },
  isCurrentTag: function (tag) {
    return (tag === currentTag)
  },
  isCurrentNote: function (note) {
    return (note === currentNote)
  }
}


text:
namespace Syndicate { namespace Graphics {

TileLayer::TileLayer()
{

}

TileLayer::TileLayer(Shader* shader)
	: Layer(synnew BatchRenderer2D(), shader, glm::ortho(-16.0f, 16.0f, -9.0f, 9.0f))
{

}

void TileLayer::SetProjectionMatrix()
{
	Layer::SetProjectionMatrix(glm::ortho(-16.0f, 16.0f, -9.0f, 9.0f));
}

void TileLayer::SetProjectionMatrix(const glm::mat4& prMatrix)
{
	Layer::SetProjectionMatrix(prMatrix);
}

TileLayer::~TileLayer()
{

}

}}


text:
import os
import sys
import shlex

from setuptools import setup, Extension
from setuptools.command.test import test as TestCommand

# Determine if a base directory has been provided with the --basedir option
in_tree = False
# Add compiler flags if debug is set
compile_args = ['-Wno-unused-function']
for arg in sys.argv:
    if arg.startswith('--debug'):
        # Note from GCC manual:
        #       If you use multiple -O options, with or without level numbers,
        #       the last such option is the one that is effective.
        compile_args.extend('-Wall -O0 -g'.split())
    elif arg.startswith('--basedir='):
        basedir = arg.split('=')[1]
        sys.argv.remove(arg)
        in_tree = True

# If a base directory has been provided, we use it
if in_tree:
    netsnmp_libs = os.popen(basedir + '/net-snmp-config --libs').read()

    libdirs = os.popen('{0}/net-snmp-config --build-lib-dirs {1}'.format(basedir, basedir)).read()  # noqa
    incdirs = os.popen('{0}/net-snmp-config --build-includes {1}'.format(basedir, basedir)).read()  # noqa

    libs = [flag[2:] for flag in shlex.split(netsnmp_libs) if flag.startswith('-l')]  # noqa
    libdirs = [flag[2:] for flag in shlex.split(libdirs) if flag.startswith('-L')]    # noqa
    incdirs = [flag[2:] for flag in shlex.split(incdirs) if flag.startswith('-I')]    # noqa

# Otherwise, we use the system-installed SNMP libraries
else:
    netsnmp_libs = os.popen('net-snmp-config --libs').read()

    libs = [flag[2:] for flag in shlex.split(netsnmp_libs) if flag.startswith('-l')]     # noqa
    libdirs = [flag[2:] for flag in shlex.split(netsnmp_libs) if flag.startswith('-L')]  # noqa
    incdirs = []

# Setup the py.test class for use with the test command
class PyTest(TestCommand):
    user_options = [('pytest-args=', 'a', 'Arguments to pass to py.test')]

    def initialize_options(self):
        TestCommand.initialize_options(self)
        self.pytest_args = []

    def finalize_options(self):
        TestCommand.finalize_options(self)
        self.test_args = []
        self.test_suite = True

    def run_tests(self):
        # Import here, cause outside the eggs aren't loaded
        import pytest
        errno = pytest.main(self.pytest_args)
        sys.exit(errno)

# Read the long description from readme.rst
try:
    with open('setup.rst') as f:
        long_description = f.read()
except IOError:
    long_description = None

setup(
    name='easysnmp',
    version='3.0',
    description='A blazingly fast and Pythonic SNMP library based on the '
                'official Net-SNMP bindings',
    long_description=long_description,
    author='Fotis Gimian',
    author_email='fgimiansoftware@gmail.com',
    url='https://github.com/fgimian/easysnmp',
    license='BSD',
    packages=['easysnmp'],
    tests_require=['pytest-cov', 'pytest-flake8', 'pytest-sugar', 'pytest'],
    cmdclass={'test': PyTest},
    ext_modules=[
        Extension(
            'easysnmp.interface', ['easysnmp/interface.c'],
            library_dirs=libdirs, include_dirs=incdirs, libraries=libs,
            extra_compile_args=compile_args
        )
    ],
    classifiers=[
        'Development Status :: 4 - Beta',
        'Intended Audience :: Developers',
        'License :: OSI Approved :: BSD License',
        'Operating System :: OS Independent',
        'Programming Language :: Python',
        'Programming Language :: Python :: 2.6',
        'Programming Language :: Python :: 2.7',
        'Programming Language :: Python :: 3.2',
        'Programming Language :: Python :: 3.3',
        'Programming Language :: Python :: 3.4',
        'Topic :: System :: Networking',
        'Topic :: System :: Networking :: Monitoring'
    ]
)


text:
import React from 'react'
import { makeStyles } from '@material-ui/core/styles'
import { Typography, Paper, Modal, IconButton, Icon } from '@material-ui/core'

const useStyles = makeStyles(theme => ({
  positioning: {
    width: '100vw',
    height: '100vh',
    display: 'flex',
    justifyContent: 'center',
    alignItems: 'center'
  },
  paper: {
    width: 700,
    display: 'flex',
    flexDirection: 'column',
    backgroundColor: theme.palette.background.paper,
    boxShadow: theme.shadows[5],
    padding: theme.spacing(4),
    outline: 'none',
    maxHeight: `calc(100% - 88px)`,
  },
  header: {
    display: 'flex',
    alignItems: 'center',
    justifyContent: 'space-between'
  },
  modalContents: {
    overflowY: 'auto',
  },
  bottomRow: {
    marginTop: '16px',
    height: '48px',
  }
}));

export default function ModalWrapper (props) {
  const { headerText, closeAction, children, bottomRowContents } = props
  const classes = useStyles();
  return (
    <Modal open={true}>

        <Paper className={classes.paper}>

            <Typography variant='h6'>{headerText}</Typography>
            <IconButton onClick={closeAction}>
              <Icon>
                close
              </Icon>
            </IconButton>

            {children}

        </Paper>

    </Modal>
  )
}


text:
/**
 * Created by schwarzkopfb on 15/8/21.
 */

/*

    Here you can find a measurement for one member of each important Enum instance method family.
    Run this file if you're curious about the results on your machine.

 */

var ITERATIONS = +process.argv[2] || 50000000

var Enum      = require('../enumerated'),
    test      = Enum(1, 2, 3, 4, 5, 6, 7, 8),
    timestamp = +new Date,
    i         = ITERATIONS

function rand() {
    return Math.round(Math.random() * 255)
}

function snapshot(name) {
    var d = ((+new Date - timestamp) / 1000).toFixed(2)
    console.log(ITERATIONS + ' ' + name + ' calls performed in ' + d + ' seconds (' + (ITERATIONS / d).toFixed(2) + ' ops/sec)')
    i = ITERATIONS
    timestamp = +new Date
}

// get()

while(--i)
    test.get(2)

snapshot('get()')

// valueOf()

while(--i)
    test.valueOf(rand())

snapshot('valueOf()')

// valuesOf()

while(--i)
    test.valuesOf(rand())

snapshot('valuesOf()')

// slower methods coming, it's time to reduce iteration count...

while(ITERATIONS > 1000000)
    ITERATIONS = Math.round(ITERATIONS / 50)

i = ITERATIONS

// fromValues()

while(--i)
    test.fromValues(1, 4, 5, 2)

snapshot('fromValues()')

// valuesByKeys()

while(--i)
    test.valuesByKeys(1, 4, 5, 2)

snapshot('valuesByKeys()')

// ...and it's time again

i = ITERATIONS = 100000

// constructor call

while(--i)
    test = Enum(1, 2, 3, 4, 5, 6, 7, 8)

snapshot('constructor')


text:
/**
 * Fixes the console for every possible browser.
 *
 * Author: Antti Hukkanen
 *
 */
if (window.loadFirebugConsole) {
	window.loadFirebugConsole();
} else {
	if (!window.console) {
		window.console = {
			logindex: 0,
			consolewin: null,
			consoleelem: null,
			initialized: false,
			html: {
				separator: '<br/>'
			},
			windowoptions: {
				width: 300,
				height: 200
			},
			init: function() {
				if (console.consolewin === null) {
					console.initialized = true;
					var options = '';
					for (var i in console.windowoptions) {
						if (options.length > 0) {
							options += ',';
						}
						options += i + '=' + console.windowoptions[i];
					}
					console.consolewin = window.open('','Console',options);
					console.consolewin.document.body.innerHTML = "";
				}
			},
			getTime: function() {
				var now = new Date();
				var year = now.getFullYear();
				var mon = now.getMonth() < 9 ? '0' + (now.getMonth()+1) : now.getMonth()+1;
				var day = now.getDate() < 10 ? '0' + now.getDate() : now.getDate();
				var hrs = now.getHours() < 10 ? '0' + now.getHours() : now.getHours();
				var mins = now.getMinutes() < 10 ? '0' + now.getMinutes() : now.getMinutes();
				var secs = now.getSeconds() < 10 ? '0' + now.getSeconds() : now.getSeconds();

				return year + "-" + mon + "-" + day + " " + hrs + ":" + mins + ":" + secs;
			},
			writemsg: function(msg) {
				if (!console.initialized) {
					console.init();
				}
				msg = console.getTime() + " " + msg;
				if (console.logindex > 0) {
					msg = console.html.separator + msg;
				}
				console.consolewin.document.body.innerHTML =
					console.consolewin.document.body.innerHTML + msg;
				console.logindex++;
			},
			info: function(msg) {
				console.writemsg(msg);
			},
			log: function(msg) {
				console.writemsg(msg);
			},
			warn: function(msg) {
				console.writemsg(msg);
			},
			error: function(msg) {
				console.writemsg(msg);
			}
		};
	}
}


text:
game.ExperienceManager = Object.extend({
   init: function(x, y, settings){
       this.alwaysUpdate = true;
       this.gameover = false;
   },

   update: function(){
       //okay so this will look at the data stuff and if we win obviously rhere will be a message alerting that you won.
       if(game.data.win === true && !this.gameover){
           this.gameOver(true);
           alert ("YOU WIN!");
       }else if(game.data.win === false && !this.gameover){
           this.gameOver(false);
           //vise versa for if you lose
           alert ("YOU LOSE!");
       }

       return true;
   },

   gameOver: function(win){
       if(win){
        game.data.exp += 10;
        //if the player wins then wew gain 10 ppoints of experience
       }else{
        game.data.exp += 1;
        //if the player loses we only get 1 point
       }
       this.gameover = true;
       me.save.exp = game.data.exp; //saves the experience

            $.ajax({
            type: "POST",
            url: "php/controller/save-user.php",
            data: {
               exp: game.data.exp,
               exp1: game.data.exp1,
               exp2: game.data.exp2,
               exp3: game.data.exp3,
               exp4: game.data.exp4,
            },
            dataType: "text"
        })
                .success(function(response) {
                    if (response === "true") {
                        me.state.change(me.state.MENU);
                    } else {
                        alert(response);
                    }
                })
                .fail(function(response) {
                    alert: ("Fail");
                });
    }

});


text:
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package br.com.ti4b.modelo;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;

/**
 *
 * @author StreamRead
 */
@Entity
public class SubCategoria implements Modelo, Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;
    @ManyToOne
    @JoinColumn(name = "id_categoria")
    private Categoria categoria;

    private String descricao;

    private int idadeInicio;
    private int idadedoFim;

    @Override
    public long getId() {
        return id;
    }

    public Categoria getCategoria() {
        return categoria;
    }

    public void setCategoria(Categoria categoria) {
        this.categoria = categoria;
    }

    public String getDescricao() {
        return descricao;
    }

    public void setDescricao(String descricao) {
        this.descricao = descricao;
    }

    public int getIdadeInicio() {
        return idadeInicio;
    }

    public void setIdadeInicio(int idadeInicio) {
        this.idadeInicio = idadeInicio;
    }

    public int getIdadedoFim() {
        return idadedoFim;
    }

    public void setIdadedoFim(int idadedoFim) {
        this.idadedoFim = idadedoFim;
    }

}


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

package com.google.gerrit.server.plugins;

import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.gerrit.extensions.registration.PrivateInternals_DynamicTypes.dynamicItemsOf;
import static com.google.gerrit.extensions.registration.PrivateInternals_DynamicTypes.dynamicMapsOf;
import static com.google.gerrit.extensions.registration.PrivateInternals_DynamicTypes.dynamicSetsOf;

import com.google.common.collect.LinkedListMultimap;
import com.google.common.collect.ListMultimap;
import com.google.common.collect.Lists;
import com.google.gerrit.common.Nullable;
import com.google.gerrit.extensions.annotations.RootRelative;
import com.google.gerrit.extensions.events.LifecycleListener;
import com.google.gerrit.extensions.registration.DynamicItem;
import com.google.gerrit.extensions.registration.DynamicMap;
import com.google.gerrit.extensions.registration.DynamicSet;
import com.google.gerrit.extensions.registration.PrivateInternals_DynamicMapImpl;
import com.google.gerrit.extensions.registration.PrivateInternals_DynamicTypes;
import com.google.gerrit.extensions.registration.RegistrationHandle;
import com.google.gerrit.extensions.registration.ReloadableRegistrationHandle;
import com.google.gerrit.extensions.systemstatus.ServerInformation;
import com.google.gerrit.extensions.webui.WebUiPlugin;
import com.google.gerrit.metrics.MetricMaker;
import com.google.gerrit.server.util.PluginRequestContext;
import com.google.gerrit.server.util.RequestContext;
import com.google.gerrit.server.util.ThreadLocalRequestContext;
import com.google.inject.AbstractModule;
import com.google.inject.Binding;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.Key;
import com.google.inject.Module;
import com.google.inject.Provider;
import com.google.inject.Singleton;
import com.google.inject.TypeLiteral;
import com.google.inject.internal.UniqueAnnotations;

import java.lang.annotation.Annotation;
import java.lang.reflect.ParameterizedType;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArrayList;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Tracks Guice bindings that should be exposed to loaded plugins.
 * <p>
 * This is an internal implementation detail of how the main server is able to
 * export its explicit Guice bindings to tightly coupled plugins, giving them
 * access to singletons and request scoped resources just like any core code.
 */
@Singleton
public class PluginGuiceEnvironment {
  private final Injector sysInjector;
  private final ServerInformation srvInfo;
  private final ThreadLocalRequestContext local;
  private final CopyConfigModule copyConfigModule;
  private final Set<Key<?>> copyConfigKeys;
  private final List<StartPluginListener> onStart;
  private final List<StopPluginListener> onStop;
  private final List<ReloadPluginListener> onReload;
  private final MetricMaker serverMetrics;

  private Module sysModule;
  private Module sshModule;
  private Module httpModule;

  private Provider<ModuleGenerator> sshGen;
  private Provider<ModuleGenerator> httpGen;

  private Map<TypeLiteral<?>, DynamicItem<?>> sysItems;
  private Map<TypeLiteral<?>, DynamicItem<?>> sshItems;
  private Map<TypeLiteral<?>, DynamicItem<?>> httpItems;

  private Map<TypeLiteral<?>, DynamicSet<?>> sysSets;
  private Map<TypeLiteral<?>, DynamicSet<?>> sshSets;
  private Map<TypeLiteral<?>, DynamicSet<?>> httpSets;

  private Map<TypeLiteral<?>, DynamicMap<?>> sysMaps;
  private Map<TypeLiteral<?>, DynamicMap<?>> sshMaps;
  private Map<TypeLiteral<?>, DynamicMap<?>> httpMaps;

  @Inject
  PluginGuiceEnvironment(
      Injector sysInjector,
      ThreadLocalRequestContext local,
      ServerInformation srvInfo,
      CopyConfigModule ccm,
      MetricMaker serverMetrics) {
    this.sysInjector = sysInjector;
    this.srvInfo = srvInfo;
    this.local = local;
    this.copyConfigModule = ccm;
    this.copyConfigKeys = Guice.createInjector(ccm).getAllBindings().keySet();
    this.serverMetrics = serverMetrics;

    onStart = new CopyOnWriteArrayList<>();
    onStart.addAll(listeners(sysInjector, StartPluginListener.class));

    onStop = new CopyOnWriteArrayList<>();
    onStop.addAll(listeners(sysInjector, StopPluginListener.class));

    onReload = new CopyOnWriteArrayList<>();
    onReload.addAll(listeners(sysInjector, ReloadPluginListener.class));

    sysItems = dynamicItemsOf(sysInjector);
    sysSets = dynamicSetsOf(sysInjector);
    sysMaps = dynamicMapsOf(sysInjector);
  }

  ServerInformation getServerInformation() {
    return srvInfo;
  }

  MetricMaker getServerMetrics() {
    return serverMetrics;
  }

  boolean hasDynamicItem(TypeLiteral<?> type) {
    return sysItems.containsKey(type)
        || (sshItems != null && sshItems.containsKey(type))
        || (httpItems != null && httpItems.containsKey(type));
  }

  boolean hasDynamicSet(TypeLiteral<?> type) {
    return sysSets.containsKey(type)
        || (sshSets != null && sshSets.containsKey(type))
        || (httpSets != null && httpSets.containsKey(type));
  }

  boolean hasDynamicMap(TypeLiteral<?> type) {
    return sysMaps.containsKey(type)
        || (sshMaps != null && sshMaps.containsKey(type))
        || (httpMaps != null && httpMaps.containsKey(type));
  }

  public Module getSysModule() {
    return sysModule;
  }

  public void setDbCfgInjector(Injector dbInjector, Injector cfgInjector) {
    final Module db = copy(dbInjector);
    final Module cm = copy(cfgInjector);
    final Module sm = copy(sysInjector);
    sysModule = new AbstractModule() {
      @Override
      protected void configure() {
        install(copyConfigModule);
        install(db);
        install(cm);
        install(sm);
      }
    };
  }

  public void setSshInjector(Injector injector) {
    sshModule = copy(injector);
    sshGen = injector.getProvider(ModuleGenerator.class);
    sshItems = dynamicItemsOf(injector);
    sshSets = dynamicSetsOf(injector);
    sshMaps = dynamicMapsOf(injector);
    onStart.addAll(listeners(injector, StartPluginListener.class));
    onStop.addAll(listeners(injector, StopPluginListener.class));
    onReload.addAll(listeners(injector, ReloadPluginListener.class));
  }

  boolean hasSshModule() {
    return sshModule != null;
  }

  Module getSshModule() {
    return sshModule;
  }

  ModuleGenerator newSshModuleGenerator() {
    return sshGen.get();
  }

  public void setHttpInjector(Injector injector) {
    httpModule = copy(injector);
    httpGen = injector.getProvider(ModuleGenerator.class);
    httpItems = dynamicItemsOf(injector);
    httpSets = httpDynamicSetsOf(injector);
    httpMaps = dynamicMapsOf(injector);
    onStart.addAll(listeners(injector, StartPluginListener.class));
    onStop.addAll(listeners(injector, StopPluginListener.class));
    onReload.addAll(listeners(injector, ReloadPluginListener.class));
  }

  private Map<TypeLiteral<?>, DynamicSet<?>> httpDynamicSetsOf(Injector i) {
    // Copy binding of DynamicSet<WebUiPlugin> from sysInjector to HTTP.
    // This supports older plugins that bound a plugin in the HttpModule.
    TypeLiteral<WebUiPlugin> key = TypeLiteral.get(WebUiPlugin.class);
    DynamicSet<?> web = sysSets.get(key);
    checkNotNull(web, "DynamicSet<WebUiPlugin> exists in sysInjector");

    Map<TypeLiteral<?>, DynamicSet<?>> m = new HashMap<>(dynamicSetsOf(i));
    m.put(key, web);
    return Collections.unmodifiableMap(m);
  }

  boolean hasHttpModule() {
    return httpModule != null;
  }

  Module getHttpModule() {
    return httpModule;
  }

  ModuleGenerator newHttpModuleGenerator() {
    return httpGen.get();
  }

  public RequestContext enter(Plugin plugin) {
    return local.setContext(new PluginRequestContext(plugin.getPluginUser()));
  }

  public void exit(RequestContext old) {
    local.setContext(old);
  }

  public void onStartPlugin(Plugin plugin) {
    RequestContext oldContext = enter(plugin);
    try {
      attachItem(sysItems, plugin.getSysInjector(), plugin);
      attachItem(sshItems, plugin.getSshInjector(), plugin);
      attachItem(httpItems, plugin.getHttpInjector(), plugin);

      attachSet(sysSets, plugin.getSysInjector(), plugin);
      attachSet(sshSets, plugin.getSshInjector(), plugin);
      attachSet(httpSets, plugin.getHttpInjector(), plugin);

      attachMap(sysMaps, plugin.getSysInjector(), plugin);
      attachMap(sshMaps, plugin.getSshInjector(), plugin);
      attachMap(httpMaps, plugin.getHttpInjector(), plugin);
    } finally {
      exit(oldContext);
    }

    for (StartPluginListener l : onStart) {
      l.onStartPlugin(plugin);
    }
  }

  void onStopPlugin(Plugin plugin) {
    for (StopPluginListener l : onStop) {
      l.onStopPlugin(plugin);
    }
  }

  private void attachItem(Map<TypeLiteral<?>, DynamicItem<?>> items,
      @Nullable Injector src,
      Plugin plugin) {
    for (RegistrationHandle h : PrivateInternals_DynamicTypes
        .attachItems(src, items, plugin.getName())) {
      plugin.add(h);
    }
  }

  private void attachSet(Map<TypeLiteral<?>, DynamicSet<?>> sets,
      @Nullable Injector src,
      Plugin plugin) {
    for (RegistrationHandle h : PrivateInternals_DynamicTypes
        .attachSets(src, sets)) {
      plugin.add(h);
    }
  }

  private void attachMap(Map<TypeLiteral<?>, DynamicMap<?>> maps,
      @Nullable Injector src,
      Plugin plugin) {
    for (RegistrationHandle h : PrivateInternals_DynamicTypes
        .attachMaps(src, plugin.getName(), maps)) {
      plugin.add(h);
    }
  }

  void onReloadPlugin(Plugin oldPlugin, Plugin newPlugin) {
    // Index all old registrations by the raw type. These may be replaced
    // during the reattach calls below. Any that are not replaced will be
    // removed when the old plugin does its stop routine.
    ListMultimap<TypeLiteral<?>, ReloadableRegistrationHandle<?>> old =
        LinkedListMultimap.create();
    for (ReloadableRegistrationHandle<?> h : oldPlugin.getReloadableHandles()) {
      old.put(h.getKey().getTypeLiteral(), h);
    }

    RequestContext oldContext = enter(newPlugin);
    try {
      reattachMap(old, sysMaps, newPlugin.getSysInjector(), newPlugin);
      reattachMap(old, sshMaps, newPlugin.getSshInjector(), newPlugin);
      reattachMap(old, httpMaps, newPlugin.getHttpInjector(), newPlugin);

      reattachSet(old, sysSets, newPlugin.getSysInjector(), newPlugin);
      reattachSet(old, sshSets, newPlugin.getSshInjector(), newPlugin);
      reattachSet(old, httpSets, newPlugin.getHttpInjector(), newPlugin);

      reattachItem(old, sysItems, newPlugin.getSysInjector(), newPlugin);
      reattachItem(old, sshItems, newPlugin.getSshInjector(), newPlugin);
      reattachItem(old, httpItems, newPlugin.getHttpInjector(), newPlugin);
    } finally {
      exit(oldContext);
    }

    for (ReloadPluginListener l : onReload) {
      l.onReloadPlugin(oldPlugin, newPlugin);
    }
  }

  private void reattachMap(
      ListMultimap<TypeLiteral<?>, ReloadableRegistrationHandle<?>> oldHandles,
      Map<TypeLiteral<?>, DynamicMap<?>> maps,
      @Nullable Injector src,
      Plugin newPlugin) {
    if (src == null || maps == null || maps.isEmpty()) {
      return;
    }

    for (Map.Entry<TypeLiteral<?>, DynamicMap<?>> e : maps.entrySet()) {
      @SuppressWarnings("unchecked")
      TypeLiteral<Object> type = (TypeLiteral<Object>) e.getKey();

      @SuppressWarnings("unchecked")
      PrivateInternals_DynamicMapImpl<Object> map =
          (PrivateInternals_DynamicMapImpl<Object>) e.getValue();

      Map<Annotation, ReloadableRegistrationHandle<?>> am = new HashMap<>();
      for (ReloadableRegistrationHandle<?> h : oldHandles.get(type)) {
        Annotation a = h.getKey().getAnnotation();
        if (a != null && !UNIQUE_ANNOTATION.isInstance(a)) {
          am.put(a, h);
        }
      }

      for (Binding<?> binding : bindings(src, e.getKey())) {
        @SuppressWarnings("unchecked")
        Binding<Object> b = (Binding<Object>) binding;
        Key<Object> key = b.getKey();
        if (key.getAnnotation() == null) {
          continue;
        }

        @SuppressWarnings("unchecked")
        ReloadableRegistrationHandle<Object> h =
            (ReloadableRegistrationHandle<Object>) am.remove(key.getAnnotation());
        if (h != null) {
          replace(newPlugin, h, b);
          oldHandles.remove(type, h);
        } else {
          newPlugin.add(map.put(
              newPlugin.getName(),
              b.getKey(),
              b.getProvider()));
        }
      }
    }
  }

  /** Type used to declare unique annotations. Guice hides this, so extract it. */
  private static final Class<?> UNIQUE_ANNOTATION =
      UniqueAnnotations.create().getClass();

  private void reattachSet(
      ListMultimap<TypeLiteral<?>, ReloadableRegistrationHandle<?>> oldHandles,
      Map<TypeLiteral<?>, DynamicSet<?>> sets,
      @Nullable Injector src,
      Plugin newPlugin) {
    if (src == null || sets == null || sets.isEmpty()) {
      return;
    }

    for (Map.Entry<TypeLiteral<?>, DynamicSet<?>> e : sets.entrySet()) {
      @SuppressWarnings("unchecked")
      TypeLiteral<Object> type = (TypeLiteral<Object>) e.getKey();

      @SuppressWarnings("unchecked")
      DynamicSet<Object> set = (DynamicSet<Object>) e.getValue();

      // Index all old handles that match this DynamicSet<T> keyed by
      // annotations. Ignore the unique annotations, thereby favoring
      // the @Named annotations or some other non-unique naming.
      Map<Annotation, ReloadableRegistrationHandle<?>> am = new HashMap<>();
      List<ReloadableRegistrationHandle<?>> old = oldHandles.get(type);
      Iterator<ReloadableRegistrationHandle<?>> oi = old.iterator();
      while (oi.hasNext()) {
        ReloadableRegistrationHandle<?> h = oi.next();
        Annotation a = h.getKey().getAnnotation();
        if (a != null && !UNIQUE_ANNOTATION.isInstance(a)) {
          am.put(a, h);
          oi.remove();
        }
      }

      // Replace old handles with new bindings, favoring cases where there
      // is an exact match on an @Named annotation. If there is no match
      // pick any handle and replace it. We generally expect only one
      // handle of each DynamicSet type when using unique annotations, but
      // possibly multiple ones if @Named was used. Plugin authors that want
      // atomic replacement across reloads should use @Named annotations with
      // stable names that do not change across plugin versions to ensure the
      // handles are swapped correctly.
      oi = old.iterator();
      for (Binding<?> binding : bindings(src, type)) {
        @SuppressWarnings("unchecked")
        Binding<Object> b = (Binding<Object>) binding;
        Key<Object> key = b.getKey();
        if (key.getAnnotation() == null) {
          continue;
        }

        @SuppressWarnings("unchecked")
        ReloadableRegistrationHandle<Object> h1 =
            (ReloadableRegistrationHandle<Object>) am.remove(key.getAnnotation());
        if (h1 != null) {
          replace(newPlugin, h1, b);
        } else if (oi.hasNext()) {
          @SuppressWarnings("unchecked")
          ReloadableRegistrationHandle<Object> h2 =
            (ReloadableRegistrationHandle<Object>) oi.next();
          oi.remove();
          replace(newPlugin, h2, b);
        } else {
          newPlugin.add(set.add(b.getKey(), b.getProvider()));
        }
      }
    }
  }

  private void reattachItem(
      ListMultimap<TypeLiteral<?>, ReloadableRegistrationHandle<?>> oldHandles,
      Map<TypeLiteral<?>, DynamicItem<?>> items,
      @Nullable Injector src,
      Plugin newPlugin) {
    if (src == null || items == null || items.isEmpty()) {
      return;
    }

    for (Map.Entry<TypeLiteral<?>, DynamicItem<?>> e : items.entrySet()) {
      @SuppressWarnings("unchecked")
      TypeLiteral<Object> type = (TypeLiteral<Object>) e.getKey();

      @SuppressWarnings("unchecked")
      DynamicItem<Object> item = (DynamicItem<Object>) e.getValue();

      Iterator<ReloadableRegistrationHandle<?>> oi =
          oldHandles.get(type).iterator();

      for (Binding<?> binding : bindings(src, type)) {
        @SuppressWarnings("unchecked")
        Binding<Object> b = (Binding<Object>) binding;
        if (oi.hasNext()) {
          @SuppressWarnings("unchecked")
          ReloadableRegistrationHandle<Object> h =
            (ReloadableRegistrationHandle<Object>) oi.next();
          oi.remove();
          replace(newPlugin, h, b);
        } else {
          newPlugin.add(item.set(b.getKey(), b.getProvider(),
              newPlugin.getName()));
        }
      }
    }
  }

  private static <T> void replace(Plugin newPlugin,
      ReloadableRegistrationHandle<T> h, Binding<T> b) {
    RegistrationHandle n = h.replace(b.getKey(), b.getProvider());
    if (n != null) {
      newPlugin.add(n);
    }
  }

  static <T> List<T> listeners(Injector src, Class<T> type) {
    List<Binding<T>> bindings = bindings(src, TypeLiteral.get(type));
    int cnt = bindings != null ? bindings.size() : 0;
    List<T> found = Lists.newArrayListWithCapacity(cnt);
    if (bindings != null) {
      for (Binding<T> b : bindings) {
        found.add(b.getProvider().get());
      }
    }
    return found;
  }

  private static <T> List<Binding<T>> bindings(Injector src, TypeLiteral<T> type) {
    return src.findBindingsByType(type);
  }

  private Module copy(Injector src) {
    Set<TypeLiteral<?>> dynamicTypes = new HashSet<>();
    Set<TypeLiteral<?>> dynamicItemTypes = new HashSet<>();
    for (Map.Entry<Key<?>, Binding<?>> e : src.getBindings().entrySet()) {
      TypeLiteral<?> type = e.getKey().getTypeLiteral();
      if (type.getRawType() == DynamicItem.class) {
        ParameterizedType t = (ParameterizedType) type.getType();
        dynamicItemTypes.add(TypeLiteral.get(t.getActualTypeArguments()[0]));
      } else if (type.getRawType() == DynamicSet.class
          || type.getRawType() == DynamicMap.class) {
        ParameterizedType t = (ParameterizedType) type.getType();
        dynamicTypes.add(TypeLiteral.get(t.getActualTypeArguments()[0]));
      }
    }

    final Map<Key<?>, Binding<?>> bindings = new LinkedHashMap<>();
    for (Map.Entry<Key<?>, Binding<?>> e : src.getBindings().entrySet()) {
      if (dynamicTypes.contains(e.getKey().getTypeLiteral())
          && e.getKey().getAnnotation() != null) {
        // A type used in DynamicSet or DynamicMap that has an annotation
        // must be picked up by the set/map itself. A type used in either
        // but without an annotation may be magic glue implementing F and
        // using DynamicSet<F> or DynamicMap<F> internally. That should be
        // exported to plugins.
        continue;
      } else if (dynamicItemTypes.contains(e.getKey().getTypeLiteral())) {
        continue;
      } else if (shouldCopy(e.getKey())) {
        bindings.put(e.getKey(), e.getValue());
      }
    }
    bindings.remove(Key.get(Injector.class));
    bindings.remove(Key.get(java.util.logging.Logger.class));

    @Nullable
    final Binding<HttpServletRequest> requestBinding =
        src.getExistingBinding(Key.get(HttpServletRequest.class));

    @Nullable
    final Binding<HttpServletResponse> responseBinding =
        src.getExistingBinding(Key.get(HttpServletResponse.class));

    return new AbstractModule() {
      @SuppressWarnings("unchecked")
      @Override
      protected void configure() {
        for (Map.Entry<Key<?>, Binding<?>> e : bindings.entrySet()) {
          Key<Object> k = (Key<Object>) e.getKey();
          Binding<Object> b = (Binding<Object>) e.getValue();
          bind(k).toProvider(b.getProvider());
        }

        if (requestBinding != null) {
          bind(HttpServletRequest.class)
              .annotatedWith(RootRelative.class)
              .toProvider(requestBinding.getProvider());
        }
        if (responseBinding != null) {
          bind(HttpServletResponse.class)
              .annotatedWith(RootRelative.class)
              .toProvider(responseBinding.getProvider());
        }
      }
    };
  }

  private boolean shouldCopy(Key<?> key) {
    if (copyConfigKeys.contains(key)) {
      return false;
    }
    Class<?> type = key.getTypeLiteral().getRawType();
    if (LifecycleListener.class.isAssignableFrom(type)
        // This is needed for secondary index to work from plugin listeners
        && !is("com.google.gerrit.server.index.IndexCollection", type)) {
      return false;
    }
    if (StartPluginListener.class.isAssignableFrom(type)) {
      return false;
    }
    if (StopPluginListener.class.isAssignableFrom(type)) {
      return false;
    }
    if (MetricMaker.class.isAssignableFrom(type)) {
      return false;
    }

    if (type.getName().startsWith("com.google.inject.")) {
      return false;
    }

    if (is("org.apache.sshd.server.Command", type)) {
      return false;
    }

    if (is("javax.servlet.Filter", type)) {
      return false;
    }
    if (is("javax.servlet.ServletContext", type)) {
      return false;
    }
    if (is("javax.servlet.ServletRequest", type)) {
      return false;
    }
    if (is("javax.servlet.ServletResponse", type)) {
      return false;
    }
    if (is("javax.servlet.http.HttpServlet", type)) {
      return false;
    }
    if (is("javax.servlet.http.HttpServletRequest", type)) {
      return false;
    }
    if (is("javax.servlet.http.HttpServletResponse", type)) {
      return false;
    }
    if (is("javax.servlet.http.HttpSession", type)) {
      return false;
    }
    if (Map.class.isAssignableFrom(type)
        && key.getAnnotationType() != null
        && "com.google.inject.servlet.RequestParameters"
            .equals(key.getAnnotationType().getName())) {
      return false;
    }
    if (type.getName().startsWith("com.google.gerrit.httpd.GitOverHttpServlet$")) {
      return false;
    }
    return true;
  }

  static boolean is(String name, Class<?> type) {
    while (type != null) {
      if (name.equals(type.getName())) {
        return true;
      }

      Class<?>[] interfaces = type.getInterfaces();
      if (interfaces != null) {
        for (Class<?> i : interfaces) {
          if (is(name, i)) {
            return true;
          }
        }
      }

      type = type.getSuperclass();
    }
    return false;
  }
}


text:
package org.springframework.jdbc.support.lob;

import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.springframework.dao.DataAccessResourceFailureException;
import org.springframework.dao.InvalidDataAccessApiUsageException;
import org.springframework.jdbc.support.nativejdbc.NativeJdbcExtractor;
import org.springframework.util.FileCopyUtils;

/**
 * {@link LobHandler} implementation for Oracle databases. Uses proprietary API
 * to create {@code oracle.sql.BLOB} and {@code oracle.sql.CLOB}
 * instances, as necessary when working with Oracle's JDBC driver.
 * Note that this LobHandler requires Oracle JDBC driver 9i or higher!
 *
 *
While most databases are able to work with {@link DefaultLobHandler},
 * Oracle 9i (or more specifically, the Oracle 9i JDBC driver) just accepts
 * Blob/Clob instances created via its own proprietary BLOB/CLOB API,
 * and additionally doesn't accept large streams for PreparedStatement's
 * corresponding setter methods. Therefore, you need to use a strategy like
 * this LobHandler implementation, or upgrade to the Oracle 10g/11g driver
 * (which still supports access to Oracle 9i databases).
 *
 *
NOTE: As of Oracle 10.2, {@link DefaultLobHandler} should work equally
 * well out of the box. On Oracle 11g, JDBC 4.0 based options such as
 * {@link DefaultLobHandler#setStreamAsLob} and {@link DefaultLobHandler#setCreateTemporaryLob}
 * are available as well, rendering this proprietary OracleLobHandler obsolete.
 * Also, consider upgrading to a new driver even when accessing an older database.
 * See the {@link LobHandler} interface javadoc for a summary of recommendations.
 *
 *
Needs to work on a native JDBC Connection, to be able to cast it to
 * {@code oracle.jdbc.OracleConnection}. If you pass in Connections from a
 * connection pool (the usual case in a Java EE environment), you need to set an
 * appropriate {@link org.springframework.jdbc.support.nativejdbc.NativeJdbcExtractor}
 * to allow for automatic retrieval of the underlying native JDBC Connection.
 * LobHandler and NativeJdbcExtractor are separate concerns, therefore they
 * are represented by separate strategy interfaces.
 *
 *
Coded via reflection to avoid dependencies on Oracle classes.
 * Even reads in Oracle constants via reflection because of different Oracle
 * drivers (classes12, ojdbc14, ojdbc5, ojdbc6) having different constant values!
 * As this LobHandler initializes Oracle classes on instantiation, do not define
 * this as eager-initializing singleton if you do not want to depend on the Oracle
 * JAR being in the class path: use "lazy-init=true" to avoid this issue.
 *
 * @author Juergen Hoeller
 * @author Thomas Risberg
 * @since 04.12.2003
 * @see DefaultLobHandler
 * @see #setNativeJdbcExtractor
 * @deprecated in favor of {@link DefaultLobHandler} for the Oracle 10g driver and
 * higher. Consider using the 10g/11g driver even against an Oracle 9i database!
 * {@link DefaultLobHandler#setCreateTemporaryLob} is the direct equivalent of this
 * OracleLobHandler's implementation strategy, just using standard JDBC 4.0 API.
 * That said, in most cases, regular DefaultLobHandler setup will work fine as well.
 */
@Deprecated
public class OracleLobHandler extends AbstractLobHandler {

	private static final String BLOB_CLASS_NAME = "oracle.sql.BLOB";

	private static final String CLOB_CLASS_NAME = "oracle.sql.CLOB";

	private static final String DURATION_SESSION_FIELD_NAME = "DURATION_SESSION";

	private static final String MODE_READWRITE_FIELD_NAME = "MODE_READWRITE";

	private static final String MODE_READONLY_FIELD_NAME = "MODE_READONLY";

	protected final Log logger = LogFactory.getLog(getClass());

	private NativeJdbcExtractor nativeJdbcExtractor;

	private Boolean cache = Boolean.TRUE;

	private Boolean releaseResourcesAfterRead = Boolean.FALSE;

	private Class<?> blobClass;

	private Class<?> clobClass;

	private final Map<Class<?>, Integer> durationSessionConstants = new HashMap<Class<?>, Integer>(2);

	private final Map<Class<?>, Integer> modeReadWriteConstants = new HashMap<Class<?>, Integer>(2);

	private final Map<Class<?>, Integer> modeReadOnlyConstants = new HashMap<Class<?>, Integer>(2);

	/**
	 * Set an appropriate NativeJdbcExtractor to be able to retrieve the underlying
	 * native {@code oracle.jdbc.OracleConnection}. This is necessary for
	 * DataSource-based connection pools, as those need to return wrapped JDBC
	 * Connection handles that cannot be cast to a native Connection implementation.
	 *
Effectively, this LobHandler just invokes a single NativeJdbcExtractor
	 * method, namely {@code getNativeConnectionFromStatement} with a
	 * PreparedStatement argument (falling back to a
	 * {@code PreparedStatement.getConnection()} call if no extractor is set).
	 *
A common choice is {@code SimpleNativeJdbcExtractor}, whose Connection unwrapping
	 * (which is what OracleLobHandler needs) will work with many connection pools.
	 * See {@code SimpleNativeJdbcExtractor} and
	 *
	 * oracle.jdbc.OracleConnection javadoc for details.
	 * @see org.springframework.jdbc.support.nativejdbc.NativeJdbcExtractor#getNativeConnectionFromStatement
	 * @see org.springframework.jdbc.support.nativejdbc.SimpleNativeJdbcExtractor
	 * @see org.springframework.jdbc.support.nativejdbc.OracleJdbc4NativeJdbcExtractor
	 */
	public void setNativeJdbcExtractor(NativeJdbcExtractor nativeJdbcExtractor) {
		this.nativeJdbcExtractor = nativeJdbcExtractor;
	}

	/**
	 * Set whether to cache the temporary LOB in the buffer cache.
	 * This value will be passed into BLOB/CLOB.createTemporary.
	 *
Default is {@code true}.
	 *
See Also:
	 *

	 *
oracle.sql.BLOB.createTemporary

	 *
oracle.sql.CLOB.createTemporary

	 *

	 */
	public void setCache(boolean cache) {
		this.cache = cache;
	}

	/**
	 * Set whether to aggressively release any resources used by the LOB. If set to {@code true}
	 * then you can only read the LOB values once. Any subsequent reads will fail since the resources
	 * have been closed.
	 *
Setting this property to {@code true} can be useful when your queries generates large
	 * temporary LOBs that occupy space in the TEMPORARY tablespace or when you want to free up any
	 * memory allocated by the driver for the LOB reading.
	 *
Default is {@code false}.
	 *
See Also:
	 *

	 *
oracle.sql.BLOB.freeTemporary

	 *
oracle.sql.CLOB.freeTemporary

	 *
oracle.sql.BLOB.open

	 *
oracle.sql.CLOB.open

	 *
oracle.sql.BLOB.close

	 *
oracle.sql.CLOB.close

	 *

	 */
	public void setReleaseResourcesAfterRead(boolean releaseResources) {
		this.releaseResourcesAfterRead = releaseResources;
	}

	/**
	 * Retrieve the {@code oracle.sql.BLOB} and {@code oracle.sql.CLOB}
	 * classes via reflection, and initialize the values for the
	 * DURATION_SESSION, MODE_READWRITE and MODE_READONLY constants defined there.
	 *
See Also:
	 *

	 *
oracle.sql.BLOB.DURATION_SESSION

	 *
oracle.sql.BLOB.MODE_READWRITE

	 *
oracle.sql.BLOB.MODE_READONLY

	 *
oracle.sql.CLOB.DURATION_SESSION

	 *
oracle.sql.CLOB.MODE_READWRITE

	 *
oracle.sql.CLOB.MODE_READONLY

	 *

	 * @param con the Oracle Connection, for using the exact same class loader
	 * that the Oracle driver was loaded with
	 */
	protected synchronized void initOracleDriverClasses(Connection con) {
		if (this.blobClass == null) {
			try {
				// Initialize oracle.sql.BLOB class
				this.blobClass = con.getClass().getClassLoader().loadClass(BLOB_CLASS_NAME);
				this.durationSessionConstants.put(
						this.blobClass, this.blobClass.getField(DURATION_SESSION_FIELD_NAME).getInt(null));
				this.modeReadWriteConstants.put(
						this.blobClass, this.blobClass.getField(MODE_READWRITE_FIELD_NAME).getInt(null));
				this.modeReadOnlyConstants.put(
						this.blobClass, this.blobClass.getField(MODE_READONLY_FIELD_NAME).getInt(null));

				// Initialize oracle.sql.CLOB class
				this.clobClass = con.getClass().getClassLoader().loadClass(CLOB_CLASS_NAME);
				this.durationSessionConstants.put(
						this.clobClass, this.clobClass.getField(DURATION_SESSION_FIELD_NAME).getInt(null));
				this.modeReadWriteConstants.put(
						this.clobClass, this.clobClass.getField(MODE_READWRITE_FIELD_NAME).getInt(null));
				this.modeReadOnlyConstants.put(
						this.clobClass, this.clobClass.getField(MODE_READONLY_FIELD_NAME).getInt(null));
			}
			catch (Exception ex) {
				throw new InvalidDataAccessApiUsageException(
						"Couldn't initialize OracleLobHandler because Oracle driver classes are not available. " +
						"Note that OracleLobHandler requires Oracle JDBC driver 9i or higher!", ex);
			}
		}
	}

	@Override
	public byte[] getBlobAsBytes(ResultSet rs, int columnIndex) throws SQLException {
		logger.debug("Returning Oracle BLOB as bytes");
		Blob blob = rs.getBlob(columnIndex);
		initializeResourcesBeforeRead(rs.getStatement().getConnection(), blob);
		byte[] retVal = (blob != null ? blob.getBytes(1, (int) blob.length()) : null);
		releaseResourcesAfterRead(rs.getStatement().getConnection(), blob);
		return retVal;
	}

	@Override
	public InputStream getBlobAsBinaryStream(ResultSet rs, int columnIndex) throws SQLException {
		logger.debug("Returning Oracle BLOB as binary stream");
		Blob blob = rs.getBlob(columnIndex);
		initializeResourcesBeforeRead(rs.getStatement().getConnection(), blob);
		InputStream retVal = (blob != null ? blob.getBinaryStream() : null);
		releaseResourcesAfterRead(rs.getStatement().getConnection(), blob);
		return retVal;
	}

	@Override
	public String getClobAsString(ResultSet rs, int columnIndex) throws SQLException {
		logger.debug("Returning Oracle CLOB as string");
		Clob clob = rs.getClob(columnIndex);
		initializeResourcesBeforeRead(rs.getStatement().getConnection(), clob);
		String retVal = (clob != null ? clob.getSubString(1, (int) clob.length()) : null);
		releaseResourcesAfterRead(rs.getStatement().getConnection(), clob);
		return retVal;
	}

	@Override
	public InputStream getClobAsAsciiStream(ResultSet rs, int columnIndex) throws SQLException {
		logger.debug("Returning Oracle CLOB as ASCII stream");
		Clob clob = rs.getClob(columnIndex);
		initializeResourcesBeforeRead(rs.getStatement().getConnection(), clob);
		InputStream retVal = (clob != null ? clob.getAsciiStream() : null);
		releaseResourcesAfterRead(rs.getStatement().getConnection(), clob);
		return retVal;
	}

	@Override
	public Reader getClobAsCharacterStream(ResultSet rs, int columnIndex) throws SQLException {
		logger.debug("Returning Oracle CLOB as character stream");
		Clob clob = rs.getClob(columnIndex);
		initializeResourcesBeforeRead(rs.getStatement().getConnection(), clob);
		Reader retVal = (clob != null ? clob.getCharacterStream() : null);
		releaseResourcesAfterRead(rs.getStatement().getConnection(), clob);
		return retVal;
	}

	@Override
	public LobCreator getLobCreator() {
		return new OracleLobCreator();
	}

	/**
	 * Initialize any LOB resources before a read is done.
	 *
This implementation calls {@code BLOB.open(BLOB.MODE_READONLY)} or
	 * {@code CLOB.open(CLOB.MODE_READONLY)} on any non-temporary LOBs if
	 * {@code releaseResourcesAfterRead} property is set to {@code true}.
	 *
This method can be overridden by sublcasses if different behavior is desired.
	 * @param con the connection to be usde for initilization
	 * @param lob the LOB to initialize
	 */
	protected void initializeResourcesBeforeRead(Connection con, Object lob) {
		if (this.releaseResourcesAfterRead) {
			initOracleDriverClasses(con);
			try {
				/*
				if (!((BLOB) lob.isTemporary() {
				*/
				Method isTemporary = lob.getClass().getMethod("isTemporary");
				Boolean temporary = (Boolean) isTemporary.invoke(lob);
				if (!temporary) {
					/*
					((BLOB) lob).open(BLOB.MODE_READONLY);
					*/
					Method open = lob.getClass().getMethod("open", int.class);
					open.invoke(lob, this.modeReadOnlyConstants.get(lob.getClass()));
				}
			}
			catch (InvocationTargetException ex) {
				logger.error("Could not open Oracle LOB", ex.getTargetException());
			}
			catch (Exception ex) {
				throw new DataAccessResourceFailureException("Could not open Oracle LOB", ex);
			}
		}
	}

	/**
	 * Release any LOB resources after read is complete.
	 *
If {@code releaseResourcesAfterRead} property is set to {@code true}
	 * then this implementation calls
	 * {@code BLOB.close()} or {@code CLOB.close()}
	 * on any non-temporary LOBs that are open or
	 * {@code BLOB.freeTemporary()} or {@code CLOB.freeTemporary()}
	 * on any temporary LOBs.
	 *
This method can be overridden by sublcasses if different behavior is desired.
	 * @param con the connection to be usde for initilization
	 * @param lob the LOB to initialize
	 */
	protected void releaseResourcesAfterRead(Connection con, Object lob) {
		if (this.releaseResourcesAfterRead) {
			initOracleDriverClasses(con);
			Boolean temporary = Boolean.FALSE;
			try {
				/*
				if (((BLOB) lob.isTemporary() {
				*/
				Method isTemporary = lob.getClass().getMethod("isTemporary");
				temporary = (Boolean) isTemporary.invoke(lob);
				if (temporary) {
					/*
					((BLOB) lob).freeTemporary();
					*/
					Method freeTemporary = lob.getClass().getMethod("freeTemporary");
					freeTemporary.invoke(lob);
				}
				else {
					/*
					if (((BLOB) lob.isOpen() {
					*/
					Method isOpen = lob.getClass().getMethod("isOpen");
					Boolean open = (Boolean) isOpen.invoke(lob);
					if (open) {
						/*
						((BLOB) lob).close();
						*/
						Method close = lob.getClass().getMethod("close");
						close.invoke(lob);
					}
				}
			}
			catch (InvocationTargetException ex) {
				if (temporary) {
					logger.error("Could not free Oracle LOB", ex.getTargetException());
				}
				else {
					logger.error("Could not close Oracle LOB", ex.getTargetException());
				}
			}
			catch (Exception ex) {
				if (temporary) {
					throw new DataAccessResourceFailureException("Could not free Oracle LOB", ex);
				}
				else {
					throw new DataAccessResourceFailureException("Could not close Oracle LOB", ex);
				}
			}
		}
	}

	/**
	 * LobCreator implementation for Oracle databases.
	 * Creates Oracle-style temporary BLOBs and CLOBs that it frees on close.
	 * @see #close
	 */
	protected class OracleLobCreator implements LobCreator {

		private final List<Object> temporaryLobs = new LinkedList<Object>();

		@Override
		public void setBlobAsBytes(PreparedStatement ps, int paramIndex, final byte[] content)
				throws SQLException {

			if (content != null) {
				Blob blob = (Blob) createLob(ps, false, new LobCallback() {
					@Override
					public void populateLob(Object lob) throws Exception {
						Method methodToInvoke = lob.getClass().getMethod("getBinaryOutputStream");
						OutputStream out = (OutputStream) methodToInvoke.invoke(lob);
						FileCopyUtils.copy(content, out);
					}
				});
				ps.setBlob(paramIndex, blob);
				if (logger.isDebugEnabled()) {
					logger.debug("Set bytes for Oracle BLOB with length " + blob.length());
				}
			}
			else {
				ps.setBlob(paramIndex, (Blob) null);
				logger.debug("Set Oracle BLOB to null");
			}
		}

		@Override
		public void setBlobAsBinaryStream(
				PreparedStatement ps, int paramIndex, final InputStream binaryStream, int contentLength)
				throws SQLException {

			if (binaryStream != null) {
				Blob blob = (Blob) createLob(ps, false, new LobCallback() {
					@Override
					public void populateLob(Object lob) throws Exception {
						Method methodToInvoke = lob.getClass().getMethod("getBinaryOutputStream", (Class[]) null);
						OutputStream out = (OutputStream) methodToInvoke.invoke(lob, (Object[]) null);
						FileCopyUtils.copy(binaryStream, out);
					}
				});
				ps.setBlob(paramIndex, blob);
				if (logger.isDebugEnabled()) {
					logger.debug("Set binary stream for Oracle BLOB with length " + blob.length());
				}
			}
			else {
				ps.setBlob(paramIndex, (Blob) null);
				logger.debug("Set Oracle BLOB to null");
			}
		}

		@Override
		public void setClobAsString(PreparedStatement ps, int paramIndex, final String content)
			throws SQLException {

			if (content != null) {
				Clob clob = (Clob) createLob(ps, true, new LobCallback() {
					@Override
					public void populateLob(Object lob) throws Exception {
						Method methodToInvoke = lob.getClass().getMethod("getCharacterOutputStream", (Class[]) null);
						Writer writer = (Writer) methodToInvoke.invoke(lob, (Object[]) null);
						FileCopyUtils.copy(content, writer);
					}
				});
				ps.setClob(paramIndex, clob);
				if (logger.isDebugEnabled()) {
					logger.debug("Set string for Oracle CLOB with length " + clob.length());
				}
			}
			else {
				ps.setClob(paramIndex, (Clob) null);
				logger.debug("Set Oracle CLOB to null");
			}
		}

		@Override
		public void setClobAsAsciiStream(
				PreparedStatement ps, int paramIndex, final InputStream asciiStream, int contentLength)
			throws SQLException {

			if (asciiStream != null) {
				Clob clob = (Clob) createLob(ps, true, new LobCallback() {
					@Override
					public void populateLob(Object lob) throws Exception {
						Method methodToInvoke = lob.getClass().getMethod("getAsciiOutputStream", (Class[]) null);
						OutputStream out = (OutputStream) methodToInvoke.invoke(lob, (Object[]) null);
						FileCopyUtils.copy(asciiStream, out);
					}
				});
				ps.setClob(paramIndex, clob);
				if (logger.isDebugEnabled()) {
					logger.debug("Set ASCII stream for Oracle CLOB with length " + clob.length());
				}
			}
			else {
				ps.setClob(paramIndex, (Clob) null);
				logger.debug("Set Oracle CLOB to null");
			}
		}

		@Override
		public void setClobAsCharacterStream(
				PreparedStatement ps, int paramIndex, final Reader characterStream, int contentLength)
			throws SQLException {

			if (characterStream != null) {
				Clob clob = (Clob) createLob(ps, true, new LobCallback() {
					@Override
					public void populateLob(Object lob) throws Exception {
						Method methodToInvoke = lob.getClass().getMethod("getCharacterOutputStream", (Class[]) null);
						Writer writer = (Writer) methodToInvoke.invoke(lob, (Object[]) null);
						FileCopyUtils.copy(characterStream, writer);
					}
				});
				ps.setClob(paramIndex, clob);
				if (logger.isDebugEnabled()) {
					logger.debug("Set character stream for Oracle CLOB with length " + clob.length());
				}
			}
			else {
				ps.setClob(paramIndex, (Clob) null);
				logger.debug("Set Oracle CLOB to null");
			}
		}

		/**
		 * Create a LOB instance for the given PreparedStatement,
		 * populating it via the given callback.
		 */
		protected Object createLob(PreparedStatement ps, boolean clob, LobCallback callback)
				throws SQLException {

			Connection con = null;
			try {
				con = getOracleConnection(ps);
				initOracleDriverClasses(con);
				Object lob = prepareLob(con, clob ? clobClass : blobClass);
				callback.populateLob(lob);
				lob.getClass().getMethod("close", (Class[]) null).invoke(lob, (Object[]) null);
				this.temporaryLobs.add(lob);
				if (logger.isDebugEnabled()) {
					logger.debug("Created new Oracle " + (clob ? "CLOB" : "BLOB"));
				}
				return lob;
			}
			catch (SQLException ex) {
				throw ex;
			}
			catch (InvocationTargetException ex) {
				if (ex.getTargetException() instanceof SQLException) {
					throw (SQLException) ex.getTargetException();
				}
				else if (con != null && ex.getTargetException() instanceof ClassCastException) {
					throw new InvalidDataAccessApiUsageException(
							"OracleLobCreator needs to work on [oracle.jdbc.OracleConnection], not on [" +
							con.getClass().getName() + "]: specify a corresponding NativeJdbcExtractor",
							ex.getTargetException());
				}
				else {
					throw new DataAccessResourceFailureException("Could not create Oracle LOB",
							ex.getTargetException());
				}
			}
			catch (Exception ex) {
				throw new DataAccessResourceFailureException("Could not create Oracle LOB", ex);
			}
		}

		/**
		 * Retrieve the underlying OracleConnection, using a NativeJdbcExtractor if set.
		 */
		protected Connection getOracleConnection(PreparedStatement ps)
				throws SQLException, ClassNotFoundException {

			return (nativeJdbcExtractor != null ?
					nativeJdbcExtractor.getNativeConnectionFromStatement(ps) : ps.getConnection());
		}

		/**
		 * Create and open an oracle.sql.BLOB/CLOB instance via reflection.
		 */
		protected Object prepareLob(Connection con, Class<?> lobClass) throws Exception {
			/*
			BLOB blob = BLOB.createTemporary(con, false, BLOB.DURATION_SESSION);
			blob.open(BLOB.MODE_READWRITE);
			return blob;
			*/
			Method createTemporary = lobClass.getMethod(
					"createTemporary", Connection.class, boolean.class, int.class);
			Object lob = createTemporary.invoke(null, con, cache, durationSessionConstants.get(lobClass));
			Method open = lobClass.getMethod("open", int.class);
			open.invoke(lob, modeReadWriteConstants.get(lobClass));
			return lob;
		}

		/**
		 * Free all temporary BLOBs and CLOBs created by this creator.
		 */
		@Override
		public void close() {
			try {
				for (Iterator<?> it = this.temporaryLobs.iterator(); it.hasNext();) {
					/*
					BLOB blob = (BLOB) it.next();
					blob.freeTemporary();
					*/
					Object lob = it.next();
					Method freeTemporary = lob.getClass().getMethod("freeTemporary");
					freeTemporary.invoke(lob);
					it.remove();
				}
			}
			catch (InvocationTargetException ex) {
				logger.error("Could not free Oracle LOB", ex.getTargetException());
			}
			catch (Exception ex) {
				throw new DataAccessResourceFailureException("Could not free Oracle LOB", ex);
			}
		}
	}

	/**
	 * Internal callback interface for use with createLob.
	 */
	protected interface LobCallback {

		/**
		 * Populate the given BLOB or CLOB instance with content.
		 * @throws Exception any exception including InvocationTargetException
		 */
		void populateLob(Object lob) throws Exception;
	}

}


text:
"""
Support for interfacing to the Logitech SqueezeBox API.

For more details about this platform, please refer to the documentation at
https://home-assistant.io/components/media_player.squeezebox/
"""
import logging
import telnetlib
import urllib.parse

import voluptuous as vol

from homeassistant.components.media_player import (
    ATTR_MEDIA_ENQUEUE, SUPPORT_PLAY_MEDIA,
    MEDIA_TYPE_MUSIC, SUPPORT_NEXT_TRACK, SUPPORT_PAUSE, PLATFORM_SCHEMA,
    SUPPORT_PREVIOUS_TRACK, SUPPORT_SEEK, SUPPORT_TURN_OFF, SUPPORT_TURN_ON,
    SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET, MediaPlayerDevice)
from homeassistant.const import (
    CONF_HOST, CONF_PASSWORD, CONF_USERNAME, STATE_IDLE, STATE_OFF,
    STATE_PAUSED, STATE_PLAYING, STATE_UNKNOWN, CONF_PORT)
import homeassistant.helpers.config_validation as cv

_LOGGER = logging.getLogger(__name__)

DEFAULT_PORT = 9090

KNOWN_DEVICES = []

SUPPORT_SQUEEZEBOX = SUPPORT_PAUSE | SUPPORT_VOLUME_SET | \
    SUPPORT_VOLUME_MUTE | SUPPORT_PREVIOUS_TRACK | SUPPORT_NEXT_TRACK | \
    SUPPORT_SEEK | SUPPORT_TURN_ON | SUPPORT_TURN_OFF | SUPPORT_PLAY_MEDIA

PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Required(CONF_HOST): cv.string,
    vol.Optional(CONF_PASSWORD): cv.string,
    vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
    vol.Optional(CONF_USERNAME): cv.string,
})

def setup_platform(hass, config, add_devices, discovery_info=None):
    """Setup the squeezebox platform."""
    username = config.get(CONF_USERNAME)
    password = config.get(CONF_PASSWORD)

    if discovery_info is not None:
        host = discovery_info[0]
        port = DEFAULT_PORT
    else:
        host = config.get(CONF_HOST)
        port = config.get(CONF_PORT)

    # Only add a media server once
    if host in KNOWN_DEVICES:
        return False
    KNOWN_DEVICES.append(host)

    lms = LogitechMediaServer(host, port, username, password)

    if not lms.init_success:
        return False

    add_devices(lms.create_players())

    return True

class LogitechMediaServer(object):
    """Representation of a Logitech media server."""

    def __init__(self, host, port, username, password):
        """Initialize the Logitech device."""
        self.host = host
        self.port = port
        self._username = username
        self._password = password
        self.http_port = self._get_http_port()
        self.init_success = True if self.http_port else False

    def _get_http_port(self):
        """Get http port from media server, it is used to get cover art."""
        http_port = None
        try:
            http_port = self.query('pref', 'httpport', '?')
            if not http_port:
                _LOGGER.error("Unable to read data from server %s:%s",
                              self.host, self.port)
                return
            return http_port
        except ConnectionError as ex:
            _LOGGER.error("Failed to connect to server %s:%s - %s",
                          self.host, self.port, ex)
            return

    def create_players(self):
        """Create a list of SqueezeBoxDevices connected to the LMS."""
        players = []
        count = self.query('player', 'count', '?')
        for index in range(0, int(count)):
            player_id = self.query('player', 'id', str(index), '?')
            player = SqueezeBoxDevice(self, player_id)
            players.append(player)
        return players

    def query(self, *parameters):
        """Send request and await response from server."""
        telnet = telnetlib.Telnet(self.host, self.port)
        if self._username and self._password:
            telnet.write('login {username} {password}\n'.format(
                username=self._username,
                password=self._password).encode('UTF-8'))
            telnet.read_until(b'\n', timeout=3)
        message = '{}\n'.format(' '.join(parameters))
        telnet.write(message.encode('UTF-8'))
        response = telnet.read_until(b'\n', timeout=3)\
            .decode('UTF-8')\
            .split(' ')[-1]\
            .strip()
        telnet.write(b'exit\n')
        return urllib.parse.unquote(response)

    def get_player_status(self, player):
        """Get ithe status of a player."""
        #   (title) : Song title
        # Requested Information
        # a (artist): Artist name 'artist'
        # d (duration): Song duration in seconds 'duration'
        # K (artwork_url): URL to remote artwork
        tags = 'adK'
        new_status = {}
        telnet = telnetlib.Telnet(self.host, self.port)
        telnet.write('{player} status - 1 tags:{tags}\n'.format(
            player=player,
            tags=tags
            ).encode('UTF-8'))
        response = telnet.read_until(b'\n', timeout=3)\
            .decode('UTF-8')\
            .split(' ')
        telnet.write(b'exit\n')
        for item in response:
            parts = urllib.parse.unquote(item).partition(':')
            new_status[parts[0]] = parts[2]
        return new_status

# pylint: disable=too-many-instance-attributes
# pylint: disable=too-many-public-methods
class SqueezeBoxDevice(MediaPlayerDevice):
    """Representation of a SqueezeBox device."""

    # pylint: disable=too-many-arguments, abstract-method
    def __init__(self, lms, player_id):
        """Initialize the SqeezeBox device."""
        super(SqueezeBoxDevice, self).__init__()
        self._lms = lms
        self._id = player_id
        self._name = self._lms.query(self._id, 'name', '?')
        self._status = self._lms.get_player_status(self._id)

    @property
    def name(self):
        """Return the name of the device."""
        return self._name

    @property
    def state(self):
        """Return the state of the device."""
        if 'power' in self._status and self._status['power'] == '0':
            return STATE_OFF
        if 'mode' in self._status:
            if self._status['mode'] == 'pause':
                return STATE_PAUSED
            if self._status['mode'] == 'play':
                return STATE_PLAYING
            if self._status['mode'] == 'stop':
                return STATE_IDLE
        return STATE_UNKNOWN

    def update(self):
        """Retrieve latest state."""
        self._status = self._lms.get_player_status(self._id)

    @property
    def volume_level(self):
        """Volume level of the media player (0..1)."""
        if 'mixer volume' in self._status:
            return int(float(self._status['mixer volume'])) / 100.0

    @property
    def is_volume_muted(self):
        """Return true if volume is muted."""
        if 'mixer volume' in self._status:
            return self._status['mixer volume'].startswith('-')

    @property
    def media_content_id(self):
        """Content ID of current playing media."""
        if 'current_title' in self._status:
            return self._status['current_title']

    @property
    def media_content_type(self):
        """Content type of current playing media."""
        return MEDIA_TYPE_MUSIC

    @property
    def media_duration(self):
        """Duration of current playing media in seconds."""
        if 'duration' in self._status:
            return int(float(self._status['duration']))

    @property
    def media_image_url(self):
        """Image url of current playing media."""
        if 'artwork_url' in self._status:
            media_url = self._status['artwork_url']
        elif 'id' in self._status:
            media_url = ('/music/{track_id}/cover.jpg').format(
                track_id=self._status['id'])
        else:
            media_url = ('/music/current/cover.jpg?player={player}').format(
                player=self._id)

        base_url = 'http://{server}:{port}/'.format(
            server=self._lms.host,
            port=self._lms.http_port)

        return urllib.parse.urljoin(base_url, media_url)

    @property
    def media_title(self):
        """Title of current playing media."""
        if 'artist' in self._status and 'title' in self._status:
            return '{artist} - {title}'.format(
                artist=self._status['artist'],
                title=self._status['title']
                )
        if 'current_title' in self._status:
            return self._status['current_title']

    @property
    def supported_media_commands(self):
        """Flag of media commands that are supported."""
        return SUPPORT_SQUEEZEBOX

    def turn_off(self):
        """Turn off media player."""
        self._lms.query(self._id, 'power', '0')
        self.update_ha_state()

    def volume_up(self):
        """Volume up media player."""
        self._lms.query(self._id, 'mixer', 'volume', '+5')
        self.update_ha_state()

    def volume_down(self):
        """Volume down media player."""
        self._lms.query(self._id, 'mixer', 'volume', '-5')
        self.update_ha_state()

    def set_volume_level(self, volume):
        """Set volume level, range 0..1."""
        volume_percent = str(int(volume*100))
        self._lms.query(self._id, 'mixer', 'volume', volume_percent)
        self.update_ha_state()

    def mute_volume(self, mute):
        """Mute (true) or unmute (false) media player."""
        mute_numeric = '1' if mute else '0'
        self._lms.query(self._id, 'mixer', 'muting', mute_numeric)
        self.update_ha_state()

    def media_play_pause(self):
        """Send pause command to media player."""
        self._lms.query(self._id, 'pause')
        self.update_ha_state()

    def media_play(self):
        """Send play command to media player."""
        self._lms.query(self._id, 'play')
        self.update_ha_state()

    def media_pause(self):
        """Send pause command to media player."""
        self._lms.query(self._id, 'pause', '1')
        self.update_ha_state()

    def media_next_track(self):
        """Send next track command."""
        self._lms.query(self._id, 'playlist', 'index', '+1')
        self.update_ha_state()

    def media_previous_track(self):
        """Send next track command."""
        self._lms.query(self._id, 'playlist', 'index', '-1')
        self.update_ha_state()

    def media_seek(self, position):
        """Send seek command."""
        self._lms.query(self._id, 'time', position)
        self.update_ha_state()

    def turn_on(self):
        """Turn the media player on."""
        self._lms.query(self._id, 'power', '1')
        self.update_ha_state()

    def play_media(self, media_type, media_id, **kwargs):
        """
        Send the play_media command to the media player.

        If ATTR_MEDIA_ENQUEUE is True, add `media_id` to the current playlist.
        """
        if kwargs.get(ATTR_MEDIA_ENQUEUE):
            self._add_uri_to_playlist(media_id)
        else:
            self._play_uri(media_id)

    def _play_uri(self, media_id):
        """
        Replace the current play list with the uri.

        Telnet Command Strucutre:
        <playerid> playlist play <item> <title> <fadeInSecs>

        The "playlist play" command puts the specified song URL,
        playlist or directory contents into the current playlist
        and plays starting at the first item. Any songs previously
        in the playlist are discarded. An optional title value may be
        passed to set a title. This can be useful for remote URLs.
        The "fadeInSecs" parameter may be passed to specify fade-in period.

        Examples:
        Request: "04:20:00:12:23:45 playlist play
                    /music/abba/01_Voulez_Vous.mp3<LF>"
        Response: "04:20:00:12:23:45 playlist play
            /music/abba/01_Voulez_Vous.mp3<LF>"

        """
        self._lms.query(self._id, 'playlist', 'play', media_id)
        self.update_ha_state()

    def _add_uri_to_playlist(self, media_id):
        """
        Add a items to the existing playlist.

        Telnet Command Strucutre:
        <playerid> playlist add <item>

        The "playlist add" command adds the specified song URL, playlist or
        directory contents to the end of the current playlist. Songs
        currently playing or already on the playlist are not affected.

        Examples:
        Request: "04:20:00:12:23:45 playlist add
            /music/abba/01_Voulez_Vous.mp3<LF>"
        Response: "04:20:00:12:23:45 playlist add
            /music/abba/01_Voulez_Vous.mp3<LF>"

        Request: "04:20:00:12:23:45 playlist add
            /playlists/abba.m3u<LF>"
        Response: "04:20:00:12:23:45 playlist add
            /playlists/abba.m3u<LF>"

        """
        self._lms.query(self._id, 'playlist', 'add', media_id)
        self.update_ha_state()


text:
package Lev12;
/*
Три метода и максимум
Написать public static методы: int max(int, int), long max(long, long), double max(double, double).
Каждый метод должен возвращать максимальное из двух переданных в него чисел.

Требования:
1. Программа не должна выводить текст на экран.
2. Класс Solution должен содержать четыре метода.
3. Класс Solution должен содержать статический метод int max(int, int).
4. Метод int max(int, int) должен возвращать максимальное из двух чисел типа int.
5. Класс Solution должен содержать статический метод long max(long, long).
6. Метод long max(long, long) должен возвращать максимальное из двух чисел типа long.
7. Класс Solution должен содержать статический метод double max(double, double).
8. Метод double max(double, double) должен возвращать максимальное из двух чисел типа double.
 */
public class Task1210done {
  public static void main(String[] args) {

  }

  public static int max(int a, int b){
    if (a <= b){return b;}
    else {return a;}
  }

  public static long max(long a, long b){
    if (a <= b){return b;}
    else {return a;}
  }

  public static double max(double a, double b){
    if (a <= b){return b;}
    else {return a;}
  }
}


text:
"""
Copyright (c) 2013 ICRL
See the file license.txt for copying permission.
"""

from . import customisable

class Game(customisable.effects.EffectFunctions, customisable.conditions.ConditionFunctions):
	"""
	The :class:`Game` class basically represents the structure of the game (interactive novel or
	text adventure). Therefore it contains the various :class:`Scene`, global :class:`Resource` and
	global :class:`Action` instances of the game. It also keeps track of the starting scene and the
	current scene.

	:attributes:
	- `name`: A :class:`string` with the name of the game.
	- `author`:  :class:`string` with the author(s) of the game.
	- `startingScene`: A :class:`Scene` object which is the first scene that the game will load.
	- `currentScene`: A :class:`Scene` object which is the scene the player is currently in.
	- `scenes`: A :class:`list` of :class:`Scene` objects which holds all of the scenes of the game, along with their corresponding attributes.
	- `globalResources`: A :class:`list` of :class:`Resource` for storing global resources, such as player HP.
	- `globalActions`: A :class:`list` of :class:`Action` for storing global actions, such as actions which are	always available to the player (e.g. `'help'`) or actions such as checking if the player's HP falls under a certain	threshold.
	- `narrative`: A :class:`list` of narrative elements (e.g. a :class:`string` equal to "You go south.").

	"""
	def __init__(self):
		"""Initialise a :class:`Game` object."""
		self.name = ""
		self.author = ""
		self.startingScene = None
		self.currentScene = None
		self.scenes = []
		self.globalResources = []
		self.globalActions = []
		self.narrative = []
	def addResource(self, name, value):
		"""
		Initialise a :class:`Resource` object and add it to the game's Global Resources :class:`list` `globalResources`.

		:parameters:
		- `name`: The name of the new resource.
		- `value`: The value of the new resource.
		"""
		self.globalResources.append(Resource(name, value))
	def removeResource(self, resource):
		"""
		Remove a :class:`Resource` object from the the game's Global Resources :class:`list` `globalResources`.

		:parameters:
		- `resource`: The :class:`Resource` object to be removed.
		"""
		self.globalResources.remove(resource)
	def getSceneByName(self, name):
		"""
		Finds and returns a :class:`Scene` object given a :class:`string` with the name of the scene.

		:parameters:
		- `name`: A :class:`string` containing the name of the scene.

		:exceptions:
		- "ERROR: Scene not found." if no :class:`Scene` which matches `name` is found.

		:Returns:
		- The first :class:`Scene` object in `scenes` with a name that matches `name`.
		"""
		firstScene = [scene for scene in self.scenes if scene.name == name]
		if len(firstScene) == 0:
			print("ERROR: Scene '" + name + "' not found.")
			raise
		else:
			return firstScene[0]
	def getResourceByName(self, name):
		"""
		Finds and returns a :class:`Resource` object given a :class:`string` with the name of the resource. It returns the
		first resource which matches the name, starting by searching through the current scene and then through the global resources.

		:parameters:
		- `name`: A :class:`string` containing the name of the resource.

		:exceptions:
		- "ERROR: Resource not found." if no :class:`Resource` which matches `name` is found.

		:Returns:
		- The first :class:`Resource` object in `globalResources` with a name that matches `name`.
		"""
		firstResource = [resource for resource in self.currentScene.resources if resource.name == name]
		if len(firstResource) == 0:
			firstResource = [resource for resource in self.globalResources if resource.name == name]
		if len(firstResource) == 0:
			return "ERROR: Resource '" + name + "' not found."
		else:
			return firstResource[0]

class Resource:
	"""
	The :class:`Resource` class represents global information, such as the date or the weather
	in the fictional world, or values like the health state of the player. It is basically a tuple,
	containing a `name` attribute and a `value` attribute.

	:attributes:
	- `name`: A :class:`string` which holds the name of the :class:`Resource`, e.g. 'HP'.
	- `value`: This attribute holds the actual value of the resource, which can be of any type.	For example, if the resource represents the player's HP, the `value` of the :class:`Resource` can be an :class:`int` of value 10.
	"""
	def __init__(self, name, value):
		"""
		Initialise a :class:`Resource` object.
		"""
		self.name = name
		self.value = value
	def __eq__(self, other):
		return self.value == other
	def __lt__(self, other):
		return self.value < other
	def __gt__(self, other):
		return self.value > other
	def __le__(self, other):
		return self.value <= other
	def __ge__(self, other):
		return self.value >= other

class Scene:
	"""
	The :class:`Scene` class represents a location or a state in the game. Just like a :class:`Game` object
	contains lists of global resources and global actions, a :class:`Scene` object contains lists of local resources
	and local actions.

	:attributes:
	- `name`: A :class:`string` containing the name of the scene (e.g. "Cave 1").
	- `description`: A :class:`string` containing the description of the scene, which is used in the narrative of the game (e.g. "There are two doors in front of you".)
	- `resources`: A :class:`list` of :class:`Resource` objects known as local resources of a scene.
	- `actions`: A :class:`list` of :class:`Action` objects known as local actions of a scene.
	"""
	def __init__(self, description='default description', name='default room'):
		"""
		Initialise a :class:`Scene` object.
		"""
		self.name = name
		self.description = description
		self.resources = []
		self.actions = []
	def addResource(self, name, value):
		"""
		Initialise a :class:`Resource` object and add it to the scene's local Resources :class:`list` `resources`.

		:parameters:
		- `name`: The name of the new resource.
		- `value`: The value of the new resource.
		"""
		self.resources.append(Resource(name, value))
	def removeResource(self, resource):
		"""
		Remove a :class:`Resource` object from the the scene's local Resources :class:`list` `resources`.

		:parameters:
		- `resource`: The :class:`Resource` object to be removed.
		"""
		self.resources.remove(resource)

class Action:
	"""
	The :class:`Action` class represents an action that either occurs by itself or can be triggered by the player.
	An action has three switches which can be toggled:
	- `Visible`: if an action is visible it means that the player can see it as an available action.
	- `Enabled`: if an action is enabled it means that it can be viewed and triggered.
	- `Active`: if an action is active it means that it needs to be triggered by the player, otherwise it is performed on every frame.

	:attributes:
	- `name`: A :class:`string` containing the name of the action (e.g. "Go south").
	- `conditions`: A :class:`list` containing the :class:`Condition` objects that need to be evaluated before the action is performed.
	- `effectsIfTrue`: A :class:`list` containing the :class:`Effect` objects that will be resolved if all of the `conditions` return ``True``.
	- `effectsIfFalse`: A :class:`list` containing the :class:`Effect` objects that will be resolved if all of the `conditions` do NOT return ``True``.
	- `visible`: A :class:`bool` representing whether the action is visible or not.
	- `enabled`: A :class:`bool` representing whether the action is enabled or not.
	- `active`: A :class:`bool` representing whether the action is active or not.
	"""
	def __init__(self, name='default action', visible=True, enabled=True, active=True, effectsIfTrue=[], effectsIfFalse=[], conditions=[]):
		"""Initialise an :class:`Action` object."""
		self.name = name
		self.keywords = []
		self.conditions = conditions
		self.effectsIfTrue = effectsIfTrue
		self.effectsIfFalse = effectsIfFalse
		self.visible = visible
		self.enabled = enabled
		self.active = active
	def conditionsAreTrue(self):
		"""
		Checks whether all of the :class:`Condition` objects in `condition` are evaluated as ``True``.

		:Returns:
		- ``True`` if all conditions are evaluated as ``True``.
		- ``False`` otherwise.
		"""
		booleanCount = sum( [condition.evaluate() for condition in self.conditions] )
		return booleanCount == len(self.conditions)
	def perform(self):
		"""
		Resolves the :class:`Effect` objects from `effectsIfTrue` if :func:`conditionsAreTrue` returns ``True``.
		Resolves the :class:`Effect` objects from `effectsIfFalse` if :func:`conditionsAreTrue` returns ``False`.
		"""
		if self.conditionsAreTrue():
			for effect in self.effectsIfTrue:
				effect.resolve()
		else:
			for effect in self.effectsIfFalse:
				effect.resolve()

class Condition:
	"""
	The :class:`Condition` class is used in an :class:`Action` object to create conditional evaluation of actions.

	:attributes:
	- `conditionFunction`: A function which is used as an operator to compare `args`.
	- `args`: A :class:`list` containing the arguments for the conditional (usually a left-hand side and a right-hand side element).
	- `rawArgs`: A :class:`list` containing the names of the arguments from `args`.
	- `evalArgs`: A :class:`list` which is populated with the actual values of `args`, which are evaluated during run-time.
	"""
	def __init__(self, conditionFunction=None, *args):
		"""Initialise a :class:`Condition` object."""
		self.conditionFunction = conditionFunction
		self.args = args
		self.rawArgs = []
		self.evalArgs = []
	def evaluate(self):
		"""
		Evaluate the condition.

		:Returns:
		- A :class:`bool`.
		"""
		self.evalArgs = [arg(n) for arg,n in zip(self.args, self.rawArgs)]
		return self.conditionFunction(*self.evalArgs)

class Effect:
	"""
	The :class:`Effect` class is used in an :class:`Action` object to create the output of actions.

	:attributes:
	- `effectFunction`: A function which performs the wanted behaviour of the effect.
	- `args`: A :class:`list` containing the arguments which are passed to `effectFunction`.
	- `rawArgs`: A :class:`list` containing the names of the arguments from `args`.
	- `evalArgs`: A :class:`list` which is populated with the actual values of `args`, which are evaluated during run-time.
	- `parent`: A container of the :class:`Action` object to which the current :class:`Effect` objects belongs.
	"""
	def __init__(self, effectFunction=None, *args):
		""" Initialise an :class:`Effect` object."""
		self.effectFunction = effectFunction
		self.args = args
		self.rawArgs = []
		self.evalArgs = []
		self.parent = None
	def resolve(self):
		"""
		Resolve the effect.
		"""
		self.evalArgs = [self.parent] + [arg(n) for arg,n in zip(self.args, self.rawArgs)]
		self.effectFunction(*self.evalArgs)


text:
	<title>Julia Smith's panel show appearances</title>

	<link rel="stylesheet" media="all" href="../style.css" type="text/css"/>

Julia Smith's panel show appearances

Julia Smith (born 1927-05-26[ref]) has appeared in 1 episodes between 2006-2006.  Julia Smith on IMDB. Julia Smith on Wikipedia.

2006

2006-03-30 / In Our Time