text:
#pragma once

extern const IID IID_IDWriteFont;

#include "../ComObject.h"
#include "Enums.h"
#include "LocalizedStrings.h"
#include "FontFamily.h"
#include "FontMetrics.h"

namespace SlimDX
{
	namespace DirectWrite
	{
		public ref class Font : public ComObject
		{
			COMOBJECT(IDWriteFont, Font);

		public:
			FontFace^ CreateFontFace();
			LocalizedStrings^ GetInformationalStrings(InformationalStringId stringId);
			bool HasCharacter(int characterCode);

			property LocalizedStrings^ FaceNames
			{
				LocalizedStrings^ get();
			}

			property SlimDX::DirectWrite::FontFamily^ FontFamily
			{
				SlimDX::DirectWrite::FontFamily^ get();
			}

			property FontMetrics Metrics
			{
				FontMetrics get();
			}

			property FontSimulations Simulations
			{
				FontSimulations get();
			}

			property FontStretch Stretch
			{
				FontStretch get();
			}

			property FontStyle Style
			{
				FontStyle get();
			}

			property FontWeight Weight
			{
				FontWeight get();
			}

			property bool IsSymbolFont
			{
				bool get();
			}
		};
	}
}


text:
title: Vestibular
date: 2017-01-15 00:00:00 Z
categories:
- services
service: Vestibular and Neurological Rehabilitation
subtitle: and Neurological Rehab
layout: default
modal-id: "-neurological-rehabilitation"
img: neurological-rehab.jpg
thumbnail: neurological-rehab-thumbnail.jpg
alt:
description: Not every patient at RISE is being treated for a musculoskeletal disorder.
  Many of our patients have had a disruption to other systems in the body and need
  help returning to the activities they enjoy. We help these individuals function
  optimally by challenging their bodies in safe, fun, and functional tasks. Some common
  non-orthopedic disorders that can be benefitted by physical therapy and neurological
  rehabilitation are Parkinson's disease, CVA or "stroke", pinched nerves, Multiple
  Sclerosis, headaches or migraines, and vertigo or dizziness. Learn more about RISE
  Physical Therapy, browse our staff profiles, or contact us today!
---

redpajama_set_name: RedPajamaGithub


text:
<!DOCTYPE html>

Obsługa klientów

Obsługa pobytów

Obsługa personelu


text:
/*!
 *  Copyright (c) 2017 by Contributors
 * \file Use external mps utils function
 */

#ifndef TVM_CONTRIB_MPS_MPS_UTILS_H_
#define TVM_CONTRIB_MPS_MPS_UTILS_H_

#import <MetalPerformanceShaders/MetalPerformanceShaders.h>
#include <dmlc/logging.h>
#include <dmlc/thread_local.h>
#include <tvm/runtime/device_api.h>
#include <tvm/runtime/registry.h>
#include <tvm/runtime/util.h>
#include <vector>
#include "../../runtime/metal/metal_common.h"

namespace tvm {
namespace contrib {

/*! breif Convert DLTensor type to MPS type */
struct MPSType {
  static MPSDataType DLTypeToMPSType(const DLDataType &dtype);
};  // struct MPSType

struct MetalThreadEntry {
  MetalThreadEntry();
  ~MetalThreadEntry();
  MPSImage *AllocMPSImage(id<MTLDevice> dev, MPSImageDescriptor *desc);
  MPSTemporaryImage *AllocTempImage(id<MTLCommandBuffer> cb,
                                    MPSImageDescriptor *desc);
  runtime::metal::MetalWorkspace *metal_api{nullptr};
  static MetalThreadEntry *ThreadLocal();
  std::vector<MPSImage *> img_table;
};  // MetalThreadEntry

}  // namespace contrib
}  // namespace tvm

#endif  // TVM_CONTRIB_MPS_MPS_UTILS_H_


text:
#ifndef __XN_WHOLE_PACKET_PROCESSOR_H__
#define __XN_WHOLE_PACKET_PROCESSOR_H__

//---------------------------------------------------------------------------
// Includes
//---------------------------------------------------------------------------
#include "XnDataProcessor.h"

//---------------------------------------------------------------------------
// XnWholePacketProcessor Class
//---------------------------------------------------------------------------
class XnWholePacketProcessor : public XnDataProcessor
{
public:
	XnWholePacketProcessor(XnDevicePrivateData* pDevicePrivateData, const XnChar* csName, XnUInt32 nMaxPacketSize);
	~XnWholePacketProcessor();

	XnStatus Init();

//---------------------------------------------------------------------------
// Overridden Functions
//---------------------------------------------------------------------------
protected:
	void ProcessPacketChunk(const XnSensorProtocolResponseHeader* pHeader, const XnUChar* pData, XnUInt32 nDataOffset, XnUInt32 nDataSize);

//---------------------------------------------------------------------------
// Virtual Functions
//---------------------------------------------------------------------------
protected:
	virtual void ProcessWholePacket(const XnSensorProtocolResponseHeader* pHeader, const XnUChar* pData) = 0;

private:
	/* The maximum size of the packet. */
	XnUInt32 m_nMaxPacketSize;
	/* A buffer to store whole packet */
	XnBuffer m_WholePacket;
};

#endif //__XN_WHOLE_PACKET_PROCESSOR_H__


text:
#import "UIButton.h"

@interface UIButton (SUScriptButtonAdditions)
- (void)configureFromScriptButton:(id)arg1;
@end


text:
from .masks import masks_CFA_Bayer
from .mosaicing import mosaicing_CFA_Bayer
from .demosaicing import *  # noqa
from . import demosaicing

__all__ = []
__all__ += [
    "masks_CFA_Bayer",
]
__all__ += [
    "mosaicing_CFA_Bayer",
]
__all__ += demosaicing.__all__


text:
package jlibs.xml.sax.dog.path.tests;

import jlibs.xml.sax.dog.NodeType;
import jlibs.xml.sax.dog.path.Constraint;
import jlibs.xml.sax.dog.sniff.Event;

/**
 * @author Santhosh Kumar T
 */
public final class Element extends Constraint{
    public static final Element INSTANCE = new Element();

    private Element(){
        super(ID_ELEMENT);
    }

    @Override
    public boolean matches(Event event){
        return event.type()==NodeType.ELEMENT;
    }

    @Override
    public String toString(){
        return "element()";
    }
}


text:
package org.mengyun.tcctransaction.repository;

//
public enum StorageMode {
    ALONE,
    CENTRAL
}


text:
  Alvignac est
       un village
       localisé dans le département de Lot en Midi-Pyrénées. On dénombrait 638 habitants en 2008.

À proximité de Alvignac sont positionnées géographiquement les villes de
Mayrinhac-Lentour située à 8 km, 466 habitants,
Meyronne située à 9 km, 295 habitants,
Montvalent située à 8 km, 299 habitants,
Miers à 3 km, 424 habitants,
Gramat située à 5 km, 3 536 habitants,
Lavergne située à 5 km, 429 habitants,
 entre autres. De plus, Alvignac est située à seulement 26 km de Gourdon.

Si vous envisagez de venir habiter à Alvignac, vous pourrez facilement trouver une maison à acheter.

À Alvignac, le prix moyen à l'achat d'un appartement s'évalue à zero € du m² en vente. Le prix moyen d'une maison à l'achat se situe à 2 411 € du m². À la location la valeur moyenne se situe à 0 € du m² par mois.

La commune compte quelques  aménagements, elle dispose, entre autres, de un terrain de tennis, un équipement de roller/skate et une boucle de randonnée.

Le nombre d'habitations, à Alvignac, était réparti en 2011 en 190 appartements et 377 maisons soit
 un marché plutôt équilibré.


text:
using System;
using Elders.Skynet.Core.Transport;

namespace Elders.Skynet.Transport.Tcp.Server
{
    public class TcpServerSubscriber : IObserver<IConnection>
    {
        IConnection connection;

        public void OnCompleted()
        {
            //Console.WriteLine("Server stopped");
        }

        public void OnError(Exception error)
        {
            //Console.WriteLine(error);
        }

        public void Send(BasicMessage message)
        {
            if (connection != null)
                connection.SendMessage(message);
            else
                Console.WriteLine("Connection not established");
        }

        public void OnNext(IConnection connection)
        {
            this.connection = connection;
            Console.WriteLine("New connection established");
            connection.Subscribe(new MessageObserver());
        }
    }
}


text:
using System;
using SimpleHoneypot.Core;
using System.Web;
using SimpleHoneypot.Core.Common.Thermador.Core.Common;

namespace SimpleHoneypot.Extensions {
    public static class HttpContextBaseExtensions {

        public static bool ValidateHoneypot(this HttpRequestBase request) {
            Check.Argument.IsNotNull(request, "context");

            if (HttpContext.Current.Items[Honeypot.HttpContextKey] == null)
                throw new NullReferenceException("HttpContext.Items must have entry for Honeypot.HttpContextKey. Ensure your action has HoneypotAttribute");
            return (bool)HttpContext.Current.Items[Honeypot.HttpContextKey];

        }
    }
}


text:
package com.gentics.mesh.core.rest.tag;

import com.gentics.mesh.core.rest.common.AbstractNameUuidReference;

/**
 * POJO for a tag reference model.
 */
public class TagReference extends AbstractNameUuidReference<TagReference> {

	String tagFamily;

	/**
	 * Return the name of the tag family of the tag.
	 *
	 * @return
	 */
	public String getTagFamily() {
		return tagFamily;
	}

	/**
	 * Set the tag family name of the tag.
	 *
	 * @param tagFamily Name of the tag family
	 * @return Fluent API
	 */
	public TagReference setTagFamily(String tagFamily) {
		this.tagFamily = tagFamily;
		return this;
	}
}


