text:
if [[ -z "$NVM_DIR" ]]; then
  if [[ -d "$HOME/.nvm" ]]; then
    export NVM_DIR="$HOME/.nvm"
  elif [[ -d "${XDG_CONFIG_HOME:-$HOME/.config}/nvm" ]]; then
    export NVM_DIR="${XDG_CONFIG_HOME:-$HOME/.config}/nvm"
  elif (( $+commands[brew] )); then
    NVM_HOMEBREW="${NVM_HOMEBREW:-${HOMEBREW_PREFIX:-$(brew --prefix)}/opt/nvm}"
    if [[ -d "$NVM_HOMEBREW" ]]; then
      export NVM_DIR="$NVM_HOMEBREW"
    fi
  fi
fi

# Don't try to load nvm if command already available
# Note: nvm is a function so we need to use `which`
which nvm &>/dev/null && return

# TODO: 2022-11-11: Remove soft-deprecate options
if (( ${+NVM_LAZY} + ${+NVM_LAZY_CMD} + ${+NVM_AUTOLOAD} )); then
  # Get list of NVM_* variable settings defined
  local -a used_vars
  used_vars=(${(o)parameters[(I)NVM_(AUTOLOAD|LAZY|LAZY_CMD)]})
  # Nicely print the list in the style `var1, var2 and var3`
  echo "${fg[yellow]}[nvm plugin] Variable-style settings are deprecated. Instead of ${(j:, :)used_vars[1,-2]}${used_vars[-2]+ and }${used_vars[-1]}, use:\n"
  if (( $+NVM_AUTOLOAD )); then
    echo "  zstyle ':omz:plugins:nvm' autoload true"
    zstyle ':omz:plugins:nvm' autoload yes
  fi
  if (( $+NVM_LAZY )); then
    echo "  zstyle ':omz:plugins:nvm' lazy true"
    zstyle ':omz:plugins:nvm' lazy yes
  fi
  if (( $+NVM_LAZY_CMD )); then
    echo "  zstyle ':omz:plugins:nvm' lazy-cmd $NVM_LAZY_CMD"
    zstyle ':omz:plugins:nvm' lazy-cmd $NVM_LAZY_CMD
  fi
  echo "$reset_color"
  unset used_vars NVM_AUTOLOAD NVM_LAZY NVM_LAZY_CMD
fi

