text:
file(REMOVE_RECURSE
  "CMakeFiles/LLVMNaClTransforms.dir/AddPNaClExternalDecls.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/BackendCanonicalize.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/CanonicalizeMemIntrinsics.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/CleanupUsedGlobalsMetadata.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/ConstantInsertExtractElementIndex.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/ExceptionInfoWriter.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/ExpandArithWithOverflow.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/ExpandByVal.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/ExpandConstantExpr.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/ExpandCtors.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/ExpandGetElementPtr.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/ExpandIndirectBr.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/ExpandLargeIntegers.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/ExpandShuffleVector.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/ExpandSmallArguments.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/ExpandStructRegs.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/ExpandTls.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/ExpandTlsConstantExpr.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/ExpandUtils.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/ExpandVarArgs.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/FixVectorLoadStoreAlignment.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/FlattenGlobals.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/SimplifiedFuncTypeMap.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/GlobalCleanup.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/GlobalizeConstantVectors.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/InsertDivideCheck.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/InternalizeUsedGlobals.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/NormalizeAlignment.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/PNaClABISimplify.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/PNaClSjLjEH.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/PromoteI1Ops.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/PromoteIntegers.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/RemoveAsmMemory.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/ReplacePtrsWithInts.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/ResolvePNaClIntrinsics.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/RewriteAtomics.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/RewriteLLVMIntrinsics.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/RewritePNaClLibraryCalls.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/SimplifyAllocas.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/SimplifyStructRegSignatures.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/StripAttributes.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/StripMetadata.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/ExpandI64.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/ExpandInsertExtractElement.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/LowerEmAsyncify.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/LowerEmExceptionsPass.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/LowerEmSetjmp.cpp.o"
  "CMakeFiles/LLVMNaClTransforms.dir/NoExitRuntime.cpp.o"
  "../../libLLVMNaClTransforms.pdb"
  "../../libLLVMNaClTransforms.a"
)