text:
namespace content {

class ScopedAllowWaitForDebugURL {
 private:
  base::ThreadRestrictions::ScopedAllowWait wait;
};

namespace {

// Define the Asan debug URLs.
const char kAsanCrashDomain[] = "crash";
const char kAsanHeapOverflow[] = "/browser-heap-overflow";
const char kAsanHeapUnderflow[] = "/browser-heap-underflow";
const char kAsanUseAfterFree[] = "/browser-use-after-free";
#if defined(SYZYASAN)
const char kAsanCorruptHeapBlock[] = "/browser-corrupt-heap-block";
const char kAsanCorruptHeap[] = "/browser-corrupt-heap";
#endif

#if BUILDFLAG(ENABLE_KASKO)
// Define the Kasko debug URLs.
const char kKaskoCrashDomain[] = "kasko";
const char kKaskoSendReport[] = "/send-report";
#endif

void HandlePpapiFlashDebugURL(const GURL& url) {
#if defined(ENABLE_PLUGINS)
  bool crash = url == GURL(kChromeUIPpapiFlashCrashURL);

  std::vector<PpapiPluginProcessHost*> hosts;
  PpapiPluginProcessHost::FindByName(
      base::UTF8ToUTF16(kFlashPluginName), &hosts);
  for (std::vector<PpapiPluginProcessHost*>::iterator iter = hosts.begin();
       iter != hosts.end(); ++iter) {
    if (crash)
      (*iter)->Send(new PpapiMsg_Crash());
    else
      (*iter)->Send(new PpapiMsg_Hang());
  }
#endif
}

bool IsKaskoDebugURL(const GURL& url) {
#if BUILDFLAG(ENABLE_KASKO)
  return (url.is_valid() && url.SchemeIs(kChromeUIScheme) &&
          url.DomainIs(kKaskoCrashDomain) &&
          url.path() == kKaskoSendReport);
#else
  return false;
#endif
}

void HandleKaskoDebugURL() {
#if BUILDFLAG(ENABLE_KASKO)
  // Signature of the exported crash key setting function.
  using SetCrashKeyValueImplPtr = void(__cdecl *)(const wchar_t*,
                                                  const wchar_t*);
  // Signature of an enhanced crash reporting function.
  using ReportCrashWithProtobufPtr = void(__cdecl *)(EXCEPTION_POINTERS*,
                                                     const char*);

  HMODULE exe_hmodule = ::GetModuleHandle(NULL);

  // First, set a crash key using the exported function reserved for Kasko
  // clients (SyzyASAN for now).
  SetCrashKeyValueImplPtr set_crash_key_value_impl =
      reinterpret_cast<SetCrashKeyValueImplPtr>(
          ::GetProcAddress(exe_hmodule, "SetCrashKeyValueImpl"));
  if (set_crash_key_value_impl)
    set_crash_key_value_impl(L"kasko-set-crash-key-value-impl", L"true");
  else
    NOTREACHED();

  // Next, invoke a crash report via Kasko.
  ReportCrashWithProtobufPtr report_crash_with_protobuf =
      reinterpret_cast<ReportCrashWithProtobufPtr>(
          ::GetProcAddress(exe_hmodule, "ReportCrashWithProtobuf"));
  if (report_crash_with_protobuf)
    report_crash_with_protobuf(NULL, "Invoked from debug url.");
  else
    NOTREACHED();
#else
  NOTIMPLEMENTED();
#endif
}

bool IsAsanDebugURL(const GURL& url) {
#if defined(SYZYASAN)
  if (!base::debug::IsBinaryInstrumented())
    return false;
#endif

  if (!(url.is_valid() && url.SchemeIs(kChromeUIScheme) &&
        url.DomainIs(kAsanCrashDomain) &&
        url.has_path())) {
    return false;
  }

  if (url.path() == kAsanHeapOverflow || url.path() == kAsanHeapUnderflow ||
      url.path() == kAsanUseAfterFree) {
    return true;
  }

#if defined(SYZYASAN)
  if (url.path() == kAsanCorruptHeapBlock || url.path() == kAsanCorruptHeap)
    return true;
#endif

  return false;
}

bool HandleAsanDebugURL(const GURL& url) {
#if defined(SYZYASAN)
  if (!base::debug::IsBinaryInstrumented())
    return false;

  if (url.path() == kAsanCorruptHeapBlock) {
    base::debug::AsanCorruptHeapBlock();
    return true;
  } else if (url.path() == kAsanCorruptHeap) {
    base::debug::AsanCorruptHeap();
    return true;
  }
#endif

#if defined(ADDRESS_SANITIZER) || defined(SYZYASAN)
  if (url.path() == kAsanHeapOverflow) {
    base::debug::AsanHeapOverflow();
  } else if (url.path() == kAsanHeapUnderflow) {
    base::debug::AsanHeapUnderflow();
  } else if (url.path() == kAsanUseAfterFree) {
    base::debug::AsanHeapUseAfterFree();
  } else {
    return false;
  }
#endif

  return true;
}

void HangCurrentThread() {
  ScopedAllowWaitForDebugURL allow_wait;
  base::WaitableEvent(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                      base::WaitableEvent::InitialState::NOT_SIGNALED)
      .Wait();
}

}  // namespace

bool HandleDebugURL(const GURL& url, ui::PageTransition transition) {
  // Ensure that the user explicitly navigated to this URL, unless
  // kEnableGpuBenchmarking is enabled by Telemetry.
  bool is_telemetry_navigation =
      base::CommandLine::ForCurrentProcess()->HasSwitch(
          cc::switches::kEnableGpuBenchmarking) &&
      (PageTransitionCoreTypeIs(transition, ui::PAGE_TRANSITION_TYPED));

  if (!(transition & ui::PAGE_TRANSITION_FROM_ADDRESS_BAR) &&
      !is_telemetry_navigation)
    return false;

  if (IsAsanDebugURL(url))
    return HandleAsanDebugURL(url);

  if (IsKaskoDebugURL(url)) {
    HandleKaskoDebugURL();
    return true;
  }

  if (url == GURL(kChromeUIBrowserCrashURL)) {
    // Induce an intentional crash in the browser process.
    CHECK(false);
    return true;
  }

  if (url == GURL(kChromeUIBrowserUIHang)) {
    HangCurrentThread();
    return true;
  }

  if (url == GURL(kChromeUIDelayedBrowserUIHang)) {
    // Webdriver-safe url to hang the ui thread. Webdriver waits for the onload
    // event in javascript which needs a little more time to fire.
    BrowserThread::PostDelayedTask(BrowserThread::UI, FROM_HERE,
                                   base::Bind(&HangCurrentThread),
                                   base::TimeDelta::FromSeconds(2));
    return true;
  }

  if (url == GURL(kChromeUIGpuCleanURL)) {
    GpuProcessHostUIShim* shim = GpuProcessHostUIShim::GetOneInstance();
    if (shim)
      shim->SimulateRemoveAllContext();
    return true;
  }

  if (url == GURL(kChromeUIGpuCrashURL)) {
    GpuProcessHostUIShim* shim = GpuProcessHostUIShim::GetOneInstance();
    if (shim)
      shim->SimulateCrash();
    return true;
  }

  if (url == GURL(kChromeUIGpuHangURL)) {
    GpuProcessHostUIShim* shim = GpuProcessHostUIShim::GetOneInstance();
    if (shim)
      shim->SimulateHang();
    return true;
  }

  if (url == GURL(kChromeUIPpapiFlashCrashURL) ||
      url == GURL(kChromeUIPpapiFlashHangURL)) {
    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                            base::Bind(&HandlePpapiFlashDebugURL, url));
    return true;
  }

  return false;
}

bool IsRendererDebugURL(const GURL& url) {
  if (!url.is_valid())
    return false;

  if (url.SchemeIs(url::kJavaScriptScheme))
    return true;

  return url == GURL(kChromeUIBadCastCrashURL) ||
         url == GURL(kChromeUICrashURL) ||
         url == GURL(kChromeUIDumpURL) ||
         url == GURL(kChromeUIKillURL) ||
         url == GURL(kChromeUIHangURL) ||
         url == GURL(kChromeUIShorthangURL) ||
         url == GURL(kChromeUIMemoryExhaustURL);
}

}  // namespace content


text:
var SecurityConstants = require('../constants/SecurityConstants');

var ErrorActions = require('./ErrorActions');

var models = require('../models.js');
var Security = models.Security;
var Error = models.Error;

function fetchSecurities() {
	return {
		type: SecurityConstants.FETCH_SECURITIES
	}
}

function securitiesFetched(securities) {
	return {
		type: SecurityConstants.SECURITIES_FETCHED,
		securities: securities
	}
}

function createSecurity() {
	return {
		type: SecurityConstants.CREATE_SECURITY
	}
}

function securityCreated(security) {
	return {
		type: SecurityConstants.SECURITY_CREATED,
		security: security
	}
}

function updateSecurity() {
	return {
		type: SecurityConstants.UPDATE_SECURITY
	}
}

function securityUpdated(security) {
	return {
		type: SecurityConstants.SECURITY_UPDATED,
		security: security
	}
}

function removeSecurity() {
	return {
		type: SecurityConstants.REMOVE_SECURITY
	}
}

function securityRemoved(securityId) {
	return {
		type: SecurityConstants.SECURITY_REMOVED,
		securityId: securityId
	}
}

function securitySelected(securityId) {
	return {
		type: SecurityConstants.SECURITY_SELECTED,
		securityId: securityId
	}
}

function fetchAll() {
	return function (dispatch) {
		dispatch(fetchSecurities());

		$.ajax({
			type: "GET",
			dataType: "json",
			url: "v1/securities/",
			success: function(data, status, jqXHR) {
				var e = new Error();
				e.fromJSON(data);
				if (e.isError()) {
					dispatch(ErrorActions.serverError(e));
				} else {
					dispatch(securitiesFetched(data.securities.map(function(json) {
						var s = new Security();
						s.fromJSON(json);
						return s;
					})));
				}
			},
			error: function(jqXHR, status, error) {
				dispatch(ErrorActions.ajaxError(error));
			}
		});
	};
}

function create(security) {
	return function (dispatch) {
		dispatch(createSecurity());

		$.ajax({
			type: "POST",
			contentType: "application/json",
			dataType: "json",
			url: "v1/securities/",
			data: security.toJSON(),
			success: function(data, status, jqXHR) {
				var e = new Error();
				e.fromJSON(data);
				if (e.isError()) {
					dispatch(ErrorActions.serverError(e));
				} else {
					var s = new Security();
					s.fromJSON(data);
					dispatch(securityCreated(s));
				}
			},
			error: function(jqXHR, status, error) {
				dispatch(ErrorActions.ajaxError(error));
			}
		});
	};
}

function update(security) {
	return function (dispatch) {
		dispatch(updateSecurity());

		$.ajax({
			type: "PUT",
			contentType: "application/json",
			dataType: "json",
			url: "v1/securities/"+security.SecurityId+"/",
			data: security.toJSON(),
			success: function(data, status, jqXHR) {
				var e = new Error();
				e.fromJSON(data);
				if (e.isError()) {
					dispatch(ErrorActions.serverError(e));
				} else {
					var s = new Security();
					s.fromJSON(data);
					dispatch(securityUpdated(s));
				}
			},
			error: function(jqXHR, status, error) {
				dispatch(ErrorActions.ajaxError(error));
			}
		});
	};
}

function remove(security) {
	return function(dispatch) {
		dispatch(removeSecurity());

		$.ajax({
			type: "DELETE",
			dataType: "json",
			url: "v1/securities/"+security.SecurityId+"/",
			success: function(data, status, jqXHR) {
				var e = new Error();
				e.fromJSON(data);
				if (e.isError()) {
					dispatch(ErrorActions.serverError(e));
				} else {
					dispatch(securityRemoved(security.SecurityId));
				}
			},
			error: function(jqXHR, status, error) {
				dispatch(ErrorActions.ajaxError(error));
			}
		});
	};
}

module.exports = {
	fetchAll: fetchAll,
	create: create,
	update: update,
	remove: remove,
	select: securitySelected
};


text:
package com.linecorp.armeria.internal.thrift;

import static java.util.Objects.requireNonNull;

import java.lang.reflect.Constructor;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.apache.thrift.AsyncProcessFunction;
import org.apache.thrift.ProcessFunction;
import org.apache.thrift.TBaseAsyncProcessor;
import org.apache.thrift.TBaseProcessor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Provides the metadata of a Thrift service interface or implementation.
 */
public final class ThriftServiceMetadata {

    private static final Logger logger = LoggerFactory.getLogger(ThriftServiceMetadata.class);

    private final Set<Class<?>> interfaces;

    /**
     * A map whose key is a method name and whose value is {@link AsyncProcessFunction} or
     * {@link ProcessFunction}.
     */
    private final Map<String, ThriftFunction> functions = new HashMap<>();

    /**
     * Creates a new instance from a Thrift service implementation that implements one or more Thrift service
     * interfaces.
     */
    public ThriftServiceMetadata(Object implementation) {
        requireNonNull(implementation, "implementation");
        interfaces = init(implementation);
    }

    /**
     * Creates a new instance from a single Thrift service interface.
     */
    public ThriftServiceMetadata(Class<?> serviceType) {
        requireNonNull(serviceType, "serviceType");
        interfaces = init(null, Collections.singleton(serviceType));
    }

    private Set<Class<?>> init(Object implementation) {
        return init(implementation, getAllInterfaces(implementation.getClass()));
    }

    private Set<Class<?>> init(Object implementation, Iterable<Class<?>> candidateInterfaces) {

        // Build the map of method names and their corresponding process functions.
        final Set<String> methodNames = new HashSet<>();
        final Set<Class<?>> interfaces = new HashSet<>();

        for (Class<?> iface : candidateInterfaces) {
            final Map<String, AsyncProcessFunction<?, ?, ?>> asyncProcessMap;
            asyncProcessMap = getThriftAsyncProcessMap(implementation, iface);
            if (asyncProcessMap != null) {
                asyncProcessMap.forEach(
                        (name, func) -> registerFunction(methodNames, iface, name, func));
                interfaces.add(iface);
            }

            final Map<String, ProcessFunction<?, ?>> processMap;
            processMap = getThriftProcessMap(implementation, iface);
            if (processMap != null) {
                processMap.forEach(
                        (name, func) -> registerFunction(methodNames, iface, name, func));
                interfaces.add(iface);
            }
        }

        if (functions.isEmpty()) {
            if (implementation != null) {
                throw new IllegalArgumentException('\'' + implementation.getClass().getName() +
                                                   "' is not a Thrift service implementation.");
            } else {
                throw new IllegalArgumentException("not a Thrift service interface: " + candidateInterfaces);
            }
        }

        return Collections.unmodifiableSet(interfaces);
    }

    private static Set<Class<?>> getAllInterfaces(Class<?> cls) {
        final Set<Class<?>> interfacesFound = new HashSet<>();
        getAllInterfaces(cls, interfacesFound);
        return interfacesFound;
    }

    private static void getAllInterfaces(Class<?> cls, Set<Class<?>> interfacesFound) {
        while (cls != null) {
            final Class<?>[] interfaces = cls.getInterfaces();
            for (final Class<?> i : interfaces) {
                if (interfacesFound.add(i)) {
                    getAllInterfaces(i, interfacesFound);
                }
            }
            cls = cls.getSuperclass();
        }
    }