if zstyle -t ':omz:plugins:nvm' lazy; then
  # Call nvm when first using nvm, node, npm, pnpm, yarn or other commands in lazy-cmd
  zstyle -a ':omz:plugins:nvm' lazy-cmd nvm_lazy_cmd
  eval "
    function nvm node npm pnpm yarn $nvm_lazy_cmd {
      unfunction nvm node npm pnpm yarn $nvm_lazy_cmd
      # Load nvm if it exists in \$NVM_DIR
      [[ -f \"\$NVM_DIR/nvm.sh\" ]] && source \"\$NVM_DIR/nvm.sh\"
      \"\$0\" \"\$@\"
    }
  "
  unset nvm_lazy_cmd
elif [[ -f "$NVM_DIR/nvm.sh" ]]; then
  # Load nvm if it exists in $NVM_DIR
  source "$NVM_DIR/nvm.sh"
else
  return
fi

# Autoload nvm when finding a .nvmrc file in the current directory
# Adapted from: https://github.com/nvm-sh/nvm#zsh
if zstyle -t ':omz:plugins:nvm' autoload; then
  load-nvmrc() {
    local node_version="$(nvm version)"
    local nvmrc_path="$(nvm_find_nvmrc)"

    if [[ -n "$nvmrc_path" ]]; then
      local nvmrc_node_version=$(nvm version "$(cat "${nvmrc_path}")")

      if [[ "$nvmrc_node_version" = "N/A" ]]; then
        nvm install
      elif [[ "$nvmrc_node_version" != "$node_version" ]]; then
        nvm use
      fi
    elif [[ "$node_version" != "$(nvm version default)" ]]; then
      echo "Reverting to nvm default version"
      nvm use default
    fi
  }

  autoload -U add-zsh-hook
  add-zsh-hook chpwd load-nvmrc

  load-nvmrc
fi

# Load nvm bash completion
for nvm_completion in "$NVM_DIR/bash_completion" "$NVM_HOMEBREW/etc/bash_completion.d/nvm"; do
  if [[ -f "$nvm_completion" ]]; then
    # Load bashcompinit
    autoload -U +X bashcompinit && bashcompinit
    # Bypass compinit call in nvm bash completion script. See:
    # https://github.com/nvm-sh/nvm/blob/4436638/bash_completion#L86-L93
    ZSH_VERSION= source "$nvm_completion"
    break
  fi
done

unset NVM_HOMEBREW nvm_completion


text:
/**
 * @module  uifactory/window
 * @author  Flavio De Stefano <flavio.destefano@caffeinalab.com>
 */

var UIUtil = require('T/uiutil');

module.exports = function(args) {
	_.defaults(args, {

		/**
		 * **(Android only)** Set the property `displayHomeAsUp` and the relative close listener.
		 * @property {Boolean} [displayHomeAsUp=false]
		 */
		displayHomeAsUp: false,

		/**
		 * **(Android only)** Disable the hardware back button (do nothing on click)
		 * @property {Boolean} [backButtonDisabled=false]
		 */
		backButtonDisabled: false,

		/**
		 * View {@link #setDeferredBackgroundImage}
		 * @property {String} [deferredBackgroundImage=null]
		 */
		deferredBackgroundImage: null,

		/**
		 * View {@link #setBackgroundCoverImage}
		 * @property {String} [backgroundCoverImage=null]
		 */
		backgroundCoverImage: null,

		/**
		 * View {@link #setActivityProperties}
		 * @property {Object} [activityProperties=null]
		 */
		activityProperties: null,

		/**
		 * View {@link #setActionBarProperties}
		 * @property {Object} [actionBarProperties=null]
		 */
		actionBarProperties: null,

		/**
		 * @property {Object} [rightNavButton=null]
		 * View {@link #setRightNavButton}
		 */
		rightNavButton: null,

		/**
		 * View {@link #addActivityButton}
		 * @property {Array} [activityButtons=null]
		 */
		activityButtons: null,

		/**
		 * View {@link #setActivityButton}
		 * @property {Object} [activityButton=null]
		 */
		activityButton: null,

		/**
		 * Set an handler that kill the entire app when back button is closed
		 * @property {Boolean} [exitOnBack=null]
		 */
		exitOnBack: null

	});

	var $this = Ti.UI.createWindow(args);

	$this.opened = false;
	var onOpenFuncs = [];
	function onOpen(callback) {
		if ($this.opened === true) {
			callback();
			return;
		}
		onOpenFuncs.push(callback);
	}

	$this.addEventListener('open', function() {
		$this.opened = true;
		_.each(onOpenFuncs, function(openFunc){
			openFunc();
		});
	});

	/**
	 * When large images are requested, it's useful to set `deferredBackgroundImage` to set the background on window open.
	 * @method setDeferredBackgroundImage
	 * @param {String} val
	 */
	$this.setDeferredBackgroundImage = function(val) {
		onOpen(function() {
			$this.backgroundImage = val;
		});
	};

	/**
	 * @method  setBackgroundCoverImage
	 * @param {String} url
	 */
	$this.setBackgroundCoverImage = function(url) {
		UIUtil.setBackgroundCoverForView($this, url, function(file) {
			$this.backgroundImage = file;
		});
	};

	/**
	 * Fade in this window
	 * @method  fadeIn
	 */
	$this.fadeIn = function() {
		$this.opacity = 0;
		$this.open();
		$this.animate({
			opacity: 1,
			duration: 300
		});
	};

	/**
	 * Fade in this window
	 * @method  fadeOut
	 */
	$this.fadeOut = function() {
		setTimeout(function() { $this.close(); }, 300);
		$this.animate({
			opacity: 0,
			duration: 300
		});
	};

	if (OS_ANDROID) {

		/**
		 * Set the properties for the Activity
		 * @method setActivityProperties
		 * @param {Object} props
		 */
		$this.setActivityProperties = function(props) {
			_.each(props, function(v, k) {
				$this.activity[k] = v;
			});
		};

		/**
		 * Set the properties for the ActionBar
		 * @method  setActionBarProperties
		 * @param {Object}   props
		 * @param {Function} callback
		 */
		$this.setActionBarProperties = function(props, callback) {
			onOpen(function(){
				if ($this.activity.actionBar == null) return;

				_.each(props, function(v, k) {
					$this.activity.actionBar[k] = v;
				});
				if (_.isFunction(callback)) callback($this.activity.actionBar);
			});
		};

		var activityButtons = [];

		$this.setActivityProperties({
			onCreateOptionsMenu: function(e) {
				_.each(activityButtons, function(btn) {
					var menuItem = e.menu.add({
						title: btn.title || '',
						icon: btn.icon || btn.image || '',
						actionView: btn.actionView,
						showAsAction: btn.showAsAction != null ? btn.showAsAction : Ti.Android.SHOW_AS_ACTION_ALWAYS
					});
					menuItem.addEventListener('click', function(){
						if (_.isFunction(btn.click)) btn.click();
						if (_.isFunction(btn.fireEvent)) btn.fireEvent('click');
					});
				});
			}
		});

		/**
		 * **Android specific**
		 * @method  addActivityButton
		 * @param {Object} opt
		 */
		$this.addActivityButton = function(opt) {
			if (opt != null) {
				while (opt && opt.children && opt.children[0]) opt = opt.children[0]; // hack for Alloy, just ignore it
				activityButtons.push(opt);
			}
			if (_.isFunction($this.activity.invalidateOptionsMenu)) $this.activity.invalidateOptionsMenu();
		};

		/**
		 * **Android specific**
		 * @method  setActivityButton
		 * @param {Object} opt
		 */
		$this.setActivityButton = function(opt) {
			activityButtons = [];
			$this.addActivityButton(opt);
		};

 		/**
 		 * @method setRightNavButton
 		 * @see {@link setActivityButton}
 		 */
		$this.setRightNavButton = $this.setActivityButton;

		/**
		 * Auto-process the titles
		 * @method  processTitles
		 */
		$this.processTitles = function () {
			$this.setActionBarProperties({
				title: ($this.title && $this.subtitle) ? $this.title : ($this.subtitle === false ? $this.title : Ti.App.name),
				subtitle: ($this.title && $this.subtitle) ? $this.subtitle : ($this.subtitle === false ? null : ($this.title || null))
			});
		};

		/**
		 * **Android fix**
		 * @method setTitle
		 * @param {String} value
		 */
		$this.setTitle = function(value) {
			$this.title = value;
			$this.processTitles();
		};

		/**
		 * **Android fix**
		 * @method  setSubtitle
		 * @param {String} value
		 */
		$this.setSubtitle = function(value) {
			$this.subtitle = value;
			$this.processTitles();
		};

	}

	//////////////////////
	// Parse arguments //
	//////////////////////

	if (args.deferredBackgroundImage != null) $this.setDeferredBackgroundImage(args.deferredBackgroundImage);
	if (args.backgroundCoverImage != null) $this.setBackgroundCoverImage(args.backgroundCoverImage);

	if (OS_ANDROID) {

		$this.processTitles();
		if (_.isFunction($this.activity.invalidateOptionsMenu)) {
			$this.activity.invalidateOptionsMenu();
		}

		if (args.displayHomeAsUp === true && args.exitOnClose !== true) {
			$this.setActionBarProperties({
				displayHomeAsUp: true,
				onHomeIconItemSelected: function() {
					$this.close();
				}
			});
		}

		if (args.backButtonDisabled === true) {
			$this.addEventListener('androidback', function() {
				return false;
			});
		}

		if (args.exitOnBack === true) {
			$this.addEventListener('androidback', function() {
				Ti.Android.currentActivity.finish();
			});
		}

		if (args.activityProperties != null) $this.setActivityProperties(args.activityProperties);
		if (args.actionBarProperties != null) $this.setActionBarProperties(args.actionBarProperties);
		if (args.rightNavButton != null) $this.setRightNavButton(args.rightNavButton);
		if (args.activityButtons != null) _.each(args.activityButtons, function(val) { $this.addActivityButton(val); });
		if (args.activityButton != null) $this.setActivityButton(args.activityButton);
	}

	return $this;
};

redpajama_set_name: RedPajamaGithub


text:
/**
 * ClearBufferStage
 */

import { ITutorialContext, ITutorialStage } from "./../ITutorial"

export class SetBufferStage implements ITutorialStage {
    public get goalName(): string {
        return null
    }

    constructor(private _lines: string[]) {}

    public async tickFunction(context: ITutorialContext): Promise<boolean> {
        const allLines = context.buffer.lineCount
        await context.buffer.setLines(0, allLines, this._lines)
        return true
    }

    public render(): JSX.Element {
        return null
    }
}

export class ClearBufferStage extends SetBufferStage {
    constructor() {
        super([])
    }
}


text:
package com.facebook.buck.rules;

import com.facebook.buck.android.AndroidAarDescription;
import com.facebook.buck.android.AndroidBinaryDescription;
import com.facebook.buck.android.AndroidBuckConfig;
import com.facebook.buck.android.AndroidBuildConfigDescription;
import com.facebook.buck.android.AndroidDirectoryResolver;
import com.facebook.buck.android.AndroidInstrumentationApkDescription;
import com.facebook.buck.android.AndroidInstrumentationTestDescription;
import com.facebook.buck.android.AndroidLibraryDescription;
import com.facebook.buck.android.AndroidManifestDescription;
import com.facebook.buck.android.AndroidPrebuiltAarDescription;
import com.facebook.buck.android.AndroidResourceDescription;
import com.facebook.buck.android.ApkGenruleDescription;
import com.facebook.buck.android.GenAidlDescription;
import com.facebook.buck.android.ImmutableNdkCxxPlatforms;
import com.facebook.buck.android.NdkCxxPlatform;
import com.facebook.buck.android.NdkCxxPlatforms;
import com.facebook.buck.android.NdkLibraryDescription;
import com.facebook.buck.android.PrebuiltNativeLibraryDescription;
import com.facebook.buck.android.ProGuardConfig;
import com.facebook.buck.android.RobolectricTestDescription;
import com.facebook.buck.android.SmartDexingStep;
import com.facebook.buck.apple.AppleAssetCatalogDescription;
import com.facebook.buck.apple.AppleBinaryDescription;
import com.facebook.buck.apple.AppleBundleDescription;
import com.facebook.buck.apple.AppleConfig;
import com.facebook.buck.apple.AppleCxxPlatform;
import com.facebook.buck.apple.AppleCxxPlatforms;
import com.facebook.buck.apple.AppleLibraryDescription;
import com.facebook.buck.apple.ApplePackageDescription;
import com.facebook.buck.apple.AppleResourceDescription;
import com.facebook.buck.apple.AppleSdk;
import com.facebook.buck.apple.AppleSdkDiscovery;
import com.facebook.buck.apple.AppleSdkPaths;
import com.facebook.buck.apple.AppleTestDescription;
import com.facebook.buck.apple.AppleToolchain;
import com.facebook.buck.apple.AppleToolchainDiscovery;
import com.facebook.buck.apple.CodeSignIdentityStore;
import com.facebook.buck.apple.CoreDataModelDescription;
import com.facebook.buck.apple.ProvisioningProfileStore;
import com.facebook.buck.apple.XcodePostbuildScriptDescription;
import com.facebook.buck.apple.XcodePrebuildScriptDescription;
import com.facebook.buck.apple.XcodeWorkspaceConfigDescription;
import com.facebook.buck.cli.BuckConfig;
import com.facebook.buck.cli.DownloadConfig;
import com.facebook.buck.cxx.CxxBinaryDescription;
import com.facebook.buck.cxx.CxxBuckConfig;
import com.facebook.buck.cxx.CxxLibraryDescription;
import com.facebook.buck.cxx.CxxPlatform;
import com.facebook.buck.cxx.CxxPlatforms;
import com.facebook.buck.cxx.CxxPythonExtensionDescription;
import com.facebook.buck.cxx.CxxTestDescription;
import com.facebook.buck.cxx.DefaultCxxPlatforms;
import com.facebook.buck.cxx.InferBuckConfig;
import com.facebook.buck.cxx.PrebuiltCxxLibraryDescription;
import com.facebook.buck.d.DBinaryDescription;
import com.facebook.buck.d.DBuckConfig;
import com.facebook.buck.d.DLibraryDescription;
import com.facebook.buck.d.DTestDescription;
import com.facebook.buck.dotnet.CSharpLibraryDescription;
import com.facebook.buck.dotnet.PrebuiltDotNetLibraryDescription;
import com.facebook.buck.file.Downloader;
import com.facebook.buck.file.ExplodingDownloader;
import com.facebook.buck.file.RemoteFileDescription;
import com.facebook.buck.file.StackedDownloader;
import com.facebook.buck.go.GoBinaryDescription;
import com.facebook.buck.go.GoBuckConfig;
import com.facebook.buck.go.GoLibraryDescription;
import com.facebook.buck.go.GoTestDescription;
import com.facebook.buck.gwt.GwtBinaryDescription;
import com.facebook.buck.halide.HalideBuckConfig;
import com.facebook.buck.halide.HalideLibraryDescription;
import com.facebook.buck.io.ExecutableFinder;
import com.facebook.buck.io.ProjectFilesystem;
import com.facebook.buck.js.AndroidReactNativeLibraryDescription;
import com.facebook.buck.js.IosReactNativeLibraryDescription;
import com.facebook.buck.js.ReactNativeBuckConfig;
import com.facebook.buck.jvm.java.JavaBinaryDescription;
import com.facebook.buck.jvm.java.JavaBuckConfig;
import com.facebook.buck.jvm.java.JavaLibraryDescription;
import com.facebook.buck.jvm.java.JavaTestDescription;
import com.facebook.buck.jvm.java.JavacOptions;
import com.facebook.buck.jvm.java.KeystoreDescription;
import com.facebook.buck.jvm.java.PrebuiltJarDescription;
import com.facebook.buck.log.CommandThreadFactory;
import com.facebook.buck.log.Logger;
import com.facebook.buck.model.Flavor;
import com.facebook.buck.model.FlavorDomain;
import com.facebook.buck.ocaml.OCamlBinaryDescription;
import com.facebook.buck.ocaml.OCamlBuckConfig;
import com.facebook.buck.ocaml.OCamlLibraryDescription;
import com.facebook.buck.ocaml.PrebuiltOCamlLibraryDescription;
import com.facebook.buck.python.PrebuiltPythonLibraryDescription;
import com.facebook.buck.python.PythonBinaryDescription;
import com.facebook.buck.python.PythonBuckConfig;
import com.facebook.buck.python.PythonLibraryDescription;
import com.facebook.buck.python.PythonPlatform;
import com.facebook.buck.python.PythonTestDescription;
import com.facebook.buck.rust.RustBinaryDescription;
import com.facebook.buck.rust.RustBuckConfig;
import com.facebook.buck.rust.RustLibraryDescription;
import com.facebook.buck.shell.ExportFileDescription;
import com.facebook.buck.shell.GenruleDescription;
import com.facebook.buck.shell.ShBinaryDescription;
import com.facebook.buck.shell.ShTestDescription;
import com.facebook.buck.thrift.ThriftBuckConfig;
import com.facebook.buck.thrift.ThriftCxxEnhancer;
import com.facebook.buck.thrift.ThriftJavaEnhancer;
import com.facebook.buck.thrift.ThriftLibraryDescription;
import com.facebook.buck.thrift.ThriftPythonEnhancer;
import com.facebook.buck.util.HumanReadableException;
import com.facebook.buck.util.ProcessExecutor;
import com.facebook.buck.util.environment.Platform;
import com.facebook.buck.zip.ZipDescription;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Supplier;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Maps;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Map;
import java.util.concurrent.Executors;

import javax.annotation.Nullable;

/**
 * A registry of all the build rules types understood by Buck.
 */
public class KnownBuildRuleTypes {

  private static final Logger LOG = Logger.get(KnownBuildRuleTypes.class);
  private final ImmutableMap<BuildRuleType, Description<?>> descriptions;
  private final ImmutableMap<String, BuildRuleType> types;
  private final FlavorDomain<CxxPlatform> cxxPlatforms;
  private final CxxPlatform defaultCxxPlatforms;

  private KnownBuildRuleTypes(
      Map<BuildRuleType, Description<?>> descriptions,
      Map<String, BuildRuleType> types,
      FlavorDomain<CxxPlatform> cxxPlatforms,
      CxxPlatform defaultCxxPlatforms) {
    this.descriptions = ImmutableMap.copyOf(descriptions);
    this.types = ImmutableMap.copyOf(types);
    this.cxxPlatforms = cxxPlatforms;
    this.defaultCxxPlatforms = defaultCxxPlatforms;
  }

  public BuildRuleType getBuildRuleType(String named) {
    BuildRuleType type = types.get(named);
    if (type == null) {
      throw new HumanReadableException("Unable to find build rule type: " + named);
    }
    return type;
  }

  public Description<?> getDescription(BuildRuleType buildRuleType) {
    Description<?> description = descriptions.get(buildRuleType);
    if (description == null) {
      throw new HumanReadableException(
          "Unable to find description for build rule type: " + buildRuleType);
    }
    return description;
  }

  public ImmutableSet<Description<?>> getAllDescriptions() {
    return ImmutableSet.copyOf(descriptions.values());
  }

  public FlavorDomain<CxxPlatform> getCxxPlatforms() {
    return cxxPlatforms;
  }

  public CxxPlatform getDefaultCxxPlatforms() {
    return defaultCxxPlatforms;
  }

  public static Builder builder() {
    return new Builder();
  }

  public static KnownBuildRuleTypes createInstance(
      BuckConfig config,
      ProcessExecutor processExecutor,
      AndroidDirectoryResolver androidDirectoryResolver,
      Optional<Path> testTempDirOverride) throws InterruptedException, IOException {
    return createBuilder(
        config,
        processExecutor,
        androidDirectoryResolver,
        testTempDirOverride).build();
  }

  private static void buildAppleCxxPlatforms(
      Supplier<Optional<Path>> appleDeveloperDirectorySupplier,
      ImmutableList<Path> extraToolchainPaths,
      ImmutableList<Path> extraPlatformPaths,
      BuckConfig buckConfig,
      AppleConfig appleConfig,
      ImmutableMap.Builder<Flavor, AppleCxxPlatform> platformFlavorsToAppleSdkPathsBuilder)
      throws IOException {
    Optional<Path> appleDeveloperDirectory = appleDeveloperDirectorySupplier.get();
    if (appleDeveloperDirectory.isPresent() &&
        !Files.isDirectory(appleDeveloperDirectory.get())) {
      LOG.error(
        "Developer directory is set to %s, but is not a directory",
        appleDeveloperDirectory.get());
      return;
    }

    ImmutableMap<String, AppleToolchain> toolchains =
        AppleToolchainDiscovery.discoverAppleToolchains(
            appleDeveloperDirectory,
            extraToolchainPaths);

    ImmutableMap<AppleSdk, AppleSdkPaths> sdkPaths = AppleSdkDiscovery.discoverAppleSdkPaths(
        appleDeveloperDirectory,
        extraPlatformPaths,
        toolchains);

    for (Map.Entry<AppleSdk, AppleSdkPaths> entry : sdkPaths.entrySet()) {
      AppleSdk sdk = entry.getKey();
      AppleSdkPaths appleSdkPaths = entry.getValue();
      String targetSdkVersion = appleConfig.getTargetSdkVersion(
          sdk.getApplePlatform()).or(sdk.getVersion());
      LOG.debug("SDK %s using default version %s", sdk, targetSdkVersion);
      for (String architecture : sdk.getArchitectures()) {
        AppleCxxPlatform appleCxxPlatform = AppleCxxPlatforms.build(
            sdk,
            targetSdkVersion,
            architecture,
            appleSdkPaths,
            buckConfig);
        platformFlavorsToAppleSdkPathsBuilder.put(
            appleCxxPlatform.getCxxPlatform().getFlavor(),
            appleCxxPlatform);
      }
    }
  }

  @VisibleForTesting
  static Builder createBuilder(
      BuckConfig config,
      ProcessExecutor processExecutor,
      AndroidDirectoryResolver androidDirectoryResolver,
      Optional<Path> testTempDirOverride) throws InterruptedException, IOException {

    Platform platform = Platform.detect();

    AndroidBuckConfig androidConfig = new AndroidBuckConfig(config, platform);
    Optional<String> ndkVersion = androidConfig.getNdkVersion();
    // If a NDK version isn't specified, we've got to reach into the runtime environment to find
    // out which one we will end up using.
    if (!ndkVersion.isPresent()) {
      ndkVersion = androidDirectoryResolver.getNdkVersion();
    }

    AppleConfig appleConfig = new AppleConfig(config);
    ImmutableMap.Builder<Flavor, AppleCxxPlatform> platformFlavorsToAppleCxxPlatformsBuilder =
        ImmutableMap.builder();
    buildAppleCxxPlatforms(
        appleConfig.getAppleDeveloperDirectorySupplier(processExecutor),
        appleConfig.getExtraToolchainPaths(),
        appleConfig.getExtraPlatformPaths(),
        config,
        appleConfig,
        platformFlavorsToAppleCxxPlatformsBuilder);
    ImmutableMap<Flavor, AppleCxxPlatform> platformFlavorsToAppleCxxPlatforms =
        platformFlavorsToAppleCxxPlatformsBuilder.build();

    // Setup the NDK C/C++ platforms.
    Optional<Path> ndkRoot = androidDirectoryResolver.findAndroidNdkDir();
    ImmutableMap.Builder<NdkCxxPlatforms.TargetCpuType, NdkCxxPlatform> ndkCxxPlatformsBuilder =
        ImmutableMap.builder();
    if (ndkRoot.isPresent()) {
      NdkCxxPlatforms.Compiler.Type compilerType =
          androidConfig.getNdkCompiler().or(NdkCxxPlatforms.DEFAULT_COMPILER_TYPE);
      String gccVersion = androidConfig.getNdkGccVersion().or(NdkCxxPlatforms.DEFAULT_GCC_VERSION);
      NdkCxxPlatforms.Compiler compiler =
          ImmutableNdkCxxPlatforms.Compiler.builder()
              .setType(compilerType)
              .setVersion(
                  compilerType == NdkCxxPlatforms.Compiler.Type.GCC ?
                      gccVersion :
                      androidConfig.getNdkClangVersion().or(NdkCxxPlatforms.DEFAULT_CLANG_VERSION))
              .setGccVersion(gccVersion)
              .build();
      ndkCxxPlatformsBuilder.putAll(
          NdkCxxPlatforms.getPlatforms(
              new ProjectFilesystem(ndkRoot.get()),
              compiler,
              androidConfig.getNdkCxxRuntime().or(NdkCxxPlatforms.DEFAULT_CXX_RUNTIME),
              androidConfig.getNdkAppPlatform().or(NdkCxxPlatforms.DEFAULT_TARGET_APP_PLATFORM),
              androidConfig.getNdkCpuAbis().or(NdkCxxPlatforms.DEFAULT_CPU_ABIS),
              platform));
    }
    ImmutableMap<NdkCxxPlatforms.TargetCpuType, NdkCxxPlatform> ndkCxxPlatforms =
        ndkCxxPlatformsBuilder.build();

    // Construct the C/C++ config wrapping the buck config.
    CxxBuckConfig cxxBuckConfig = new CxxBuckConfig(config);
    ImmutableMap.Builder<Flavor, CxxPlatform> cxxPlatformsBuilder = ImmutableMap.builder();

    // If an Android NDK is present, add platforms for that.  This is mostly useful for
    // testing our Android NDK support for right now.
    for (NdkCxxPlatform ndkCxxPlatform : ndkCxxPlatforms.values()) {
      cxxPlatformsBuilder.put(
          ndkCxxPlatform.getCxxPlatform().getFlavor(),
          ndkCxxPlatform.getCxxPlatform());
    }

    for (Map.Entry<Flavor, AppleCxxPlatform> entry :
        platformFlavorsToAppleCxxPlatforms.entrySet()) {
      cxxPlatformsBuilder.put(entry.getKey(), entry.getValue().getCxxPlatform());
    }

    // Add the default, config-defined C/C++ platform.
    CxxPlatform systemDefaultCxxPlatform = DefaultCxxPlatforms.build(platform, cxxBuckConfig);
    cxxPlatformsBuilder.put(systemDefaultCxxPlatform.getFlavor(), systemDefaultCxxPlatform);
    ImmutableMap<Flavor, CxxPlatform> cxxPlatformsMap = cxxPlatformsBuilder.build();

    // Get the default platform from config.
    CxxPlatform defaultCxxPlatform = CxxPlatforms.getConfigDefaultCxxPlatform(
        cxxBuckConfig,
        cxxPlatformsMap,
        systemDefaultCxxPlatform);

    // Add platforms for each cxx flavor obtained from the buck config files
    // from sections of the form cxx#{flavor name}
    ImmutableSet<Flavor> cxxFlavors = CxxBuckConfig.getCxxFlavors(config);
    for (Flavor flavor: cxxFlavors) {
      CxxBuckConfig flavoredCxxBuckConfig =  new CxxBuckConfig(config, flavor);
      CxxPlatform defaultPlatformForFlavor = CxxPlatforms.getConfigDefaultCxxPlatform(
          flavoredCxxBuckConfig,
          cxxPlatformsMap,
          systemDefaultCxxPlatform);
      cxxPlatformsBuilder.put(flavor, CxxPlatforms.copyPlatformWithFlavorAndConfig(
          defaultPlatformForFlavor,
          flavoredCxxBuckConfig,
          flavor));
    }

    cxxPlatformsMap = cxxPlatformsBuilder.build();

    // Build up the final list of C/C++ platforms.
    FlavorDomain<CxxPlatform> cxxPlatforms = new FlavorDomain<>(
        "C/C++ platform",
        cxxPlatformsMap);

    DBuckConfig dBuckConfig = new DBuckConfig(config);

    ReactNativeBuckConfig reactNativeBuckConfig = new ReactNativeBuckConfig(config);

    RustBuckConfig rustBuckConfig = new RustBuckConfig(config);

    GoBuckConfig goBuckConfig = new GoBuckConfig(config, processExecutor);

    HalideBuckConfig halideBuckConfig = new HalideBuckConfig(config);

    ProGuardConfig proGuardConfig = new ProGuardConfig(config);

    PythonBuckConfig pyConfig = new PythonBuckConfig(config, new ExecutableFinder());
    ImmutableList<PythonPlatform> pythonPlatformsList =
        pyConfig.getPythonPlatforms(processExecutor);
    ImmutableMap.Builder<Flavor, PythonPlatform> pythonPlatformsMapBuilder = ImmutableMap.builder();
    for (PythonPlatform pythonPlatform : pythonPlatformsList) {
      pythonPlatformsMapBuilder.put(pythonPlatform.getFlavor(), pythonPlatform);
    }
    ImmutableMap<Flavor, PythonPlatform> pythonPlatformsMap = pythonPlatformsMapBuilder.build();
    FlavorDomain<PythonPlatform> pythonPlatforms =
        new FlavorDomain<>("Python Platform", pythonPlatformsMap);
    PythonBinaryDescription pythonBinaryDescription =
        new PythonBinaryDescription(
            pyConfig,
            pythonPlatforms,
            defaultCxxPlatform,
            cxxPlatforms);

    // Look up the timeout to apply to entire test rules.
    Optional<Long> defaultTestRuleTimeoutMs = config.getLong("test", "rule_timeout");

    // Prepare the downloader if we're allowing mid-build downloads
    Downloader downloader;
    DownloadConfig downloadConfig = new DownloadConfig(config);
    if (downloadConfig.isDownloadAtRuntimeOk()) {
      downloader = StackedDownloader.createFromConfig(
          config,
          androidDirectoryResolver.findAndroidSdkDirSafe());
    } else {
      // Or just set one that blows up
      downloader = new ExplodingDownloader();
    }

    Builder builder = builder();

    JavaBuckConfig javaConfig = new JavaBuckConfig(config);
    JavacOptions defaultJavacOptions = javaConfig.getDefaultJavacOptions();
    JavacOptions androidBinaryOptions = JavacOptions.builder(defaultJavacOptions)
        .build();

    InferBuckConfig inferBuckConfig = new InferBuckConfig(config);

    CxxBinaryDescription cxxBinaryDescription =
        new CxxBinaryDescription(
            inferBuckConfig,
            defaultCxxPlatform,
            cxxPlatforms,
            cxxBuckConfig.getPreprocessMode());

    CxxLibraryDescription cxxLibraryDescription = new CxxLibraryDescription(
        cxxBuckConfig,
        inferBuckConfig,
        cxxPlatforms,
        cxxBuckConfig.getPreprocessMode());

    AppleLibraryDescription appleLibraryDescription =
        new AppleLibraryDescription(
            cxxLibraryDescription,
            cxxPlatforms);
    builder.register(appleLibraryDescription);

    AppleBinaryDescription appleBinaryDescription =
        new AppleBinaryDescription(cxxBinaryDescription, platformFlavorsToAppleCxxPlatforms);
    builder.register(appleBinaryDescription);

    // Create an executor service exclusively for the smart dexing step.
    ListeningExecutorService dxExecutorService =
        MoreExecutors.listeningDecorator(
            Executors.newFixedThreadPool(
                SmartDexingStep.determineOptimalThreadCount(),
                new CommandThreadFactory("SmartDexing")));

    CodeSignIdentityStore codeSignIdentityStore =
        CodeSignIdentityStore.fromSystem(processExecutor);
    ProvisioningProfileStore provisioningProfileStore =
        ProvisioningProfileStore.fromSearchPath(appleConfig.getProvisioningProfileSearchPath());

    builder.register(new AndroidAarDescription(new AndroidManifestDescription(), ndkCxxPlatforms));
    builder.register(
        new AndroidBinaryDescription(
            androidBinaryOptions,
            proGuardConfig,
            ndkCxxPlatforms,
            dxExecutorService));
    builder.register(new AndroidBuildConfigDescription(androidBinaryOptions));
    builder.register(new AndroidInstrumentationApkDescription(
            proGuardConfig,
            androidBinaryOptions,
            ndkCxxPlatforms,
            dxExecutorService));
    builder.register(new AndroidInstrumentationTestDescription(defaultTestRuleTimeoutMs));
    builder.register(new AndroidLibraryDescription(androidBinaryOptions));
    builder.register(new AndroidManifestDescription());
    builder.register(new AndroidPrebuiltAarDescription(androidBinaryOptions));
    builder.register(new AndroidReactNativeLibraryDescription(reactNativeBuckConfig));
    builder.register(new AndroidResourceDescription());
    builder.register(new ApkGenruleDescription());
    builder.register(new AppleAssetCatalogDescription());
    builder.register(new ApplePackageDescription());
    AppleBundleDescription appleBundleDescription =
        new AppleBundleDescription(
            appleBinaryDescription,
            appleLibraryDescription,
            cxxPlatforms,
            platformFlavorsToAppleCxxPlatforms,
            defaultCxxPlatform,
            codeSignIdentityStore,
            provisioningProfileStore);
    builder.register(appleBundleDescription);
    builder.register(new AppleResourceDescription());
    builder.register(
        new AppleTestDescription(
            appleConfig,
            appleBundleDescription,
            appleLibraryDescription,
            cxxPlatforms,
            platformFlavorsToAppleCxxPlatforms,
            defaultCxxPlatform,
            codeSignIdentityStore,
            provisioningProfileStore,
            appleConfig.getAppleDeveloperDirectorySupplier(processExecutor)));
    builder.register(new CoreDataModelDescription());
    builder.register(new CSharpLibraryDescription());
    builder.register(cxxBinaryDescription);
    builder.register(cxxLibraryDescription);
    builder.register(
        new CxxPythonExtensionDescription(pythonPlatforms, cxxBuckConfig, cxxPlatforms));
    builder.register(
        new CxxTestDescription(
            cxxBuckConfig,
            defaultCxxPlatform,
            cxxPlatforms,
            defaultTestRuleTimeoutMs));
    builder.register(new DBinaryDescription(dBuckConfig, defaultCxxPlatform));
    builder.register(new DLibraryDescription(dBuckConfig));
    builder.register(new DTestDescription(dBuckConfig, defaultCxxPlatform));
    builder.register(new ExportFileDescription());
    builder.register(new GenruleDescription());
    builder.register(new GenAidlDescription());
    builder.register(new GoBinaryDescription(goBuckConfig, defaultCxxPlatform));
    builder.register(new GoLibraryDescription(goBuckConfig));
    builder.register(new GoTestDescription(goBuckConfig, defaultCxxPlatform));
    builder.register(new GwtBinaryDescription());
    builder.register(
      new HalideLibraryDescription(
        cxxPlatforms,
        cxxBuckConfig.getPreprocessMode(),
        halideBuckConfig));
    builder.register(new IosReactNativeLibraryDescription(reactNativeBuckConfig));
    builder.register(new JavaBinaryDescription(defaultJavacOptions, defaultCxxPlatform));
    builder.register(new JavaLibraryDescription(defaultJavacOptions));
    builder.register(
        new JavaTestDescription(
            defaultJavacOptions,
            defaultTestRuleTimeoutMs,
            defaultCxxPlatform,
            testTempDirOverride));
    builder.register(new KeystoreDescription());
    builder.register(new NdkLibraryDescription(ndkVersion, ndkCxxPlatforms));
    OCamlBuckConfig ocamlBuckConfig = new OCamlBuckConfig(platform, config);
    builder.register(new OCamlBinaryDescription(ocamlBuckConfig));
    builder.register(new OCamlLibraryDescription(ocamlBuckConfig));
    builder.register(new PrebuiltCxxLibraryDescription(cxxPlatforms));
    builder.register(new PrebuiltDotNetLibraryDescription());
    builder.register(new PrebuiltJarDescription());
    builder.register(new PrebuiltNativeLibraryDescription());
    builder.register(new PrebuiltOCamlLibraryDescription());
    builder.register(new PrebuiltPythonLibraryDescription());
    builder.register(new ProjectConfigDescription());
    builder.register(pythonBinaryDescription);
    builder.register(new PythonLibraryDescription());
    builder.register(
        new PythonTestDescription(
            pythonBinaryDescription,
            pyConfig,
            pythonPlatforms,
            defaultCxxPlatform,
            cxxPlatforms));
    builder.register(new RemoteFileDescription(downloader));
    builder.register(new RobolectricTestDescription(
            androidBinaryOptions,
            defaultTestRuleTimeoutMs,
            defaultCxxPlatform,
            testTempDirOverride));
    builder.register(new RustBinaryDescription(rustBuckConfig));
    builder.register(new RustLibraryDescription(rustBuckConfig));
    builder.register(new ShBinaryDescription());
    builder.register(new ShTestDescription());
    ThriftBuckConfig thriftBuckConfig = new ThriftBuckConfig(config);
    builder.register(
        new ThriftLibraryDescription(
            thriftBuckConfig,
            ImmutableList.of(
                new ThriftJavaEnhancer(thriftBuckConfig, defaultJavacOptions),
                new ThriftCxxEnhancer(
                    thriftBuckConfig,
                    cxxLibraryDescription,
                    /* cpp2 */ false),
                new ThriftCxxEnhancer(
                    thriftBuckConfig,
                    cxxLibraryDescription,
                    /* cpp2 */ true),
                new ThriftPythonEnhancer(thriftBuckConfig, ThriftPythonEnhancer.Type.NORMAL),
                new ThriftPythonEnhancer(thriftBuckConfig, ThriftPythonEnhancer.Type.TWISTED))));
    builder.register(new XcodePostbuildScriptDescription());
    builder.register(new XcodePrebuildScriptDescription());
    builder.register(new XcodeWorkspaceConfigDescription());
    builder.register(new ZipDescription());

    builder.setCxxPlatforms(cxxPlatforms);
    builder.setDefaultCxxPlatform(defaultCxxPlatform);

    return builder;
  }

  public static class Builder {
    private final Map<BuildRuleType, Description<?>> descriptions;
    private final Map<String, BuildRuleType> types;

    @Nullable
    private FlavorDomain<CxxPlatform> cxxPlatforms;
    @Nullable
    private CxxPlatform defaultCxxPlatform;

    protected Builder() {
      this.descriptions = Maps.newConcurrentMap();
      this.types = Maps.newConcurrentMap();
    }

    public Builder register(Description<?> description) {
      BuildRuleType type = description.getBuildRuleType();
      types.put(type.getName(), type);
      descriptions.put(type, description);
      return this;
    }

    public Builder setCxxPlatforms(FlavorDomain<CxxPlatform> cxxPlatforms) {
      this.cxxPlatforms = cxxPlatforms;
      return this;
    }

    public Builder setDefaultCxxPlatform(CxxPlatform defaultCxxPlatform) {
      this.defaultCxxPlatform = defaultCxxPlatform;
      return this;
    }

    public KnownBuildRuleTypes build() {
      return new KnownBuildRuleTypes(
          descriptions,
          types,
          Preconditions.checkNotNull(cxxPlatforms),
          Preconditions.checkNotNull(defaultCxxPlatform));
    }
  }
}


text:
[Fluent Bit](http://fluentbit.io) uses [CMake](http://cmake.org) as it build system. The suggested procedure to prepare the build system consist on the following steps:

## Prepare environment

> In the following steps you can find exact commands to build and install the project with the default options. If you already know how CMake works you can skip this part and look at the build options available.

Create a temporary _build/_ directory inside the Fluent Bit sources:

```bash
$ mkdir build
$ cd build/
```

Let [CMake](http://cmake.org) configure the project specifying where the root path is located:

```bash
$ cmake ../
-- The C compiler identification is GNU 4.9.2
-- Check for working C compiler: /usr/bin/cc
-- Check for working C compiler: /usr/bin/cc -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- The CXX compiler identification is GNU 4.9.2
-- Check for working CXX compiler: /usr/bin/c++
-- Check for working CXX compiler: /usr/bin/c++ -- works
...
-- Could NOT find Doxygen (missing:  DOXYGEN_EXECUTABLE)
-- Looking for accept4
-- Looking for accept4 - not found
-- Configuring done
-- Generating done
-- Build files have been written to: /home/edsiper/coding/fluent-bit/build
```

For OSX, pass the `-DWITH_IN_MEM=OFF` option as follows

```bash
$ cmake -DWITH_IN_MEM=OFF ../
...
...
```

Now you are ready to start the compilation process through the simple _make_ command:

```bash
$ make
Scanning dependencies of target msgpack
[  2%] Building C object lib/msgpack-1.1.0/CMakeFiles/msgpack.dir/src/unpack.c.o
[  4%] Building C object lib/msgpack-1.1.0/CMakeFiles/msgpack.dir/src/objectc.c.o
[  7%] Building C object lib/msgpack-1.1.0/CMakeFiles/msgpack.dir/src/version.c.o
...
[ 19%] Building C object lib/monkey/mk_core/CMakeFiles/mk_core.dir/mk_file.c.o
[ 21%] Building C object lib/monkey/mk_core/CMakeFiles/mk_core.dir/mk_rconf.c.o
[ 23%] Building C object lib/monkey/mk_core/CMakeFiles/mk_core.dir/mk_string.c.o
...
Scanning dependencies of target fluent-bit-static
[ 66%] Building C object src/CMakeFiles/fluent-bit-static.dir/flb_pack.c.o
[ 69%] Building C object src/CMakeFiles/fluent-bit-static.dir/flb_input.c.o
[ 71%] Building C object src/CMakeFiles/fluent-bit-static.dir/flb_output.c.o
...
Linking C executable ../bin/fluent-bit
[100%] Built target fluent-bit-bin
```

to continue installing the binary on the system just do:

```bash
$ make install
```

it's likely you may need root privileges so you can try to prefixing the command with _sudo_.

## Build Options

Fluent Bit provides certain options to CMake that can be enabled or disabled when configuring, please refer to the following tables under the _General Options_, _Input Plugins_ and _Output Plugins_ sections.

### General Options

| option           |  description                         | default  |
|------------------|--------------------------------------|----------|
| WITH_ALL         | Enable all features available        | No       |
| WITH_DEBUG       | Build binaries with debug symbols    | No       |

### Input Plugins

The _input plugins_ provides certain features to gather information from a specific source type which can be a
network interface, some built-in metric or through a specific input device, the following input plugins are
available:

| option           |  description                         | default  |
|-------------------------------------|--------------------------------------|----------|
| [WITH_IN_CPU](../input/cpu.md)      | Enable CPU input plugin              | On       |
| [WITH_IN_KMSG](../input/kmsg.md)    | Enable Kernel log input plugin       | On       |
| [WITH_IN_MEM](../input/mem.md)      | Enable Memory input plugin           | On       |
| [WITH_IN_SERIAL](../input/serial.md)| Enable Serial input plugin           | On       |
| [WITH_IN_STDIN](../input/stdin.md)  | Enable Standard input plugin         | On       |
| [WITH_IN_XBEE](../input/xbee.md)    | Enable Xbee input plugin             | No       |

### Output Plugins

The _output plugins_ gives the capacity to flush the information to some external interface, service or terminal, the following table describes the output plugins available as of this version:

| option           |  description                         | default  |
|------------------|--------------------------------------|----------|
| [WITH_OUT_FLUENTD](../output/fluentd.md) | Enable [Fluentd](http://www.fluentd.org) output plugin | On |
| [WITH_OUT_STDOUT](../output/stdout.md) | Enable STDOUT output plugin          | On       |
| [WITH_OUT_TD](../output/td.md) | Enable [Treasure Data](http://www.treasuredata.com) output plugin | On |


text:
<!DOCTYPE HTML>

  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <title>In 2016 I want</title>
  <meta name="viewport" content="width=device-width, initial-scale=1">

  <link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Open+Sans:400,300">
  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/normalize/3.0.3/normalize.min.css" type="text/css">
  <link rel="stylesheet" href="http://cdn.jsdelivr.net/flexboxgrid/6.3.0/flexboxgrid.min.css" type="text/css" >
  <link rel="stylesheet" href="./css/index.min.css" type="text/css" >

In 2016 I want

Definindo algumas prioridades para o ano de 2016

Leia um 1 livro a cada 3 meses e, caso seja possível, 1 livro técnico a cada 6 meses.

–  Carlos Bueno em Guia do mestre programador

Em 2016 eu quero ler mais (livros).

 [X] Guia do mestre programador - Compre o seu.

 [X] O Pequeno Príncipe - Compre o seu.

 [X] Oportunidades disfarcadas - Compre o seu.

 [X] Coletânea Front-end - Compre o seu.

 [ ] Religião para Ateus - Compre o seu.

 [X] Orientação a Objetos e SOLID para Ninjas - Compre o seu.

 [X] REST - Compre o seu.

 [X] Faça Amor Não Faça Jogo - Compre o seu.

 [X] Hackeando Tudo - Compre o seu.

 [  ] ...

          Em 2016 eu quero aprender Inglês.

          Em 2016 eu quero escrever mais.

          Em 2016 eu quero passar mais tempo ao lado de pessoas que me agradam.

          Em 2016 eu quero viajar.

          Em 2016 eu quero give it five minutes.

            Acredite em você

            Acredite no seu projeto

            Faça o bem para os outros e a transformação vai ser recíproca

            Você pode e você consegue

            Concentre-se

  </row>


text:
package com.awsmithson.tcx2nikeplus.cli;

import com.awsmithson.tcx2nikeplus.http.NikePlus;
import com.awsmithson.tcx2nikeplus.nike.NikeActivityData;
import org.w3c.dom.Document;

import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

@Deprecated
public class Upload
{
	public static void main(String[] args) {
		String nikePlusEmail = args[0];
		String nikePlusPassword = args[1];
		File tcxFile = new File(args[2]);
		File gpxFile = (args.length > 3) ? new File(args[3]) : null;

		try {
			DocumentBuilder documentBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
			Document runXML = documentBuilder.parse(tcxFile);
			Document gpxXML = (gpxFile == null) ? null : documentBuilder.parse(gpxFile);

			NikeActivityData nikeActivityData = new NikeActivityData(runXML, gpxXML);

			NikePlus.fullSync(nikePlusEmail, nikePlusPassword.toCharArray(), nikeActivityData);
		}
		catch (Throwable t) {
			t.printStackTrace();
		}
	}
}


text:
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Diagnostics.Contracts;
using System;

// Disable the "this variable is not used" warning as every field would imply it.
#pragma warning disable 0414
// Disable the "this variable is never assigned to".
#pragma warning disable 0649
// Disable the "this variable is never used".
#pragma warning disable 0169
// Disable the "new keyword not required" warning.
#pragma warning disable 0109
// Disable the "extern without DllImport" warning.
#pragma warning disable 0626
// Disable the "could hide other member" warning, can happen on certain properties.
#pragma warning disable 0108

namespace System.Web.UI
{
  public partial interface IStyleSheet
  {
    #region Methods and constructors
    void CreateStyleRule (System.Web.UI.WebControls.Style style, IUrlResolutionService urlResolver, string selector);

    void RegisterStyle (System.Web.UI.WebControls.Style style, IUrlResolutionService urlResolver);
    #endregion
  }
}


text:
Subscription Management for Mobile Cart

Install into your app/AppKernel.php . place it after MobileCartCoreBundle()

Update the Database, add new tables:

$ ./app/console doctrine:schema:update

Add a Variant with the code subscription_id to the Variant Set for Products.
There is a CLI command also:

$ ./app/console cart:sub:itemvars


text:
<?php
# Generated by the protocol buffer compiler.  DO NOT EDIT!
# source: google/privacy/dlp/v2/dlp.proto

namespace Google\Cloud\Dlp\V2;

if (false) {
    /**
     * This class is deprecated. Use Google\Cloud\Dlp\V2\InfoTypeCategory\IndustryCategory instead.
     * @deprecated
     */
    class InfoTypeCategory_IndustryCategory {}
}
class_exists(InfoTypeCategory\IndustryCategory::class);
@trigger_error('Google\Cloud\Dlp\V2\InfoTypeCategory_IndustryCategory is deprecated and will be removed in the next major release. Use Google\Cloud\Dlp\V2\InfoTypeCategory\IndustryCategory instead', E_USER_DEPRECATED);


text:
	{% if paginator.next_page %}
		Older Posts
	{% endif %}
	{% if paginator.previous_page %}
		{% if paginator.previous_page == 1 %}
			Newer Posts
		{% else %}
			Newer Posts
		{% endif %}
	{% endif %}


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

using System;

namespace NtApiDotNet
{
#pragma warning disable 1591
    /// <summary>
    /// Supported windows verion
    /// </summary>
    public enum SupportedVersion
    {
        Unknown,
        Windows7,
        Windows8,
        Windows81,
        Windows10,
        Windows10_TH2,
        Windows10_RS1,
        Windows10_RS2,
        Windows10_RS3,
        Windows10_RS4,
        Windows10_RS5,
        Windows10_19H1,
        Windows10_19H2,
        /// <summary>
        /// This should always be at the end.
        /// </summary>
        Windows10_Latest,
    }
#pragma warning restore 1591

    /// <summary>
    /// Attribute to indicate the required version for a function.
    /// Applied if the function needs a version greater than 7.
    /// </summary>
    public sealed class SupportedVersionAttribute : Attribute
    {
        /// <summary>
        /// The supported version.
        /// </summary>
        public SupportedVersion Version { get; }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="version">The supported version</param>
        public SupportedVersionAttribute(SupportedVersion version)
        {
            Version = version;
        }
    }

    /// <summary>
    /// Attribute used for managed structures to indicate the start of data.
    /// This is used in situations where the data immediately trail
    /// </summary>
    [AttributeUsage(AttributeTargets.Struct | AttributeTargets.Class)]
    public sealed class DataStartAttribute : Attribute
    {
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="field_name">The field name which indicates the first address of data.</param>
        public DataStartAttribute(string field_name)
        {
            FieldName = field_name;
        }

        /// <summary>
        /// The field name which indicates the first address of data.
        /// </summary>
        public string FieldName { get; set; }

        /// <summary>
        /// When allocating this structure always include the field in the total length calculation.
        /// </summary>
        public bool IncludeDataField { get; set; }
    }
}


text:
<?php

namespace Guzzle\Plugin\Oauth;

use Guzzle\Common\Event;
use Guzzle\Common\Collection;
use Guzzle\Http\Message\RequestInterface;
use Guzzle\Http\Message\EntityEnclosingRequestInterface;
use Guzzle\Http\QueryString;
use Guzzle\Http\Url;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;

/**
 * OAuth signing plugin
 * @link http://oauth.net/core/1.0/#rfc.section.9.1.1
 */
class OauthPlugin implements EventSubscriberInterface
{
    /**
     * Consumer request method constants. See http://oauth.net/core/1.0/#consumer_req_param
     */
    const REQUEST_METHOD_HEADER = 'header';
    const REQUEST_METHOD_QUERY  = 'query';

    /** @var Collection Configuration settings */
    protected $config;

    /**
     * Create a new OAuth 1.0 plugin
     *
     * @param array $config Configuration array containing these parameters:
     *     - string 'request_method'       Consumer request method. Use the class constants.
     *     - string 'callback'             OAuth callback
     *     - string 'consumer_key'         Consumer key
     *     - string 'consumer_secret'      Consumer secret
     *     - string 'token'                Token
     *     - string 'token_secret'         Token secret
     *     - string 'verifier'             OAuth verifier.
     *     - string 'version'              OAuth version.  Defaults to 1.0
     *     - string 'signature_method'     Custom signature method
     *     - bool   'disable_post_params'  Set to true to prevent POST parameters from being signed
     *     - array|Closure 'signature_callback' Custom signature callback that accepts a string to sign and a signing key
     */
    public function __construct($config)
    {
        $this->config = Collection::fromConfig($config, array(
            'version' => '1.0',
            'request_method' => self::REQUEST_METHOD_HEADER,
            'consumer_key' => 'anonymous',
            'consumer_secret' => 'anonymous',
            'signature_method' => 'HMAC-SHA1',
            'signature_callback' => function($stringToSign, $key) {
                return hash_hmac('sha1', $stringToSign, $key, true);
            }
        ), array(
            'signature_method', 'signature_callback', 'version',
            'consumer_key', 'consumer_secret'
        ));
    }

    public static function getSubscribedEvents()
    {
        return array(
            'request.before_send' => array('onRequestBeforeSend', -1000)
        );
    }

    /**
     * Request before-send event handler
     *
     * @param Event $event Event received
     * @return array
     * @throws \InvalidArgumentException
     */
    public function onRequestBeforeSend(Event $event)
    {
        $timestamp = $this->getTimestamp($event);
        $request = $event['request'];
        $nonce = $this->generateNonce($request);
        $authorizationParams = $this->getOauthParams($timestamp, $nonce);
        $authorizationParams['oauth_signature']  = $this->getSignature($request, $timestamp, $nonce);

        switch ($this->config['request_method']) {
            case self::REQUEST_METHOD_HEADER:
                $request->setHeader(
                    'Authorization',
                    $this->buildAuthorizationHeader($authorizationParams)
                );
                break;
            case self::REQUEST_METHOD_QUERY:
                foreach ($authorizationParams as $key => $value) {
                    $request->getQuery()->set($key, $value);
                }
                break;
            default:
                throw new \InvalidArgumentException(sprintf(
                    'Invalid consumer method "%s"',
                    $this->config['request_method']
                ));
        }

        return $authorizationParams;
    }

    /**
     * Builds the Authorization header for a request
     *
     * @param array $authorizationParams Associative array of authorization parameters
     *
     * @return string
     */
    private function buildAuthorizationHeader($authorizationParams)
    {
        $authorizationString = 'OAuth ';
        foreach ($authorizationParams as $key => $val) {
            if ($val) {
                $authorizationString .= $key . '="' . urlencode($val) . '", ';
            }
        }

        return substr($authorizationString, 0, -2);
    }

    /**
     * Calculate signature for request
     *
     * @param RequestInterface $request   Request to generate a signature for
     * @param integer          $timestamp Timestamp to use for nonce
     * @param string           $nonce
     *
     * @return string
     */
    public function getSignature(RequestInterface $request, $timestamp, $nonce)
    {
        $string = $this->getStringToSign($request, $timestamp, $nonce);
        $key = urlencode($this->config['consumer_secret']) . '&' . urlencode($this->config['token_secret']);

        return base64_encode(call_user_func($this->config['signature_callback'], $string, $key));
    }

    /**
     * Calculate string to sign
     *
     * @param RequestInterface $request   Request to generate a signature for
     * @param int              $timestamp Timestamp to use for nonce
     * @param string           $nonce
     *
     * @return string
     */
    public function getStringToSign(RequestInterface $request, $timestamp, $nonce)
    {
        $params = $this->getParamsToSign($request, $timestamp, $nonce);

        // Convert booleans to strings.
        $params = $this->prepareParameters($params);

        // Build signing string from combined params
        $parameterString = clone $request->getQuery();
        $parameterString->replace($params);

        $url = Url::factory($request->getUrl())->setQuery('')->setFragment(null);

        return strtoupper($request->getMethod()) . '&'
             . rawurlencode($url) . '&'
             . rawurlencode((string) $parameterString);
    }

    /**
     * Get the oauth parameters as named by the oauth spec
     *
     * @param $timestamp
     * @param $nonce
     * @return Collection
     */
    protected function getOauthParams($timestamp, $nonce)
    {
        $params = new Collection(array(
            'oauth_consumer_key'     => $this->config['consumer_key'],
            'oauth_nonce'            => $nonce,
            'oauth_signature_method' => $this->config['signature_method'],
            'oauth_timestamp'        => $timestamp,
        ));

        // Optional parameters should not be set if they have not been set in the config as
        // the parameter may be considered invalid by the Oauth service.
        $optionalParams = array(
            'callback'  => 'oauth_callback',
            'token'     => 'oauth_token',
            'verifier'  => 'oauth_verifier',
            'version'   => 'oauth_version'
        );

        foreach ($optionalParams as $optionName => $oauthName) {
            if (isset($this->config[$optionName]) == true) {
                $params[$oauthName] = $this->config[$optionName];
            }
        }

        return $params;
    }

    /**
     * Get all of the parameters required to sign a request including:
     * * The oauth params
     * * The request GET params
     * * The params passed in the POST body (with a content-type of application/x-www-form-urlencoded)
     *
     * @param RequestInterface $request   Request to generate a signature for
     * @param integer          $timestamp Timestamp to use for nonce
     * @param string           $nonce
     *
     * @return array
     */
    public function getParamsToSign(RequestInterface $request, $timestamp, $nonce)
    {
        $params = $this->getOauthParams($timestamp, $nonce);

        // Add query string parameters
        $params->merge($request->getQuery());

        // Add POST fields to signing string if required
        if ($this->shouldPostFieldsBeSigned($request))
        {
            $params->merge($request->getPostFields());
        }

        // Sort params
        $params = $params->toArray();
        uksort($params, 'strcmp');

        return $params;
    }

    /**
     * Decide whether the post fields should be added to the base string that Oauth signs.
     * This implementation is correct. Non-conformant APIs may require that this method be
     * overwritten e.g. the Flickr API incorrectly adds the post fields when the Content-Type
     * is 'application/x-www-form-urlencoded'
     *
     * @param $request
     * @return bool Whether the post fields should be signed or not
     */
    public function shouldPostFieldsBeSigned($request)
    {
        if (!$this->config->get('disable_post_params') &&
            $request instanceof EntityEnclosingRequestInterface &&
            false !== strpos($request->getHeader('Content-Type'), 'application/x-www-form-urlencoded'))
        {
            return true;
        }

        return false;
    }

    /**
     * Returns a Nonce Based on the unique id and URL. This will allow for multiple requests in parallel with the same
     * exact timestamp to use separate nonce's.
     *
     * @param RequestInterface $request Request to generate a nonce for
     *
     * @return string
     */
    public function generateNonce(RequestInterface $request)
    {
        return sha1(uniqid('', true) . $request->getUrl());
    }

    /**
     * Gets timestamp from event or create new timestamp
     *
     * @param Event $event Event containing contextual information
     *
     * @return int
     */
    public function getTimestamp(Event $event)
    {
       return $event['timestamp'] ?: time();
    }

    /**
     * Convert booleans to strings, removed unset parameters, and sorts the array
     *
     * @param array $data Data array
     *
     * @return array
     */
    protected function prepareParameters($data)
    {
        ksort($data);
        foreach ($data as $key => &$value) {
            switch (gettype($value)) {
                case 'NULL':
                    unset($data[$key]);
                    break;
                case 'array':
                    $data[$key] = self::prepareParameters($value);
                    break;
                case 'boolean':
                    $data[$key] = $value ? 'true' : 'false';
                    break;
            }
        }

        return $data;
    }
}


text:
/**
 * This class handles all data persistence (create-retrieve-update-delete operations)
 * for words via the AWS SDK.
 *
 * @property {AWS.DynamoDB} 				dynamodb - AWS API for interacting with DynamoDB
 * @property {AWS.DynamoDB.DocumentClient} 	docClient - AWS API for interacting with items in DynamoDB
 *
 * @author Christina Sickelco
 */

//Used to write more secure javascript. See http://www.w3schools.com/js/js_strict.asp.
'use strict';

//Alexa app server hotswap module will reload code changes to apps
//if this is set to 1. Handy for local development and testing
//See https://runkit.com/npm/alexa-app-server
module.change_code = 1;

//Dependencies
var Utils = require('../common/utils');
var DaoError = require('../common/dao_error');
var DaoUtils = require('../common/dao_utils');
var Winston = require('winston');

//Configure the logger with basic logging template
var logger = new (Winston.Logger)({
    transports: [
      new (Winston.transports.Console)({
    	  timestamp: function() {
    		  return new Date();
    	  },
    	  formatter: function(options) {
    		  return '[' + options.level.toUpperCase() + '] '+ options.timestamp() +' Word_Dao - '+ (undefined !== options.message ? options.message : '') +
              (options.meta && Object.keys(options.meta).length ? '\n\t'+ JSON.stringify(options.meta) : '' );
    	  }
      })
    ]
  });

//Constants
//DynamoDB table name
var TABLE_NAME = 'NEWBIE.WORD';

/**
 * Represents data access operations for words.
 * @constructor
 * @param {DynamoDb} DynamoDB object used to work with the database. Non-nullable.
 * @param {DocClient} DocClient object used to work with objects in the database. Non-nullable.
 * @param {DaoUtils} Utilies to perform common operations against the database. Non-nullable.
 */
function WordAWSDao(dynamodb, docClient, daoUtils) {
	this.dynamodb = dynamodb;
	this.docClient = docClient;
	this.daoUtils = daoUtils;
}

/**
 * Asynchronous operation to create the word table if it doesn't already exist.
 * If it does exist, does nothing.
 * @returns {Promise<Empty|DaoError} Returns an empty promise if the create succeeded,
 * 			else returns a rejected promise with a DaoError.
 */
WordAWSDao.prototype.createTable = function() {
	logger.debug("createTable: Starting table setup...");
	var describeParams = {
			TableName: TABLE_NAME,
	};
	var self = this;
	return self.dynamodb.describeTable(describeParams).promise()
		.catch(function(error) {
			logger.debug("createTable: Table doesn't yet exist, attempting to create..., error: " + error.message);
			var params = {
			    TableName : TABLE_NAME,
			    KeySchema: [
			        { AttributeName: "wordKey", KeyType: "HASH"},  //Partition key
			        { AttributeName: "word", KeyType: "RANGE" }  //Sort key
			    ],
			    AttributeDefinitions: [
			        { AttributeName: "wordKey", AttributeType: "S" },
			        { AttributeName: "word", AttributeType: "S" }
			    ],
			    ProvisionedThroughput: {
			        ReadCapacityUnits: 3,
			        WriteCapacityUnits: 3
			    }
			};
			return self.dynamodb.createTable(params).promise()
				.catch(function(error) {
					return Promise.reject( new DaoError("create the word table", error));
				});
	});
};

/**
 * Asynchronous operation to delete the word table
 * @returns {Promise<Empty|DaoError} Returns an empty promise if the delete succeeded,
 * 			else returns a rejected promise with a DaoError
 * 			(if an error occurred interacting with DynamoDB.
 * 			Could be caused by an InternalServerError, LimitExceededException,
 * 			ResourceInUseException, or ResourceNotFoundException).
 */
WordAWSDao.prototype.deleteTable = function() {
	logger.debug("deleteTable: Starting table delete");
	var params = {
	    TableName : TABLE_NAME
	};
	return this.dynamodb.deleteTable(params).promise()
		.catch(function(error) {
			return Promise.reject(new DaoError("delete the word table", error));
		});
};

/**
 * Asynchronous operation to persist a new word
 * (or overwrite the existing word if one exists for
 * the same userId, seq, dateTime).
 *
 * @param 	{Word} word the word object to persist. Non-nullable.
 * 			Must have all properties populated.
 * @returns {Promise<Empty|DaoError} Returns an empty promise if the create succeeded,
 * 			else returns a rejected promise with a DaoError
 * 			(if an error occurred interacting with DynamoDB.
 * 			Could be caused by an InternalServerError, ProvisionedThroughputExceededException,
 * 			or ResourceNotFoundException).
 */
WordAWSDao.prototype.createWord = function(word) {
	var dateTimeString = Utils.formatDateTimeString(word.dateTime, word.timezone);
	logger.debug("createWord: Starting word creation for user %s, dateTimeString %s, word %s...", word.userId, dateTimeString, word.word);
	var params = {
	    TableName: TABLE_NAME,
	    Item:{
	    	wordKey: word.userId + "-" + word.seq,
	    	word: word.word,
	    	dateTime: dateTimeString
	    },
	    ReturnValues: 'ALL_OLD'
	};
	return this.docClient.put(params).promise()
		.catch(function(error) {
			return Promise.reject(new DaoError("create an word", error));
		});
};

/**
 * Asynchronous operation to to get a count of all words created
 * for a given user/baby.
 *
 * @param {string} userId 	AWS user ID whose word count to retrieve. Non-nullable.
 * @param {number} seq		the sequence number of the baby whose words to retrieve. Non-nullable.
 *
 * @returns {Promise<Empty|DaoError} Returns an empty promise if the get succeeded,
 * 			else returns a rejected promise with a DaoError
 * 			(if an error occurred interacting with DynamoDB.
 * 			Could be caused by an InternalServerError, ProvisionedThroughputExceededException,
 * 			or ResourceNotFoundException).
 */
WordAWSDao.prototype.getWordCount = function(userId, seq) {
	logger.debug("getWordCountForDay: Starting get word count");
	var params = {
			TableName : TABLE_NAME,
			KeyConditionExpression: "wordKey = :val1",
		    ExpressionAttributeValues: {
		    	":val1":userId + "-" + seq
		    },
		    ProjectionExpression: "noattribute"
	};
	return this.docClient.query(params).promise()
		.then( function(queryResult)  {
			logger.debug("getWordCountForDay: query result %s", JSON.stringify(queryResult));
			return Promise.resolve(queryResult.Count);
		})
		.catch(function(error) {
			return Promise.reject(new DaoError("get word count for the day", error));
		});
};

/**
 * Asynchronous operation to delete all word records for the given baby
 * param userId {string} 	AWS user ID whose records to delete. Non-nullable.
 * @param {number} seq		the sequence number of the baby whose records to delete. Non-nullable.
 * @returns {Promise<Empty|DaoError} Returns an empty promise if the operation succeeded,
 * 			else returns a rejected promise with a DaoError
 * 			if an error occurred interacting with DynamoDB.
 * 			Could be caused by an InternalServerError, ProvisionedThroughputExceededException,
 * 			or ResourceNotFoundException.
 */
WordAWSDao.prototype.deleteWordsForBaby = function(userId, seq) {
	return this.daoUtils.deleteRecordsForBaby(TABLE_NAME, "wordKey", "word", userId, seq);
};

module.exports = WordAWSDao;


text:
define(['ember', 'app/app'], function(Ember, App) {

    App.IndexController = Ember.Controller.extend({
        featuredGames: function() {
            return this.get('model');
        }.property('model')
    });
});


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Assets.Scripts.Kinect.Gesture.States;
using UnityEngine;

namespace Assets.Scripts.Kinect.Gesture {
    public class DoubleClapGesture : IGesture {
        public Gestures Gesture { get { return Gestures.DoubleClap; } }
        public int Count { get; private set; }
        public float MaxGestureTime { get { return 1.5f; } }

        private readonly Queue<DoubleClapGestureState> _states = new Queue<DoubleClapGestureState>(1000);

        public bool Update(JointPositions positions) {
            var newState = DoubleClapGestureState.Create(positions);
            if (newState != null) _states.Enqueue(newState);

            while (_states.Count > 0 && (Time.time - _states.Peek().StartTime > MaxGestureTime || _states.Peek().Complete)) {
                _states.Dequeue();
            }

            if (_states.Any(state => state.Update(positions))) {
                _states.Clear();
                Count++;
                return true;
            }
            return false;
        }
    }
}


text:
package cogdebugger.ui.fieldvisualizations.scalar

import cogx.runtime.debugger.ProbedField
import libcog._
import cogdebugger.ui.fieldvisualizations.{UnsupportedDimensionException, Viewer, ViewerSuperPanel, EventDrivenViewer}
import cogdebugger.Memoize
import cogdebugger.ui.components.MouseDragZoom

/**
 * Host panel for Scalar field visualizations. Provides a toolbar with common
 * controls and a combo box for selecting between the different scalar field
 * visualizations.
 *
 * If you've implemented a new visualization for scalar fields and want to plug
 * it into the GUI, provide a name for it to the `viewerNames` list and a case
 * for it in the `viewerNameToInstance` memoized factory.
 *
 * Created by gonztobi on 2/24/14.
 */
class ScalarFieldSuperPanel protected (target: ProbedField,
                                       options: List[String],
                                       factory: (String) => Viewer)
        extends ViewerSuperPanel(target, options, factory) {
  require(target.fieldType.tensorShape == Shape(),
    "ScalarFieldSuperPanel only works with Scalar Fields!")
}

object ScalarFieldSuperPanel {

  val RealFieldName   = "Scalars"
  val GrayscaleName   = "Grayscale Image"
  val TimeseriesName  = "Timeseries"
  val ScatterplotName = "Scatter Plot"

  val viewerNames = List(RealFieldName,
                         GrayscaleName,
                         TimeseriesName,
                         ScatterplotName)
  val viewerNamesExceptTimeseries = List(RealFieldName,
                                         GrayscaleName,
                                         ScatterplotName)

  /** The timeseries plot takes a very long time to initialize of the target
    * field has lots of elements - it will pretty much hang the GUI if you
    * open it on a "big" field. To prevent this, the view is disabled if the
    * field contains more elements than this threshold (which has been set more
    * or less arbitrarily at 100 for the time being). */
  private val timeseriesSizeThreshold = 100

  def apply(target: ProbedField) = {
    val fieldShape  = target.fieldType.fieldShape
    val tensorShape = target.fieldType.tensorShape

    val compatibleViews = fieldShape.dimensions match {
      case 0 | 1 | 2 if fieldShape.points < timeseriesSizeThreshold =>
        List(RealFieldName, GrayscaleName, TimeseriesName, ScatterplotName)
      case 0 | 1 | 2 =>
        List(RealFieldName, GrayscaleName, ScatterplotName)
      case 3 =>
        List(RealFieldName)
      case x => throw new UnsupportedDimensionException(x)
    }

    val memoizer = Memoize[String, EventDrivenViewer] {
      case RealFieldName   => new ScalarMemoryView(target) with MouseDragZoom
      case GrayscaleName   => new GrayscaleImagePanel(target, fieldShape) with MouseDragZoom
      case TimeseriesName  => new StackedTimeSeriesPanel(target)
      case ScatterplotName => new ScatterPlot(target)
    }
    new ScalarFieldSuperPanel(target, compatibleViews, memoizer)
  }
}


text:
// Type definitions for pako 0.2.8
// Project: https://github.com/nodeca/pako
// Definitions by: Denis Cappellin <http://github.com/cappellin>
// Definitions: https://github.com/borisyankov/DefinitelyTyped

declare namespace Pako {

	/**
	 * Compress data with deflate algorithm and options.
	 */
	export function deflate( data: Uint8Array | Array<number> | string, options?: any ): string;
	/**
	 * The same as deflate, but creates raw data, without wrapper (header and adler32 crc).
	 */
	export function deflateRaw( data: Uint8Array | Array<number> | string, options?: any ): string;
	/**
	 * The same as deflate, but create gzip wrapper instead of deflate one.
	 */
	export function gzip( data: Uint8Array | Array<number> | string, options?: any ): string;
	/**
	 * Decompress data with inflate/ungzip and options. Autodetect format via wrapper header
	 * by default. That's why we don't provide separate ungzip method.
	 */
	export function inflate( data: Uint8Array | Array<number> | string, options?: any ): Uint8Array;
	export function inflate( data: Uint8Array | Array<number> | string, options?: any ): Array<number>;
	export function inflate( data: Uint8Array | Array<number> | string, options?: any ): String;
	/**
	 * The same as inflate, but creates raw data, without wrapper (header and adler32 crc).
	 */
	export function inflateRaw( data: Uint8Array | Array<number> | string, options?: any ): Uint8Array;
	export function inflateRaw( data: Uint8Array | Array<number> | string, options?: any ): Array<number>;
	export function inflateRaw( data: Uint8Array | Array<number> | string, options?: any ): string;
	/**
	 * Just shortcut to inflate, because it autodetects format by header.content. Done for convenience.
	 */
	export function ungzip( data: Uint8Array | Array<number> | string, options?: any ): Uint8Array;
	export function ungzip( data: Uint8Array | Array<number> | string, options?: any ): Array<number>;
	export function ungzip( data: Uint8Array | Array<number> | string, options?: any ): string;

	export class Deflate {
		constructor( options?: any );
		err: number;
		msg: string;
		result: Uint8Array | Array<number>;
		onData( chunk: Uint8Array | Array<number> | string ): void;
		onEnd( status: number ): void;
		push( data: Uint8Array | Array<number> | ArrayBuffer | string, mode?: number | boolean ): boolean;
	}

	export class Inflate {
		constructor( options?: any );
		err: number;
		msg: string;
		result: Uint8Array | Array<number> | string;
		onData( chunk: Uint8Array | Array<number> | string ): void;
		onEnd( status: number ): void;
		push( data: Uint8Array | Array<number> | ArrayBuffer | string, mode?: number | boolean ): boolean;
	}
}

declare module 'pako' {
	export = Pako;
}


text:
namespace crypto {

class ECPrivateKey;
class ECSignatureCreator;

class CRYPTO_EXPORT ECSignatureCreatorFactory {
 public:
  virtual ~ECSignatureCreatorFactory() {}

  virtual ECSignatureCreator* Create(ECPrivateKey* key) = 0;
};

// Signs data using a bare private key (as opposed to a full certificate).
// We need this class because SignatureCreator is hardcoded to use
// RSAPrivateKey.
class CRYPTO_EXPORT ECSignatureCreator {
 public:
  virtual ~ECSignatureCreator() {}

  // Create an instance. The caller must ensure that the provided PrivateKey
  // instance outlives the created ECSignatureCreator.
  // TODO(rch):  This is currently hard coded to use SHA1. Ideally, we should
  // pass in the hash algorithm identifier.
  static ECSignatureCreator* Create(ECPrivateKey* key);

  // Set a factory to make the Create function return non-standard
  // ECSignatureCreator objects.  Because the ECDSA algorithm involves
  // randomness, this is useful for higher-level tests that want to have
  // deterministic mocked output to compare.
  static void SetFactoryForTesting(ECSignatureCreatorFactory* factory);

  // Signs |data_len| bytes from |data| and writes the results into
  // |signature| as a DER encoded ECDSA-Sig-Value from RFC 3279.
  //
  //  ECDSA-Sig-Value ::= SEQUENCE {
  //    r     INTEGER,
  //    s     INTEGER }
  virtual bool Sign(const uint8* data,
                    int data_len,
                    std::vector<uint8>* signature) = 0;
};

}  // namespace crypto

#endif  // CRYPTO_EC_SIGNATURE_CREATOR_H_


text:
// The MIT License (MIT)
//
// Copyright (c) 2018 Robert C. Seacord
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

using System;
using System.Collections.Generic;
using System.Diagnostics;

namespace EqualsStruct
{
  internal struct TwoDPoint : IEquatable<TwoDPoint>
  {
    // Read/write auto-implemented properties.
    public int X { get; }

    public int Y { get; }

    public TwoDPoint(int x, int y)
      : this()
    {
      X = x;
      Y = y;
    }

    public override bool Equals(object obj)
    {
      if (obj is TwoDPoint point)
      {
        return this.Equals(point);
      }
      return false;
    }

    public bool Equals(TwoDPoint p)
    {
      return (X == p.X) && (Y == p.Y);
    }

    public override int GetHashCode()
    {
      return ShiftAndWrap(X.GetHashCode(), 2) ^ Y.GetHashCode();
    }

    private static int ShiftAndWrap(int value, int positions)
    {
      positions = positions & 0x1F;

      // Save the existing bit pattern, but interpret it as an unsigned integer.
      uint number = BitConverter.ToUInt32(BitConverter.GetBytes(value), 0);
      // Preserve the bits to be discarded.
      uint wrapped = number >> (32 - positions);
      // Shift and wrap the discarded bits.
      return BitConverter.ToInt32(BitConverter.GetBytes((number << positions) | wrapped), 0);
    }

    public static bool operator ==(TwoDPoint lhs, TwoDPoint rhs)
    {
      // Equals handles case of null on right side.
      return lhs.Equals(rhs);
    }

    public static bool operator !=(TwoDPoint lhs, TwoDPoint rhs)
    {
      return !lhs.Equals(rhs);
    }

    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Globalization",
      "CA1303:Do not pass literals as localized parameters", MessageId = "System.Console.WriteLine(System.String)")]
    private static void Main()
    {
      TwoDPoint pointA = new TwoDPoint(3, 4);
      TwoDPoint pointB = new TwoDPoint(3, 4);

      // Compare using virtual Equals
      Debug.Assert(pointA.Equals(pointB), "FAILED: pointA.Equals(pointB)");
      Debug.Assert(pointA == pointB, "FAILED: pointA == pointB)");
      Debug.Assert(!pointA.Equals(null), "FAILED: pointA.Equals(null)");

      // Compare using static Equals
      Debug.Assert(Object.Equals(pointA, pointB), "FAILED:  Object.Equals(pointA, pointB)");
      Debug.Assert(Object.Equals(pointB, pointA), "FAILED:  Object.Equals(pointB, pointA)");

      // Compare using reference equality and inequality operators
      Debug.Assert(pointA == pointB, "FAILED: pointA == pointB)");
      Debug.Assert(!(pointA != pointB), "FAILED: !(pointA != pointB)");
      Debug.Assert(!(pointA == null), "FAILED: !(pointA == null)");
      Debug.Assert((pointA != null), "FAILED: pointA != null");
      Debug.Assert(!(null == pointA), "FAILED: !(null == pointA)");
      Debug.Assert(null != pointA, "FAILED: pointA != null)");

      Debug.Assert(
        EqualityComparer<TwoDPoint>.Default.Equals(pointA, pointB),
        "FAILED: EqualityComparer<TwoDPoint>.Default.Equals(pointA, pointB)"
      );

      // Compare unboxed to boxed.
      System.Collections.ArrayList list = new System.Collections.ArrayList
      {
        new TwoDPoint(3, 4)
      };
      Debug.Assert(pointA.Equals(list[0]), "FAILED:  pointA.Equals(list[0])");

      // Keep the console window open in debug mode.
      Console.WriteLine("Press any key to exit.");
      Console.ReadKey();
    }
  }
} // end namespace


text:
/*
 * Genera una poblacion con ciertos cromosomas, genes y pares de bases
 */
#include "bevolucion.h"
celula *
genera_poblacion_genes_aleatorios (uint16_t num_cromosomas,
                                   uint16_t num_genes,
                                   uint16_t num_pares_bases,
                                   uint16_t habitantes)
{
  int32_t i, j, k, w;
  celula *poblacion = organismos_alloc (habitantes);

  printf ("Generando poblacion aleatoria\n");

  for (k = 0; k < habitantes; k++)
    {
      poblacion[k].num_cromo = num_cromosomas;
      poblacion[k].num_genes = num_genes;
      poblacion[k].identidad = k;
      /* La identidad del padre en los primeros 20 bits, madre en los segundos 20 bits, FFFFF,FFFFF porque ellos no fueron hijos de nadie */
      poblacion[k].identidad |= 0xFFFFFFFFFF000000;

      poblacion[k].padre = poblacion[k].madre = 0xFFFFF;

      for (i = 0; i < num_cromosomas; i++)
        for (j = 0; j < num_genes; j++)
          {

            poblacion[k].cromosomas[i].molecula_adn.genes[j].tamano =
              num_pares_bases;
            for (w = 0; w < num_pares_bases; w++)
              poblacion[k].cromosomas[i].molecula_adn.genes[j].par_bases[w] =
                pares_bases_adn[rand_int (4)];
          }
      inserta_adaptacion_gen_elite (&poblacion[k]);
    }
  return poblacion;
}


text:
package com.microsoft.azure.management.network;

import com.microsoft.azure.SubResource;

/**
 * Application gateway backendhealth http settings.
 */
public class ApplicationGatewayBackendHealthServer {
    /**
     * IP address or FQDN of backend server.
     */
    private String address;

    /**
     * Reference of IP configuration of backend server.
     */
    private SubResource ipConfiguration;

    /**
     * Health of backend server. Possible values are: 'Unknown', 'Up', 'Down',
     * and 'Partial'. Possible values include: 'Unknown', 'Up', 'Down',
     * 'Partial'.
     */
    private ApplicationGatewayBackendHealthServerHealth health;

    /**
     * Get the address value.
     *
     * @return the address value
     */
    public String address() {
        return this.address;
    }

    /**
     * Set the address value.
     *
     * @param address the address value to set
     * @return the ApplicationGatewayBackendHealthServer object itself.
     */
    public ApplicationGatewayBackendHealthServer withAddress(String address) {
        this.address = address;
        return this;
    }

    /**
     * Get the ipConfiguration value.
     *
     * @return the ipConfiguration value
     */
    public SubResource ipConfiguration() {
        return this.ipConfiguration;
    }

    /**
     * Set the ipConfiguration value.
     *
     * @param ipConfiguration the ipConfiguration value to set
     * @return the ApplicationGatewayBackendHealthServer object itself.
     */
    public ApplicationGatewayBackendHealthServer withIpConfiguration(SubResource ipConfiguration) {
        this.ipConfiguration = ipConfiguration;
        return this;
    }

    /**
     * Get the health value.
     *
     * @return the health value
     */
    public ApplicationGatewayBackendHealthServerHealth health() {
        return this.health;
    }

    /**
     * Set the health value.
     *
     * @param health the health value to set
     * @return the ApplicationGatewayBackendHealthServer object itself.
     */
    public ApplicationGatewayBackendHealthServer withHealth(ApplicationGatewayBackendHealthServerHealth health) {
        this.health = health;
        return this;
    }

}


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

define(function(require) {
  /*
    DEPENDENCIES
   */

  var Locale = require('utils/locale');
  var Config = require('sunstone-config');
  var QuotaDefaults = require('utils/quotas/quota-defaults');
  var QuotaWidgets = require('utils/quotas/quota-widgets');
  var OpenNebulaGroup = require('opennebula/group');

  /*
    CONSTANTS
   */

  var TAB_ID = require('../tabId');
  var PANEL_ID = require('./group-quotas/panelId');
  var RESOURCE = "User";
  var XML_ROOT = "USER";

  /*
    CONSTRUCTOR
   */

  function Panel(info, tabId) {
    this.tabId = tabId || TAB_ID;
    this.title = Locale.tr("Group Quotas");
    this.icon = "fa-align-left";

    this.element = info[XML_ROOT];

    return this;
  }

  Panel.PANEL_ID = PANEL_ID;
  Panel.prototype.html = _html;
  Panel.prototype.setup = _setup;

  return Panel;

  /*
    FUNCTION DEFINITIONS
   */

  function _html() {
    return '
\

\
                ' + Locale.tr("Select group") + '\
                  <select id="quota_group_sel">\
                  </select>\
                \

\

\

\

';
  }

  function _setup(context) {

    var groups = this.element.GROUPS.ID;

    if (!$.isArray(groups)){
      groups = [groups];
    }

    var groupDropdownOptions = "";
    $.each(groups, function(){
      groupDropdownOptions +=
      '<option elem_id="'+this+
      '" value="'+this+'">'+
      OpenNebulaGroup.getName(this)+' (id:'+this+')</option>';
    });

    $('select#quota_group_sel', context).html(groupDropdownOptions);

    $("#quota_group_sel", context).off("change");
    $("#quota_group_sel", context).on("change", function() {
        var value_str = $('select#quota_group_sel').val();
        if(value_str!="")
        {
          fillGroupQuotas(value_str, context);
        }
    });

    fillGroupQuotas('-1', context);

    return false;
  }

  function fillGroupQuotas(group_id, context){
    OpenNebulaGroup.show({
      data : {
        id: group_id
      },
      success: function(request,group_json){
        var info = group_json.GROUP;

        var quotas_tab_html = QuotaWidgets.initQuotasPanel(
          info,
          QuotaDefaults.getDefaultQuotas("Group"),
          false);

        $("#group_quotasTabBody", context).html(quotas_tab_html);

        QuotaWidgets.setupQuotasPanel(
          info,
          $("#group_quotasTabBody", context),
          false,
          "Group");

        $("select#quota_group_sel", context).val(info.ID);
      }
    });
  }
});


text:
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class SaveRoom : MonoBehaviour {

	public RoomController room;
	// Use this for initialization
	void Awake () {

	}
}


text:
@interface UIImageView (Utility)

+ (UIImageView *)imageViewRoundWithImage:(UIImage *)image andRound:(CGFloat)round;

@end


text:
<!DOCTYPE html>

<meta charset="UTF-8">

<title>class Test::Unit::AttributeMatcher - test-unit-3.3.0 Documentation</title>

<link href="../../css/fonts.css" rel="stylesheet">
<link href="../../css/rdoc.css" rel="stylesheet">

    Home

    Pages
    Classes
    Methods

  <form action="#" method="get" accept-charset="utf-8">

      <input id="search-field" role="combobox" aria-label="Search"
             aria-autocomplete="list" aria-controls="search-results"
             type="text" name="search" placeholder="Search" spellcheck="false"
             title="Type to search, Up and Down to navigate, Enter to load">

  </form>

Parent

Object

Methods

::new

#match?

#method_missing

    class Test::Unit::AttributeMatcher

Public Class Methods

          new(test)

          click to toggle source

# File lib/test/unit/attribute-matcher.rb, line 4
def initialize(test)
  @test = test
end

Public Instance Methods

          match?(expression)

          click to toggle source

# File lib/test/unit/attribute-matcher.rb, line 8
def match?(expression)
  matched = instance_eval(expression)
  if matched.nil?
    false
  else
    matched
  end
end

          method_missing(name, *args)

          click to toggle source

              Calls superclass method

# File lib/test/unit/attribute-matcher.rb, line 17
def method_missing(name, *args)
  if args.empty?
    @test[name]
  else
    super
  end
end

Validate

Generated by RDoc 4.2.1.

Based on Darkfish by Michael Granger.


text:
import asyncio
import discord
from discord.ext import commands
from requests import get as re_get
from random import *
import re

ownerId = '163137666341142529'

TooBig = ["You know you make a cool bot and all people want to do is kill it :(", "Dude that is wayyyyy too much for me to handle",
          "Nobody thinks you are cool", "fark", "yes", "No", "I don't like people like you",
          "Ehh", "stop it you are hurting me" , "hackerman", "Dude stop it.", "I can't believe you requested that", "meh","maybe",
          "How about you do that one hey", "Hang on", "nahh maybe I don't", "you can do that one", "You take over now", "you can handle the requests from now on, I'm done"]

def under(content):
    if(len(content)<5):
        return True
    return False

class Moderator:
    moderatorIds=[0]
    """The bot's moderation side"""
    def __init__(self, bot):
        self.bot=bot

    @commands.command(pass_context=True, no_pm=True, description="Kicks a member")
    async def kick(self,ctx, member: discord.Member):
        """Kicks a member"""
        author = ctx.message.author
        author = author.id
        if(author == ownerId):
            await self.bot.kick(member)
            string = "Member: "+member.name+"\n\nHas been kicked!"
            await self.bot.say(string)
        elif(author in Moderator.moderatorIds):
            if(member.id != ownerId):
                if(member.id in moderatorIds):
                    string = "You can't kick other verified members my dude."
                    await self.bot.say(string)
                else:
                    await self.bot.kick(member)
                    string = "Member: "+member.name+"\n\nHas been kicked!"
                    await self.bot.say(string)
            else:
                await self.bot.say('Fuck off cunt. Just because you did that you lost your verified status.')
        else:
            await self.bot.say('You do not have the permissions required to use this command. Contact someone who is verified or an admin if you need help.')

    @commands.command(pass_context=True, no_pm=True, description="deletes messages")
    async def delete(self,ctx):
        """deletes messages"""
        channel = ctx.message.channel
        role=[]
        content = ctx.message.content
        content = content[8:]
        if under(content):
            a = re.search('[a-zA-Z]', content)
            if(a==None):
                author = ctx.message.author
                role = author.roles
                i=0
                while i<len(role):
                    try:
                        role[i]=role[i].name
                    except:
                        x=0
                    i+=1
                if('Admin' in role):
                    async for message in self.bot.logs_from(channel,limit=int(content)):
                        await self.bot.delete_message(message)
                    await self.bot.say('Messages deleted')
                elif('Verified' in role):
                    async for message in self.bot.logs_from(channel,limit=int(content)):
                        await self.bot.delete_message(message)
                    await self.bot.say('Messages deleted')
                else:
                    await self.bot.say('You do not have the permissions required to use this command. Contact someone who is verified or an admin if you need help.')
            else:
                await self.bot.say('Stop trying to break me :(')
        else:
            msg = choice(TooBig)
            await self.bot.say(msg)

    @commands.command(pass_context=True, no_pm=True, description="temp mutes messages")
    async def mute(self,ctx, member: discord.Member):
        """temp mutes a member"""
        author = ctx.message.author.id
        if(author == ownerId):
            server = ctx.message.server
            role = discord.utils.get(server.roles, name="Timed Out")
            await self.bot.add_roles(member,role)
            string = "Member: "+member.name+"\n\nHas been muted!"
            await self.bot.say(string)
        elif(author in Moderator.moderatorIds):
            server = ctx.message.server
            role = discord.utils.get(server.roles, name="Timed Out")
            await self.bot.add_roles(member, role)
            string = "Member: "+member.name+"\n\nHas been temporarily muted!"
            await self.bot.say(string)
            await asyncio.sleep(60)
            await self.bot.remove_roles(member, roles)
        else:
            await self.bot.say('Either two things happened mate.\n1. You do not have permissions to use this command.\n2. I fucked up.')

    @commands.command(pass_context=True, no_pm=True, description="unmutes messages")
    async def unmute(self,ctx, member: discord.Member):
        """unmutes a member"""
        try:
            author = ctx.message.author
            author = author.id
            if(author in Moderator.moderatorIds):
                server = ctx.message.server
                role = discord.utils.get(server.roles, name="Timed Out")
                await self.bot.remove_roles(member, role)
                string = "Member: "+member.name+"\n\nHas been unmuted!"
                await self.bot.say(string)
            else:
                await self.bot.say('Either two things happened mate.\n1. You do not have permissions to use this command.\n2. I fucked up.')
        except:
            await self.bot.say('Errr, just get Tom to do it manually')

    @commands.command(pass_context=True, description="gets the ban list")
    async def bans(self,ctx):
        """gets the ban list"""
        server = ctx.message.server
        bans = await self.bot.get_bans(server)
        i = 0
        string = "\n\n"
        while(i<len(bans)):
            string = string+str(i+1)+". "+bans[i].name+".\n"
            i+=1
        string = "The people who are banned from entering this server are: "+string
        await self.bot.say(string)

    @commands.command(pass_context=True, hidden = True, no_pm=True, description="bans members")
    async def ban(self,ctx, user: discord.Member):
        """bans a members"""
        try:
            author = ctx.message.author
            author = author.id
            if(author == ownerId):
                await self.bot.ban(user, delete_message_days=7)
                string = "Member: "+user.name+"\n\nHas been banned!"
                await self.bot.say(string)
            else:
                await self.bot.say('Either two things happened mate.\n1. You do not have permissions to use this command.\n2. I fucked up.')
        except:
            await self.bot.say('Errr, just get Tom to do it manually')


text:
{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
module GHCJS.DOM.JSFFI.Generated.ScriptProfile
       (js_getTitle, getTitle, js_getUid, getUid, js_getRootNode,
        getRootNode, ScriptProfile, castToScriptProfile,
        gTypeScriptProfile)
       where
import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
import Data.Typeable (Typeable)
import GHCJS.Types (JSVal(..), JSString)
import GHCJS.Foreign (jsNull)
import GHCJS.Foreign.Callback (syncCallback, asyncCallback, syncCallback1, asyncCallback1, syncCallback2, asyncCallback2, OnBlocked(..))
import GHCJS.Marshal (ToJSVal(..), FromJSVal(..))
import GHCJS.Marshal.Pure (PToJSVal(..), PFromJSVal(..))
import Control.Monad.IO.Class (MonadIO(..))
import Data.Int (Int64)
import Data.Word (Word, Word64)
import GHCJS.DOM.Types
import Control.Applicative ((<$>))
import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
import GHCJS.DOM.JSFFI.Generated.Enums

foreign import javascript unsafe "$1[\"title\"]" js_getTitle ::
        ScriptProfile -> IO JSString

-- | <https://developer.mozilla.org/en-US/docs/Web/API/ScriptProfile.title Mozilla ScriptProfile.title documentation>
getTitle ::
         (MonadIO m, FromJSString result) => ScriptProfile -> m result
getTitle self = liftIO (fromJSString <$> (js_getTitle (self)))

foreign import javascript unsafe "$1[\"uid\"]" js_getUid ::
        ScriptProfile -> IO Word

-- | <https://developer.mozilla.org/en-US/docs/Web/API/ScriptProfile.uid Mozilla ScriptProfile.uid documentation>
getUid :: (MonadIO m) => ScriptProfile -> m Word
getUid self = liftIO (js_getUid (self))

foreign import javascript unsafe "$1[\"rootNode\"]" js_getRootNode
        :: ScriptProfile -> IO (Nullable ScriptProfileNode)

-- | <https://developer.mozilla.org/en-US/docs/Web/API/ScriptProfile.rootNode Mozilla ScriptProfile.rootNode documentation>
getRootNode ::
            (MonadIO m) => ScriptProfile -> m (Maybe ScriptProfileNode)
getRootNode self
  = liftIO (nullableToMaybe <$> (js_getRootNode (self)))


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Variable +sph-match-extended+</title><link rel="stylesheet" type="text/css" href="../index.css"><meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

	       Common Lisp Sphinx Search API	API documentation

	  Package:
	  cl-sphinx-search

	  Variable
	  +sph-match-extended+

	  No documentation string.  Possibly unimplemented or incomplete.