# Per-language clean rules from dependency scanning.
foreach(lang CXX)
  include(CMakeFiles/LLVMNaClTransforms.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()


text:
using System;

namespace Arcade.Dsl.Implementation
{
    public sealed class WriteStateFlowConfigurer<T> : BaseFlowConfigurer, IFlowConfigurer<T>, IWriteStateFlowConfigurer
    {
        private readonly Delegate _selectState;
        private readonly Delegate _selectOutput;

        public WriteStateFlowConfigurer(string flowName, IFlowConfigurer previous, Delegate selectState, Delegate selectOutput)
            : base(flowName, previous)
        {
            _selectState = selectState;
            _selectOutput = selectOutput;
        }

        public Delegate SelectState
        {
            get { return _selectState; }
        }

        public Delegate SelectOutput
        {
            get { return _selectOutput; }
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
INPUT.miniColors {
	margin-right: 4px;
}

.miniColors-selector {
	position: absolute;
	width: 175px;
	height: 150px;
	background: white;
	border: solid 1px #bababa;
	-moz-box-shadow: 0 0 6px rgba(0, 0, 0, .25);
	-webkit-box-shadow: 0 0 6px rgba(0, 0, 0, .25);
	box-shadow: 0 0 6px rgba(0, 0, 0, .25);
	-moz-border-radius: 5px;
	-webkit-border-radius: 5px;
	border-radius: 5px;
	padding: 5px;
	z-index: 999999;
}

.miniColors.opacity.miniColors-selector {
	width: 200px;
}

.miniColors-selector.black {
	background: black;
	border-color: black;
}

.miniColors-colors {
	position: absolute;
	top: 5px;
	left: 5px;
	width: 150px;
	height: 150px;
	background: url(images/colors.png) -40px 0 no-repeat;
	cursor: crosshair;
}

.miniColors.opacity .miniColors-colors {
	left: 30px;
}

.miniColors-hues {
	position: absolute;
	top: 5px;
	left: 160px;
	width: 20px;
	height: 150px;
	background: url(images/colors.png) 0 0 no-repeat;
	cursor: crosshair;
}

.miniColors.opacity .miniColors-hues {
	left: 185px;
}

.miniColors-opacity {
	position: absolute;
	top: 5px;
	left: 5px;
	width: 20px;
	height: 150px;
	background: url(images/colors.png) -20px 0 no-repeat;
	cursor: crosshair;
}

.miniColors-colorPicker {
	position: absolute;
	width: 11px;
	height: 11px;
	border: 1px solid black;
	-moz-border-radius: 11px;
	-webkit-border-radius: 11px;
	border-radius: 11px;
}
.miniColors-colorPicker-inner {
	position: absolute;
	top: 0;
	left: 0;
	width: 7px;
	height: 7px;
	border: 2px solid white;
	-moz-border-radius: 9px;
	-webkit-border-radius: 9px;
	border-radius: 9px;
}

.miniColors-huePicker,
.miniColors-opacityPicker {
	position: absolute;
	left: -2px;
	width: 22px;
	height: 2px;
	border: 1px solid black;
	background: white;
	margin-top: -1px;
	border-radius: 2px;
}

.miniColors-trigger,
.miniColors-triggerWrap {
	width: 22px;
	height: 22px;
	display: inline-block;
}

.miniColors-triggerWrap {
	background: url(images/trigger-wrap.png) no-repeat;
}

.miniColors-triggerWrap.disabled {
	filter: alpha(opacity=50);
	opacity: .5;
}

.miniColors-trigger {
	vertical-align: middle;
	outline: none;
	background: url(images/trigger.png) 0 0 no-repeat;
}

.miniColors-triggerWrap.disabled .miniColors-trigger {
	cursor: default;
}


text:
package 'libmysql++-dev'

include_recipe "postgresql::client"

script 'download libstemmer once' do
  interpreter 'bash'
  code <<-SHELL
    mkdir -p /tmp/sphinx_install
    cd /tmp/sphinx_install
    curl -L -o libstemmer_c.tgz https://api.github.com/repos/zvelo/libstemmer/tarball/master
  SHELL
end

node.sphinx.versions.each do |version, path|
  log("Installing Sphinx #{version} to #{path}") { level :debug }

  script 'install sphinx with libstemmer' do
    interpreter 'bash'
    code <<-SHELL
      cd /tmp/sphinx_install
      wget http://www.sphinxsearch.com/files/sphinx-#{version}.tar.gz
      tar zxf sphinx-#{version}.tar.gz
      cp libstemmer_c.tgz sphinx-#{version}/libstemmer_c.tgz
      cd sphinx-#{version}/libstemmer_c
      tar zxvf ../libstemmer_c.tgz --strip-components 1
      cd ..
      sed -i -e 's/stem_ISO_8859_2_hungarian/stem_ISO_8859_1_hungarian/g' libstemmer_c/Makefile.in
      ./configure --with-mysql --with-pgsql --with-libstemmer --prefix=#{path}
      make && make install
    SHELL

    not_if "test -d #{path}"
  end
end

%w(indexer indextool search searchd spelldump).each do |binary|
  link "/usr/local/bin/#{binary}" do
    to "/usr/local/sphinx-#{node.sphinx.linked}/bin/#{binary}"
  end
end


text:
(function() {
    'use strict';
    // dynamic header directive
    angular
        .module('evalai')
        .directive('dynHeader', dynHeader);

    function dynHeader() {
        var directive = {
            link: link,
            templateUrl: 'dist/views/web/partials/dyn-header.html',
            transclude: true,
            restrict: 'EA'
        };
        return directive;

        function link() {
            function headerComp() {
                this.init();
            }
            headerComp.prototype = {
                init: function() {
                    // initialized mobile sidebar
                    angular.element(".button-collapse").sideNav({
                        menuWidth: 200,
                        closeOnClick: true,
                        draggable: true
                    });
                }
            };
            new headerComp();
        }
    }
})();
// define directives here
(function() {
    'use strict';
    // dynamic header directive
    angular
        .module('evalai')
        .directive('mainHeader', dynHeader);

    function dynHeader() {
        var directive = {
            link: link,
            templateUrl: 'dist/views/web/partials/main-header.html',
            transclude: true,
            restrict: 'EA',
            controller: controller,
            controllerAs: 'header'
        };
        return directive;

        function controller($scope, $element, $attrs, $http, utilities, $state, $rootScope) {
            var vm = this;

            vm.user = {};

            // get token
            var userKey = utilities.getData('userKey');

            if (userKey) {
                var parameters = {};
                parameters.url = 'auth/user/';
                parameters.method = 'GET';
                parameters.token = userKey;
                parameters.callback = {
                    onSuccess: function(response) {
                        var status = response.status;
                        var data = response.data;
                        if (status == 200) {
                            vm.user.name = data.username;
                        }
                    },
                    onError: function(response) {

                        var status = response.status;
                        if (status == 401) {
                            utilities.resetStorage();
                            $state.go("auth.login");
                            $rootScope.isAuth = false;
                        }
                    }
                };

                utilities.sendRequest(parameters);
            }
            vm.profileDropdown = function() {
                angular.element(".dropdown-button").dropdown();

            };

        }

        function link(scope) {
            function headerComp() {
                this.init();
            }
            headerComp.prototype = {
                init: function() {
                    // initialized mobile sidebar
                    angular.element(".button-collapse").sideNav({
                        menuWidth: 200,
                        closeOnClick: true,
                        draggable: true
                    });

                    // initialized shadow to main header
                    angular.element(window).bind('scroll', function() {

                        if (this.pageYOffset >= 10) {
                            angular.element(" nav").addClass('grad-shadow-1');
                        } else {
                            angular.element(" nav").removeClass('grad-shadow-1');
                        }
                        scope.$apply();
                    });
                }
            };
            new headerComp();
        }
    }
})();
//Landing Footer directive
(function() {
    'use strict';
    angular.module('evalai').directive('landingFooter', landingFooter);

    function landingFooter() {
        var directive = {
            templateUrl: 'dist/views/web/partials/footer.html',
            transclude: true,
            restrict: 'EA',
            controller: controller
        };
        return directive;

        function controller($scope, $element, $attrs, $http) {
            var githubRepoUrl = "https://api.github.com/repos/Cloud-CV/EvalAI";
            $http.get(githubRepoUrl).then(function(res) {
                $scope.githubStats = {
                    forksCount: res.data.forks_count,
                    starsCount: res.data.stargazers_count,
                    htmlUrl: res.data.html_url
                };
            });
        }
    }
})();
//Dashboard Footer directive
(function() {
    'use strict';
    // dynamic header directive
    angular.module('evalai').directive('dashboardFooter', dashboardFooter);

    function dashboardFooter() {
        var directive = {
            templateUrl: 'dist/views/web/partials/dashboard-footer.html',
            transclude: true,
            restrict: 'EA',
            controller: controller
        };
        return directive;

        function controller($scope, $element, $attrs, $http) {
            var githubRepoUrl = "https://api.github.com/repos/Cloud-CV/EvalAI";
            $http.get(githubRepoUrl).then(function(res) {
                $scope.githubStats = {
                    forksCount: res.data.forks_count,
                    starsCount: res.data.stargazers_count,
                    htmlUrl: res.data.html_url
                };
            });
        }
    }
})();
// loader directive
(function() {
    'use strict';
    angular.module('evalai').directive('evalLoader', evalLoader);

    function evalLoader() {
        var directive = {
            link: link,
            templateUrl: 'dist/views/web/partials/loader.html',
            transclude: true,
            restrict: 'EA'
        };
        return directive;

        function link() {
            function evalLoader() {
                this.init();
            }
            evalLoader.prototype = {
                init: function() {}
            };
            new evalLoader();
        }
    }
})();
// simple loader directive
(function() {
    'use strict';
    angular.module('evalai').directive('simLoader', simLoader);

    function simLoader() {
        var directive = {
            link: link,
            templateUrl: 'dist/views/web/partials/sim-loader.html',
            transclude: true,
            restrict: 'EA'
        };
        return directive;

        function link() {
            function loaderComp() {
                this.init();
            }
            loaderComp.prototype = {
                init: function() {
                    angular.element("#sim-loader").hide();
                }
            };
            new loaderComp();
        }
    }
})();
//Sidebar in Dashboard
(function() {
    'use strict';
    // dynamic header directive
    angular.module('evalai').directive('sideBar', sideBar);

    function sideBar() {
        var directive = {
            link: function() {
                //do nothing
            },
            templateUrl: 'dist/views/web/partials/sidebar.html',
            transclude: true,
            restrict: 'EA'
        };
        return directive;
    }
})();
//Dashboard header
(function() {
    'use strict';
    // dynamic header directive
    angular.module('evalai').directive('simHeader', simHeader);

    function simHeader() {
        var directive = {
            link: link,
            templateUrl: 'dist/views/web/partials/sim-header.html',
            transclude: true,
            restrict: 'EA'
        };
        return directive;

        function link() {
            function headerComp() {
                this.init();
            }
            headerComp.prototype = {
                init: function() {
                    // initialized mobile sidebar
                    angular.element(".button-collapse").sideNav({
                        menuWidth: 200,
                        closeOnClick: true,
                        draggable: true
                    });
                }
            };
            new headerComp();
        }
    }
})();
// scroll directive
(function() {
    'use strict';
    // dynamic header directive
    angular.module('evalai').directive('scrollShadow', scrollShadow);

    function scrollShadow() {
        var directive = {
            link: link,
            // template : '
EvalAI

{{web.name}}
',
            transclude: true,
            restrict: 'EA'
        };
        return directive;

        function link(scope) {
            function shadowComp() {
                this.init();
            }
            shadowComp.prototype = {
                init: function() {
                    // initialized mobile sidebar
                    angular.element(".links-section-outer").bind('scroll', function() {
                        if (this.scrollTop >= 5) {
                            angular.element(".side-intro").addClass('z-depth-3');
                        } else {
                            angular.element(".side-intro").removeClass('z-depth-3');
                        }
                        scope.$apply();
                    });
                }
            };
            new shadowComp();
        }
    }
})();
// profile directive slider component
(function() {
    'use strict';
    // dynamic header directive
    angular.module('evalai').directive('slideProfile', slideProfile);

    function slideProfile() {
        var directive = {
            link: link,
            transclude: true,
            restrict: 'EA'
        };
        return directive;

        function link() {
            function slideComp() {
                this.init();
            }
            slideComp.prototype = {
                init: function() {
                    // initialized mobile sidebar
                    angular.element(".profile-sidebar").animate({
                        'left': '219px'
                    }, 200);
                }
            };
            new slideComp();
        }
    }
})();


text:
"use strict";

$(function() {
    var CaffeineTheme,
        openHash = "#open";

    window.CaffeineTheme = CaffeineTheme = {
        version: "2.7.3",
        search: {
            container: function() {
                return $("#results");
            },
            form: function(action) {
                return $("#search-container")[action]();
            }
        },
        context: function() {
            var className;
            className = document.body.className.split(" ")[0].split("-")[0];
            if (className === "") {
                return "error";
            } else {
                return className;
            }
        },
        app: (function() {
            return document.body;
        })(),
        is: function(property, value) {
            if (this.app.dataset) {
                return this.app.dataset[property] === value;
            } else {
                return this.app.getAttribute("data-" + property) === value;
            }

        },
        redirect: function (pageNum) {
            var redirectUrl = "";

            if (pageNum > 1) {
                redirectUrl += "/page/" + pageNum + "/#open";
            } else {
                redirectUrl += "/#open";
            }

            window.location.href = redirectUrl;
        },
        isOpen: function () {
            return location.hash === openHash;
        },
        getOpenHashFragment: function() {
            return openHash;
        },
        open: function() {
             window.history.replaceState(null, null, openHash);
        },
        close: function() {
             window.history.replaceState(null, null, "#");
        },
        getLastPageNum: function() {
            var pageNum = "";

            if (window.store && window.store.enabled) {
                pageNum = window.store.get("pageNum") || "";
            }

            return pageNum;
        },
        setLastPageNum: function() {
            var pageNum = $("#pageNum").text() || "";

            if (pageNum.length > 0 && window.store && window.store.enabled) {
                window.store.set("pageNum", pageNum);
            }
        },
        readTime: function() {
            var DateInDays;
            DateInDays = function(selector) {
                return $(selector).each(function() {
                    var publishDate,
                        timeAgo;

                    publishDate = $(this).attr("datetime");
                    timeAgo = $(this).html();

                    $(this).mouseover(function() {
                        return $(this).html(publishDate);
                    });

                    return $(this).mouseout(function() {
                        return $(this).html(timeAgo);
                    });
                });
            };

            return new DateInDays(".meta > time");
        },
        device: function() {
            var h, w;
            w = window.innerWidth;
            h = window.innerHeight;
            if (w <= 480) {
                return "mobile";
            }
            if (w <= 1024) {
                return "tablet";
            }
            return "desktop";
        },
        hideIndexPage: function () {
            $("#default-nav-header, .blog-header, .material-cover, .page-index").addClass("transparent");
        },
        showIndexPage: function () {
            $("#default-nav-header, .blog-header, .material-cover, .page-index").removeClass("transparent");
        },
        showNotification: function() {
            if (window.notificationOptions && window.toastr) {
                var message = window.notificationOptions.message || "",
                    type = window.notificationOptions.type || "info",
                    isShownOnce = window.notificationOptions.isShownOnce || true,
                    notificationStore = "notification",
                    storeValue = "",
                    setNotificationStore;

                setNotificationStore = function () {
                    if (window.store && window.store.enabled) {
                         if (storeValue) {
                             window.store.remove(notificationStore);
                        }

                        if (isShownOnce) {
                            window.store.set(notificationStore, message);
                        }
                    }
                };

                window.toastr.options = {
                    "closeButton": true,
                    "debug": false,
                    "newestOnTop": false,
                    "progressBar": true,
                    "positionClass": "toast-bottom-right",
                    "preventDuplicates": true,
                    "onclick": null,
                    "escapeHtml": window.notificationOptions.escapeHtml || false,
                    "timeOut": window.notificationOptions.timeOut || "25000",
                    "extendedTimeOut": window.notificationOptions.extendedTimeOut ||  "10000",
                    "onHidden": setNotificationStore
                };

                if (window.store && window.store.enabled) {
                    storeValue = window.store.get(notificationStore) || "";
                }

                if (storeValue === undefined || storeValue !== message) {
                    window.toastr[type](message);
                }
            }
        },
        getGridWidth: function(numColumns) {
            var width = null;

            if (!isNaN(numColumns) && numColumns > 0 && numColumns !== 2) {
                width = Math.floor((100 - 2 * numColumns) / numColumns);
                width += "%";
            }

            return width;
        },
        mediaQueryListener: function (mediaQuery, onMatch, onNoMatch) {
            var mq = window.matchMedia(mediaQuery);

            if(mq.matches) {
                onMatch.call(this);
            } else {
                onNoMatch.call(this);
            }

            mq.addListener(function(changed) {
                if(changed.matches) {
                    onMatch.call(this);

                } else {
                    onNoMatch.call(this);
                }
            });
        }
    };
});


text:
from wallaby.pf.room import *

from wallaby.pf.peer.documentChanger import *
import wallaby.backends.couchdb as couchdb

from datetime import date

from wallaby.pf.peer.documentCache import *
from twisted.internet import defer

class Customer(Room):
    def __init__(self, name):
        Room.__init__(self, name)

        DocumentChanger.registerToken("EMBEDCUSTOMER", self._embedCustomer)
        DocumentChanger.registerToken("CUSTOMERNUMBER", self._customerNumber)
        DocumentChanger.registerToken("INVOICENUMBER", self._invoiceNumber)

        self._couchdb = couchdb.Database.getDatabase(None)

        self._deferredDocs = {}

    def customPeers(self):
        self.catch(DocumentCache.Out.RequestedDocument, self._requestedDocument)
        pass

    def _requestedDocument(self, action, doc):
        if doc == None or doc.documentID not in self._deferredDocs:
            return

        self._deferredDocs[doc.documentID].callback(doc)
        del self._deferredDocs[doc.documentID]

    @defer.inlineCallbacks
    def _invoiceNumber(self, invoice):
        if invoice != None:
            oldNumber = invoice.get('invoiceNumber')
            if oldNumber != None and len(oldNumber) > 0 and oldNumber != '-':
                defer.returnValue(oldNumber)
                return

        try:
            numbers = yield self._couchdb.get('numbers')
            number = unicode(numbers['invoiceNumber'])
            year, month, day, inc = number[0:4], number[4:6], number[6:8], number[9:]
            today = date.today()
            y, m, d = today.year, today.month, today.day
            y = "%04d" % y
            m = "%02d" % m
            d = "%02d" % d

            if y==year and month==m and day==d:
                inc = str(int(inc) + 1)
            else:
                inc = "1"

            number = y + m + d + "-" + inc
            numbers['invoiceNumber'] = number
            yield self._couchdb.save(numbers)
            defer.returnValue(number)
        except Exception as e:
            print "customerContext.py: _invoiceNumber", e

    @defer.inlineCallbacks
    def _customerNumber(self, customer):
        try:
            numbers = yield self._couchdb.get('numbers')
            number = str(int(numbers['customerNumber']) + 1)
            numbers['customerNumber'] = number
            yield self._couchdb.save(numbers)
            defer.returnValue(number)
        except Exception as e:
            print "customerContext.py: _customerNumber", e

    @defer.inlineCallbacks
    def _embedCustomer(self, article):
        customerID = article.get('customerID')

        if customerID == None:
            defer.returnValue('null')
            return

        if customerID not in self._deferredDocs:
            self._deferredDocs[customerID] = defer.Deferred()

        self.throw(DocumentCache.In.RequestDocument, customerID)

        doc = yield self._deferredDocs[customerID]

        if doc != None:
            defer.returnValue({
                "name": doc.get('name'),
                "name2": doc.get('name2'),
                "street": doc.get('street'),
                "zip": doc.get('zip'),
                "city": doc.get('city'),
                "customerNumber": doc.get('customerNumber')
            })
        else:
            defer.returnValue('null')


text:
module VCR
  module Normalizers
    module Header
      # These headers get added by the various HTTP clients automatically,
      # and we don't care about them.  We store the headers for the purposes
      # of request matching, and we only care to match on headers users
      # explicitly set.
      HEADERS_TO_SKIP = {
        'connection' => %w[ close Keep-Alive ],
        'accept'     => %w[ */* ],
        'expect'     => [''],
        'user-agent' => ["Typhoeus - http://github.com/dbalatero/typhoeus/tree/master", 'Ruby']
      }

      def initialize(*args)
        super
        normalize_headers
      end

      private

      def important_header_values(k, values)
        skip_values = HEADERS_TO_SKIP[k] || []
        values - skip_values
      end

      def normalize_headers
        new_headers = {}

        headers.each do |k, v|
          k = k.downcase

          val_array = case v
            when Array then v
            when nil then []
            else [v]
          end

          important_vals = important_header_values(k, val_array)
          next unless important_vals.size > 0

          new_headers[k] = convert_to_raw_strings(important_vals)
        end if headers

        self.headers = new_headers.empty? ? nil : new_headers
      end

      def convert_to_raw_strings(array)
        # Ensure the values are raw strings.
        # Apparently for Paperclip uploads to S3, headers
        # get serialized with some extra stuff which leads
        # to a seg fault. See this issue for more info:
        # https://github.com/myronmarston/vcr/issues#issue/39
        array.map do |v|
          case v
            when String; String.new(v)
            when Array; convert_to_raw_strings(v)
            else v
          end
        end
      end
    end
  end
end


text:
> Easily get, set and persist config data.

## Install

Install with [npm](https://www.npmjs.com/)

```sh
$ npm i data-store --save
```

## Usage example

```js
var Store = require('data-store');
// default cwd is `~/data-store/`
var store = new Store('app', {cwd: 'actual'});

store
  .set('a', 'b')
  .set('c.d', {e: 'f'})
  .set('c.d', {g: 'h'});

console.log(store.get('c.d'));
//=> { e: 'f', g: 'h' }

console.log(store.get());
//=> { name: 'app', data: { a: 'b', c: { d: { e: 'f', g: 'h' } } } }

console.log(store.data);
//=> { a: 'b', c: { d: { e: 'f', g: 'h' } } }
```

## API

### [Store](index.js#L58)

Initialize a new `Store` with the given `name` and `options`.

**Params**

* `name` **{String}**: Store name.
* `options` **{Object}**

- `cwd` **{String}**: Current working directory for storage. If not defined, the user home directory is used, based on OS. This is the only option currently, other may be added in the future.
- `indent` **{Number}**: Number passed to `JSON.stringify` when saving the data. Defaults to `2` if `null` or `undefined`

**Example**

```js
var store = new Store('abc');
//=> '~/data-store/a.json'

var store = new Store('abc', {cwd: 'test/fixtures'});
//=> './test/fixtures/abc.json'
```

### [.set](index.js#L104)

Assign `value` to `key` and save to disk. Can be a key-value pair or an object.

**Params**

* `key` **{String}**
* `val` **{any}**: The value to save to `key`. Must be a valid JSON type: String, Number, Array or Object.
* `returns` **{Object}** `Store`: for chaining

**Example**

```js
// key, value
store.set('a', 'b');
//=> {a: 'b'}

// extend the store with an object
store.set({a: 'b'});
//=> {a: 'b'}

// extend the the given value
store.set('a', {b: 'c'});
store.set('a', {d: 'e'}, true);
//=> {a: {b 'c', d: 'e'}}

// overwrite the the given value
store.set('a', {b: 'c'});
store.set('a', {d: 'e'});
//=> {d: 'e'}
```

### [.union](index.js#L140)

Add or append an array of unique values to the given `key`.

**Params**

* `key` **{String}**
* `returns` **{any}**: The array to add or append for `key`.

**Example**

```js
store.union('a', ['a']);
store.union('a', ['b']);
store.union('a', ['c']);
store.get('a');
//=> ['a', 'b', 'c']
```

### [.get](index.js#L166)

Get the stored `value` of `key`, or return the entire store if no `key` is defined.

**Params**

* `key` **{String}**
* `returns` **{any}**: The value to store for `key`.

**Example**

```js
store.set('a', {b: 'c'});
store.get('a');
//=> {b: 'c'}

store.get();
//=> {b: 'c'}
```

### [.has](index.js#L189)

Returns `true` if the specified `key` has truthy value.

**Params**

* `key` **{String}**
* `returns` **{Boolean}**: Returns true if `key` has

**Example**

```js
store.set('a', 'b');
store.set('c', null);
store.has('a'); //=> true
store.has('c'); //=> false
store.has('d'); //=> false
```

### [.hasOwn](index.js#L214)

Returns `true` if the specified `key` exists.

**Params**

* `key` **{String}**
* `returns` **{Boolean}**: Returns true if `key` exists

**Example**

```js
store.set('a', 'b');
store.set('b', false);
store.set('c', null);
store.set('d', true);

store.hasOwn('a'); //=> true
store.hasOwn('b'); //=> true
store.hasOwn('c'); //=> true
store.hasOwn('d'); //=> true
store.hasOwn('foo'); //=> false
```

### [.save](index.js#L231)

Persist the store to disk.

**Params**

* `dest` **{String}**: Optionally define an alternate destination file path.

**Example**

```js
store.save();
```

### [.del](index.js#L253)

Delete `keys` from the store, or delete the entire store if no keys are passed.

**Note that to delete the entire store you must pass `{force: true}`**

**Params**

* `keys` **{String|Array|Object}**: Keys to remove, or options.
* `options` **{Object}**

**Example**

```js
store.del();

// to delete paths outside cwd
store.del({force: true});
```

## Related

* [assign-value](https://github.com/jonschlinkert/assign-value): Extend a value or deeply nested property of an object using object path notation.
* [get-value](https://github.com/jonschlinkert/get-value): Use property paths (`  a.b.c`) to get a nested value from an object.
* [has-own-deep](https://github.com/jonschlinkert/has-own-deep): Returns true if an object has an own, nested property using dot notation paths ('a.b.c').
* [has-value](https://github.com/jonschlinkert/has-value): Returns true if a value exists, false if empty. Works with deeply nested values using… [more](https://github.com/jonschlinkert/has-value)
* [set-value](https://github.com/jonschlinkert/set-value): Create nested values and any intermediaries using dot notation (`'a.b.c'`) paths.
* [union-value](https://github.com/jonschlinkert/union-value): Set an array of unique values as the property of an object. Supports setting deeply… [more](https://github.com/jonschlinkert/union-value)

## Contributing

Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](https://github.com/jonschlinkert/data-store/issues/new)

## Running tests

Install dev dependencies:

```sh
$ npm i -d && npm test
```

## Author

**Jon Schlinkert**

+ [github/jonschlinkert](https://github.com/jonschlinkert)
+ [twitter/jonschlinkert](http://twitter.com/jonschlinkert)

## License

Copyright © 2015 Jon Schlinkert
Released under the MIT license.

***

_This file was generated by [verb-cli](https://github.com/assemble/verb-cli) on August 19, 2015._


text:
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Msagl.Core.DataStructures;
using Microsoft.Msagl.Core.Geometry;
using Microsoft.Msagl.Core.Geometry.Curves;
using Microsoft.Msagl.Layout.LargeGraphLayout;
#if TEST_MSAGL
using Microsoft.Msagl.DebugHelpers;
using System.Diagnostics;
#endif

namespace Microsoft.Msagl.Core.Layout {
    ///
    /// This class keeps the graph nodes, edges, and clusters, together with their geometries
    ///
#if TEST_MSAGL
    [Serializable]
#endif
    public class GeometryGraph : GeometryObject {
         IList<Node> nodes;
         EdgeCollection edges;
#if TEST_MSAGL
    [NonSerialized]
#endif
         Cluster rootCluster;

        ///
        /// Creates a new GeometryGraph.
        ///
        public GeometryGraph()
        {
            this.nodes = new NodeCollection(this);
            this.edges = new EdgeCollection(this);
            this.rootCluster = new Cluster();
        }

        ///
        /// The root cluster for this graph. Will never be null.
        ///
        public Cluster RootCluster
        {
            get
            {
                return this.rootCluster;
            }
            set
            {
                ValidateArg.IsNotNull(value, "value");
                this.rootCluster = value;
            }
        }

        internal Rectangle boundingBox;

        ///
        /// Bounding box of the graph
        ///
        public override Rectangle BoundingBox {
            get { return boundingBox; }
            set { boundingBox = value; }
        }

        double margins;
#if DEBUG && TEST_MSAGL
        ///
        /// curves to show debug stuff
        ///
        public DebugCurve[] DebugCurves;
#endif

        ///
        /// margins width are equal from the left and from the right; they are given in percents
        ///
        public double Margins
        {
            get { return margins; }
            set { margins = value; }
        }

        ///
        /// Width of the graph
        ///
        public double Width {
            get { return BoundingBox.RightBottom.X - BoundingBox.LeftTop.X; }
        }

        ///
        /// Height of the graph
        ///
        public double Height {
            get { return BoundingBox.Height; }
        }

        ///
        /// Left bound of the graph
        ///
        public double Left {
            get { return BoundingBox.Left; }
        }

        ///
        /// Right bound of the graph
        ///
        public double Right {
            get { return BoundingBox.Right; }
        }

        ///
        /// Left bottom corner of the graph
        ///
        internal Point LeftBottom {
            get { return new Point(BoundingBox.Left, BoundingBox.Bottom); }
        }

        ///
        /// Right top corner of the graph
        ///
        internal Point RightTop {
            get { return new Point(Right, Top); }
        }

        ///
        /// Bottom bound of the graph
        ///
        public double Bottom {
            get { return BoundingBox.Bottom; }
        }

        ///
        /// Top bound of the graph
        ///
        public double Top {
            get { return BoundingBox.Bottom + BoundingBox.Height; }
        }

        ///
        /// The nodes in the graph.
        ///
        public IList<Node> Nodes {
            get { return nodes; }
            set { nodes = value; }
        }

        ///
        /// Edges of the graph
        ///
        public EdgeCollection Edges {
            get { return edges; }
            set { edges =value; }
        }

        ///
        /// Returns a collection of all the labels in the graph.
        ///
        /// <returns></returns>
        public ICollection CollectAllLabels()
        {
            return Edges.SelectMany(e => e.Labels).ToList();
        }

        ///
        /// transforms the graph by the given matrix
        ///
        /// <param name="matrix">the matrix</param>
        public void Transform(PlaneTransformation matrix) {
            foreach (var node in Nodes)
                node.Transform(matrix);
            foreach (var edge in Edges)
                edge.Transform(matrix);
#if DEBUG && TEST_MSAGL
            if (DebugCurves != null)
                foreach (var dc in DebugCurves)
                    dc.Curve = dc.Curve.Transform(matrix);
#endif
            UpdateBoundingBox();
        }

        ///
        ///
        ///
        /// <returns></returns>
        public Rectangle PumpTheBoxToTheGraphWithMargins() {
            var b = Rectangle.CreateAnEmptyBox();
            PumpTheBoxToTheGraph(ref b);
            var del=new Point(Margins, -Margins);
            b.RightBottom += del;
            b.LeftTop -= del;
            b.Width = Math.Max(b.Width, MinimalWidth);
            b.Height = Math.Max(b.Height, MinimalHeight);

            return b;
        }

        ///
        ///the minimal width of the graph
        ///
        public double MinimalWidth { get; set; }
        ///
        ///the minimal height of the graph
        ///
        public double MinimalHeight { get; set; }
        ///
        /// enlarge the rectangle to contain the graph
        ///
        /// <param name="b"></param>
        void PumpTheBoxToTheGraph(ref Rectangle b) {
            foreach (Edge e in Edges) {
                if (e.UnderCollapsedCluster()) continue;
                if (e.Curve != null) {
                    var cb = e.Curve.BoundingBox;
                    cb.Pad(e.LineWidth);
                    b.Add(cb);
                }

                foreach (var l in e.Labels.Where(lbl => lbl != null))
                    b.Add(l.BoundingBox);
            }

            foreach (Node n in Nodes) {
                if (n.UnderCollapsedCluster()) continue;
                b.Add(n.BoundingBox);
            }

            foreach (var c in RootCluster.Clusters) {
                if (c.BoundaryCurve == null) {
                    if (c.RectangularBoundary != null)
                        c.BoundaryCurve = c.RectangularBoundary.RectangularHull();
                }
                if (c.BoundaryCurve != null)
                    b.Add(c.BoundaryCurve.BoundingBox);
            }
#if DEBUG && TEST_MSAGL
            if(DebugCurves!=null)
                foreach (var debugCurve in DebugCurves.Where(d => d.Curve != null))
                    b.Add(debugCurve.Curve.BoundingBox);
#endif
        }

        ///
        /// Translates the graph by delta.
        /// Assumes bounding box is already up to date.
        ///
        public void Translate(Point delta)
        {
            var nodeSet = new Set<Node>(Nodes);
            foreach (var v in Nodes)
                v.Center += delta;

            foreach (var cluster in RootCluster.AllClustersDepthFirstExcludingSelf()) {
                foreach (var node in cluster.Nodes.Where(n => !nodeSet.Contains(n)))
                    node.Center += delta;
                cluster.Center += delta;
                cluster.RectangularBoundary.TranslateRectangle(delta);
            }

            foreach (var e in edges)
                e.Translate(delta);

            BoundingBox = new Rectangle(BoundingBox.Left + delta.X, BoundingBox.Bottom + delta.Y, new Point(BoundingBox.Width, BoundingBox.Height));
        }

        ///
        /// Updates the bounding box to fit the contents.
        ///
        public void UpdateBoundingBox() {
            this.BoundingBox = PumpTheBoxToTheGraphWithMargins();
        }

        ///
        /// Flatten the list of nodes and clusters
        ///
        /// <returns></returns>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate")]
        public IEnumerable<Node> GetFlattenedNodesAndClusters()
        {
            foreach (Node v in Nodes)
            {
                yield return v;
            }

            foreach(Cluster cluster in this.RootCluster.AllClustersDepthFirst())
            {
                if (cluster != this.RootCluster)
                {
                    yield return cluster;
                }
            }
        }

        ///
        /// Finds the first node with the corresponding user data.
        ///
        /// <returns>The first node with the given user data. Null if no such node exists.</returns>
        public Node FindNodeByUserData(object userData)
        {
            return this.Nodes.FirstOrDefault(n => n.UserData.Equals(userData));
        }
#if TEST_MSAGL
        ///
        ///

        public void SetDebugIds()
        {
            int id = 0;
            foreach (var node in RootCluster.AllClustersDepthFirst())
                node.DebugId = id++;

            foreach (var node in Nodes)
                if (node.DebugId == null)
                    node.DebugId = id++;
        }

        internal void CheckClusterConsistency() {
            foreach (var cluster in RootCluster.AllClustersDepthFirst())
                CheckClusterConsistency(cluster);
        }

        static void CheckClusterConsistency(Cluster cluster) {
            if (cluster.BoundaryCurve == null)
                return;
            foreach (var child in cluster.Clusters.Concat(cluster.Nodes)) {
                var inside=Curve.CurveIsInsideOther(child.BoundaryCurve, cluster.BoundaryCurve);
#if TEST_MSAGL && DEBUG
//                if (!inside)
//                    LayoutAlgorithmSettings.ShowDebugCurves(new DebugCurve("green", cluster.BoundaryCurve), new DebugCurve("red", child.BoundaryCurve));
#endif
                Debug.Assert(inside,
                             "A child of a cluster has to have the BoundaryCurve inside of the BoundaryCurve of the cluster");
            }

        }
#endif
        ///
        /// info of layers for large graph browsing
        ///
        public LgData LgData { get; set; }
    }
}


text:
#pragma once
#include <aws/worklink/WorkLink_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>

namespace Aws
{
namespace WorkLink
{
namespace Model
{
  enum class AuthorizationProviderType
  {
    NOT_SET,
    SAML
  };

namespace AuthorizationProviderTypeMapper
{
AWS_WORKLINK_API AuthorizationProviderType GetAuthorizationProviderTypeForName(const Aws::String& name);

AWS_WORKLINK_API Aws::String GetNameForAuthorizationProviderType(AuthorizationProviderType value);
} // namespace AuthorizationProviderTypeMapper
} // namespace Model
} // namespace WorkLink
} // namespace Aws


text:
function ver=SONVersion(varargin)
%SONVERSION returns/displays the version number of the matlab SON library
%
% VER=SONVERSION
%       returns and displays the version while
% VER=SONVERSION('nodisplay')
%       suppresses the display
%
% Author: Malcolm Lidierth 10/06
% Copyright © The Author & King's College London 2002-2009

title='MATLAB SON  library';
ver=2.32;
if nargin==0 || strcmpi(varargin{1},'nodisplay')~=1
st=sprintf('Author:Malcolm Lidierth\nmalcolm.lidierth@kcl.ac.uk\n Copyright %c King%cs College London 2002-2007\n Version:%3.2f 20.05.06\n\nSON Filing system \nCopyright %c Cambridge Electronic Design 1988-2004 Version 7.0',169,39,ver,169);
(msgbox( st,title,'modal'));
end;


text:
class CreateSeoMeta < ActiveRecord::Migration

  def self.up
    create_table :seo_meta do |t|
      t.integer :seo_meta_id
      t.string :seo_meta_type

      t.string :browser_title
      t.string :meta_keywords
      t.text :meta_description

      t.timestamps
    end

    add_index :seo_meta, :id
    add_index :seo_meta, [:seo_meta_id, :seo_meta_type]

    # Grab the attributes of the records that currently exist
    existing_translations = ::Page.translation_class.all.map(&:attributes)

    # Remove columns
    ::SeoMeta.attributes.keys.each do |field|
      if ::Page.translation_class.column_names.map(&:to_sym).include?(field)
        remove_column ::Page.translation_class.table_name, field
      end
    end

    # Reset column information because otherwise the old columns will still exist.
    ::Page.translation_class.reset_column_information

    # Re-attach seo_meta
    ::Page.translation_class.module_eval do
      is_seo_meta
    end

    # Migrate data
    existing_translations.each do |translation|
      ::Page.translation_class.find(translation['id']).update_attributes(
        ::SeoMeta.attributes.keys.inject({}) {|attributes, name|
          attributes.merge(name => translation[name.to_s])
        }
      )
    end

    # Reset column information again because otherwise the old columns will still exist.
    ::Page.reset_column_information
  end

  def self.down
    # Grab the attributes of the records that currently exist
    existing_translations = ::Page.translation_class.all.map(&:attributes)

    # Add columns back to your model
    ::SeoMeta.attributes.each do |field, field_type|
      unless ::Page.translation_class.column_names.map(&:to_sym).include?(field)
        add_column ::Page.translation_class.table_name, field, field_type
      end
    end

    # Reset column information because otherwise the new columns won't exist yet.
    ::Page.translation_class.reset_column_information

    # Migrate data
    existing_translations.each do |translation|
      ::Page.translation_class.update_all(
        ::SeoMeta.attributes.keys.inject({}) {|attributes, name|
          attributes.merge(name => translation[name.to_s])
        }, :id => translation['id']
      )
    end

    ::SeoMeta.attributes.keys.each do |k|
      ::Page.translation_class.module_eval %{
        def #{k}
        end

        def #{k}=(*args)
        end
      }
    end

    # Reset column information again because otherwise the old columns will still exist.
    ::Page.reset_column_information

    drop_table :seo_meta
  end

end


text:
(function(exports) {
	function applyCSM(selectElements,spec,doc) {
		if(!spec) {
			applyCSM.spec || (applyCSM.spec = parse(doc));
			spec = applyCSM.spec;
		}
		var selectors = Object.keys(spec);
		selectors.forEach(function(selector) {
			var elements = (selectElements ? selectElements : document.querySelectorAll(selector));
			var mixins = spec[selector];
			Array.prototype.forEach.call(elements,function(element) {
				if(!selectElements || (selectElements.indexOf(element)>=0 && element.matches(selector))) {
					mixins.forEach(function(mixin) {
						element.className = mixin + " " + element.className; // do not replace with classList.add, prefix order of addition is important
					});
				}
			});
		});
	}
	function parse(doc) {
		doc || (doc = document);
		var result = {};
		var scripts = document.getElementsByTagName("SCRIPT");
		for(var i=0;i<scripts.length;i++) {
			var script = scripts[i];
			if(script.type==="text/csm") {
				var spec = Function("var spec; return spec = " + script.innerHTML)();
				for(var key in spec) {
					result[key] = spec[key];
				}
			}
		}
		return result;
	}
	exports.applyCSM = applyCSM;
})("undefined"!=typeof exports&&"undefined"!=typeof global?global:window);


text:
package unison

import "fmt"

// DuplicateCommandError command error
type DuplicateCommandError struct {
	Existing *Command
	New      *Command
	Name     string
}

func (e DuplicateCommandError) Error() string {
	return fmt.Sprintf("commands: name/alias '%s' already exists", e.Name)
}

// DuplicateEventHookError event hook error
type DuplicateEventHookError struct {
	Existing *EventHook
	New      *EventHook
	Name     string
}

func (e DuplicateEventHookError) Error() string {
	return fmt.Sprintf("event hooks: name '%s' already exists", e.Name)
}

// DuplicateServiceError service error
type DuplicateServiceError struct {
	Existing *Service
	New      *Service
	Name     string
}

func (e DuplicateServiceError) Error() string {
	return fmt.Sprintf("service: name '%s' already exists", e.Name)
}

// TooShortCommandPrefixError short command prefix error
type TooShortCommandPrefixError struct {
	Prefix string
}

func (e TooShortCommandPrefixError) Error() string {
	return fmt.Sprintf("command prefix: '%s' is too short, must me minimum 1 char", e.Prefix)
}


text:
{% extends "layout.nunjucks" %}

{% set page_title = "gifts-of-hope" %}

{% set num_sponsors = 19 %}
{% set donation_total = 17000 %}
{% set donation_goal = 17000 %}
{% set num_families = 85 %}

{% block site_title %}Give a Christmas Gift of Hope to Parents of Children Undergoing Cancer Treatment |
{% endblock %}

{% block share_meta %}
  <meta property="og:url" content="https://www.emmashopeinc.org/gifts-of-hope/2020"/>
  <meta property="og:type" content="article"/>
  <meta property="og:title" content="Give the Gift of Hope This Christmas"/>
  <meta property="og:description" content="Spread kindness and hope this Christmas season by giving the gift of a $200 gift card to families whose children are battling cancer or life-threatening illnesses."/>
  <meta property="og:image" content="https://www.emmashopeinc.org/img/gifts-of-hope/2019/gifts-of-hope-2019.jpg"/>
  <meta property="og:image:width" content="2401"/>
  <meta property="og:image:height" content="1261"/>
{% endblock share_meta %}

{% block page_class %}gifts-of-hope{% endblock %}

{% block site_content %}

Gifts of Hope - 2020

Thank You!

Because of your incredible generosity, all 85 families were sponsored!! Your gift is a big deal! Because of you, these families will all receive a $200 gift card to use as they need.

Thank you for making this last Gifts of Hope special for these families!

Past Years

Look back on how you and the community helped families at Christmas time!

    ← 2019

    ← 2018

    ← 2017

{% endblock %}


text:
import _dom from "../utils/dom-utils.js";

const windowEvents = window_events();

export default windowEvents

function window_events() {

    _dom.logHead( "Module loaded" );

	 let windowResizeTimer;

	 $( window ).resize( function () {

		  clearTimeout( windowResizeTimer );
		  windowResizeTimer = setTimeout( function () {
				resizeComponents()
		  }, 200 );
	 } );

	 return {
		  resizeComponents: function () {

				resizeComponents()
		  }
	 }

	 function resizeComponents() {

		  let displayHeight = $( window ).outerHeight( true )
					 - $( "header" ).outerHeight( true ) - $( "#vmSummary" ).outerHeight( true );
		  // - $(".ui-tabs-nav").outerHeight( true)
		  // - $("#reportOptions").outerHeight( true) ;

		  let targetHeight = Math.floor( displayHeight - 200 );

		  if ( $( "#isShowJmx" ).is( ":visible" ) )
				targetHeight = targetHeight - $( "#isShowJmx" ).outerHeight( true )
		  //
//		 console.log("targetHeight: " + targetHeight + " displayHeight: " +
//		 displayHeight + " outer: " + $(window).outerHeight( true)
//		   + " header: " + $("header").outerHeight( true) ) ;

		  setTableHeight( $( "#vmTable" ), targetHeight );
		  setTableHeight( $( "#serviceSummaryTable" ), targetHeight );
		  setTableHeight( $( "#serviceDetailTable" ), targetHeight );
		  setTableHeight( $( "#jmxSummaryTable" ), targetHeight );
		  setTableHeight( $( "#jmxDetailTable" ), targetHeight );
		  setTableHeight( $( "#jmxCustomTable" ), targetHeight );
		  setTableHeight( $( "#useridTable" ), targetHeight );

	 }

	 function setTableHeight(tableObject, targetHeight) {

//		  $( "tbody", tableObject ).css( "height", targetHeight );
//		  let rowCount = $( "tr", tableObject ).length;
//		  let rowHeight = $( "thead", tableObject ).outerHeight( true ) - 8;
//		  let measuredHeight = Math.floor( rowCount * rowHeight );
//
//		  // console.log("Row Height: " + measuredHeight + " targetHeight: " +
//		  // targetHeight) ;
//		  if ( (measuredHeight) < targetHeight ) {
//				// Compress table so it does not steal space
//				// console.log("Setting summary height to auto, measuredHeight: " +
//				// measuredHeight + "targetHeight: " + targetHeight) ;
//				$( "tbody", tableObject ).css( "height", "auto" );
//		  }
	 }

}


text:
require 'rancher/shell/config'

describe Rancher::Shell::Config do

  let(:config_file_path_home) { "#{ENV['HOME']}/.rancher-shell.yml" }
  let(:config_file_path_pwd) { "#{Dir.pwd}/.rancher-shell.yml" }

  describe "self.load" do

    before do
      [config_file_path_home, config_file_path_pwd].each do |file_path|
        allow(File).to receive(:exists?).with(file_path).and_return false
      end
    end

    # TODO: Move this to a helper, can't remember the syntax off the top of my head
    def set_config_file_content file_path, hash_data
      expect(File).to receive(:exists?).with(file_path).and_return true
      expect(YAML).to receive(:load_file).with(file_path).and_return hash_data
    end

    context "no config specified" do
      it "should be empty" do
        Rancher::Shell::Config.load {}
        expect(Rancher::Shell::Config.get_all).to eq('options' => {}, 'projects' => {})
      end
    end

    context "config specified via files" do
      let(:home_config) { { 'test1' => { 'stack' => 'qa', 'api' => { 'host' => 'rancher.example.com' } } } }
      let(:pwd_config) { { 'test1' => { 'api' => { 'host' => 'rancher.example.net' } } } }
      it "populate config from ~/.rancher-shell.yml" do
        set_config_file_content config_file_path_home, { 'projects' => [ home_config ] }
        Rancher::Shell::Config.load
        expect(Rancher::Shell::Config.get_all).to eq('options' => {}, 'projects' => [ home_config ])
      end
      it "~/.rancher-shell.yml is deep_merged with ./.rancher-shell.yml" do
        set_config_file_content config_file_path_home, { 'projects' => home_config }
        set_config_file_content config_file_path_pwd, { 'projects' => pwd_config }
        Rancher::Shell::Config.load
        expect(Rancher::Shell::Config.get_all['projects']).to eq('test1' => { 'stack' => 'qa', 'api' => { 'host' => 'rancher.example.net' } } )
      end
      it "identifies the project via options" do
        set_config_file_content config_file_path_home, { 'projects' => home_config }
        Rancher::Shell::Config.load('project' => 'test1')
        expect(Rancher::Shell::Config.get('project')).to eq home_config['test1']
      end
      context "options.stack is supplied" do
        let(:stack_config) { home_config.deep_merge('test1' => { 'stacks' => {'qa' => {'options' => { 'container' => 'qa_web_1' } }, 'production' => { 'options' => { 'container' => 'production_web_1' }  } }}) }
        it "ignores stack when no match is found" do
          set_config_file_content config_file_path_home, { 'projects' => stack_config }
          Rancher::Shell::Config.load('project' => 'test1', 'stack' => 'staging')
          expect(Rancher::Shell::Config.get('options')['container']).to eq nil
        end
        it "sets container when a stack is set via config file" do
          set_config_file_content config_file_path_home, { 'projects' => stack_config.deep_merge('test1' => { 'options' => { 'stack' => 'qa' } }) }
          Rancher::Shell::Config.load('project' => 'test1')
          expect(Rancher::Shell::Config.get('options')['container']).to eq 'qa_web_1'
        end
        it "sets container when a stack is set via CLI" do
          set_config_file_content config_file_path_home, { 'projects' => stack_config }
          Rancher::Shell::Config.load('project' => 'test1', 'stack' => 'qa')
          expect(Rancher::Shell::Config.get('options')['container']).to eq 'qa_web_1'
        end
        context "defined at root level" do
          it "cannot override a stack set via CLI" do
            set_config_file_content config_file_path_home, { 'options' => { 'stack' => 'qa' } }
            Rancher::Shell::Config.load('stack' => 'production')
            expect(Rancher::Shell::Config.get('options')['stack']).to eq 'production'
          end
        end
        context "defined at project level" do
          it "cannot override a stack set via CLI" do
            set_config_file_content config_file_path_home, { 'projects' => stack_config.deep_merge('test1' => { 'options' => { 'stack' => 'qa' } }) }
            Rancher::Shell::Config.load('project' => 'test1', 'stack' => 'production')
            expect(Rancher::Shell::Config.get('options')['container']).to eq 'production_web_1'
          end
          it "cannot override a container set via CLI" do
            set_config_file_content config_file_path_home, { 'projects' => stack_config }
            Rancher::Shell::Config.load('project' => 'test1', 'stack' => 'qa', 'container' => 'qa_web_2')
            expect(Rancher::Shell::Config.get('options')['container']).to eq 'qa_web_2'
          end
        end
      end
      context "options.container is specified" do
        let(:container_config) { home_config.deep_merge('test1' => { 'options' => {'container' => 'qa_web_1'} }) }
        it "sets container if passed as part of project options" do
          set_config_file_content config_file_path_home, { 'projects' => container_config }
          Rancher::Shell::Config.load('project' => 'test1')
          expect(Rancher::Shell::Config.get('options')['container']).to eq 'qa_web_1'
        end
        it "cannot override a container set via CLI" do
          set_config_file_content config_file_path_home, { 'projects' => container_config }
          Rancher::Shell::Config.load('project' => 'test1', 'container' => 'qa_web_2')
          expect(Rancher::Shell::Config.get('options')['container']).to eq 'qa_web_2'
        end
      end
      context "options.command is specified" do
        let(:command_config) { home_config.deep_merge('test1' => { 'options' => {'command' => 'bash'}, 'stacks' => { 'staging' => { 'options' => { 'command' => '/bin/bash' } } } }) }
        it "sets command if passed as part of project options" do
          set_config_file_content config_file_path_home, { 'projects' => command_config }
          Rancher::Shell::Config.load('project' => 'test1')
          expect(Rancher::Shell::Config.get('options')['command']).to eq 'bash'
        end
        it "sets command if passed as part of stack options" do
          set_config_file_content config_file_path_home, { 'projects' => command_config }
          Rancher::Shell::Config.load('project' => 'test1', 'stack' => 'staging')
          expect(Rancher::Shell::Config.get('options')['command']).to eq '/bin/bash'
        end
        it "cannot override a container set via CLI" do
          set_config_file_content config_file_path_home, { 'projects' => command_config }
          Rancher::Shell::Config.load('project' => 'test1', 'command' => 'bundle exec rails console')
          expect(Rancher::Shell::Config.get('options')['command']).to eq 'bundle exec rails console'
        end
      end
    end

  end

end


text:
import React from 'react';
import { createStore, combineReducers } from 'redux';
import { Provider } from 'react-redux';
import { Route } from 'react-router';
import {
  BrowserRouter,
  Redirect,
  Switch,
} from 'react-router-dom';
import { reducer as formReducer } from 'redux-form';
import { DslApplication } from 'revenj';

import { ForFakeUser } from './components/Auth';
import { FieldControls } from './components/Fields';
import { Loading } from './components/Loading';
import { Layout } from './components/Layout';
import { IPackageMixin } from './dsl/interface/demo.PackageMixin';
import { CreatePackage } from './pages/Package/Create';
import { ListPackages } from './pages/Package/List';
import { EditPackage, ViewPackage } from './pages/Package/ViewEdit';
import { api, onExport, ExportButton } from './util/Api';
import { notifyError } from './util/notify';
import * as validators from './util/validators';

import 'revenj/dist/index.css';
import 'react-toastify/dist/ReactToastify.css';

// No extra configuration
const emptyConfig = {};
const getS3FileUrl = (_s3: S3) => {
  throw new Error('S3 not supported in demo app');
}

const visibility = {
  hasReturnAddress: (values: IPackageMixin) => values?.returnAddress != null,
};

const store = createStore(combineReducers({
  form: formReducer,
}), (window as any).__REDUX_DEVTOOLS_EXTENSION__ && (window as any).__REDUX_DEVTOOLS_EXTENSION__());

const App = () => {
  return (
    <Provider store={store}>
      <DslApplication
        api={api}
        marshalling={emptyConfig}
        Fields={FieldControls}
        validators={validators}
        defaults={emptyConfig}
        visibility={visibility}
        getS3DownloadUrl={getS3FileUrl}
        notifyError={notifyError}
        ExportButton={ExportButton}
        onExport={onExport}
        LoadingComponent={Loading}
      >
        <BrowserRouter>
          <Layout>
            <ForFakeUser>
              <Switch>
                <Route path='/package/create' component={CreatePackage} />
                <Route path='/package/list' component={ListPackages} />
                <Route path='/package/:id/edit' component={EditPackage} />
                <Route path='/package/:id/dashboard' component={ViewPackage} />
                <Redirect to='/package/list' />
              </Switch>
            </ForFakeUser>
          </Layout>
        </BrowserRouter>
      </DslApplication>
    </Provider>
  );
};

export default App;


text:
module Appsignal
  class CLI
    module Helpers
      private

      def colorize(text, color)
        return text if Gem.win_platform?

        color_code =
          case color
          when :red then 31
          when :green then 32
          when :yellow then 33
          when :blue then 34
          when :pink then 35
          else 0
          end

        "\e[#{color_code}m#{text}\e[0m"
      end

      def periods
        3.times do
          print "."
          sleep 0.5
        end
      end

      def press_any_key
        puts
        print "  Ready? Press any key:"
        stdin.getc
        puts
        puts
      end

      def ask_for_input
        value = stdin.gets
        value ? value.chomp : ""
      rescue Interrupt
        puts "\nExiting..."
        exit 1
      end

      def required_input(prompt)
        loop do
          print prompt
          value = ask_for_input
          return value unless value.empty?
        end
      end

      def yes_or_no(prompt, options = {})
        loop do
          print prompt
          input = ask_for_input.strip
          input = options[:default] if input.empty? && options[:default]
          case input
          when "y", "Y", "yes"
            return true
          when "n", "N", "no"
            return false
          end
        end
      end

      def stdin
        $stdin
      end
    end
  end
end


text:
using System;
using System.Collections.Generic;
using Newtonsoft.Json;

namespace NHLDotNet.Model
{
    /// <summary>
    /// Represents team in a box score
    /// </summary>
    public class BoxScoreTeam
    {
        [JsonProperty("team")]
        public Team Team { get; set; }

        [JsonProperty("teamStats")]
        public TeamStats TeamStats { get; set; }

        [JsonProperty("players")]
        public Dictionary<string, BoxScorePlayer> Players { get; set; }

        [JsonProperty("goalies")]
        public List<int> Goalies { get; set; }

        [JsonProperty("skaters")]
        public List<int> Skaters { get; set; }

        [JsonProperty("onIce")]
        public List<int> OnIce { get; set; }

        [JsonProperty("onIcePlus")]
        public List<OnIcePlus> OnIcePlus { get; set; }

        [JsonProperty("scratches")]
        public List<int> Scratches { get; set; }

        // [JsonProperty("penaltyBox")]
        // public object[] PenaltyBox { get; set; }

        [JsonProperty("coaches")]
        public List<Coach> Coaches { get; set; }
    }
}


text:
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
    <soap:Body>
        <soap:Fault>
            <faultcode>soap:Server</faultcode>
            <faultstring>CEP NAO ENCONTRADO</faultstring>
            <detail>
                <ns2:SigepClienteException xmlns:ns2="http://cliente.bean.master.sigep.bsb.correios.com.br/">CEP NAO ENCONTRADO</ns2:SigepClienteException>
            </detail>
        </soap:Fault>
    </soap:Body>
</soap:Envelope>


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

namespace MusicBrainz
{
    public sealed class Release : MusicBrainzItem
    {

        #region Private

        const string EXTENSION = "release";
        ReleaseType? type;
        ReleaseStatus? status;
        string language;
        string script;
        string asin;
        ReadOnlyCollection<Disc> discs;
        ReadOnlyCollection<Event> events;
        ReadOnlyCollection<Track> tracks;
        int? track_number;

        #endregion

        #region Constructors

        Release (string id) : base (id)
        {
        }

        internal Release (XmlReader reader) : base (reader, null, false)
        {
        }

        #endregion

        #region Protected

        internal override string UrlExtension {
            get { return EXTENSION; }
        }

        static readonly string [] track_params = new string [] { "tracks", "track-level-rels", "artist" };

        internal override void CreateIncCore (StringBuilder builder)
        {
            AppendIncParameters (builder, "release-events", "labels");
            if (discs == null) AppendIncParameters (builder, "discs");
            if (tracks == null) {
                AppendIncParameters (builder, track_params);
                AllRelsLoaded = false;
            }
            base.CreateIncCore (builder);
        }

        internal override void LoadMissingDataCore ()
        {
            Release release = new Release (Id);
            type = release.GetReleaseType ();
            status = release.GetReleaseStatus ();
            language = release.GetLanguage ();
            script = release.GetScript ();
            asin = release.GetAsin ();
            events = release.GetEvents ();
            if (discs == null) discs = release.GetDiscs ();
            if (tracks == null) tracks = release.GetTracks ();
            base.LoadMissingDataCore (release);
        }

        internal override void ProcessAttributes (XmlReader reader)
        {
            // How sure am I about getting the type and status in the "Type Status" format?
            // MB really ought to specify these two things seperatly.
            string type_string = reader ["type"];
            if (type_string != null) {
                foreach (string token in type_string.Split (' ')) {
                    if (type == null) {
                        type = Utils.StringToEnumOrNull<ReleaseType> (token);
                        if (type != null) continue;
                    }
                    this.status = Utils.StringToEnumOrNull<ReleaseStatus> (token);
                }
            }
        }

        internal override void ProcessXmlCore (XmlReader reader)
        {
            switch (reader.Name) {
            case "text-representation":
                language = reader["language"];
                script = reader["script"];
                break;
            case "asin":
                asin = reader.ReadString ();
                break;
            case "disc-list":
                if (reader.ReadToDescendant ("disc")) {
                    List<Disc> discs = new List<Disc> ();
                    do discs.Add (new Disc (reader.ReadSubtree ()));
                    while (reader.ReadToNextSibling ("disc"));
                    this.discs = discs.AsReadOnly ();
                }
                break;
            case "release-event-list":
                if (!AllDataLoaded) {
                    reader.Skip (); // FIXME this is a workaround for Mono bug 334752
                    return;
                }
                if (reader.ReadToDescendant ("event")) {
                    List<Event> events = new List<Event> ();
                    do events.Add (new Event (reader.ReadSubtree ()));
                    while (reader.ReadToNextSibling ("event"));
                    this.events = events.AsReadOnly ();
                }
                break;
            case "track-list":
                string offset = reader["offset"];
                if (offset != null)
                    track_number = int.Parse (offset) + 1;
                if (reader.ReadToDescendant ("track")) {
                    List<Track> tracks = new List<Track> ();
                    do tracks.Add (new Track (reader.ReadSubtree (), GetArtist (), AllDataLoaded));
                    while (reader.ReadToNextSibling ("track"));
                    this.tracks = tracks.AsReadOnly ();
                }
                break;
            default:
                base.ProcessXmlCore (reader);
                break;
            }
        }

        #endregion

        #region Public

        [Queryable ("reid")]
        public override string Id {
            get { return base.Id; }
        }

        [Queryable ("release")]
        public override string GetTitle ()
        {
            return base.GetTitle ();
        }

        [Queryable ("type")]
        public ReleaseType GetReleaseType ()
        {
            return GetPropertyOrDefault (ref type, ReleaseType.None);
        }

        [Queryable ("status")]
        public ReleaseStatus GetReleaseStatus ()
        {
            return GetPropertyOrDefault (ref status, ReleaseStatus.None);
        }

        public string GetLanguage ()
        {
            return GetPropertyOrNull (ref language);
        }

        [Queryable ("script")]
        public string GetScript ()
        {
            return GetPropertyOrNull (ref script);
        }

        [Queryable ("asin")]
        public string GetAsin ()
        {
            return GetPropertyOrNull (ref asin);
        }

        [QueryableMember("Count", "discids")]
        public ReadOnlyCollection<Disc> GetDiscs ()
        {
            return GetPropertyOrNew (ref discs);
        }

        public ReadOnlyCollection<Event> GetEvents ()
        {
            return GetPropertyOrNew (ref events);
        }

        [QueryableMember ("Count", "tracks")]
        public ReadOnlyCollection<Track> GetTracks ()
        {
            return GetPropertyOrNew (ref tracks);
        }

        internal int TrackNumber {
            get { return track_number ?? -1; }
        }

        #endregion

        #region Static

        public static Release Get (string id)
        {
            if (id == null) throw new ArgumentNullException ("id");
            return new Release (id);
        }

        public static Query<Release> Query (string title)
        {
            if (title == null) throw new ArgumentNullException ("title");

            ReleaseQueryParameters parameters = new ReleaseQueryParameters ();
            parameters.Title = title;
            return Query (parameters);
        }

        public static Query<Release> Query (string title, string artist)
        {
            if (title == null) throw new ArgumentNullException ("title");
            if (artist == null) throw new ArgumentNullException ("artist");

            ReleaseQueryParameters parameters = new ReleaseQueryParameters ();
            parameters.Title = title;
            parameters.Artist = artist;
            return Query (parameters);
        }

        public static Query<Release> Query (Disc disc)
        {
            if (disc == null) throw new ArgumentNullException ("disc");

            ReleaseQueryParameters parameters = new ReleaseQueryParameters ();
            parameters.DiscId = disc.Id;
            return Query (parameters);
        }

        public static Query<Release> Query (ReleaseQueryParameters parameters)
        {
            if (parameters == null) throw new ArgumentNullException ("parameters");
            return new Query<Release> (EXTENSION, parameters.ToString ());
        }

        public static Query<Release> QueryFromDevice(string device)
        {
            if (device == null) throw new ArgumentNullException ("device");

            ReleaseQueryParameters parameters = new ReleaseQueryParameters ();
            parameters.DiscId = LocalDisc.GetFromDevice (device).Id;
            return Query (parameters);
        }

        public static Query<Release> QueryLucene (string luceneQuery)
        {
            if (luceneQuery == null) throw new ArgumentNullException ("luceneQuery");
            return new Query<Release> (EXTENSION, CreateLuceneParameter (luceneQuery));
        }

        public static implicit operator string (Release release)
        {
            return release.ToString ();
        }

        #endregion

    }

    #region Ancillary Types

    public enum ReleaseType
    {
        None,
        Album,
        Single,
        EP,
        Compilation,
        Soundtrack,
        Spokenword,
        Interview,
        Audiobook,
        Live,
        Remix,
        Other
    }

    public enum ReleaseStatus
    {
        None,
        Official,
        Promotion,
        Bootleg,
        PsudoRelease
    }

    public enum ReleaseFormat
    {
        None,
        Cartridge,
        Cassette,
        CD,
        DAT,
        Digital,
        DualDisc,
        DVD,
        LaserDisc,
        MiniDisc,
        Other,
        ReelToReel,
        SACD,
        Vinyl
    }

    public sealed class ReleaseQueryParameters : ItemQueryParameters
    {
        string disc_id;
        public string DiscId {
            get { return disc_id; }
            set { disc_id = value; }
        }

        string date;
        public string Date {
            get { return date; }
            set { date = value; }
        }

        string asin;
        public string Asin {
            get { return asin; }
            set { asin = value; }
        }

        string language;
        public string Language {
            get { return language; }
            set { language = value; }
        }

        string script;
        public string Script {
            get { return script; }
            set { script = value; }
        }

        internal override void ToStringCore (StringBuilder builder)
        {
            if (disc_id != null) {
                builder.Append ("&discid=");
                builder.Append (disc_id);
            }
            if (date != null) {
                builder.Append ("&date=");
                Utils.PercentEncode (builder, date);
            }
            if (asin != null) {
                builder.Append ("&asin=");
                builder.Append (asin);
            }
            if (language != null) {
                builder.Append ("&lang=");
                builder.Append (language);
            }
            if (script != null) {
                builder.Append ("&script=");
                builder.Append (script);
            }
        }
    }

    #endregion

}


text:
#include "own_functions.h"

//
void findMatches(StringSet<String<Dna>> & Reads,StringSet<String<char>> & ReadID,StringSet<String<AminoAcid>> & Proteine,
StringSet<String<char>> & ProteinID, int seed,StringSet<String<int>> & Alphabete){
	// Schleife fuer jedes Alphabet
	for(int alp=0;alp<length(Alphabete);++alp){
		StringSet<String<int>> trans_reads;
		// Schleife fuer jedes Read // Uebersetzung
		for (int read=0;read<length(Reads);++read){
			// Schleife fuer jedes moegliche Reading-Frame
			for(int reading_frame=0;reading_frame<6;++reading_frame){
				// Funktion in translate.cpp
				translate_reads(trans_reads,Reads[read],Alphabete[alp],reading_frame);
			}
		}
		for (int p=0;p<length(trans_reads);p++) cout << trans_reads[p]<<endl;
		// Schleife fuer jedes Protein // Uebersetzung
		StringSet<String<int>> trans_databank;
		String<AminoAcid> x = Proteine[0];
		for (int p=0;p<length(x);++p) cout << (int)x[p]<<"\t";
		//for (int protein=0;protein<length(Proteine);++protein){

		//}
	}
}


text:
============
Group policy
============

TBD

How it differs from legacy neutron data model
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

TBD


text: This is a tool to map C data structures to the corresponding memory dumps.


text:
package memory

import (
	"testing"

	"github.com/distribution/distribution/v3/registry/storage/cache/cachecheck"
)

// TestInMemoryBlobInfoCache checks the in memory implementation is working
// correctly.
func TestInMemoryBlobInfoCache(t *testing.T) {
	cachecheck.CheckBlobDescriptorCache(t, NewInMemoryBlobDescriptorCacheProvider())
}


text:
import Document, { DocumentContext, DocumentInitialProps, Head, Html, Main, NextScript } from 'next/document';
import { ReactNode, StrictMode } from 'react';

import { createEmotionCache } from 'styles';
import createEmotionServer from '@emotion/server/create-instance';
import crypto from 'crypto';
import { v4 } from 'uuid';
import { withRouter } from 'next/router';

const generateCsp = (): [csp: string, nonce: string] => {
  const hash = crypto.createHash('sha256');
  hash.update(v4());
  const nonce = hash.digest('base64');

  const isDevelopment = process.env.NODE_ENV === 'development';
  const cspDirectives: { [key: string]: string[] } = {
    'connect-src': isDevelopment
      ? ['*']
      : ["'self'", 'https://*.ingest.sentry.io', 'https://vitals.vercel-insights.com'],
    'default-src': ["'self'"],
    'font-src': ["'self'", 'https:'],
    // TODO(mime)
    //'frame-ancestors': ["'self'"],
    'frame-src': ["'self'", 'http:', 'https:'],
    'img-src': ['data:', 'http:', 'https:', 'blob:'],
    'manifest-src': ["'self'"],
    'media-src': ["'self'", 'blob:'],
    'object-src': ["'self'"],
    'prefetch-src': ["'self'"],
    // TODO(mime)
    //'report-uri': ['/api/report-csp-violation'],
    'script-src': ["'self'", 'https://cdn.auth0.com', 'https://storage.googleapis.com'].concat(
      isDevelopment ? ["'unsafe-inline'", "'unsafe-eval'"] : [`'nonce-${nonce}'`]
    ),

    // XXX(mime): we have inline styles around - can we pass nonce around the app properly?
    'style-src': ["'self'", 'https:', "'unsafe-inline'"], //(req, res) => `'nonce-${nonce}'`],
  };
  if (!isDevelopment) {
    cspDirectives['upgrade-insecure-requests'] = [];
  }
  const csp = Object.keys(cspDirectives)
    .map((directive) => `${directive} ${cspDirectives[directive].join(' ')}`)
    .join('; ');

  return [csp, nonce];
};

export interface CustomDocumentInitialProps extends DocumentInitialProps {
  emotionStyleTags: ReactNode[];
}

class MyDocument extends Document {
  // Based off of: https://github.com/mui-org/material-ui/blob/master/examples/nextjs/pages/_document.js
  static async getInitialProps(ctx: DocumentContext): Promise<CustomDocumentInitialProps> {
    const originalRenderPage = ctx.renderPage;

    // You can consider sharing the same emotion cache between all the SSR requests to speed up performance.
    // However, be aware that it can have global side effects.
    const cache = createEmotionCache();
    const { extractCriticalToChunks } = createEmotionServer(cache);

    ctx.renderPage = () =>
      originalRenderPage({
        enhanceApp: (App) =>
          function EnhanceApp(props) {
            // @ts-ignore not sure how to fix this yet
            return <App emotionCache={cache} {...props} />;
          },
      });

    const initialProps = await Document.getInitialProps(ctx);
    // This is important. It prevents emotion to render invalid HTML.
    // See https://github.com/mui-org/material-ui/issues/26561#issuecomment-855286153
    const emotionStyles = extractCriticalToChunks(initialProps.html);
    const emotionStyleTags = emotionStyles.styles.map((style) => (
      <style
        data-emotion={`${style.key} ${style.ids.join(' ')}`}
        key={style.key}
        // eslint-disable-next-line react/no-danger
        dangerouslySetInnerHTML={{ __html: style.css }}
      />
    ));

    return {
      ...initialProps,
      emotionStyleTags,
    };
  }

  render(): JSX.Element {
    const { locale } = this.props;
    const [csp, nonce] = generateCsp();

    return (
      <StrictMode>
        <Html lang={locale}>
          <Head>
            <meta charSet="utf-8" />
            <meta property="csp-nonce" content={nonce} />
            <meta httpEquiv="Content-Security-Policy" content={csp} />
            <link rel="preconnect" href="https://fonts.gstatic.com" />
            {/* This is because of the withRouter */}
            {/* eslint-disable-next-line @next/next/no-page-custom-font */}
            <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Roboto:300,400,500,700&display=swap" />
            <link rel="stylesheet" href="https://fonts.googleapis.com/icon?family=Material+Icons" />
            <link rel="author" href={`/humans.txt`} />
            <meta name="generator" content="Hello, world. https://github.com/mimecuvalo/helloworld" />
            {/*
              manifest.json provides metadata used when your web app is added to the
              homescreen on Android. See https://developers.google.com/web/fundamentals/web-app-manifest/
            */}
            <link rel="manifest" href={`/manifest.json`} />
            {/* Inject MUI styles first to match with the prepend: true configuration. */}
            {/* @ts-ignore not sure how to fix this yet */}
            {this.props.emotionStyleTags}
          </Head>
          <body>
            <Main />

            <WindowErrorScript nonce={nonce} />

            <NextScript nonce={nonce} />
          </body>
        </Html>
      </StrictMode>
    );
  }
}

// @ts-ignore not sure how to fix this yet
export default withRouter(MyDocument);

// If there is an error that occurs upon page load, i.e. when executing the initial app code,
// then we send the error up to the server via this mechanism.
// Once the app is loaded, then the rest of error reporting goes through error.js -> logError.
function WindowErrorScript({ nonce }: { nonce: string }) {
  return (
    <script
      nonce={nonce}
      dangerouslySetInnerHTML={{
        __html: `
        var hasGlobalErrorFired = false;
        window.onerror = function(message, file, line, column, error) {
          if (hasGlobalErrorFired) {
            return;
          }
          hasGlobalErrorFired = true;

          var data = {
            random: Math.random(),
            context: navigator.userAgent,
            message: message,
            file: file,
            line: line,
            column: column,
            url: window.location.href
          };
          var img = new Image();
          img.src = '/api/report-error?data=' + encodeURIComponent(JSON.stringify(data));
        };`,
      }}
    />
  );
}


text:
(function() {
	var takePicture = document.querySelector("#input-image");

	if (takePicture) {
		// Set events
		takePicture.onchange = function(event) {
			// Get a reference to the taken picture or chosen file
			var files = event.target.files, file;

			if (!isFileSizeAllowed(files, 0.999)) {
				takePicture.value = "";
				$("#id-label-inputfile").css("background-image", "url(" + contextPath + "/img/user-icon.png" + ")");
				$("#imageHelp-error").hide();
				$("#imageHelp").hide();
				$("#imageHelp-invalid").css("display", "block");
				return;
			}

			$("#imageHelp-error").hide();
			$("#imageHelp").hide();
			$("#imageHelp-invalid").hide();

			if (files && files.length > 0) {
				file = files[0];
				try {
					// Get window.URL object
					var URL = window.URL || window.webkitURL;

					// Create ObjectURL
					var imgURL = URL.createObjectURL(file);

					// Set img src to ObjectURL
					$("#id-label-inputfile").css("background-image", "url(" + imgURL + ")");

				} catch (e) {
					try {
						// Fallback if createObjectURL is not supported
						var fileReader = new FileReader();
						fileReader.onload = function(event) {
							$("#id-label-inputfile").css("background-image", "url(" + event.target.result + ")");
						};
						fileReader.readAsDataURL(file);
					} catch (e) {
						// Display error message
						$("#imageHelp-error").css("display", "block");
					}
				}
			}
		};
	}
})();


text:
package com.intellij.codeInspection;

import com.intellij.codeInspection.ex.EntryPointsManagerImpl;
import com.intellij.codeInspection.reference.SmartRefElementPointer;
import com.intellij.openapi.util.JDOMExternalizableStringList;
import com.intellij.openapi.util.JDOMUtil;
import com.intellij.util.containers.HashMap;
import junit.framework.TestCase;
import org.jdom.Element;

public class EntryPointsConverterTest extends TestCase {
  public void testMethodConverter1() throws Exception {
    doTest("method", "String java.lang.String.replace(char oldChar, char newChar)", "java.lang.String String replace(char oldChar, char newChar)");
  }

  public void testMethodConverter2() throws Exception {
    doTest("method", "void java.lang.String.replace(char oldChar, char newChar)", "java.lang.String void replace(char oldChar, char newChar)");
  }

  public void testMethodConverter3() throws Exception {
    doTest("method", "java.lang.String.String(char oldChar)", "java.lang.String String(char oldChar)");
  }

  public void testFieldConverter() throws Exception {
    doTest("field", "java.lang.String.myFakeField", "java.lang.String myFakeField");
  }

  private static void doTest(String type, String fqName, String expectedFQName) throws Exception {
    final Element entryPoints = setUpEntryPoint(type, fqName);

    final HashMap<String, SmartRefElementPointer> persistentEntryPoints = new HashMap<String, SmartRefElementPointer>();
    EntryPointsManagerImpl.convert(entryPoints, persistentEntryPoints);

    final Element testElement = new Element("comp");
    EntryPointsManagerImpl.writeExternal(testElement, persistentEntryPoints, new JDOMExternalizableStringList());

    final Element expectedEntryPoints = setUpEntryPoint(type, expectedFQName);
    expectedEntryPoints.setAttribute("version", "2.0");
    final Element expected = new Element("comp");
    expected.addContent(expectedEntryPoints);

    assertTrue(JDOMUtil.areElementsEqual(testElement, expected));
  }

  private static Element setUpEntryPoint(String type, String fqName) {
    Element entryPoints = new Element("entry_points");
    Element entryPoint = new Element("entry_point");
    entryPoint.setAttribute("TYPE", type);
    entryPoint.setAttribute("FQNAME", fqName);
    entryPoints.addContent(entryPoint);
    return entryPoints;
  }

}


text:
<?php

namespace App\Providers;

use Illuminate\Support\Facades\Event;
use Illuminate\Foundation\Support\Providers\EventServiceProvider as ServiceProvider;

class EventServiceProvider extends ServiceProvider
{
    protected $listen = [
        'App\Events\Event' => [
            'App\Listeners\EventListener',
        ],
    ];

    public function boot()
    {
        parent::boot();

        //
    }
}


text:
<?php

namespace Zend\Paginator;

class Module
{
    /**
     * Retrieve default zend-paginator config for zend-mvc context.
     *
     * @return array
     */
    public function getConfig()
    {
        $provider = new ConfigProvider();
        return [
            'service_manager' => $provider->getDependencyConfig(),
        ];
    }
}


text:
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TupleSections #-}

module Azure.DocDB.ServiceHeader where

import Control.Lens (lens)
import qualified Network.HTTP.Types.Header as HT

contentJSON :: HT.Header
contentJSON = (HT.hContentType, "application/json")

contentJSONQuery :: HT.Header
contentJSONQuery = (HT.hContentType, "application/query+json")

acceptJSON :: HT.Header
acceptJSON = (HT.hAccept, "application/json")

isQuery :: HT.Header
isQuery = ("x-ms-documentdb-isquery", "True")

maxItemCount :: HT.HeaderName
maxItemCount = "x-ms-max-item-count"

continuation :: HT.HeaderName
continuation = "x-ms-continuation"

queryCrossPartition :: HT.HeaderName
queryCrossPartition = "x-ms-documentdb-query-enablecrosspartition"

version :: HT.Header
version = ("x-ms-version", "2016-07-11")

sessionToken :: HT.HeaderName
sessionToken = "x-ms-session-token"

msDate :: HT.HeaderName
msDate = "x-ms-date"

-- | Get or set a named header
-- header' :: Eq k => k -> Lens' [(k, v)] (Maybe v)
header' :: (Functor f, Eq a)
  => a
  -> (Maybe b -> f (Maybe b))
  -> [(a, b)]
  -> f [(a, b)]
header' name = lens (lookup name) setOrRemove
  where
    setOrRemove lst =
      ($ remove lst)  -- apply to filtered list (remove old value)
      . maybe id (:)  -- either no change or cons
      . fmap (name, ) -- make key + value pair
    remove = filter ((/= name) . fst)


text:
var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();

var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };

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

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

WebInspector.ConsoleGroup = (function (_WebInspector$Object) {
    _inherits(ConsoleGroup, _WebInspector$Object);

    function ConsoleGroup(parentGroup) {
        _classCallCheck(this, ConsoleGroup);

        _get(Object.getPrototypeOf(ConsoleGroup.prototype), "constructor", this).call(this);

        this._parentGroup = parentGroup;
    }

    // Public

    _createClass(ConsoleGroup, [{
        key: "render",
        value: function render(messageView) {
            var groupElement = document.createElement("div");
            groupElement.className = "console-group";
            groupElement.group = this;
            this.element = groupElement;

            var titleElement = messageView.element;
            titleElement.classList.add(WebInspector.LogContentView.ItemWrapperStyleClassName);
            titleElement.addEventListener("click", this._titleClicked.bind(this));
            titleElement.addEventListener("mousedown", this._titleMouseDown.bind(this));

            if (groupElement && messageView.message.type === WebInspector.ConsoleMessage.MessageType.StartGroupCollapsed) groupElement.classList.add("collapsed");

            groupElement.appendChild(titleElement);

            var messagesElement = document.createElement("div");
            this._messagesElement = messagesElement;
            messagesElement.className = "console-group-messages";
            groupElement.appendChild(messagesElement);

            return groupElement;
        }
    }, {
        key: "addMessageView",
        value: function addMessageView(messageView) {
            var element = messageView.element;
            element.classList.add(WebInspector.LogContentView.ItemWrapperStyleClassName);
            this.append(element);
        }
    }, {
        key: "append",
        value: function append(messageOrGroupElement) {
            this._messagesElement.appendChild(messageOrGroupElement);
        }

        // Private

    }, {
        key: "_titleMouseDown",
        value: function _titleMouseDown(event) {
            event.preventDefault();
        }
    }, {
        key: "_titleClicked",
        value: function _titleClicked(event) {
            var groupTitleElement = event.target.enclosingNodeOrSelfWithClass("console-group-title");
            if (groupTitleElement) {
                var groupElement = groupTitleElement.enclosingNodeOrSelfWithClass("console-group");
                if (groupElement) if (groupElement.classList.contains("collapsed")) groupElement.classList.remove("collapsed");else groupElement.classList.add("collapsed");
                groupTitleElement.scrollIntoViewIfNeeded(true);
            }
        }
    }, {
        key: "parentGroup",
        get: function get() {
            return this._parentGroup;
        }
    }]);

    return ConsoleGroup;
})(WebInspector.Object);


text:
namespace MusicStore.Models
{
    using System.Collections.Generic;
    using System.ComponentModel.DataAnnotations;

    using Common.Constants;

    public class Album
    {
        private ICollection<Artist> artists;
        private ICollection<Song> songs;

        public Album()
        {
            this.artists = new HashSet<Artist>();
            this.songs = new HashSet<Song>();
        }

        [Key]
        public int AlbumId { get; set; }

        [Required]
        [MaxLength(ValidationConstants.AlbumTitleMaxLength)]
        [MinLength(ValidationConstants.AlbumTitleMinLength)]
        public string Title { get; set; }

        [Required]
        public int Year { get; set; }

        [Required]
        [MaxLength(ValidationConstants.ProducerNameMaxLength)]
        [MinLength(ValidationConstants.ProducerNameMinLength)]
        public string Producer { get; set; }

        public virtual ICollection<Artist> Artists
        {
            get
            {
                return this.artists;
            }

            set
            {
                this.artists = value;
            }
        }

        public virtual ICollection<Song> Songs
        {
            get
            {
                return this.songs;
            }

            set
            {
                this.songs = value;
            }
        }
    }
}


text:
import { GoogleConfig, GoogleOptions } from 'ash/google';

export const googleConfig: GoogleConfig = {
  options: { recaptchaKey: '6LdjbCkUAAAAABpe9bn0CoQ5Jeyj84te73Fzafk6' },
};


text:
#ifndef CHEMKIT_TRAJECTORYFRAME_H
#define CHEMKIT_TRAJECTORYFRAME_H

#include "md.h"

#include <chemkit/point3.h>

namespace chemkit {

class UnitCell;
class CartesianCoordinates;
class Trajectory;
class TrajectoryFramePrivate;

class CHEMKIT_MD_EXPORT TrajectoryFrame
{
public:
    // properties
    size_t size() const;
    bool isEmpty() const;
    size_t index() const;
    Trajectory* trajectory() const;

    // time
    void setTime(Real time);
    Real time() const;

    // coordinates
    void setPosition(size_t index, const Point3 &position);
    Point3 position(size_t index) const;
    const CartesianCoordinates* coordinates() const;

    // unit cell
    void setUnitCell(UnitCell *cell);
    UnitCell* unitCell() const;

private:
    // construction and destruction
    TrajectoryFrame(Trajectory *trajectory, size_t size);
    ~TrajectoryFrame();

    void resize(size_t size);

    friend class Trajectory;

private:
    TrajectoryFramePrivate* const d;
};

} // end chemkit namespace

#endif // CHEMKIT_TRAJECTORYFRAME_H


text:
#include "stdneb.h"
#include "resourcepriority.h"

namespace Resources
{
	const Priority ResourcePriority::Synchronization = 0;
	const Priority ResourcePriority::Undefinition = -1;
	const Priority ResourcePriority::MeshDefault = 1;
	const Priority ResourcePriority::TextureDefault = 1;
	const Priority ResourcePriority::SoundDefault = 1;
	const Priority ResourcePriority::AnimationDefault = 1;
	const Priority ResourcePriority::SkeletonDefault = 1;
}