    private static Map<String, ProcessFunction<?, ?>> getThriftProcessMap(Object service, Class<?> iface) {

        final String name = iface.getName();
        if (!name.endsWith("$Iface")) {
            return null;
        }

        final String processorName = name.substring(0, name.length() - 5) + "Processor";
        try {
            final Class<?> processorClass = Class.forName(processorName, false, iface.getClassLoader());
            if (!TBaseProcessor.class.isAssignableFrom(processorClass)) {
                return null;
            }

            final Constructor<?> processorConstructor = processorClass.getConstructor(iface);

            @SuppressWarnings("rawtypes")
            final TBaseProcessor processor = (TBaseProcessor) processorConstructor.newInstance(service);

            @SuppressWarnings("unchecked")
            Map<String, ProcessFunction<?, ?>> processMap =
                    (Map<String, ProcessFunction<?, ?>>) processor.getProcessMapView();

            return processMap;
        } catch (Exception e) {
            logger.debug("Failed to retrieve the process map from: {}", iface, e);
            return null;
        }
    }

    private static Map<String, AsyncProcessFunction<?, ?, ?>> getThriftAsyncProcessMap(
            Object service, Class<?> iface) {

        final String name = iface.getName();
        if (!name.endsWith("$AsyncIface")) {
            return null;
        }

        final String processorName = name.substring(0, name.length() - 10) + "AsyncProcessor";
        try {
            Class<?> processorClass = Class.forName(processorName, false, iface.getClassLoader());
            if (!TBaseAsyncProcessor.class.isAssignableFrom(processorClass)) {
                return null;
            }

            final Constructor<?> processorConstructor = processorClass.getConstructor(iface);

            @SuppressWarnings("rawtypes")
            final TBaseAsyncProcessor processor =
                    (TBaseAsyncProcessor) processorConstructor.newInstance(service);

            @SuppressWarnings("unchecked")
            Map<String, AsyncProcessFunction<?, ?, ?>> processMap =
                    (Map<String, AsyncProcessFunction<?, ?, ?>>) processor.getProcessMapView();

            return processMap;
        } catch (Exception e) {
            logger.debug("Failed to retrieve the asynchronous process map from:: {}", iface, e);
            return null;
        }
    }

    @SuppressWarnings("rawtypes")
    private void registerFunction(Set<String> methodNames, Class<?> iface, String name, Object func) {
        checkDuplicateMethodName(methodNames, name);
        methodNames.add(name);

        try {
            final ThriftFunction f;
            if (func instanceof ProcessFunction) {
                f = new ThriftFunction(iface, (ProcessFunction) func);
            } else {
                f = new ThriftFunction(iface, (AsyncProcessFunction) func);
            }
            functions.put(name, f);
        } catch (Exception e) {
            throw new IllegalArgumentException("failed to retrieve function metadata: " +
                                               iface.getName() + '.' + name + "()", e);
        }
    }

    private static void checkDuplicateMethodName(Set<String> methodNames, String name) {
        if (methodNames.contains(name)) {
            throw new IllegalArgumentException("duplicate Thrift method name: " + name);
        }
    }

    /**
     * Returns the Thrift service interfaces implemented.
     */
    public Set<Class<?>> interfaces() {
        return interfaces;
    }

    /**
     * Returns the {@link ThriftFunction} that provides the metadata of the specified Thrift function.
     *
     * @return the {@link ThriftFunction}. {@code null} if there's no such function.
     */
    public ThriftFunction function(String method) {
        return functions.get(method);
    }
}


text:
'use strict';

const test = require('tape');
const { join } = require('path');
const cwd = process.cwd();
const consoleModule = require('../../lib/modules/console.mdl');

const unifiedList = require('../../lib/utils/unified-list');
const canonicalName = require('../../lib/utils/canonical-name');

const ul = join(__dirname, '../../lib/utils/resources/default-unified-list.json');
const nm = join(__dirname, '../../lib/utils/resources/default-canonical-names.json');

unifiedList.load(ul);

const rawData = [
  { dependency: 'foo@123',
    licenses: '(MIT OR Apache-2.0)',
    file: '/foo/LICENSE' },
  { dependency: 'yargs@8.0.2', // declared
    licenses: 'MIT',
    file: '/foo/LICENSE' },
  { dependency: 'bar@321',
    licenses: 'APACHE-2.0',
    file: '/bar/LICENSE' },
  { dependency: 'license-checker@13.1.0', // declared
    licenses: 'BSD-3-Clause',
    file: '/bar/LICENSE' }];

test('Transforms the raw data.', (t) => {
  t.plan(5);
  const mappings = canonicalName.loadNameMapperFile(nm);
  const cnm = canonicalName.init(mappings);
  const data = consoleModule.transform(rawData, cnm, cwd, true, true, true);
  t.ok(data, `raw data was transformed.`);
  t.ok(data.hasOwnProperty('project'), `data has project attribute.`);
  t.ok(data.hasOwnProperty('version'), `data has version attribute.`);
  t.ok(data.hasOwnProperty('license'), `data has license attribute.`);
  t.ok(data.hasOwnProperty('dependencies'), `data has dependencies attribute.`);
  t.end();
});


text:
<?php

use \ca\bueller\Formation\FormEvents,
    \ca\bueller\Formation\ValidationFailed,
    \ca\bueller\Formation\FormField;

class FormEventsTest extends PHPUnit_Framework_TestCase
{
    protected $event = NULL;

    public function testRaiseEvent ()
    {
        FormEvents::registerHandler('ValidationFailed', array($this, 'captureEvent'));
        $field = new FormField('foo');
        FormEvents::raise(new ValidationFailed($field));

        $this->assertInstanceOf('\\ca\\bueller\\Formation\\ValidationFailed', $this->event);

        $this->event = NULL;
    }

    public function captureEvent ( $event )
    {
        $this->event = $event;
    }
}


text:
package main

import (
	"github.com/ant0ine/go-json-rest"
	"log"
	"net/http"
	"os"
	"runtime"
//	"runtime/pprof"
//	_ "net/http/pprof"
//	"flag"
)

// var cpuprofile = flag.String("cpuprofile", "", "write cpu profile to file")

func main() {
	// flag.Parse()
    // if *cpuprofile != "" {
    //     f, err := os.Create(*cpuprofile)
    //     if err != nil {
    //         log.Fatal(err)
    //     }
	// 	pprof.StartCPUProfile(f)
    //     defer pprof.StopCPUProfile()
	// }
	// go func() {
	// 	log.Println(http.ListenAndServe("localhost:6060", nil))
	// }()
	runtime.GOMAXPROCS(config.server.cpuCore)
	parseConfig("./conf/config.conf")
	logFile := getLogFile(config.global.logFile)
	startLogger := serverStartInfoLog(logFile)
	indexLogger := serverIndexInfoLog(logFile)
	startLogger.Println("AT-AT version", version)
	startLogger.Println(ascii_icon)
	startLogger.Println("Start atat server......")
	startLogger.Println("Server PID: ", os.Getpid())

	startLogger.Println("Starting Initialize Mysql Connection Pool")
	model.Init()
	startLogger.Println("Initialize Mysql Connection Pool Successful.")

	if config.global.cacheEable {
		startLogger.Println("Starting Initialize Redis Connection Pool.....")
		cache.Init()
		startLogger.Println("Initialize Redis Connection Pool Successful.")
		indexLogger.Println("Starting Initialize Indexer.....")
		engine.Init()
		go engine.IndexAll()
		go engine.checkStatus()
	}
//	startLogger.Println("Starting Initialize Controller")
//	controller.Init()
//	startLogger.Println("Initialize Controller Successful")

//	indexLogger.Println("Initialize Indexer Successful.")

	handler := rest.ResourceHandler{}
	handler.EnableGzip = config.server.gzip
	handler.EnableStatusService = config.server.gzip
	handler.EnableResponseStackTrace = config.global.debug
	handler.DisableJsonIndent = config.server.jsonIndent
	handler.Logger = log.New(logFile, "[Request] ", log.LstdFlags)

	handler.SetRoutes(
		rest.Route{"GET", "/app/release", controller.GetAppRelease},
		rest.Route{"GET", "/book/search", controller.GetBookListFromKeyword},
		rest.Route{"HEAD", "/book/search", controller.GetBookListFromKeyword},
		rest.Route{"GET", "/book/:id", controller.GetBookFromBookId},
		rest.Route{"HEAD", "/book/:id", controller.GetBookFromBookId},
		rest.Route{"GET", "/book/isbn/:isbn", controller.GetBookFromBookISBN},
		rest.Route{"HEAD", "/book/isbn/:isbn", controller.GetBookFromBookISBN},
	)

	if config.server.listenAddr != "" && config.server.port != "" {
		ListenAddrPort := config.server.listenAddr + ":" + config.server.port
		startLogger.Println("Server listen on: ", ListenAddrPort)
		http.ListenAndServe(ListenAddrPort, &handler)

	} else {
		startLogger.Println("Server listen on: ", defaultListenAddrPort)
		http.ListenAndServe(defaultListenAddrPort, &handler)
	}
}


text:
title: "Sequence Alignments and Similarity Searching"
linkTitle: "Sequence Alignments"
description: >
type: docs
weight: 106
---

[ [Download](https://docs.google.com/presentation/d/1sRtY1hkaeWGsvYLF3KOwpxK2DClzBNEApw9C5J6zT0E/edit?usp=sharing) ]


text:
using java.lang;
using stab.query;

public class IntIterable2 {
	public static bool test() {
		Iterable<Integer> it1 = Query.range(0, 5).toList();
		Iterable<Integer> it2 = Query.range(0, 5);
		return it1.sequenceEqual(it2);
	}
}


text:
import { applyMiddleware, createStore } from 'redux'
import thunk from 'redux-thunk'
import createLogger from 'redux-logger'
import { camelCase } from 'lodash-node'
import immutableToObject from 'utils/immutableToObject'
import rootReducer from 'reducers/index'

export function configureStore(initialState) {
  const logger = createLogger({
    transformer: immutableToObject
  })

  const middleware = process.env.NODE_ENV !== 'production'
    ? [thunk, logger]
    : [thunk]

  const createStoreWithMiddleware = applyMiddleware(
    ...middleware
  )(createStore)

  const store = createStoreWithMiddleware(rootReducer, initialState)

  if (module.hot) {
    module.hot.accept('reducers', () => {
      const nextRootReducer = require('reducers/index')
      store.replaceReducer(nextRootReducer)
    })
  }

  return store
}

export function reducer(actionsMap, initialState) {
  return (state = initialState, action) => {
    const reduceFn = actionsMap[camelCase(action.type)]

    if (!reduceFn) {
      return state
    }

    return state.mergeDeep(reduceFn(state, action))
  }
}


text:
package com.naughtyzombie.demo.screens;

import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;

public interface ScreenTransition {
    public float getDuration();
    public void render(SpriteBatch batch, Texture currScreen,Texture nextScreen, float alpha);
}


text:
/**
 */
package guizmo.tiles;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import org.eclipse.emf.common.util.Enumerator;

/**
 *
 * A representation of the literals of the enumeration 'Allen Interval Type',
 * and utility methods for working with them.
 *
 * @see guizmo.tiles.TilesPackage#getAllenIntervalType()
 * @model
 * @generated
 */
public enum AllenIntervalType implements Enumerator {
	/**
	 * The 'BEFORE' literal object.
	 *
	 *
	 * @see #BEFORE_VALUE
	 * @generated
	 * @ordered
	 */
	BEFORE(0, "BEFORE", "BEFORE"),

	/**
	 * The 'AFTER' literal object.
	 *
	 *
	 * @see #AFTER_VALUE
	 * @generated
	 * @ordered
	 */
	AFTER(1, "AFTER", "AFTER"),

	/**
	 * The 'MEETS' literal object.
	 *
	 *
	 * @see #MEETS_VALUE
	 * @generated
	 * @ordered
	 */
	MEETS(2, "MEETS", "MEETS"),

	/**
	 * The 'MET BY' literal object.
	 *
	 *
	 * @see #MET_BY_VALUE
	 * @generated
	 * @ordered
	 */
	MET_BY(3, "MET_BY", "MET_BY"),

	/**
	 * The 'STARTS' literal object.
	 *
	 *
	 * @see #STARTS_VALUE
	 * @generated
	 * @ordered
	 */
	STARTS(4, "STARTS", "STARTS"),

	/**
	 * The 'STARTED BY' literal object.
	 *
	 *
	 * @see #STARTED_BY_VALUE
	 * @generated
	 * @ordered
	 */
	STARTED_BY(5, "STARTED_BY", "STARTED_BY"),

	/**
	 * The 'FINISHES' literal object.
	 *
	 *
	 * @see #FINISHES_VALUE
	 * @generated
	 * @ordered
	 */
	FINISHES(6, "FINISHES", "FINISHES"),

	/**
	 * The 'FINISHED BY' literal object.
	 *
	 *
	 * @see #FINISHED_BY_VALUE
	 * @generated
	 * @ordered
	 */
	FINISHED_BY(7, "FINISHED_BY", "FINISHED_BY"),

	/**
	 * The 'DURING' literal object.
	 *
	 *
	 * @see #DURING_VALUE
	 * @generated
	 * @ordered
	 */
	DURING(8, "DURING", "DURING"),

	/**
	 * The 'CONTAINS' literal object.
	 *
	 *
	 * @see #CONTAINS_VALUE
	 * @generated
	 * @ordered
	 */
	CONTAINS(9, "CONTAINS", "CONTAINS"),

	/**
	 * The 'OVERLAPS' literal object.
	 *
	 *
	 * @see #OVERLAPS_VALUE
	 * @generated
	 * @ordered
	 */
	OVERLAPS(10, "OVERLAPS", "OVERLAPS"),

	/**
	 * The 'OVERLAPPED BY' literal object.
	 *
	 *
	 * @see #OVERLAPPED_BY_VALUE
	 * @generated
	 * @ordered
	 */
	OVERLAPPED_BY(11, "OVERLAPPED_BY", "OVERLAPPED_BY"),

	/**
	 * The 'EQUAL' literal object.
	 *
	 *
	 * @see #EQUAL_VALUE
	 * @generated
	 * @ordered
	 */
	EQUAL(12, "EQUAL", "EQUAL");

	/**
	 * The 'BEFORE' literal value.
	 *
	 *

	 * If the meaning of 'BEFORE' literal object isn't clear,
	 * there really should be more of a description here...
	 *

	 *
	 * @see #BEFORE
	 * @model
	 * @generated
	 * @ordered
	 */
	public static final int BEFORE_VALUE = 0;

	/**
	 * The 'AFTER' literal value.
	 *
	 *

	 * If the meaning of 'AFTER' literal object isn't clear,
	 * there really should be more of a description here...
	 *

	 *
	 * @see #AFTER
	 * @model
	 * @generated
	 * @ordered
	 */
	public static final int AFTER_VALUE = 1;

	/**
	 * The 'MEETS' literal value.
	 *
	 *

	 * If the meaning of 'MEETS' literal object isn't clear,
	 * there really should be more of a description here...
	 *

	 *
	 * @see #MEETS
	 * @model
	 * @generated
	 * @ordered
	 */
	public static final int MEETS_VALUE = 2;

	/**
	 * The 'MET BY' literal value.
	 *
	 *

	 * If the meaning of 'MET BY' literal object isn't clear,
	 * there really should be more of a description here...
	 *

	 *
	 * @see #MET_BY
	 * @model
	 * @generated
	 * @ordered
	 */
	public static final int MET_BY_VALUE = 3;

	/**
	 * The 'STARTS' literal value.
	 *
	 *

	 * If the meaning of 'STARTS' literal object isn't clear,
	 * there really should be more of a description here...
	 *

	 *
	 * @see #STARTS
	 * @model
	 * @generated
	 * @ordered
	 */
	public static final int STARTS_VALUE = 4;

	/**
	 * The 'STARTED BY' literal value.
	 *
	 *

	 * If the meaning of 'STARTED BY' literal object isn't clear,
	 * there really should be more of a description here...
	 *

	 *
	 * @see #STARTED_BY
	 * @model
	 * @generated
	 * @ordered
	 */
	public static final int STARTED_BY_VALUE = 5;

	/**
	 * The 'FINISHES' literal value.
	 *
	 *

	 * If the meaning of 'FINISHES' literal object isn't clear,
	 * there really should be more of a description here...
	 *

	 *
	 * @see #FINISHES
	 * @model
	 * @generated
	 * @ordered
	 */
	public static final int FINISHES_VALUE = 6;

	/**
	 * The 'FINISHED BY' literal value.
	 *
	 *

	 * If the meaning of 'FINISHED BY' literal object isn't clear,
	 * there really should be more of a description here...
	 *

	 *
	 * @see #FINISHED_BY
	 * @model
	 * @generated
	 * @ordered
	 */
	public static final int FINISHED_BY_VALUE = 7;

	/**
	 * The 'DURING' literal value.
	 *
	 *

	 * If the meaning of 'DURING' literal object isn't clear,
	 * there really should be more of a description here...
	 *

	 *
	 * @see #DURING
	 * @model
	 * @generated
	 * @ordered
	 */
	public static final int DURING_VALUE = 8;

	/**
	 * The 'CONTAINS' literal value.
	 *
	 *

	 * If the meaning of 'CONTAINS' literal object isn't clear,
	 * there really should be more of a description here...
	 *

	 *
	 * @see #CONTAINS
	 * @model
	 * @generated
	 * @ordered
	 */
	public static final int CONTAINS_VALUE = 9;

	/**
	 * The 'OVERLAPS' literal value.
	 *
	 *

	 * If the meaning of 'OVERLAPS' literal object isn't clear,
	 * there really should be more of a description here...
	 *

	 *
	 * @see #OVERLAPS
	 * @model
	 * @generated
	 * @ordered
	 */
	public static final int OVERLAPS_VALUE = 10;

	/**
	 * The 'OVERLAPPED BY' literal value.
	 *
	 *

	 * If the meaning of 'OVERLAPPED BY' literal object isn't clear,
	 * there really should be more of a description here...
	 *

	 *
	 * @see #OVERLAPPED_BY
	 * @model
	 * @generated
	 * @ordered
	 */
	public static final int OVERLAPPED_BY_VALUE = 11;

	/**
	 * The 'EQUAL' literal value.
	 *
	 *

	 * If the meaning of 'EQUAL' literal object isn't clear,
	 * there really should be more of a description here...
	 *

	 *
	 * @see #EQUAL
	 * @model
	 * @generated
	 * @ordered
	 */
	public static final int EQUAL_VALUE = 12;

	/**
	 * An array of all the 'Allen Interval Type' enumerators.
	 *
	 *
	 * @generated
	 */
	private static final AllenIntervalType[] VALUES_ARRAY =
		new AllenIntervalType[] {
			BEFORE,
			AFTER,
			MEETS,
			MET_BY,
			STARTS,
			STARTED_BY,
			FINISHES,
			FINISHED_BY,
			DURING,
			CONTAINS,
			OVERLAPS,
			OVERLAPPED_BY,
			EQUAL,
		};

	/**
	 * A public read-only list of all the 'Allen Interval Type' enumerators.
	 *
	 *
	 * @generated
	 */
	public static final List<AllenIntervalType> VALUES = Collections.unmodifiableList(Arrays.asList(VALUES_ARRAY));

	/**
	 * Returns the 'Allen Interval Type' literal with the specified literal value.
	 *
	 *
	 * @generated
	 */
	public static AllenIntervalType get(String literal) {
		for (int i = 0; i < VALUES_ARRAY.length; ++i) {
			AllenIntervalType result = VALUES_ARRAY[i];
			if (result.toString().equals(literal)) {
				return result;
			}
		}
		return null;
	}

	/**
	 * Returns the 'Allen Interval Type' literal with the specified name.
	 *
	 *
	 * @generated
	 */
	public static AllenIntervalType getByName(String name) {
		for (int i = 0; i < VALUES_ARRAY.length; ++i) {
			AllenIntervalType result = VALUES_ARRAY[i];
			if (result.getName().equals(name)) {
				return result;
			}
		}
		return null;
	}

	/**
	 * Returns the 'Allen Interval Type' literal with the specified integer value.
	 *
	 *
	 * @generated
	 */
	public static AllenIntervalType get(int value) {
		switch (value) {
			case BEFORE_VALUE: return BEFORE;
			case AFTER_VALUE: return AFTER;
			case MEETS_VALUE: return MEETS;
			case MET_BY_VALUE: return MET_BY;
			case STARTS_VALUE: return STARTS;
			case STARTED_BY_VALUE: return STARTED_BY;
			case FINISHES_VALUE: return FINISHES;
			case FINISHED_BY_VALUE: return FINISHED_BY;
			case DURING_VALUE: return DURING;
			case CONTAINS_VALUE: return CONTAINS;
			case OVERLAPS_VALUE: return OVERLAPS;
			case OVERLAPPED_BY_VALUE: return OVERLAPPED_BY;
			case EQUAL_VALUE: return EQUAL;
		}
		return null;
	}

	/**
	 *
	 *
	 * @generated
	 */
	private final int value;

	/**
	 *
	 *
	 * @generated
	 */
	private final String name;

	/**
	 *
	 *
	 * @generated
	 */
	private final String literal;

	/**
	 * Only this class can construct instances.
	 *
	 *
	 * @generated
	 */
	private AllenIntervalType(int value, String name, String literal) {
		this.value = value;
		this.name = name;
		this.literal = literal;
	}

	/**
	 *
	 *
	 * @generated
	 */
	public int getValue() {
	  return value;
	}

	/**
	 *
	 *
	 * @generated
	 */
	public String getName() {
	  return name;
	}

	/**
	 *
	 *
	 * @generated
	 */
	public String getLiteral() {
	  return literal;
	}

	/**
	 * Returns the literal value of the enumerator, which is its string representation.
	 *
	 *
	 * @generated
	 */
	@Override
	public String toString() {
		return literal;
	}

} //AllenIntervalType


text:
package io.freefair.gradle.plugins.maven.javadoc.linkproviders;

import io.freefair.gradle.plugins.maven.javadoc.JavadocLinkProvider;

import javax.annotation.Nullable;
import java.util.HashMap;
import java.util.Map;

public class JakartaEE8LinkProvider implements JavadocLinkProvider {

    Map<String, String> artifactVersions = new HashMap<>();

    public JakartaEE8LinkProvider() {
        artifactVersions.put("jakarta.annotation-api", "1.");
        artifactVersions.put("jakarta.ejb-api", "3.");
        artifactVersions.put("jakarta.el-api", "3.");
        artifactVersions.put("jakarta.enterprise.cdi-api", "2.");
        artifactVersions.put("jakarta.faces-api", "2.");
        artifactVersions.put("jakarta.inject-api", "1.");
        artifactVersions.put("jakarta.interceptor-api", "1.");
        artifactVersions.put("jakarta.json-api", "1.");
        artifactVersions.put("jakarta.json.bind-api", "1.");
        artifactVersions.put("jakarta.persistence-api", "2.");
        artifactVersions.put("jakarta.security.auth.message-api", "1.");
        artifactVersions.put("jakarta.security.enterprise-api", "1.");
        artifactVersions.put("jakarta.servlet-api", "4.");
        artifactVersions.put("jakarta.servlet.jsp-api", "2.");
        artifactVersions.put("jakarta.servlet.jsp.jstl-api", "1.");
        artifactVersions.put("jakarta.transaction-api", "1.");
        artifactVersions.put("jakarta.validation-api", "2.");
        artifactVersions.put("jakarta.websocket-api", "1.");
        artifactVersions.put("jakarta.ws.rs-api", "2.");
        artifactVersions.put("jakarta.mail", "1.");
        artifactVersions.put("jakarta.authorization-api", "1.");
        artifactVersions.put("jakarta.batch-api", "1.");
        artifactVersions.put("jakarta.enterprise.concurrent-api", "1.");
        artifactVersions.put("jakarta.enterprise.deploy-api", "1.");
        artifactVersions.put("jakarta.jms-api", "2.");
        artifactVersions.put("jakarta.mail-api", "1.");
        artifactVersions.put("jakarta.management.j2ee-api", "1.");
        artifactVersions.put("jakarta.jakartaee-web-api", "8.");
        artifactVersions.put("jakarta.jakartaee-api", "8.");
        artifactVersions.put("jakarta.resource-api", "1.");
        artifactVersions.put("jakarta.xml.registry-api", "1.");
        artifactVersions.put("jakarta.xml.rpc-api", "1.");
        artifactVersions.put("jakarta.faces", "2.");
    }

    @Override
    @Nullable
    public String getJavadocLink(String group, String artifact, String version) {
        if (isJakarta8Dependency(group, artifact, version)) {
            return "https://jakarta.ee/specifications/platform/8/apidocs/";
        }

        return null;
    }

    private boolean isJakarta8Dependency(String group, String artifact, String version) {
        if (artifactVersions.containsKey(artifact)) {
            return version.startsWith(artifactVersions.get(artifact));
        }
        return false;
    }
}


text: R CMD REMOVE --library=$PREFIX/lib/R/library/ maizeprobe


text:
using System;
using System.ComponentModel;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Xna.Framework;
using SMLimitless;
using SMLimitless.Content;
using SMLimitless.Graphics;
using SMLimitless.Physics;
using SMLimitless.Sprites;
using SMLimitless.Sprites.Assemblies;
using SMLimitless.IO.LevelSerializers;
using SMLimitless.Sprites.Collections;

namespace SmlSprites.Tiles
{
	public sealed class QuestionBlock : ItemBlock
	{
		private AnimatedGraphicsObject questionGraphics;
		private StaticGraphicsObject emptyGraphics;

		public override string EditorCategory => "Interactive Tiles";

		public override float SurfaceFriction => 1000f;

		public override void Initialize(Section owner)
		{
			questionGraphics = (AnimatedGraphicsObject)ContentPackageManager.GetGraphicsResource("SMBQuestionBlock");
			emptyGraphics = (StaticGraphicsObject)ContentPackageManager.GetGraphicsResource("SMBEmptyBlock");

			SetGraphicsObjects(questionGraphics, emptyGraphics);
			base.Initialize(owner);
		}
	}
}


text:
module AdminAuthHelpers

  DEFAULT_OPTIONS = {
    via: :developer
  }

  PROVIDERS = {
    developer: {
      method: :post
    }
  }

  def authenticate_as(user, options = {})
    options = DEFAULT_OPTIONS.merge(options)

    if options[:mock]
      mock_authentication(options[:via], user.authorization)
    else
      send("authenticate_via_#{options[:via]}", user)
    end
  end

  def mock_authentication(strategy, authorization)
    OmniAuth.config.test_mode = true

    OmniAuth.config.add_mock(
      strategy,
      uid:  authorization.uid,
      info: {
        email: authorization.user.email
      }
    )

    action = PROVIDERS[strategy][:method]
    path   = send("admin_#{strategy}_callback_path")

    action == :get ? visit(path) : page.driver.send(action, path)
  end

end


text:
package jp.co.opentone.bsol.linkbinder.dao;

import org.springframework.dao.DataIntegrityViolationException;

import jp.co.opentone.bsol.framework.core.dao.Entity;
import jp.co.opentone.bsol.framework.core.dao.GenericDao;
import jp.co.opentone.bsol.framework.core.dao.KeyDuplicateException;
import jp.co.opentone.bsol.framework.core.dao.RecordNotFoundException;
import jp.co.opentone.bsol.framework.core.dao.StaleRecordException;
import jp.co.opentone.bsol.framework.core.dao.VersioningEntity;

/**
 * Daoの親クラス.
 *
 * @author opentone
 *
 */
public abstract class AbstractDao<T extends Entity> extends BaseDao implements GenericDao<T> {

    /**
     * SerialVersionID.
     */
    private static final long serialVersionUID = 8264014886725665143L;

    /**
     * SQLID: 新規作成.
     */
    public static final String SQL_ID_CREATE = "create";
    /**
     * SQLID: 更新.
     */
    public static final String SQL_ID_UPDATE = "update";
    /**
     * SQLID: 削除.
     */
    public static final String SQL_ID_DELETE = "delete";
    /**
     * SQLID: 1件取得.
     */
    public static final String SQL_ID_FIND_BY_ID = "findById";
    /**
     * SQLID: 1件取得(FOR UPDATE).
     */
    public static final String SQL_ID_FIND_BY_ID_FOR_UPDATE = "findByIdForUpdate";

    /**
     * SQL定義ファイルの名前空間を指定してインスタンス化する.
     * @param namespace
     *            SQL定義ファイルのnamespace
     */
    public AbstractDao(String namespace) {
        super(namespace);
    }

    /*
     * (非 Javadoc)
     * @see
     * jp.co.opentone.bsol.framework.core.enericDao#create(jp.c.framework.core.daok.core.dao.Entity)
     */
    public Long create(T entity) throws KeyDuplicateException {
        try {
            return (Long) getSqlMapClientTemplate().insert(getSqlId(SQL_ID_CREATE), entity);
        } catch (DataIntegrityViolationException e) {
            KeyDuplicateException ex = new KeyDuplicateException("primary key duplicate.", entity);
            ex.initCause(e);

            throw ex;
        }
    }

    /*
     * (非 Javadoc)
     * @see
     *.framework.core.daomework.core.dao.GenericDao#u.framework.core.daoc.framework.core.dao.Entity)
     */
    public Integer update(T entity) throws KeyDuplicateException, StaleRecordException {
        return update(entity, SQL_ID_UPDATE);
    }

    private Integer update(T dto, String sqlId) throws KeyDuplicateException, StaleRecordException {

        checkVersionNo(dto);
        try {
            return getSqlMapClientTemplate().update(getSqlId(sqlId), dto);
        } catch (DataIntegrityViolationException e) {
            KeyDuplicateException ex =
                    new KeyDuplicateException("primary key or foreign key duplicate.", dto);
            ex.initCause(e);
            throw ex;
        }
    }

    private void checkVersionNo(T dto) throws StaleRecordException {
        if (!(dto instanceof VersioningEntity)) {
            return;
        }
        try {
            T current = findByIdForUpdate(dto.getId());
            if (!((VersioningEntity) current).getVersionNo()
                                             .equals(((VersioningEntity) dto).getVersionNo())) {
                throw new StaleRecordException("record is already old. version_no : "
                        + ((VersioningEntity) current).getVersionNo());
            }
        } catch (RecordNotFoundException e) {
            throw new StaleRecordException("record already deleted.");
        }
    }

    /*
     * (non-Javadoc)
     * @see GenericDao#delete(Entity)
     */
    public Integer delete(T entity) throws KeyDuplicateException, StaleRecordException {
        return update(entity, SQL_ID_DELETE);
    }

    /*
     * (non-Javadoc)
     * @see GenericDao#findById(java.lang.Long)
     */
    @SuppressWarnings("unchecked")
    public T findById(Long id) throws RecordNotFoundException {
        T record = (T) getSqlMapClientTemplate().queryForObject(getSqlId(SQL_ID_FIND_BY_ID), id);

        if (record == null) {
            throw new RecordNotFoundException(id.toString());
        }
        return record;
    }

    /*
     * (non-Javadoc)
     * @see GenericDao#findByIdForUpdate(java.lang.Long)
     */
    @SuppressWarnings("unchecked")
    public T findByIdForUpdate(Long id) throws RecordNotFoundException {
        T record =
                (T) getSqlMapClientTemplate()
                                             .queryForObject(
                                                             getSqlId(SQL_ID_FIND_BY_ID_FOR_UPDATE),
                                                             id);

        if (record == null) {
            throw new RecordNotFoundException(id.toString());
        }
        return record;
    }
}


text:
require "spec_helper"
require "webmock/rspec"

command VMC::App::Start do
  let(:client) { fake_client :apps => [app] }
  let(:app) { fake :app }

  subject { vmc %W[start #{app.name}] }

  context "with an app that's already started" do
    let(:app) { fake :app, :state => "STARTED" }

    it "skips starting the application" do
      dont_allow(app).start!
      subject
    end

    it "says the app is already started" do
      subject
      expect(error_output).to say("Application #{app.name} is already started.")
    end
  end

  context "with an app that's NOT already started" do
    def self.it_says_application_is_starting
      it "says that it's starting the application" do
        subject
        expect(output).to say("Starting #{app.name}... OK")
      end
    end

    def self.it_prints_log_progress
      it "prints out the log progress" do
        subject
        expect(output).to say(log_text)
      end
    end

    def self.it_does_not_print_log_progress
      it "does not print the log progress" do
        subject
        expect(output).to_not say(log_text)
      end
    end

    def self.it_waits_for_application_to_become_healthy
      describe "waits for application to become healthy" do
        let(:app) { fake :app, :total_instances => 2 }

        def after_sleep
          any_instance_of described_class do |cli|
            stub(cli).sleep { yield }
          end
        end

        before do
          stub(app).instances do
            [ CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "DOWN"),
              CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING")
            ]
          end

          after_sleep do
            stub(app).instances { final_instances }
          end
        end

        context "when all instances become running" do
          let(:final_instances) do
            [ CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING"),
              CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING")
            ]
          end

          it "says app is started" do
            subject
            expect(output).to say("Checking #{app.name}...")
            expect(output).to say("1 running, 1 down")
            expect(output).to say("2 running")
          end
        end

        context "when any instance becomes flapping" do
          let(:final_instances) do
            [ CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "FLAPPING"),
              CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "STARTING")
            ]
          end

          it "says app failed to start" do
            subject
            expect(output).to say("Checking #{app.name}...")
            expect(output).to say("1 running, 1 down")
            expect(output).to say("1 starting, 1 flapping")
            expect(error_output).to say("Application failed to start")
          end
        end
      end
    end

    before do
      stub(app).invalidate!
      stub(app).instances do
        [ CFoundry::V2::App::Instance.new(nil, nil, nil, :state => "RUNNING") ]
      end

      stub(app).start!(true) do |_, blk|
        app.state = "STARTED"
        blk.call(log_url)
      end
    end

    context "when progress log url is provided" do
      let(:log_url) { "http://example.com/my-app-log" }
      let(:log_text) { "Staging complete!" }

      context "and progress log url is not available immediately" do
        before do
          stub_request(:get, "#{log_url}&tail&tail_offset=0").to_return(
            :status => 404, :body => "")
        end

        it_says_application_is_starting
        it_does_not_print_log_progress
        it_waits_for_application_to_become_healthy
      end

      context "and progress log url becomes unavailable after some time" do
        before do
          stub_request(:get, "#{log_url}&tail&tail_offset=0").to_return(
            :status => 200, :body => log_text[0...5])
          stub_request(:get, "#{log_url}&tail&tail_offset=5").to_return(
            :status => 200, :body => log_text[5..-1])
          stub_request(:get, "#{log_url}&tail&tail_offset=#{log_text.size}").to_return(
            :status => 404, :body => "")
        end

        it_says_application_is_starting
        it_prints_log_progress
        it_waits_for_application_to_become_healthy
      end

      context "and a request times out" do
        before do
          stub_request(:get, "#{log_url}&tail&tail_offset=0").to_return(
            :should_timeout => true)
          stub_request(:get, "#{log_url}&tail&tail_offset=0").to_return(
            :status => 200, :body => log_text)
          stub_request(:get, "#{log_url}&tail&tail_offset=#{log_text.size}").to_return(
            :status => 404, :body => "")
        end

        it_says_application_is_starting
        it_prints_log_progress
        it_waits_for_application_to_become_healthy
      end
    end

    context "when progress log url is not provided" do
      let(:log_url) { nil }
      let(:log_text) { "Staging complete!" }

      it_says_application_is_starting
      it_does_not_print_log_progress
      it_waits_for_application_to_become_healthy
    end
  end
end


text:
// Copyright 2017, University of Colorado Boulder

/**
 * git push
 *
 * @author Jonathan Olson <jonathan.olson@colorado.edu>
 */

const execute = require( './execute' );
const winston = require( 'winston' );

/**
 * Executes git push
 * @public
 *
 * @param {string} repo - The repository name
 * @param {string} remoteBranch - The branch that is getting pushed to, e.g. 'master' or '1.0'
 * @returns {Promise.<string>} - Stdout
 * @rejects {ExecuteError}
 */
module.exports = function( repo, remoteBranch ) {
  winston.info( `git push on ${repo} to ${remoteBranch}` );

  return execute( 'git', [ 'push', '-u', 'origin', remoteBranch ], `../${repo}` );
};


text:
distributed create table lineitem to 4 on l_orderkey as external
select
  cast(c1 as int) as l_orderkey,
  cast(c2 as int) as l_partkey,
  cast(c3 as int) as l_suppkey,
  cast(c4 as int) as l_linenumber,
  cast(c5 as int) as l_quantity,
  cast(c6 as float) as l_extendedprice,
  cast(c7 as float) as l_discount,
  cast(c8 as float) as l_tax,
  cast(c9 as text) as l_returnflag,
  cast(c10 as text) as l_linestatus,
  cast(c11 as text) as l_shipdate,
  cast(c12 as text) as l_commitdate,
  cast(c13 as text) as l_receiptdate,
  cast(c14 as text) as l_shipinstruct,
  cast(c15 as text) as l_shipmode,
  cast(c16 as text) as l_comment
from (file '/home/vaggelis/tpch-kit/tpch/datasets/lineitem.tbl' delimiter:|);


text:
var express = require('express')
var twilio = require('twilio');
var dotenv = require('dotenv');
dotenv.load();
var app = express();

app.set('port', (process.env.PORT || 5000))
app.use(express.static(__dirname + '/public'))

app.get('/', function(request, response) {
  response.send('Hello World!')
});

var accentsTidy = function(s){
  var r = s.toLowerCase();
  r = r.replace(new RegExp(/\s/g),"");
  r = r.replace(new RegExp(/[á]/g),"a");
  r = r.replace(new RegExp(/[é]/g),"e");
  r = r.replace(new RegExp(/[í]/g),"i");
  r = r.replace(new RegExp(/ñ/g),"n");
  r = r.replace(new RegExp(/[ó]/g),"o");
  r = r.replace(new RegExp(/[úü]/g),"u");
  return r;
};

app.get('/negocio/sms', function(req, res, next) {
  var data = req.query;
  var fromNum = data.From;
  var message = 'Hola! ';
  var incomingText = accentsTidy(data.Body);
  if (incomingText == 'hsp') {
    message += 'La historia del café hacienda San Pedro se remonta a los finales del siglo XIX cuando llega a nuestras orillas un joven español de 13 años con una sola maleta y sus sueños. ';
  }
  else if (incomingText == 'meson') {
    message += 'La historia de El Meson Sandwiches comenzó en 1972 en nuestro primer establecimiento en Aguadilla. Somos la primera cadena de comida rápida netamente puertorriqueña, lo que nos llena de sumo orgullo y nos impulsa a continuar elevando los estándares de calidad en el producto y servicio a usted, nuestro invitado. ';
  }
  else {
     message += '';
  }

  var randomPct = Math.floor((Math.random()*100)+1);
  message += " \n Tu eres " + randomPct + "% Boricua.  Visita mas negocios locales para probar cuan Boricua eres.";

  // Return Message.
  var resp = new twilio.TwimlResponse();

  resp.message({
    to: fromNum,
    from: process.env.TWILIO_NUMBER,
  }, message);

  res.writeHead(200, {
    'Content-Type':'text/xml'
  });
  res.end(resp.toString());

});

app.listen(app.get('port'), function() {
  console.log("Node app is running at localhost:" + app.get('port'))
})


text:
**Make sure you have Node version >= 6.0 and NPM >= 3**

### Installing

```bash
# clone our repo
# --depth 1 removes all but one .git commit history
git clone https://github.com/shekhra400/wheather-report-app.git

# change directory to our repo
cd wheather-report-app

# WINDOWS only. In terminal as administrator
npm install -g node-pre-gyp

# install the repo with npm
npm install

# start the server
npm start

# use Hot Module Replacement
npm run server:dev:hmr

# if you're in China use cnpm
# https://github.com/cnpm/cnpm
```

go to [http://0.0.0.0:3000](http://0.0.0.0:3000) or [http://localhost:3000](http://localhost:3000) in your browser

## Demo
https://shekhra400.github.io/wheather-report-app/
# Api called are running on http where as hosting is on https.Thatswhy it is not working

## Running the tests

To run the test cases through karma:

```
npm test
```

## Deployment

To create a build and deploy in the server.

```
npm run build:server
```

## License

This project is licensed under the MIT License.


text:
PKG_NAME = nmap
PKG_VERS = 6.47
PKG_EXT = tar.bz2
PKG_DIST_NAME = $(PKG_NAME)-$(PKG_VERS).$(PKG_EXT)
PKG_DIST_SITE = https://nmap.org/dist
PKG_DIR = $(PKG_NAME)-$(PKG_VERS)

DEPENDS = cross/libpcap cross/openssl

HOMEPAGE = https://nmap.org/
COMMENT  = Nmap ("Network Mapper") is a free and open source (license) utility for network discovery and security auditing
LICENSE  = GPL

GNU_CONFIGURE = 1
CONFIGURE_ARGS = --without-zenmap --without-ncat --with-liblua=included --with-libpcre=included CFLAGS=$(TC_CFLAGS)

include ../../mk/spksrc.cross-cc.mk


text:
import nodeResolve from 'rollup-plugin-node-resolve';
//import commonjs from 'rollup-plugin-commonjs';

export default {
    entry: 'test/temp/post-babel.js',
    dest: 'test/temp/out.js',
    plugins: [
        nodeResolve({
            jsnext: true,
            main: true
        })//,
        //commonjs()
    ],
    format: 'iife'
};


text:
using Microsoft.SharePoint.Client;
using Microsoft.SharePoint.Client.WebParts;
using System;
using System.Configuration;
using System.Web;
using System.Web.Hosting;

namespace EmployeeRegistration.MVCWeb
{
    public static class SetupManager
    {

        static SetupManager()
        {
            Initialized = false;
        }

        public static bool Initialized
        {
            get; set;
        }

        #region Application provisioning
        public static void Provision(ClientContext ctx)
        {
            if (!SetupManager.Initialized)
            {
                // Provision lists
                SetupManager.ProvisionLists(ctx);

                // upload assets and provision the application
                ProvisionEmployeeRegistrationApplication(ctx);

                SetupManager.Initialized = true;
            }
        }

        private static void ProvisionEmployeeRegistrationApplication(ClientContext ctx)
        {
            // upload files to the style library
            List styleLibrary = ctx.Web.Lists.GetByTitle("Style Library");
            ctx.Load(styleLibrary, l => l.RootFolder);
            Folder pnpFolder = styleLibrary.RootFolder.EnsureFolder("OfficeDevPnP");

            string fileName = "AppLauncher.js";
            File assetFile = pnpFolder.GetFile(fileName);
            if (assetFile != null)
            {
                assetFile.CheckOut();
            }

            string clientId = ConfigurationManager.AppSettings["ClientId"];
            Uri redirectUri = new Uri(HttpContext.Current.Request.Url.AbsoluteUri);
            string redirectUrl = String.Format("{0}://{1}{2}", redirectUri.Scheme, redirectUri.Authority, redirectUri.LocalPath);

            string localFilePath = "Assets/" + fileName;
            string newLocalFilePath = Utilities.ReplaceTokensInAssetFile(ctx, localFilePath, clientId, redirectUrl);

            assetFile = pnpFolder.UploadFile(fileName, newLocalFilePath, true);
            assetFile.CheckIn("Uploaded by provisioning engine.", CheckinType.MajorCheckIn);
            ctx.ExecuteQuery();
            System.IO.File.Delete(newLocalFilePath);

            Web web = ctx.Web;
            ctx.Load(web, w => w.ServerRelativeUrl);
            ctx.ExecuteQuery();
            Console.WriteLine("");

            // Inject the content editor web parts on the new and edit form pages
            if (!SetupManager.IsWebPartOnPage(ctx, String.Format("{0}/Lists/Employees/newform.aspx", web.ServerRelativeUrl), "Employee Registration"))
            {
                string newFormUrl = string.Format("{0}/{1}", web.ServerRelativeUrl, "Lists/Employees/newform.aspx");
                SetupManager.CloseAllWebParts(ctx, newFormUrl);
                ProvisionWebPart(ctx, newFormUrl, "AppLauncher.js");
            }
            else
            {
                Console.WriteLine("The New form page was already customized");
            }

            if (!SetupManager.IsWebPartOnPage(ctx, String.Format("{0}/Lists/Employees/editform.aspx", web.ServerRelativeUrl), "Employee Registration"))
            {
                string editFormUrl = string.Format("{0}/{1}", web.ServerRelativeUrl, "Lists/Employees/editform.aspx");
                SetupManager.CloseAllWebParts(ctx, editFormUrl);
                ProvisionWebPart(ctx, editFormUrl, "AppLauncher.js");
            }
            else
            {
                Console.WriteLine("The New form page was already customized");
            }
        }

        #endregion

        #region provision data model
        public static void ProvisionLists(ClientContext ctx)
        {
            //Create country list
            Console.WriteLine("Provisioning lists:");
            List countryList = null;
            if (!ctx.Web.ListExists("EmpCountry"))
            {
                Console.WriteLine("Country list...");
                countryList = ctx.Web.CreateList(ListTemplateType.GenericList, "EmpCountry", false, false, "Lists/EmpCountry", false);

                //Provision country list items
                ListItemCreationInformation newCountryCreationInfomation;
                newCountryCreationInfomation = new ListItemCreationInformation();
                ListItem newCountry = countryList.AddItem(newCountryCreationInfomation);
                newCountry["Title"] = "Belgium";
                newCountry.Update();
                newCountry = countryList.AddItem(newCountryCreationInfomation);
                newCountry["Title"] = "United States of America";
                newCountry.Update();
                newCountry = countryList.AddItem(newCountryCreationInfomation);
                newCountry["Title"] = "India";
                newCountry.Update();
                ctx.Load(countryList);
                ctx.ExecuteQueryRetry();
            }
            else
            {
                countryList = ctx.Web.GetListByUrl("Lists/EmpCountry");
                Console.WriteLine("Country list was already available");
            }

            List stateList = null;
            if (!ctx.Web.ListExists("EmpState"))
            {
                Console.WriteLine("State list...");
                stateList = ctx.Web.CreateList(ListTemplateType.GenericList, "EmpState", false, false, "Lists/EmpState", false);
                Field countryLookup = stateList.CreateField(@"<Field Type=""Lookup"" DisplayName=""Country"" ID=""{BDEF775C-AB4B-4E86-9FB8-0A2DE40FE832}"" Name=""Country""></Field>", false);
                ctx.Load(stateList);
                ctx.Load(countryLookup);
                ctx.Load(stateList.DefaultView, p => p.ViewFields);
                ctx.ExecuteQueryRetry();

                // Add field to default view
                stateList.DefaultView.ViewFields.Add("Country");
                stateList.DefaultView.Update();
                ctx.ExecuteQueryRetry();

                // configure country lookup field
                FieldLookup countryField = ctx.CastTo<FieldLookup>(countryLookup);
                countryField.LookupList = countryList.Id.ToString();
                countryField.LookupField = "Title";
                countryField.Indexed = true;
                countryField.IsRelationship = true;
                countryField.RelationshipDeleteBehavior = RelationshipDeleteBehaviorType.Restrict;
                countryField.Update();
                ctx.ExecuteQueryRetry();

                //Provision state list items
                ListItemCreationInformation newStateCreationInfomation;
                newStateCreationInfomation = new ListItemCreationInformation();
                ListItem newState = stateList.AddItem(newStateCreationInfomation);
                newState["Title"] = "Washington";
                newState["Country"] = "2;#United States of America";
                newState.Update();
                newState = stateList.AddItem(newStateCreationInfomation);
                newState["Title"] = "Limburg";
                newState["Country"] = "1;#Belgium";
                newState.Update();
                newState = stateList.AddItem(newStateCreationInfomation);
                newState["Title"] = "Tennessee";
                newState["Country"] = "2;#United States of America";
                newState.Update();
                newState = stateList.AddItem(newStateCreationInfomation);
                newState["Title"] = "Karnataka";
                newState["Country"] = "3;#India";
                newState.Update();

                ctx.ExecuteQueryRetry();
            }
            else
            {
                countryList = ctx.Web.GetListByUrl("Lists/EmpState");
                Console.WriteLine("State list was already available");
            }

            List cityList = null;
            if (!ctx.Web.ListExists("EmpCity"))
            {
                Console.WriteLine("City list...");
                cityList = ctx.Web.CreateList(ListTemplateType.GenericList, "EmpCity", false, false, "Lists/EmpCity", false);
                Field stateLookup = cityList.CreateField(@"<Field Type=""Lookup"" DisplayName=""State"" ID=""{F55BED78-CAF9-4EDF-92B9-C46BDC032DD5}"" Name=""State""></Field>", false);
                ctx.Load(cityList);
                ctx.Load(stateLookup);
                ctx.Load(cityList.DefaultView, p => p.ViewFields);
                ctx.ExecuteQueryRetry();

                // Add field to default view
                cityList.DefaultView.ViewFields.Add("State");
                cityList.DefaultView.Update();
                ctx.ExecuteQueryRetry();

                // configure state lookup field
                FieldLookup stateField = ctx.CastTo<FieldLookup>(stateLookup);
                stateField.LookupList = stateList.Id.ToString();
                stateField.LookupField = "Title";
                stateField.Indexed = true;
                stateField.IsRelationship = true;
                stateField.RelationshipDeleteBehavior = RelationshipDeleteBehaviorType.Restrict;
                stateField.Update();
                ctx.ExecuteQueryRetry();

                //Provision city list items
                ListItemCreationInformation newCityCreationInfomation;
                newCityCreationInfomation = new ListItemCreationInformation();
                ListItem newCity = cityList.AddItem(newCityCreationInfomation);
                newCity["Title"] = "Bree";
                newCity["State"] = "2;#Limburg";
                newCity.Update();
                newCity = cityList.AddItem(newCityCreationInfomation);
                newCity["Title"] = "Redmond";
                newCity["State"] = "1;#Washington";
                newCity.Update();
                newCity = cityList.AddItem(newCityCreationInfomation);
                newCity["Title"] = "Franklin";
                newCity["State"] = "3;#Tennessee";
                newCity.Update();
                newCity = cityList.AddItem(newCityCreationInfomation);
                newCity["Title"] = "Bangalore";
                newCity["State"] = "4;#Karnataka";
                newCity.Update();

                ctx.ExecuteQueryRetry();
            }
            else
            {
                cityList = ctx.Web.GetListByUrl("Lists/EmpCity");
                Console.WriteLine("City list was already available");
            }

            List designationList = null;
            if (!ctx.Web.ListExists("EmpDesignation"))
            {
                Console.WriteLine("Designation list...");
                designationList = ctx.Web.CreateList(ListTemplateType.GenericList, "EmpDesignation", false, false, "Lists/EmpDesignation", false);
                ctx.Load(designationList);
                ctx.ExecuteQueryRetry();

                //Provision designation list items
                ListItemCreationInformation newDesignationCreationInfomation;
                newDesignationCreationInfomation = new ListItemCreationInformation();
                ListItem newDesignation = designationList.AddItem(newDesignationCreationInfomation);
                newDesignation["Title"] = "Service Engineer";
                newDesignation.Update();
                newDesignation = designationList.AddItem(newDesignationCreationInfomation);
                newDesignation["Title"] = "Service Engineer II";
                newDesignation.Update();
                newDesignation = designationList.AddItem(newDesignationCreationInfomation);
                newDesignation["Title"] = "Senior Service Engineer";
                newDesignation.Update();
                newDesignation = designationList.AddItem(newDesignationCreationInfomation);
                newDesignation["Title"] = "Principal Service Engineer";
                newDesignation.Update();
                newDesignation = designationList.AddItem(newDesignationCreationInfomation);
                newDesignation["Title"] = "Program Manager";
                newDesignation.Update();
                newDesignation = designationList.AddItem(newDesignationCreationInfomation);
                newDesignation["Title"] = "Senior Program Manager";
                newDesignation.Update();

                ctx.ExecuteQueryRetry();
            }
            else
            {
                designationList = ctx.Web.GetListByUrl("Lists/EmpDesignation");
                Console.WriteLine("Designation list was already available");
            }

            List empAttachmentsList = null;
            if (!ctx.Web.ListExists("EmpAttachments"))
            {
                Console.WriteLine("EmpAttachments list...");
                empAttachmentsList = ctx.Web.CreateList(ListTemplateType.DocumentLibrary, "EmpAttachments", false, false, "Lists/EmpAttachments", false);
                ctx.Load(empAttachmentsList);
                ctx.ExecuteQueryRetry();

                empAttachmentsList.CreateField(@"<Field Type=""Text"" DisplayName=""AttachmentID"" ID=""{E6FAC176-F466-4174-9785-7FB9611CBC00}"" Name=""AttachmentID""></Field>", false);
                empAttachmentsList.Update();
                ctx.Load(empAttachmentsList.DefaultView, p => p.ViewFields);
                ctx.ExecuteQueryRetry();

                // Add fields to view
                empAttachmentsList.DefaultView.ViewFields.Add("AttachmentID");
                empAttachmentsList.DefaultView.Update();
                ctx.ExecuteQueryRetry();

            }
            else
            {
                empAttachmentsList = ctx.Web.GetListByUrl("Lists/EmpAttachments");
                Console.WriteLine("EmpAttachments list was already available");
            }

            List employeeList = null;
            if (!ctx.Web.ListExists("Employees"))
            {
                Console.WriteLine("Employee list...");
                employeeList = ctx.Web.CreateList(ListTemplateType.GenericList, "Employees", false, false, "Lists/Employees", false);
                ctx.Load(employeeList);
                ctx.ExecuteQueryRetry();

                employeeList.CreateField(@"<Field Type=""Text"" DisplayName=""Number"" ID=""{0FFF75B6-0E57-46BE-84D7-E5225A55E914}"" Name=""EmpNumber""></Field>", false);
                employeeList.CreateField(@"<Field Type=""Text"" DisplayName=""UserID"" ID=""{D3199531-C091-4359-8CDE-86FB3924F65E}"" Name=""UserID""></Field>", false);
                employeeList.CreateField(@"<Field Type=""Text"" DisplayName=""Manager"" ID=""{B7E2F4D9-AEA2-40DB-A354-94EEDAFEF35E}"" Name=""EmpManager""></Field>", false);
                employeeList.CreateField(@"<Field Type=""Text"" DisplayName=""Designation"" ID=""{AB230804-C137-4ED8-A6D6-722037BDDA3D}"" Name=""Designation""></Field>", false);
                employeeList.CreateField(@"<Field Type=""Text"" DisplayName=""Location"" ID=""{2EE32832-5EF0-41D0-8CD3-3DE7B9616C21}"" Name=""Location""></Field>", false);
                employeeList.CreateField(@"<Field Type=""Text"" DisplayName=""Skills"" ID=""{89C02660-822D-4F41-881D-1D533C56017E}"" Name=""Skills""></Field>", false);
                employeeList.CreateField(@"<Field Type=""Text"" DisplayName=""AttachmentID"" ID=""{53A31281-1C25-4D00-B785-40C71D37AE7B}"" Name=""AttachmentID""></Field>", false);
                employeeList.Update();
                ctx.Load(employeeList.DefaultView, p => p.ViewFields);
                ctx.ExecuteQueryRetry();

                // Add fields to view
                employeeList.DefaultView.ViewFields.Add("EmpNumber");
                employeeList.DefaultView.ViewFields.Add("UserID");
                employeeList.DefaultView.ViewFields.Add("EmpManager");
                employeeList.DefaultView.ViewFields.Add("Designation");
                employeeList.DefaultView.ViewFields.Add("Location");
                employeeList.DefaultView.ViewFields.Add("Skills");
                employeeList.DefaultView.ViewFields.Add("AttachmentID");
                employeeList.DefaultView.Update();
                ctx.ExecuteQueryRetry();

            }
            else
            {
                employeeList = ctx.Web.GetListByUrl("Lists/Employees");
                Console.WriteLine("Employee list was already available");
            }
        }
        #endregion

        #region web part manipulation
        private static void ProvisionWebPart(ClientContext ctx, string relativePageUrl, string scriptFile, bool isWikiPage = false)
        {
            Console.WriteLine("Provisioning web part...");

            string webPartXml = System.IO.File.ReadAllText(HostingEnvironment.MapPath(String.Format("~/{0}", @"Assets\EmployeeRegistration.dwp")));
            //replace tokens
            string scriptUrl = String.Format("~sitecollection/Style Library/OfficeDevPnP/{0}", scriptFile);
            scriptUrl = Utilities.ReplaceTokens(ctx, scriptUrl);
            webPartXml = webPartXml.Replace("%ContentLink%", scriptUrl);

            OfficeDevPnP.Core.Entities.WebPartEntity webPart = new OfficeDevPnP.Core.Entities.WebPartEntity()
            {
                WebPartZone = "Main",
                WebPartIndex = 20,
                WebPartTitle = "Employee Registration",
                WebPartXml = webPartXml
            };

            Console.WriteLine("Adding employee registration web part to " + relativePageUrl);
            if (isWikiPage)
            {
                ctx.Web.AddWebPartToWikiPage(relativePageUrl, webPart, 1, 1, false);
            }
            else
            {
                ctx.Web.AddWebPartToWebPartPage(relativePageUrl, webPart);
            }
            Console.WriteLine("");
        }

        public static bool IsWebPartOnPage(ClientContext ctx, string relativePageUrl, string title)
        {
            var webPartPage = ctx.Web.GetFileByServerRelativeUrl(relativePageUrl);
            ctx.Load(webPartPage);
            ctx.ExecuteQuery();

            if (webPartPage == null)
            {
                return false;
            }

            LimitedWebPartManager limitedWebPartManager = webPartPage.GetLimitedWebPartManager(PersonalizationScope.Shared);
            ctx.Load(limitedWebPartManager.WebParts, wps => wps.Include(wp => wp.WebPart.Title));
            ctx.ExecuteQueryRetry();

            if (limitedWebPartManager.WebParts.Count >= 0)
            {
                for (int i = 0; i < limitedWebPartManager.WebParts.Count; i++)
                {
                    WebPart oWebPart = limitedWebPartManager.WebParts[i].WebPart;
                    if (oWebPart.Title.Equals(title, StringComparison.InvariantCultureIgnoreCase))
                    {
                        return true;
                    }
                }
            }

            return false;
        }

        public static void CloseAllWebParts(ClientContext ctx, string relativePageUrl)
        {
            var webPartPage = ctx.Web.GetFileByServerRelativeUrl(relativePageUrl);
            ctx.Load(webPartPage);
            ctx.ExecuteQuery();

            if (webPartPage == null)
            {
                return;
            }

            LimitedWebPartManager limitedWebPartManager = webPartPage.GetLimitedWebPartManager(PersonalizationScope.Shared);
            ctx.Load(limitedWebPartManager.WebParts, wps => wps.Include(wp => wp.WebPart.Title));
            ctx.ExecuteQueryRetry();

            if (limitedWebPartManager.WebParts.Count >= 0)
            {
                for (int i = 0; i < limitedWebPartManager.WebParts.Count; i++)
                {
                    limitedWebPartManager.WebParts[i].CloseWebPart();
                    limitedWebPartManager.WebParts[i].SaveWebPartChanges();
                }
                ctx.ExecuteQuery();
            }
        }
        #endregion

    }
}


text:
#include <Xm/XmAll.h>

#define print_XmNtraversalOn_value(ss,ww) \
{ \
  Boolean bb; \
  XmNavigationType nt; \
  XtVaGetValues ( ww, XmNtraversalOn, &bb, NULL ); \
  if   ( bb == True ) printf ( "%s XmNtraversalOn is True ", ss ); \
  else                printf ( "%s XmNtraversalOn is False ", ss ); \
  XtVaGetValues ( ww, XmNnavigationType, &nt, NULL ); \
  if      ( nt == XmTAB_GROUP ) printf ( " XmTAB_GROUP\n" ); \
  else if ( nt == XmNONE )      printf ( " XmNONE\n" ); \
  else                          printf ( " Xm???\n" ); \
}

#define DAVE_print_frm_nkd(f)     str_buf [ 0 ] = '\0'; \
                                  reset_res(0); \
                                  write_frm_res(f, 0); \
                                  printf ( "|%s|", str_buf )

#define DAVE_print_frm(f)     str_buf [ 0 ] = '\0'; \
                              reset_res(0); \
                              write_frm_res(f, 0); \
                              printf ( "frm %d: |%s|\n", f, str_buf )

#define DAVE_print_frm_sgl(s,f) \
  printf ( "-- DAVE_print_frm_sgl -- %s\n     - ", s ); \
  DAVE_print_frm(f)

#define DAVE_print_frm_lst(s,f) \
{ \
  int k; \
  k = 1; \
  printf ( "-- DAVE_print_frm_lst -- %s -- (len %d)\n", s, len(f) ); \
  while ( k <= len(f) ) { \
    printf ( "    %d - " , k ); \
    DAVE_print_frm(val(f,k)); \
    k++; \
  } \
}

#define DAVE_print_rule(r)     str_buf [ 0 ] = '\0'; \
                               write_hor_short_rul ( r ); \
                               printf ( "rule #%d:\n  %s", r, str_buf )

#define DAVE_print_rule_nl(r)     str_buf [ 0 ] = '\0'; \
                                  write_hor_short_rul ( r ); \
                                  printf ( "rule #%d:\n  %s\n", r, str_buf )

#define DAVE_print_goal(r)     str_buf [ 0 ] = '\0'; \
                               write_gol_prf ( r ); \
                               printf ( "goal #%d:\n  %s", r, str_buf )

/* for Proof_CB_continued */
#define proof_step_flag_NO  0
#define proof_step_flag_YES 1

#define DAVE_print_info_nod(r) \
     { \
       int i, j; \
       strcpy ( str_buf, "---------------------------------\n" ); \
       write_gol_prf ( info_nod ( r ) ); \
       DisplayCurrWinText ( str_buf ); \
       for ( i = 10 ; i <= r ; i++ ) { \
         sprintf ( buf, "node: %d  fath %d  len ( sons ) %d\n", i, fath_nod ( i ), len ( sons_nod ( i ) ) ); \
         DisplayCurrWinText ( buf ); \
         for ( j = 1 ; j <= len ( sons_nod ( i ) ) ; j++ ) { \
           sprintf ( buf, "    son %d\n", val ( sons_nod ( i ), j ) ); \
           DisplayCurrWinText ( buf ); \
	 }  \
       } \
       sprintf ( buf, "---------------------------------\n" ); \
       DisplayCurrWinText ( buf ); \
     }

#define DAVE_print_hyp(r)     str_buf [ 0 ] = '\0'; \
                              write_frm_res(frm_hyp(r),0); \
                              printf ( "hyp #%d (seq #%d):\n  %s\n", r, frm_hyp(r), str_buf )

#define DAVE_print_seq(r)     { int L = vnbs; \
                              str_buf [ 0 ] = '\0'; \
                              write_frm_res(r,0); \
                              if ( L != vnbs ) \
{ printf ( " $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ %d -> %d \n", L, vnbs ); } \
                              printf ( "seq #%d (len = %d):\n  %s\n", r, len(r), str_buf ); \
											                     } \

#define DAVE_dead_seq         { int II; \
                                for ( II = ttms ; II > 0 ; II-- ) \
                                  { DAVE_print_seq ( tmbs [ II ] ); } \
                                printf ( "%d in total\n", ttms );\
			      }

#define string_box_new_thy                  1
#define string_box_recompact                2
#define string_box_new_rule                 3
#define string_box_exec_direct              4
#define string_box_exec_file                5
#define string_box_prf_to_file              6
#define string_box_nml_tac_a_theory         7
#define string_box_fwd_tac_a_theory         8
#define string_box_nml_tac_a_rule           9
#define string_box_fwd_tac_a_rule          10
#define string_box_nml_quota               11
#define string_box_fwd_quota               12
#define string_box_move_rule               13
#define string_box_change_rule             14
#define string_box_new_rule_from_browse    15
#define string_box_change_rule_from_browse 16
#define string_box_nml_quota_from_proof    17
#define string_box_fwd_quota_from_proof    18

#define file_sel_flag_load_bin    1
#define file_sel_flag_load_src    2
#define file_sel_flag_save_bin    3

#define  bmotif_top_frame_form_min                50
#define  bmotif_bottom_frame_form_min             50
#define  bmotif_bottom_form_main_length          250
#define  bmotif_bottom_form_proof_length         400
#define  bmotif_bottom_form_proof_tree_length    650

#define ask_hyp_test_hyp1      1
#define ask_hyp_test_hyp2      2
#define ask_hyp_test_imp_hyp1  3
#define ask_hyp_test_imp_hyp2  4

#define ask_eql_hyp_test2_eql   1
#define ask_eql_hyp_test3_eql1  2
#define ask_eql_hyp_test3_eql2  3
#define ask_eql_hyp_test3_unv   4
#define ask_eql_hyp_test2_unv   5

#define allowable_dim_x 12
#define allowable_dim_y 25

#define menu_position_changed_x \
         last_menu_x - wm_width  > global_menu_x + allowable_dim_x || \
         last_menu_x - wm_width  < global_menu_x - allowable_dim_x

#define menu_position_changed_y \
         last_menu_y - wm_height > global_menu_y + allowable_dim_y || \
         last_menu_y - wm_height < global_menu_y - allowable_dim_y \

#ifndef BTOOLKIT_FLAG

int OR_sym;

#define proof_ini_horiz       5
#define proof_ini_vert        5
#define proof_header_height  35
int half_proof_goal_height;
int proof_horiz_offset;
int proof_vert_offset;
int proof_extra_lines_offset;
int goal_rule_vert_diff;

#endif

#define browse_position_changed_x \
         last_browse_x - wm_width  > global_browse_x + allowable_dim_x || \
         last_browse_x - wm_width  < global_browse_x - allowable_dim_x

#define browse_position_changed_y \
         last_browse_y - wm_height > global_browse_y + allowable_dim_y || \
         last_browse_y - wm_height < global_browse_y - allowable_dim_y

#define applicable_position_changed_x \
         last_applicable_x - wm_width  > global_applicable_x + allowable_dim_x || \
         last_applicable_x - wm_width  < global_applicable_x - allowable_dim_x

#define applicable_position_changed_y \
         last_applicable_y - wm_height > global_applicable_y + allowable_dim_y || \
         last_applicable_y - wm_height < global_applicable_y - allowable_dim_y \

#define text_trigger_tot   30000
#define text_rem_tot        2500

#define MAX_num_sel_string    1001

/*
#define write_srv_res        putc(27, bstdout); fprintf ( bstdout, "[7m")

#define write_erv_res        putc(27, bstdout); fprintf ( bstdout, "[0m")

#define write_srv_err_res    putc(27,stderr); fprintf(stderr,"[7m")

#define write_erv_err_res    putc(27,stderr); fprintf(stderr,"[0m")
*/

#define rv_char ( char )     17
#define dollar_char ( char ) 18

#define write_srv_res        str_buf_i = strlen ( str_buf ); \
                             str_buf [ str_buf_i++ ] = rv_char; \
                             str_buf [ str_buf_i ] = '\0'

#define write_erv_res        write_srv_res

#define write_srv_err_res    ;

#define write_erv_err_res    ;

/*
#define write_top_clear_res  putc(27, bstdout); \
                             fprintf ( bstdout, "[1;1H"); \
                             putc(27, bstdout); \
                             fprintf ( bstdout, "[J")
*/
#define write_top_clear_res  ;

/***
#endif

#ifdef hpcomputer

#define write_srv_res        putc(27, bstdout); fprintf ( bstdout, "&dB")

#define write_erv_res        putc(27, bstdout); fprintf ( bstdout, "&d@")

#define write_srv_err_res    putc(27,stderr); fprintf(stderr,"&dB")

#define write_erv_err_res    putc(27,stderr); fprintf(stderr,"&d@")

#define write_top_clear_res  putc(27, bstdout); fprintf ( bstdout, "H");  putc(27, bstdout); fprintf ( bstdout, "J")

#endif
***/

#define WWW(x,y) fprintf ( bstdout, x, y )

#define OK_BUTTON          1
#define CANCEL_BUTTON      2
#define HELP_BUTTON        3

#define query_box_flag_clear              1
#define query_box_flag_quit               2
#define query_box_flag_rld_src_main       3
#define query_box_flag_rem_thy            4
#define query_box_flag_rem_last_rule      5
/* #define query_box_prf_to_screen           6 */
#define query_box_rem_proof               7
#define query_box_flag_rld_src_a_theory   8
#define query_box_flag_rld_src_a_rule     9
#define query_box_flag_rem_rule          10
#define query_box_ask_ari_prf            11
#define query_box_quit_proof             12
#define query_box_ask_rul_prf            13
#define query_box_ask_eql_rul_prf        14
#define query_box_ask_hyp_prf            15
#define query_box_ask_eql_hyp_prf        16

#define main_menu          1
#define a_theory_menu      2
#define a_rule_menu        3
#define prove_rule_menu    4

#define util_str_max 1000

/*  Maximum Number of SYMBOLS  */
/*
#define max_sym_val             7500  */

/* #define max_sym_val             12544 */
#define max_sym_val             22528
			     /* multiple of 128? */

/*  Maximum Number of THEORIES  */

#define max_the_val              1250

/*  Maximum Number of RULES  */

#define max_rul_val             25000
/*  Maximum Number of GOALS  */

#define max_gol_val             45000

/*  Maximum Number of NODES  */

/* #define max_nod_val             19000 */
/* #define max_nod_val             25000 */
#define max_nod_val             60000

/*  Maximum Number of TACTICS  */

#define max_tac_val            20000
/*  Maximum Number of HYPOTHESES  */

#define max_hyp_val             3000
/*  Maximum Number of SEQUENCES  */
#define hyp_mod_val             /* max_hyp_val+10 */  10000

#define max_seq_val            225000

/*  Maximum Number of stored proofs  */

#define max_proved_rr_val        100
			     /* MUST be same as in b.c.malloc */

#define btl_proofPV1 max_proved_rr_val
#define btl_proofPV2 (25*max_proved_rr_val)

/**************************************************************************/

extern char err_str_buf [];

#ifndef BTOOLKIT_FLAG
extern char hyp_search_string [];
extern int btl_rule;
#endif

extern int ask_hyp_ret;

extern int ask_eql_hyp_ret;

extern int from_applicable_rr;

extern int exit_flag;

extern int popup_after_time_elapsed ;

extern XmFontList fontlist;

extern Position global_menu_x, global_menu_y;

extern char cur_dir [];

extern Widget curr_dialog_menu,
/* proof_tree_dialog, */
       proof_tree_dialog_form, proof_tree_scroll,
/*       proof_tree_scroll_h, proof_tree_scroll_v, */
       visible_scroll,
       proof_tree_scroll_form,
       browse_theories_dialog, browse_a_theory_dialog,
       browse_theories_dialog_form, browse_a_theory_dialog_form,
       browse_theories_menu_scroll, browse_a_theory_menu_scroll;

extern int visible_browse_but_num;
extern int visible_thy_menu_rule_num;

extern Pixmap h_pixmap, sv_pixmap, lv_pixmap;

extern Position global_proof_tree_x, global_proof_tree_y;

extern int last_node;

extern Position global_browse_x, global_browse_y;

extern Position global_query_box_x;
extern Position global_query_box_y;

extern Position global_applicable_x;
extern Position global_applicable_y;

#ifndef BTOOLKIT_FLAG
extern XmStringCharSet charset;
#endif

extern XtAppContext app;

extern Display *display;

extern Screen * proof_screen;

extern Pixel gray89, gray64, gray39, red, blue,
      main_text_col,
      option_set_col,    option_not_set_col,
#ifndef BTOOLKIT_FLAG
      Prompt_bck_col,  Prompt_top_col,  Prompt_bot_col,
      Browse_bck_col,  Browse_top_col,  Browse_bot_col,
      Prompt_text_bck_col, Browse_text_bck_col,
      Prompt_but_lab_col, Browse_but_lab_col,
#endif
      ProofTree_bck_col,  ProofTree_top_col,  ProofTree_bot_col;

extern Pixmap B_framed_pixmap_gray94;

extern Widget top_level, main_form, main_form_pane,
       top_frame_form, bottom_frame_form,
       constructs_form, constructs_frame,
       TopWin_scroll, TopWin_rc,
       bot_display_frame, main_text, curr_text;

#ifndef BTOOLKIT_FLAG
extern Widget TRBut [];
#endif

extern XmTextPosition main_text_posn, curr_text_posn;

extern int mc_interval;

extern int string_box_flag;

extern int file_sel_flag;

extern int curr_thy, curr_rule;
extern int c_arr [];

#ifndef BTOOLKIT_FLAG

extern const char *proved_label[];

extern const char *proved_class[];

#endif

extern void PopdownCurrMenu ();
extern void Popup_Info ();
extern void DisplayMainMenu ();
extern void DisplayMainTopWin ();
extern void DisplayATheoryMenu ();
extern void DisplayATheoryTopWin ();
extern void DisplayARuleMenu ();
extern void DisplayARuleTopWin ();
extern void ProveRuleMenu ();
extern void ResetTopWin ();
extern void CrePassiveButton ();
extern void QueryBox ();
extern void ApplyRuleBox ();
extern void ProveRuleMenu ();
extern XtCallbackProc SelRul_CB ();
extern void BrowseTheories ();
extern void BrowseATheory ();
extern void Popup_Error ();
extern void Popup_Info ();

extern int loop_do_prf_r,loop_do_prf_p,loop_do_prf_i,loop_do_prf_g,loop_do_prf_j;

extern int do_prf_t,do_prf_n,do_prf_a,do_prf_p,do_prf_r,do_prf_i,do_prf_l,do_prf_b,do_prf_bbuf ;

extern int run_man_prf_f,run_man_prf_r,run_man_prf_p,run_man_prf_success,run_man_prf_ff,run_man_prf_fff,run_man_prf_j,run_man_prf_i,run_man_prf_gl,run_man_prf_g,run_man_prf_menu,run_man_prf_run_man_prf_res;

/**************************************************************************/

#define read_frm_str_buf read_frmfunc_str_buf()
#define ini_prf ini_prffunc()

/**************************************************************************/

extern int browse_theories_is_up;
extern int browse_a_theory_is_up;
extern int browse_btool_theory_rul;
extern int curr_menu;
extern int util_str_i;
extern int query_box_flag;
extern int query_box_rule;
extern int Blm_registered;
extern char util_str [] [ util_str_max + 2 ];
extern int auto_prf;


text:
package org.apache.commons.daemon;

/**
 * This interface tags a Daemon as supporting some kind of
 * soft reload method that allows the java application to restart
 * in some way with out killing itself, and ideally without interrupting
 * availability of the service.
 * @author Nick Griffiths <nicobrevin@gmail.com>

 */
public interface SoftReloadable {

  /**
   * Attempt to reload the application.
   */
  void softReload();

}