text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Google Earth Enterprise Earth Plug-in</title>

There was some problem with the Google Earth Plug-in.

This Plug-in is not currently available for the Linux OS

Please use the Google Earth Client, or download the Plug-in
         here .


text:
ACCEPTED

#### According to
International Plant Names Index

#### Published in
null

#### Original name
Ranunculus cassubicus subsp. kemerovensis G.Kvist

### Remarks
null

redpajama_set_name: RedPajamaGithub


text:
package me.dcow.pearltrees;

/**
 * PearlHandler is passed to the callback fSunctions of the traversal
 * methods.
 *
 * @author David
 *
 */
public interface PearlHandler {
	public void onPearl(RootPearl 	rootPearl );
	public void onPearl(PagePearl 	pagePearl );
	public void onPearl(AliasPearl 	aliasPearl);
	public void onPearl(RefPearl 	refPearl  );
}


text:
using System.Text;
using System.Threading.Tasks;
using Metrics;
using Metrics.Json;
using Newtonsoft.Json;
using NServiceBus.Transport;

namespace ServiceControl.Monitoring
{
    public class Monitor
    {
        IDerivedMetric[] derivedMetrics;
        NServiceBusReceivedMetricContext receivedMetricContext;

        public Monitor(MetricsContext rootContext, params IDerivedMetric[] derivedMetrics)
        {
            this.derivedMetrics = derivedMetrics;
            receivedMetricContext = new NServiceBusReceivedMetricContext();
            rootContext.Advanced.AttachContext("NServiceBus.Endpoints", receivedMetricContext);

            foreach (var metric in derivedMetrics)
            {
                metric.Initialize(rootContext, receivedMetricContext);
            }
        }

        public Task OnMessage(MessageContext context, IDispatchMessages dispatcher)
        {
            var metricsData = Deserialize<JsonMetricsContext>(context);

            receivedMetricContext.Consume(metricsData.ToMetricsData());

            foreach (var metric in derivedMetrics)
            {
                metric.Consume(metricsData);
            }
            return Task.CompletedTask;
        }

        static T Deserialize<T>(MessageContext context)
        {
            return JsonConvert.DeserializeObject<T>(Encoding.UTF8.GetString(context.Body));
        }
    }
}


text:
var config_1 = require('../config');
function templateLocals() {
    return {
        APP_BASE: config_1.APP_BASE,
        APP_DEST: config_1.APP_DEST,
        APP_ROOT: config_1.APP_ROOT,
        APP_TITLE: config_1.APP_TITLE,
        SYSTEM_CONFIG: config_1.SYSTEM_CONFIG,
        VERSION: config_1.VERSION
    };
}
exports.templateLocals = templateLocals;
//# sourceMappingURL=template-locals.js.map


text:
class AddUseGravatarToUsers < ActiveRecord::Migration
  def self.up
    add_column :users, :use_gravatar, :boolean, :default => false
  end

  def self.down
    remove_column :users, :use_gravatar
  end
end


text:
<?php
namespace Render\APIs\APIv1;
interface Page
{
    /**
   * Returns the id of the page
   *
   * @return string
   */
    public function getPageId();
    /**
   * Returns the title of the page
   *
   * @return string
   */
    public function getTitle();
    /**
   * Returns the description of the page
   *
   * @return string
   */
    public function getDescription();
    /**
   * Returns the date of the page
   *
   * @return int
   */
    public function getDate();
    /**
   * Returns TRUE if the page is displayed in the navigation bar; FALSE otherwise.
   *
   * @return boolean
   */
    public function showInNavigation();
    /**
   * Returns the title of the page that is shown in the navigation bar.
   * If no navigation title was set and $useTitleAsDefault is TRUE
   * the page title is returned instead of the empty navigation title.
   *
   * @param bool $useTitleAsDefault when TRUE the page title is used as default
   *
   * @return string
   */
    public function getNavigationTitle($useTitleAsDefault = true);
    /**
   * Returns the ids of the parent pages
   *
   * @return array
   */
    public function getParentIds();
    /**
   * Returns the ids of the children pages
   *
   * @return array
   */
    public function getChildrenIds();
    /**
   * Returns the url of the page
   *
   * @return string
   */
    public function getUrl();
    /**
   * Returns the global value for the given variable name.
   * If index is given, the value of this index/position is returned.
   *
   * @param string    $name
   * @param int|null  $index
   * @return mixed|null
   */
    public function getGlobal($name, $index = NULL);
}


text:
<?php

class LZ4Exception extends Exception {

}


text:
package org.sfm.benchmark.db.jmh;

import org.jooq.SQLDialect;

public enum DbTarget {
	MOCK {
		@Override
		public SQLDialect getSqlDialect() {
			return SQLDialect.MYSQL;
		}
	}, HSQLDB {
		@Override
		public SQLDialect getSqlDialect() {
			return SQLDialect.HSQLDB;
		}
	}, MYSQL {
		@Override
		public SQLDialect getSqlDialect() {
			return SQLDialect.MYSQL;
		}
	};

	public abstract SQLDialect getSqlDialect();
}


text:
#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Copyright 2015 Daniel Fernandez (daniel@spkautomatizacion.com), Saul Pilatowsky (saul@spkautomatizacion.com)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# The user interface was created using Mark Meier UI Library.
# http://mkmra2.blogspot.com/2012/12/creating-graphical-user-interfaces-with.html
# The file uploader (MultipartPostHangler.py) was created by Will Holcomb <wholcomb@gmail.com>
#
# Find us at: http://www.spkautomatizacion.com

VARIABLE_NAMES = {

            "material_info":[
            "mat",
            "dim_x",
            "dim_y",
            "dim_z",
            "no_filos",
            "tipo_filos",
            "notas"],

            "barrenado":
            ["feed",
            "depth",
            "entries"],

"corte":[
            "depth",
            "entries",
            "plunge",
            "feed_cut",
            "feed_plunge"],

"desbaste":[
            "depth",
            "entries",
            "xy_dist",
            "plunge",
            "feed_cut",
            "feed_plunge"],

"grabado":[
            "depth",
            "entries",
            "feed_cut",
            "feed_plunge"],
                }

INPUT_VALUES_ES = {"material_info":[
            "Material:",
            "Dimension en Xmm:",
            "Dimension en Ymm:",
            "Altura material en Zmm:",
            "Numero de filos cortador:",
            "Tipo de filos",
            "Notas:"],

            "barrenado":[
            "Feed mm/min:",
            "Profundidad barreno (Negativo):",
            "Numero pasadas"],

"corte":[
            "Profundidad corte (Negativo):",
            "Numero de pasadas:",
            "Plunge mm lineales:",
            "Feed mm/min:",
            "Plunge mm/min:"],

"desbaste":[
            "Profundidad corte (Negativo):",
            "Numero de pasadas en Z:",
            "% del diametro entre pasadas (0-1):",
            "Plunge mm lineales:",
            "Feed mm/min:",
            "Plunge mm/min:"],

"grabado":["Profundidad corte (Negativo):",
            "Numero de pasadas:",
            "Feed mm/min:",
            "Plunge mm/min:"]
                }

INPUT_VALUES_EN = {"material_info":[
            "Material:",
            "Xmm Dimension:",
            "Ymm Dimension:",
            "Zmm Material Height:",
            "Number of flutes:",
            "Flute shape:",
            "Notes:"],

            "barrenado":[
            "Drill feed mm/min:",
            "Drill distance (Negative int):",
            "Number of entries:"],

"corte":[
            "Cut depth (Negative int):",
            "Number of entries:",
            "Plunge horizontal dist:",
            "Cut feed mm/min:",
            "Plunge feed mm/min:"],

"desbaste":[
            "Box depth (Negative int):",
            "Number of entries:",
            "Step dist (Float percent 0.0-1.0):",
            "Plunge horizontal dist:",
            "Cut feed mm/min:",
            "Plunge feed mm/min:"],

"grabado":[
            "Engraving depth (Negative int):",
            "Number of entries:",
            "Cut feed mm/min:",
            "Plunge feed mm/min:"]
                }

UITXT_ES = {
           "terms":"¿Aceptas los terminos y condiciones?",
           "login":"No hay login",
           "sel_r":"Seleccionar rutina",
           "sel_r_no":"No hay rutina seleccionada",
           "nr":"Nueva rutina",
           "ed":"Editar",
           "mo":"Mostrar",
           "bo":"Borrar",
           "diam":"Diametro del cortador: ",
           "autocluster":"Autodeteccion de piezas",
           "sec":"Plano de seguridad:    ",
           "xy":"Ordenar Zig-Zag",
           "mr":"Movimiento rapido:      ",
           "dist":"Ordenar cercania",
           "code":"Generara codigo",
           "gt":"Nube",
           "nube":"Subir a la nube",
           "pc":"Guardar en PC",
           "init":"Inicio de consola",
           "lfo":"Login encontrado",
           "abrexp":"Abriendo explorador",
           "loproc":"Login en proceso...revisa tu explorador.",
           "looutproc":"Logout en proceso...",
           "tmpex":"Tiempo excedido... Login fallo.",
           "error_wait":"Espera, generando codigo",
           "error_generate":"Genera un codigo antes de guardar.",
           "error_input":"Falta nombre de producto o url",
           "uploading":"Subiendo codigo al servidor...",
           "save_file":"Selecciona donde guardar el codigo",
           "error_login":"No se pudo subir el codigo a la nube. Falta Login.",
           "new_product":"Se creo un producto nuevo en la nube",
           "error_coneccion":"Error de conexion",
           "time_txt":"Tiempo de corte",
           "file_saved":"Archivo guardado",
           "conf":"Configuracion",
           "del":"Eliminado",
           "name":"Nombre:",
           "nueva":"Nueva rutina",
           "save_pers":"Guardar la rutina en la base de datos persistente? \n\nSi selecciona No la rutina se guardara unicamente en este archivo de Rhino.",
           "database":"Base de datos",
           "selobj":"Selecciona los objetos",
           "seldesc":"Selecciona curvas y puntos:",
           "selobj_res":"Objetos seleccionados",
           "selobj_res_no":"No hay objectos seleccionados",
           "gencode":"Generando codigo...",
           "gencodeok":"Codigo generado",
           "init":"Iniciando Spkcam...",
           "selobjbutton":"Selecciona curvas",
           "cutconf":"Configuracion de corte",
           "bye":"Spkcam cerrado."
           }

UITXT_EN = {
           "terms":"Click yes to accept terms and conditions",
           "login":"No login found",
           "sel_r":"Select cut preset",
           "sel_r_no":"No selected cut preset",
           "nr":"New cut preset",
           "ed":"Edit",
           "mo":"Show",
           "bo":"Delete",
           "diam":"Drill diameter:         ",
           "autocluster":"Autodetect objects",
           "sec":"Security plane:       ",
           "xy":"Sort Zig-Zag",
           "mr":"Feed rapid:            ",
           "dist":"Sort closest",
           "code":"Generate code",
           "gt":"Cloud",
           "nube":"Upload to cloud",
           "pc":"Save in PC",
           "init":"Console initiated",
           "lfo":"Login found",
           "abrexp":"Opening browser",
           "loproc":"Login in process, check your browser",
           "looutproc":"Logout in process....",
           "tmpex":"Login failed: waiting time exceeded",
           "error_wait":"Wait until de code is generated",
           "error_generate":"Generate code before saving",
           "error_input":"Insert product's name or url address.",
           "uploading":"Uploading code to server",
           "save_file":"Save path",
           "error_login":"Upload error: Please sign in.",
           "new_product":"New cloud product created",
           "error_coneccion":"Connection error",
           "time_txt":"Cut time",
           "file_saved":"File saved",
           "conf":"Settings",
           "del":"Deleted",
           "name":"Name:",
           "nueva":"New cut preset",
           "save_pers":"Save cut preset inside this Rhino file only? \n\nIf no is selected, the cut preset will appear in every file",
           "database":"Database",
           "selobj":"Select objects",
           "seldesc":"Select curves and points:",
           "selobj_res":"Selected objects",
           "selobj_res_no":"No selected objects",
           "gencode":"Generating code...",
           "gencodeok":"Code generated",
           "init":"Initiating Spkcam...",
           "selobjbutton":"Select objects",
           "cutconf":"Cut preset settings:",
           "bye":"closing spkcam"
           }

def get_variable_names():
    return VARIABLE_NAMES

def get_ui_text(lang):

    if lang == "es":
        return UITXT_ES
    elif lang == "en":
        return UITXT_EN
    else:
        return False

def get_input_values(lang):
    if lang == "es":
        return INPUT_VALUES_ES
    elif lang == "en":
        return INPUT_VALUES_EN
    else:
        return False


text:
<resources>
    <string name="app_name">bitpig</string>
</resources>


text:
require 'bank_ocr/version'

module BankOcr
  autoload :Parser, 'bank_ocr/parser'
  autoload :NumberParser, 'bank_ocr/number_parser'
  autoload :AccountNumber, 'bank_ocr/account_number'
end


text:
using System;
using System.Linq;
using System.IO;
using System.Collections.Generic;
using Microsoft.AspNetCore.OData.Routing.Controllers;
using Microsoft.AspNetCore.OData.Query;
using Microsoft.AspNetCore.OData.Results;
using Microsoft.AspNetCore.OData.Formatter;
using Microsoft.EntityFrameworkCore;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using hihapi.Models;
using hihapi.Utilities;
using Microsoft.Net.Http;
using Microsoft.AspNetCore.Authorization;
using System.Security.Claims;
using hihapi.Exceptions;

namespace hihapi.Controllers
{
    [Authorize]
    public class HomeDefinesController : ODataController
    {
        private readonly hihDataContext _context;

        public HomeDefinesController(hihDataContext context)
        {
            _context = context;
        }

        /// GET: /HomeDefines
        /// <summary>
        /// Adds support for getting home def., for example:
        ///
        /// GET /HomeDefines
        /// GET /HomeDefines?$filter=Host eq 'abc'
        /// GET /HomeDefines?
        ///
        /// <remarks>
        [HttpGet]
        [EnableQuery]
        public IActionResult Get()
        {
            String usrName = "";
            try
            {
                usrName = HIHAPIUtility.GetUserID(this);

                if (String.IsNullOrEmpty(usrName))
                {
                    throw new UnauthorizedAccessException();
                }
            }
            catch
            {
                throw new UnauthorizedAccessException();
            }

            return Ok(from hd in _context.HomeDefines
                        join hm in _context.HomeMembers
                            on hd.ID equals hm.HomeID
                        where hm.User == usrName
                           select hd);
        }

        /// GET: /HomeDefines(:id)
        /// <summary>
        /// Adds support for getting a home define by key, for example:
        ///
        /// GET /HomeDefines(1)
        /// </summary>
        /// <param name="id">The key of the home define required</param>
        /// <returns>The home define</returns>
        [HttpGet]
        [EnableQuery]
        public HomeDefine Get(int key)
        {
            String usrName = "";
            try
            {
                usrName = HIHAPIUtility.GetUserID(this);

                if (string.IsNullOrEmpty(usrName))
                {
                    throw new UnauthorizedAccessException();
                }
            }
            catch
            {
                throw new UnauthorizedAccessException();
            }

            return (from hmem in _context.HomeMembers
                           join hdef in _context.HomeDefines on hmem.HomeID equals hdef.ID
                           where hmem.User == usrName && hmem.HomeID == key
                           select hdef).FirstOrDefault();
        }

        [HttpPost]
        public async Task<IActionResult> Post([FromBody]HomeDefine homedef)
        {
            if (!ModelState.IsValid)
            {
                HIHAPIUtility.HandleModalStateError(ModelState);
            }

            if (!homedef.IsValid(this._context))
                throw new BadRequestException("Inputted object IsValid Failed");

            // User
            String usrName = String.Empty;
            try
            {
                usrName = HIHAPIUtility.GetUserID(this);
                if (String.IsNullOrEmpty(usrName))
                {
                    throw new UnauthorizedAccessException();
                }
            }
            catch
            {
                throw new UnauthorizedAccessException();
            }

            homedef.Createdby = usrName;
            homedef.CreatedAt = DateTime.Now;
            foreach(var hmem in homedef.HomeMembers)
            {
                hmem.CreatedAt = homedef.CreatedAt;
                hmem.Createdby = usrName;
            }
            _context.HomeDefines.Add(homedef);

            await _context.SaveChangesAsync();

            return Created(homedef);
        }

        [HttpPut]
        public async Task<IActionResult> Put([FromODataUri] int key, [FromBody] HomeDefine update)
        {
            if (!ModelState.IsValid)
            {
                HIHAPIUtility.HandleModalStateError(ModelState);
            }

            if (key != update.ID)
            {
                throw new BadRequestException("Inputted ID mismatched");
            }

            // User
            String usrName = String.Empty;
            try
            {
                usrName = HIHAPIUtility.GetUserID(this);
                if (String.IsNullOrEmpty(usrName))
                {
                    throw new UnauthorizedAccessException();
                }
            }
            catch
            {
                throw new UnauthorizedAccessException();
            }

            // Check whether User assigned with specified Home ID
            var hms = _context.HomeMembers.Where(p => p.HomeID == update.ID && p.User == usrName).Count();
            if (hms <= 0)
            {
                throw new UnauthorizedAccessException();
            }

            if (!update.IsValid(this._context))
                throw new BadRequestException("Inputted Object IsValid Failed");

            // Find out the home define
            var existinghd = _context.HomeDefines.Find(key);

            if (existinghd == null)
            {
                throw new NotFoundException("Inputted Object Not Found");
            }
            else
            {
                update.Updatedby = usrName;
                update.UpdatedAt = DateTime.Now;
                update.CreatedAt = existinghd.CreatedAt;
                update.Createdby = existinghd.Createdby;
                _context.Entry(existinghd).CurrentValues.SetValues(update);

                var dbmems = _context.HomeMembers.Where(p => p.HomeID == key).ToList();
                foreach (var mem in update.HomeMembers)
                {
                    var memindb = dbmems.Find(p => p.HomeID == key && p.User == mem.User);
                    if (memindb == null)
                    {
                        mem.Createdby = usrName;
                        mem.CreatedAt = DateTime.Now;
                        _context.HomeMembers.Add(mem);
                    }
                    else
                    {
                        mem.CreatedAt = memindb.CreatedAt;
                        mem.Createdby = memindb.Createdby;
                        _context.Entry(memindb).CurrentValues.SetValues(mem);
                    }
                }
                foreach (var mem in dbmems)
                {
                    var nmem = update.HomeMembers.FirstOrDefault(p => p.User == mem.User);
                    if (nmem == null)
                    {
                        _context.HomeMembers.Remove(mem);
                    }
                }
            }

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException exp)
            {
                if (!_context.HomeDefines.Any(p => p.ID == key))
                {
                    throw new NotFoundException("Inputted Object Not Found");
                }
                else
                {
                    throw new DBOperationException(exp.Message);
                }
            }

            return Updated(update);
        }

        [HttpDelete]
        public async Task<IActionResult> Delete([FromODataUri] int key)
        {
            // User
            String usrName = String.Empty;
            try
            {
                usrName = HIHAPIUtility.GetUserID(this);
                if (String.IsNullOrEmpty(usrName))
                {
                    throw new UnauthorizedAccessException();
                }
            }
            catch
            {
                throw new UnauthorizedAccessException();
            }

            // Check whether User assigned with specified Home ID
            var hms = _context.HomeMembers.Where(p => p.HomeID == key && p.User == usrName).Count();
            if (hms <= 0)
            {
                throw new UnauthorizedAccessException();
            }

            var cc = await _context.HomeDefines.FindAsync(key);
            if (cc == null)
            {
                throw new NotFoundException("Inputted Object Not Found");
            }

            // Perform the checks
            if (!cc.IsDeleteAllowed(this._context))
                throw new BadRequestException("Inputted Object IsDeleteAllowed Failed");

            _context.HomeDefines.Remove(cc);
            await _context.SaveChangesAsync();

            return StatusCode(204); // HttpStatusCode.NoContent
        }
    }
}


text:
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Diagnostics;
using System.IO;
using System.Linq;
using LitS3;
using log4net;

namespace DataMigration
{
    /// <summary>
    /// This is a location to put utility functions that don't exist in Mono/.NET, or in our
    /// source code.   If a method becomes globally useful, it should be promoted to a shared
    /// location for multiple projects to use.   It's very MS Sql Server specific, although
    /// there is some code in here for non-Sql Server things.
    /// </summary>
    static public class Utilities
    {
        static readonly ILog log = LogManager.GetLogger(typeof(Utilities));

        const int maxPasswordLength = 20;

        /// <summary>
        /// Tells if an IDataRecord has a column, avoiding exception being thrown when
        /// looking for it.
        /// </summary>
        /// <param name="dr">IDataRecord</param>
        /// <param name="columnName">Name of column to look for.</param>
        /// <returns>True if column exists, false otherwise.</returns>
        public static bool HasColumn(IDataRecord dr, string columnName)
        {
            for (int i=0; i < dr.FieldCount; i++) {
                if (dr.GetName(i).Equals(columnName,
                    StringComparison.InvariantCultureIgnoreCase))
                    return true;
            }
            return false;
        }

        /// <summary>
        /// Given a fully assembly-qualified typename, returns a Mono Type.
        /// </summary>
        /// <returns>The desired Mono type.</returns>
        /// <param name="fullyQualifiedTypeName">Fully assembly-qualified type name.</param>
        public static Type GetTypeFromFqName(string fullyQualifiedTypeName)
        {
            var type = Type.GetType(fullyQualifiedTypeName);
            if (type == null)
            {
                throw new Exception(
                    String.Format("Error creating type {0}", fullyQualifiedTypeName));
            }
            return type;
        }

        /// <summary>
        /// Given a series of uri segments, this method will return a complete Uri.
        /// </summary>
        /// <returns>The desired Uri.</returns>
        /// <param name="paths">Segments of the Uri desired.</param>
        public static string UriCombine(params string[] paths)
        {
            var result = String.Empty;

            if (paths != null && paths.Length > 0) {
                foreach (var p in paths) {
                    string temp = p;

                    if (temp.StartsWith("//"))
                        temp = temp.Substring(1, temp.Length - 1);
                    else if (temp.EndsWith ("//"))
                        temp = temp.Substring(0, temp.Length - 1);

                    if (temp.StartsWith("/") && !String.IsNullOrEmpty(result))
                        result += temp.Substring(1, temp.Length - 1);
                    else {
                        result += temp;
                    }

                    if (!result.EndsWith("/")) {
                        result += "/";
                    }
                }

                if (result.EndsWith("/"))
                    result = result.Substring (0, result.Length - 1);
            }

            return result;
        }

        /// <summary>
        /// Helper function that looks in a properties collection for values, throwing an
        /// exception if not found.
        /// <returns>The required property value.</returns>
        /// <param name="key">The key for the property value.</param>
        /// <param name="properties">The list of properties to look in.</param>
        /// </summary>
        public static string GetRequiredProperty (string key,
                                                  IEnumerable<DescriptorProperty> properties)
        {
            return GetProperty(key, properties, true);
        }

        /// <summary>
        /// Helper function that looks in a properties collection for values, throwing an
        /// exception if not found, although this can be suppressed.  It also will throw an
        /// exception if the property is not parseable as a bool.
        /// <returns>The boolean property value, if found, and parseable, null if not found and
        /// the 'required' parameter is false, or throws an exception in remaining cases.
        /// </returns>
        /// <param name="key">The key for the property value.</param>
        /// <param name="properties">The list of properties to look in.</param>
        /// <param name="required">Is the property required?  Defaults to true.</param>
        /// </summary>
        public static bool? GetBoolProperty(string key,
                                    IEnumerable<DescriptorProperty> properties,
                                    bool required = true)
        {
            var boolString = GetProperty(key, properties, required);
            if (String.IsNullOrEmpty(boolString)) {
                return null;
            }
            bool boolValue;
            if (!Boolean.TryParse(boolString, out boolValue)) {
                throw new Exception(String.Format("GetRequiredBoolProperty - value for key " +
                                    "\"{0}\" = \"{1}\", not parseable as bool",
                                    key, boolString));
            }
            return boolValue;
        }

        /// <summary>
        /// This helper is for getting boolean properties that are required to be in the Plan.
        /// </summary>
        /// <param name="key">The key for the property value.</param>
        /// <param name="properties">The list of properties to look in.</param>
        /// <returns></returns>
        public static bool GetRequiredBoolProperty(string key,
                                            IEnumerable<DescriptorProperty> properties)
        {
            // It's OK to use the .Value operator here; this will properly throw a usable
            // exception if the property is missing in the plan, and otherwise there will be a
            // valid boolean value.
            return GetBoolProperty(key, properties).Value;
        }

        /// <summary>
        /// Helper function that looks in a properties collection for values that are expected
        /// to be parseable to an int.  Will throw an exception if required == true and the
        /// property is not found, or if it is found, but is not parseable as an integer.
        /// </summary>
        /// <param name="key">Key for the integer property to look for.</param>
        /// <param name="properties">The properties collection.</param>
        /// <param name="required">If true, will throw exception if the property is missing.
        /// </param>
        /// <returns>The parsed int value, or null.</returns>
        public static int? GetIntProperty(string key,
                                    IEnumerable<DescriptorProperty> properties,
                                    bool required = true)
        {
            var intString = GetProperty(key, properties, required);
            if (String.IsNullOrEmpty(intString)) {
                return null;
            }
            int intValue;
            if (!Int32.TryParse(intString, out intValue)) {
                throw new Exception(String.Format("GetIntProperty - {0} property value is not "
                                                 + "parseable as int", key ));
            }
            return intValue;
        }

        /// <summary>
        /// Gets the property.
        /// </summary>
        /// <returns>The property.</returns>
        /// <param name="key">Key.</param>
        /// <param name="properties">Properties.</param>
        /// <param name="required">If set to <c>true</c> required.  This function will throw an
        /// exception if 'required' is true and the property doesn't exist or has a blank or
        /// null value.</param>
        public static string GetProperty(string key,
                                 IEnumerable<DescriptorProperty> properties, bool required)
        {
            if (properties == null) {
                throw new Exception("GetProperty a- properties block is needed to " +
                "function.");
            }
            var property = properties.SingleOrDefault(p => p.Name.Equals(key));
            if (property == null) {
                if (required) {
                    throw new Exception(
                        String.Format("GetRequiredProperty - missing {0} property",
                            key));
                }
                return null;
            }

            if (String.IsNullOrWhiteSpace (property.Value)) {
                if (required) {
                    throw new Exception(String.Format("GetProperty - {0} property " +
                                                    "value is empty", key));
                }
                return null;
            }

            return property.Value;
        }

        /// <summary>
        /// Given a key from the properties for the PostProcessorDescriptor that describes this
        /// PostProcessor, this will return a matching string in App.Config.
        /// </summary>
        /// <param name="keyInProperties"></param>
        /// <param name="properties">The collection of properties to search through. </param>
        /// <returns></returns>
        public static string GetConfigString(string keyInProperties,
            IEnumerable<DescriptorProperty> properties)
        {
            var connectionKey = Utilities.GetRequiredProperty(keyInProperties, properties);
            try {
                return ConfigurationManager.AppSettings[connectionKey];
            } catch (Exception ex) {
                throw new Exception(
                    String.Format("GetConfigString - missing App.Config app setting " +
                        "\"{0}\"", keyInProperties), ex);
            }
        }

        /// <summary>
        /// Instantiates and returns a LitS3 S3 service object.
        /// </summary>
        /// <returns>The LitS3 S3Service.</returns>
        public static S3Service GetS3Service()
        {
            var appSettings = ConfigurationManager.AppSettings;
            var accessKey = appSettings["AWSAccessKey"];
            var secretAccessKey = appSettings["AWSSecretAccessKey"];
            var service = new S3Service{
                AccessKeyID = accessKey,
                SecretAccessKey = secretAccessKey,
                UseSsl = true,
                UseSubdomains = true
            };
            service.BeforeAuthorize += (sender, e) => {
                e.Request.ServicePoint.ConnectionLimit = int.MaxValue;
            };

            return service;
        }

        /// <summary>
        /// A helper function to encapsulate the creation of integer parameters to stored
        /// procedures.
        /// </summary>
        /// <returns>The SqlParameter object.</returns>
        /// <param name="command">A SqlCommand object to create the parameter for.</param>
        /// <param name="direction">Is the parameter In, Out, In/Out, or Return Value?</param>
        /// <param name="name">Name of the parameter.</param>
        /// <param name="value">The integer value to set.</param>
        public static SqlParameter CreateIntParameter(SqlCommand command,
                    ParameterDirection direction, String name, int value)
        {
            var parameter = command.Parameters.Add(name, SqlDbType.Int);
            parameter.Direction = direction;
            parameter.Value = value;
            return parameter;
        }

        /// <summary>
        /// Creates an nvarchar variable length string SqlParameter object.
        /// </summary>
        /// <returns>The created parameter.</returns>
        /// <param name="command">A SqlCommand object to create the parameter for.</param>
        /// <param name="direction">Is the parameter In, Out, In/Out, or Return Value?</param>
        /// <param name="name">Name of the parameter.</param>
        /// <param name="value">The string value to set.</param>
        /// <param name="count">The length of the string</param>
        public static SqlParameter CreateNVarCharParameter(SqlCommand command,
                    ParameterDirection direction, String name, String value, int count)
        {
            var parameter = command.Parameters.Add(name, SqlDbType.NVarChar, count);
            parameter.Direction = direction;
            parameter.Value = value;
            return parameter;
        }

        /// <summary>
        /// Enables the or disable sql trigger.  This is 'tui_member', on the 'member' table.
        /// It enforces historical business logic that is different than what we are permitting
        /// for the user migration for NAMG.   We disable it, run the post-process, then
        /// re-enable it.
        /// </summary>
        /// <param name="connectionString">Database connection string.</param>
        /// <param name="triggerName">Trigger name.</param>
        /// <param name="tableName">Table name.</param>
        /// <param name="enableOrDisable">If set to <c>true</c> enable or disable.</param>
        public static void EnableOrDisableSqlTrigger(string connectionString,
                                    string triggerName, string tableName, bool enableOrDisable)
        {
            try
            {
                using (var connection = new SqlConnection(connectionString))
                {
                    connection.Open();

                    if (DoesTriggerExist(triggerName, connection))
                    {

                        var commandString = String.Format(enableOrDisable ?
                            "ALTER TABLE {0} ENABLE TRIGGER {1}" :
                            "ALTER TABLE {0} DISABLE TRIGGER {1}", tableName, triggerName);

                        using (var command = new SqlCommand(commandString, connection))
                        {
                            command.ExecuteNonQuery();
                            log.DebugFormat("Successfully executed {0}, commandString",
                                            commandString);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception(String.Format("Error {0} sql trigger {1} on table {2}" +
                        " error = {3}",
                        enableOrDisable ? "enabling" : "disabling",
                        triggerName, tableName, ex.Message), ex);
            }
        }

        /// <summary>
        /// A helper function that piggybacks on an existing open Sql connection, and let us
        /// know whether a trigger exists or not.
        /// </summary>
        /// <returns><c>true</c>, if trigger exists, <c>false</c> otherwise.</returns>
        /// <param name="triggerName">Trigger name.</param>
        /// <param name="connection">Connection.</param>
        static bool DoesTriggerExist(string triggerName, SqlConnection connection)
        {
            var commandString = String.Format("if exists (select * from sys.triggers where " +
                                        "name = '{0}') select 1 else select 0",
                                    triggerName);

            using (var command = new SqlCommand(commandString, connection))
            {
                var answer = (int)command.ExecuteScalar();
                return answer == 1;
            }
        }

        /// Gets a string from an IDataRecord safely, mapping DBNull.Value to null.
        /// </summary>
        /// <param name="record">The data record from a query.</param>
        /// <param name="name">The string value, or null.</param>
        /// <returns></returns>
        public static String GetDbString(IDataRecord record, String name)
        {
            var objectValue = GetDbValue(record, name);
            return objectValue == null ? null : (String)objectValue;
        }

        /// <summary>
        /// Gets a value type from an IDataRecord safely, mapping DBNull.Value to null.
        /// </summary>
        /// <param name="record">The data record from a query.</param>
        /// <param name="name">The column name.</param>
        /// <returns>The  value, or null.</returns>
        public static T? GetDbNullableT<T>(IDataRecord record, String name)
            where T : struct
        {
            var objectValue = GetDbValue(record, name);
            return objectValue == null ? (T?) null : (T) objectValue;
        }

        /// <summary>
        /// Helper function; turns DBNull.Value into null.
        /// </summary>
        /// <param name="record">Data Record returned from query.</param>
        /// <param name="name">The name of the column.</param>
        /// <returns></returns>
        private static object GetDbValue(IDataRecord record, string name)
        {
            var objectValue = record[name];
            return DBNull.Value == objectValue ? null : objectValue;
        }

        /// <summary>
        /// Writes the bad rows feed file.
        /// </summary>
        /// <returns>The bad rows feed file name.</returns>
        /// <param name="loadNumber">The Loadnumber.</param>
        /// <param name="phase">The Phase to use for Phase Logging.</param>
        /// <param name="dataSourcePlan">DataSourcePlan for this processor.</param>
        /// <param name="description">Description to use for phase logging.</param>
        /// <param name="badRowsFileName">Name of badRows Feed File.</param>
        /// <param name="workingDirectory">Directory to write file in.</param>
        /// <param name="connectionString">Db connection string.</param>
        /// <param name="logQuantum">How many rows to do before logging.</param>
        /// <param name="phaseLogger">Phase Logger for logging to Sql</param>
        /// <param name="logSource">logSource integer that uniquely indentifies who's doing
        /// the phase logging.</param>
        public static string WriteBadRowsFeedFile(int loadNumber, DataMigrationPhase phase,
            DataSourcePlan dataSourcePlan, string description, string badRowsFileName,
            string workingDirectory, string connectionString, int logQuantum,
            IPhaseLogger phaseLogger, int logSource)
        {
            return WriteFeedFileFromDatabaseQuery(
                    String.Format("select * from dbo.BadRows where loadnum = {0}", loadNumber),
                    badRowsFileName,
                    "LoadNumber\tDataSourceCode\tRowNumber\tDestinationColumn\tReason\t" +
                    "ForeignId\tRowData\t",
                    (reader, textWriter) => {
                        var dataSourceCode = (string)reader["DataSourceCode"];
                        var rowNumber = (int)reader["RowNumber"];
                        var destinationColumn = (string)reader["DestColumn"];
                        var reason = (string)reader["Reason"];
                        var foreignId = (string)reader["ForeignId"];

                        // BadRows generated in the PostProcessing stage do not have access to
                        // the original rowdata.
                        string rowData;
                        if (DBNull.Value == reader["RowData"]) {
                            rowData = "null";
                        } else {
                            rowData = (string)reader["RowData"];
                        }

                        textWriter.Write("{0}\t{1}\t{2}\t{3}\t{4}\t{5}\t{6}",
                            loadNumber, dataSourceCode, rowNumber, destinationColumn,
                            reason, foreignId, rowData);

                        textWriter.WriteLine();
                    },
                    loadNumber,
                    phase,
                    dataSourcePlan,
                    description,
                    workingDirectory,
                    connectionString,
                    logQuantum,
                    phaseLogger,
                    logSource
             );
        }

        /// <summary>
        /// Helper function that factors out the common code for issuing a database query and
        /// writing a log file to the local file system.
        /// </summary>
        /// <returns>The full filepath for the local file produced.</returns>
        /// <param name="sqlQuery">Text of the sql query to issue.</param>
        /// <param name="fileName">The local filename to use.</param>
        /// <param name="tabDelimitedHeaderText">A header row for the file.</param>
        /// <param name="rowWriter">A delegate that reads from the SqlDataReader and
        ///     writes to the TextWriter passed in.  It knows what arguments to pull off the
        ///     DataReader and how they should be written to the TextWriter.</param>
        /// <param name="loadNumber">The Loadnumber.</param>
        /// <param name="phase">The Phase to use for Phase Logging.</param>
        /// <param name="dataSourcePlan">DataSourcePlan for this processor.</param>
        /// <param name="description">Description to use for phase logging.</param>
        /// <param name="workingDirectory">Directory to write file in.</param>
        /// <param name="connectionString">Db connection string.</param>
        /// <param name="logQuantum">How many rows to do before logging.</param>
        /// <param name="phaseLogger">Phase Logger for logging to Sql</param>
        /// <param name="logSource">logSource integer that uniquely indentifies who's doing
        /// the phase logging.</param>
        public static string WriteFeedFileFromDatabaseQuery(string sqlQuery, string fileName,
                    string tabDelimitedHeaderText, Action<SqlDataReader, TextWriter> rowWriter,
                    int loadNumber, DataMigrationPhase phase, DataSourcePlan dataSourcePlan,
                    string description, string workingDirectory, string connectionString,
                    int logQuantum, IPhaseLogger phaseLogger,
                    int logSource)
        {
            var stopWatch = Stopwatch.StartNew();
            var recordCount = 0;
            var fullFileName = Path.Combine(workingDirectory, fileName);

            try {
                // Open up a text file for reading.
                using (var textWriter = File.CreateText(fullFileName)) {
                    // Write the column name.
                    textWriter.Write(tabDelimitedHeaderText);
                    textWriter.WriteLine();

                    using (var connection = new SqlConnection(connectionString)) {
                        connection.Open();

                        using (var command = new SqlCommand(sqlQuery, connection)) {
                            var reader = command.ExecuteReader();
                            while (reader.Read()) {
                                rowWriter(reader, textWriter);
                                recordCount++;

                                if ((recordCount % logQuantum) == 0) {
                                    log.DebugFormat("WriteFeedFileFromDatabaseQuery - rows " +
                                    "written = {0}", recordCount);
                                }
                            }
                        }
                    }
                }
                phaseLogger.Log(new PhaseLogEntry {
                    LogSource = logSource,
                    DataSourceCode = dataSourcePlan.DataSourceCode,
                    LoadNumber = loadNumber,
                    Phase = phase,
                    NumberOfRecords = recordCount,
                    Description = description
                });
            } catch (Exception ex) {
                throw new Exception(
                    String.Format("WriteFeedFileFromDatabaseQuery - error = {0}",
                                    ex.Message), ex);
            }
            stopWatch.Stop();
            log.DebugFormat("WriteFeedFileFromDictionary - wrote {0} rows in {1} seconds",
                recordCount, stopWatch.Elapsed.TotalSeconds);

            return fullFileName;
        }

        /// <summary>
        /// Copies to s3, using the LitS3 library, and the internal S3Parts class.
        /// </summary>
        /// <param name="s3Location">Full S3 url where we want this to live.</param>
        /// <param name="localFilePath">Local file path to the file to upload.</param>
        /// <param name="baseFileName">The name of the file without path.</param>
        /// <param name="loadNumber">The Load Number.</param>
        /// <param name="phase">The phase to use for phase logging.</param>
        /// <param name="dataSourcePlan">DataSourcePlan for this processor.</param>
        /// <param name="description">Description to use for phase logging.</param>
        /// <param name="phaseLogger">PhaseLogger to use to talk about progress.</param>
        /// <param name="logSource">logSource to use when logging.</param>
        public static void CopyToS3(string s3Location, string localFilePath,
            string baseFileName, int loadNumber, DataMigrationPhase phase,
            DataSourcePlan dataSourcePlan, string description, IPhaseLogger phaseLogger,
            int logSource)
        {
            log.DebugFormat("CopyToS3 - attempting upload from {0} to {1}", baseFileName,
                            s3Location);

            var stopWatch = Stopwatch.StartNew();

            var s3DestinationFile = Utilities.UriCombine(s3Location, baseFileName);
            var s3Parts = S3Parts.FromUrl(s3DestinationFile);
            var s3Service = Utilities.GetS3Service();
            EventHandler<S3ProgressEventArgs> progressHandler = (source, eventArguments) => {
                var percentDone = eventArguments.ProgressPercentage;
                if ((percentDone % 10) == 0) {  // Throttle the log messages.
                    log.DebugFormat("Uploading {0}, progress = {1}%", baseFileName,
                                    percentDone);
                }
            };

            s3Service.AddObjectProgress += progressHandler;

            try {
                s3Service.AddObject(localFilePath, s3Parts.Bucket, s3Parts.File);
                phaseLogger.Log(new PhaseLogEntry {
                    LogSource = logSource,
                    DataSourceCode = dataSourcePlan.DataSourceCode,
                    LoadNumber = loadNumber,
                    Phase = phase,
                    Description = description
                });
            } catch (Exception ex) {
                throw new Exception(String.Format("CopyToS3 - error uploading file {0} = {1}",
                    localFilePath, ex.Message), ex);
            } finally {
                s3Service.AddObjectProgress -= progressHandler;
            }
            stopWatch.Stop();
            log.DebugFormat("CopyToS3 - uploaded file {0} in {1} seconds.",
                baseFileName, stopWatch.Elapsed.TotalSeconds);
        }

        /// <summary>
        /// This function makes every effort to remove the temporary working directory, but
        /// on error will just log a warning and continue on.
        /// </summary>
        public static void DeleteWorkingDirectory(string workingDirectory)
        {
            try {
                if (String.IsNullOrWhiteSpace(workingDirectory)) {
                    return;
                }
                var directoryInfo = new DirectoryInfo(workingDirectory);
                if (!directoryInfo.Exists) {
                    return;
                }
                Directory.Delete(workingDirectory);
            } catch (Exception ex) {
                // Log a warning and continue.  This is not a fatal error.
                log.WarnFormat("DeleteWorkingDirectory - error deleting {0} = {1}",
                                workingDirectory, ex.Message);
            }
        }

        /// <summary>
        /// This function makes every effort to remove the local feed file, but  on error will
        /// just log a warning and continue on.
        /// </summary>
        /// <param name="feedFileFullPath">Full path to the file to delete.</param>
        public static void DeleteLocalFeedFile(string feedFileFullPath)
        {
            try {
                if (String.IsNullOrWhiteSpace(feedFileFullPath)) {
                    return;
                }
                var fileInfo = new FileInfo(feedFileFullPath);
                if (!fileInfo.Exists) {
                    return;
                }
                File.Delete(feedFileFullPath);
            } catch (Exception ex) {
                // Just log a warning and continue; this is not a fatal error.
                log.WarnFormat("DeleteLocalFeedFile - error deleting file {0} = {1}",
                            feedFileFullPath, ex.Message);
            }
        }
    }
}


text:
/*
  This file is licensed to You under the Apache License, Version 2.0
  (the "License"); you may not use this file except in compliance with
  the License.  You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
*/

using System.Collections.Generic;
using System.Xml;
using System.Xml.XPath;
using net.sf.xmlunit.exceptions;
using net.sf.xmlunit.util;

namespace net.sf.xmlunit.xpath {

    /// <summary>
    /// Simplified access to System.Xml.XPath API.
    /// </summary>
    public class XPathEngine : IXPathEngine {
        private XmlNamespaceManager nsContext;

        /// <summary>
        /// Returns a potentially empty collection of Nodes matching an
        /// XPath expression.
        /// </summary>
        public IEnumerable<XmlNode> SelectNodes(string xPath, ISource s) {
            try {
                XmlDocument doc = new XmlDocument();
                doc.Load(s.Reader);
                return ToNodeEnumerable(doc.SelectNodes(xPath, nsContext));
            } catch (XPathException ex) {
                throw new XMLUnitException(ex);
            }
        }

        /// <summary>
        /// Evaluates an XPath expression and stringifies the result.
        /// </summary>
        public string Evaluate(string xPath, ISource s) {
            try {
                XPathDocument doc = new XPathDocument(s.Reader);
                object v = doc.CreateNavigator().Evaluate(xPath, nsContext);
                if (v == null) {
                    return string.Empty;
                } else if (v is XPathNodeIterator) {
                    XPathNodeIterator it = v as XPathNodeIterator;
                    if (it.MoveNext()) {
                        return (string) it.Current
                            .ValueAs(typeof(string), nsContext);
                    }
                    return string.Empty;
                }
                return v.ToString();
            } catch (XPathException ex) {
                throw new XMLUnitException(ex);
            }
        }

        public IDictionary<string, string> NamespaceContext {
            set {
                nsContext = Convert.ToNamespaceContext(value);
            }
        }

        private IEnumerable<XmlNode> ToNodeEnumerable(XmlNodeList it) {
            LinkedList<XmlNode> l = new LinkedList<XmlNode>();
            foreach (XmlNode n in it) {
                l.AddLast(n);
            }
            return l;
        }
    }
}


text:
#pragma once
#ifndef OALPLUS_ALFUNC_1303201702_HPP
#define OALPLUS_ALFUNC_1303201702_HPP

#include <oalplus/config.hpp>

namespace oglplus {

#define OALPLUS_ALFUNC(FUNCNAME) \
	::al##FUNCNAME

#define OALPLUS_ALCFUNC(FUNCNAME) \
	::alc##FUNCNAME

#define OALPLUS_ALUTFUNC(FUNCNAME) \
	::alut##FUNCNAME

} // namespace oglplus

#endif // include guard


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

#include <memory>
#include <string>
#include <vector>

#include "gmock/gmock.h"
#include "source/opt/dominator_analysis.h"
#include "source/opt/pass.h"
#include "test/opt/assembly_builder.h"
#include "test/opt/function_utils.h"
#include "test/opt/pass_fixture.h"
#include "test/opt/pass_utils.h"

namespace spvtools {
namespace opt {
namespace {

using ::testing::UnorderedElementsAre;

using PassClassTest = PassTest<::testing::Test>;

/*
Generated from the following GLSL
#version 440 core
layout(location = 0) out vec4 v;
layout(location = 1) in vec4 in_val;
void main() {
  for (int i = 0; i < in_val.x; ++i) {
    for (int j = 0; j < in_val.y; j++) {
    }
  }
  for (int i = 0; i < in_val.x; ++i) {
    for (int j = 0; j < in_val.y; j++) {
    }
    break;
  }
  int i = 0;
  while (i < in_val.x) {
    ++i;
    for (int j = 0; j < 1; j++) {
      for (int k = 0; k < 1; k++) {
      }
      break;
    }
  }
  i = 0;
  while (i < in_val.x) {
    ++i;
    continue;
    for (int j = 0; j < 1; j++) {
      for (int k = 0; k < 1; k++) {
      }
      break;
    }
  }
  v = vec4(1,1,1,1);
}
*/
TEST_F(PassClassTest, BasicVisitFromEntryPoint) {
  const std::string text = R"(
    OpCapability Shader
    %1 = OpExtInstImport "GLSL.std.450"
         OpMemoryModel Logical GLSL450
         OpEntryPoint Fragment %4 "main" %20 %141
         OpExecutionMode %4 OriginUpperLeft
         OpSource GLSL 440
         OpName %4 "main"
         OpName %8 "i"
         OpName %20 "in_val"
         OpName %28 "j"
         OpName %45 "i"
         OpName %56 "j"
         OpName %72 "i"
         OpName %85 "j"
         OpName %93 "k"
         OpName %119 "j"
         OpName %127 "k"
         OpName %141 "v"
         OpDecorate %20 Location 1
         OpDecorate %141 Location 0
    %2 = OpTypeVoid
    %3 = OpTypeFunction %2
    %6 = OpTypeInt 32 1
    %7 = OpTypePointer Function %6
    %9 = OpConstant %6 0
   %16 = OpTypeFloat 32
   %18 = OpTypeVector %16 4
   %19 = OpTypePointer Input %18
   %20 = OpVariable %19 Input
   %21 = OpTypeInt 32 0
   %22 = OpConstant %21 0
   %23 = OpTypePointer Input %16
   %26 = OpTypeBool
   %36 = OpConstant %21 1
   %41 = OpConstant %6 1
  %140 = OpTypePointer Output %18
  %141 = OpVariable %140 Output
  %142 = OpConstant %16 1
  %143 = OpConstantComposite %18 %142 %142 %142 %142
    %4 = OpFunction %2 None %3
    %5 = OpLabel
    %8 = OpVariable %7 Function
   %28 = OpVariable %7 Function
   %45 = OpVariable %7 Function
   %56 = OpVariable %7 Function
   %72 = OpVariable %7 Function
   %85 = OpVariable %7 Function
   %93 = OpVariable %7 Function
  %119 = OpVariable %7 Function
  %127 = OpVariable %7 Function
         OpStore %8 %9
         OpBranch %10
   %10 = OpLabel
         OpLoopMerge %12 %13 None
         OpBranch %14
   %14 = OpLabel
   %15 = OpLoad %6 %8
   %17 = OpConvertSToF %16 %15
   %24 = OpAccessChain %23 %20 %22
   %25 = OpLoad %16 %24
   %27 = OpFOrdLessThan %26 %17 %25
         OpBranchConditional %27 %11 %12
   %11 = OpLabel
         OpStore %28 %9
         OpBranch %29
   %29 = OpLabel
         OpLoopMerge %31 %32 None
         OpBranch %33
   %33 = OpLabel
   %34 = OpLoad %6 %28
   %35 = OpConvertSToF %16 %34
   %37 = OpAccessChain %23 %20 %36
   %38 = OpLoad %16 %37
   %39 = OpFOrdLessThan %26 %35 %38
         OpBranchConditional %39 %30 %31
   %30 = OpLabel
         OpBranch %32
   %32 = OpLabel
   %40 = OpLoad %6 %28
   %42 = OpIAdd %6 %40 %41
         OpStore %28 %42
         OpBranch %29
   %31 = OpLabel
         OpBranch %13
   %13 = OpLabel
   %43 = OpLoad %6 %8
   %44 = OpIAdd %6 %43 %41
         OpStore %8 %44
         OpBranch %10
   %12 = OpLabel
         OpStore %45 %9
         OpBranch %46
   %46 = OpLabel
         OpLoopMerge %48 %49 None
         OpBranch %50
   %50 = OpLabel
   %51 = OpLoad %6 %45
   %52 = OpConvertSToF %16 %51
   %53 = OpAccessChain %23 %20 %22
   %54 = OpLoad %16 %53
   %55 = OpFOrdLessThan %26 %52 %54
         OpBranchConditional %55 %47 %48
   %47 = OpLabel
         OpStore %56 %9
         OpBranch %57
   %57 = OpLabel
         OpLoopMerge %59 %60 None
         OpBranch %61
   %61 = OpLabel
   %62 = OpLoad %6 %56
   %63 = OpConvertSToF %16 %62
   %64 = OpAccessChain %23 %20 %36
   %65 = OpLoad %16 %64
   %66 = OpFOrdLessThan %26 %63 %65
         OpBranchConditional %66 %58 %59
   %58 = OpLabel
         OpBranch %60
   %60 = OpLabel
   %67 = OpLoad %6 %56
   %68 = OpIAdd %6 %67 %41
         OpStore %56 %68
         OpBranch %57
   %59 = OpLabel
         OpBranch %48
   %49 = OpLabel
   %70 = OpLoad %6 %45
   %71 = OpIAdd %6 %70 %41
         OpStore %45 %71
         OpBranch %46
   %48 = OpLabel
         OpStore %72 %9
         OpBranch %73
   %73 = OpLabel
         OpLoopMerge %75 %76 None
         OpBranch %77
   %77 = OpLabel
   %78 = OpLoad %6 %72
   %79 = OpConvertSToF %16 %78
   %80 = OpAccessChain %23 %20 %22
   %81 = OpLoad %16 %80
   %82 = OpFOrdLessThan %26 %79 %81
         OpBranchConditional %82 %74 %75
   %74 = OpLabel
   %83 = OpLoad %6 %72
   %84 = OpIAdd %6 %83 %41
         OpStore %72 %84
         OpStore %85 %9
         OpBranch %86
   %86 = OpLabel
         OpLoopMerge %88 %89 None
         OpBranch %90
   %90 = OpLabel
   %91 = OpLoad %6 %85
   %92 = OpSLessThan %26 %91 %41
         OpBranchConditional %92 %87 %88
   %87 = OpLabel
         OpStore %93 %9
         OpBranch %94
   %94 = OpLabel
         OpLoopMerge %96 %97 None
         OpBranch %98
   %98 = OpLabel
   %99 = OpLoad %6 %93
  %100 = OpSLessThan %26 %99 %41
         OpBranchConditional %100 %95 %96
   %95 = OpLabel
         OpBranch %97
   %97 = OpLabel
  %101 = OpLoad %6 %93
  %102 = OpIAdd %6 %101 %41
         OpStore %93 %102
         OpBranch %94
   %96 = OpLabel
         OpBranch %88
   %89 = OpLabel
  %104 = OpLoad %6 %85
  %105 = OpIAdd %6 %104 %41
         OpStore %85 %105
         OpBranch %86
   %88 = OpLabel
         OpBranch %76
   %76 = OpLabel
         OpBranch %73
   %75 = OpLabel
         OpStore %72 %9
         OpBranch %106
  %106 = OpLabel
         OpLoopMerge %108 %109 None
         OpBranch %110
  %110 = OpLabel
  %111 = OpLoad %6 %72
  %112 = OpConvertSToF %16 %111
  %113 = OpAccessChain %23 %20 %22
  %114 = OpLoad %16 %113
  %115 = OpFOrdLessThan %26 %112 %114
         OpBranchConditional %115 %107 %108
  %107 = OpLabel
  %116 = OpLoad %6 %72
  %117 = OpIAdd %6 %116 %41
         OpStore %72 %117
         OpBranch %109
  %109 = OpLabel
         OpBranch %106
  %108 = OpLabel
         OpStore %141 %143
         OpReturn
         OpFunctionEnd
)";
  // clang-format on
  std::unique_ptr<IRContext> context =
      BuildModule(SPV_ENV_UNIVERSAL_1_1, nullptr, text,
                  SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS);
  Module* module = context->module();
  EXPECT_NE(nullptr, module) << "Assembling failed for shader:\n"
                             << text << std::endl;

  const Function* f = spvtest::GetFunction(module, 4);
  DominatorAnalysis* analysis = context->GetDominatorAnalysis(f);

  EXPECT_TRUE(analysis->Dominates(5, 10));
  EXPECT_TRUE(analysis->Dominates(5, 14));
  EXPECT_TRUE(analysis->Dominates(5, 11));
  EXPECT_TRUE(analysis->Dominates(5, 29));
  EXPECT_TRUE(analysis->Dominates(5, 33));
  EXPECT_TRUE(analysis->Dominates(5, 30));
  EXPECT_TRUE(analysis->Dominates(5, 32));
  EXPECT_TRUE(analysis->Dominates(5, 31));
  EXPECT_TRUE(analysis->Dominates(5, 13));
  EXPECT_TRUE(analysis->Dominates(5, 12));
  EXPECT_TRUE(analysis->Dominates(5, 46));
  EXPECT_TRUE(analysis->Dominates(5, 50));
  EXPECT_TRUE(analysis->Dominates(5, 47));
  EXPECT_TRUE(analysis->Dominates(5, 57));
  EXPECT_TRUE(analysis->Dominates(5, 61));
  EXPECT_TRUE(analysis->Dominates(5, 59));
  EXPECT_TRUE(analysis->Dominates(5, 58));
  EXPECT_TRUE(analysis->Dominates(5, 60));
  EXPECT_TRUE(analysis->Dominates(5, 48));
  EXPECT_TRUE(analysis->Dominates(5, 73));
  EXPECT_TRUE(analysis->Dominates(5, 77));
  EXPECT_TRUE(analysis->Dominates(5, 75));
  EXPECT_TRUE(analysis->Dominates(5, 106));
  EXPECT_TRUE(analysis->Dominates(5, 110));
  EXPECT_TRUE(analysis->Dominates(5, 107));
  EXPECT_TRUE(analysis->Dominates(5, 108));
  EXPECT_TRUE(analysis->Dominates(5, 109));
  EXPECT_TRUE(analysis->Dominates(5, 74));
  EXPECT_TRUE(analysis->Dominates(5, 86));
  EXPECT_TRUE(analysis->Dominates(5, 90));
  EXPECT_TRUE(analysis->Dominates(5, 87));
  EXPECT_TRUE(analysis->Dominates(5, 94));
  EXPECT_TRUE(analysis->Dominates(5, 98));
  EXPECT_TRUE(analysis->Dominates(5, 95));
  EXPECT_TRUE(analysis->Dominates(5, 97));
  EXPECT_TRUE(analysis->Dominates(5, 96));
  EXPECT_TRUE(analysis->Dominates(5, 88));
  EXPECT_TRUE(analysis->Dominates(5, 76));

  EXPECT_TRUE(analysis->Dominates(10, 14));
  EXPECT_TRUE(analysis->Dominates(10, 11));
  EXPECT_TRUE(analysis->Dominates(10, 29));
  EXPECT_TRUE(analysis->Dominates(10, 33));
  EXPECT_TRUE(analysis->Dominates(10, 30));
  EXPECT_TRUE(analysis->Dominates(10, 32));
  EXPECT_TRUE(analysis->Dominates(10, 31));
  EXPECT_TRUE(analysis->Dominates(10, 13));
  EXPECT_TRUE(analysis->Dominates(10, 12));
  EXPECT_TRUE(analysis->Dominates(10, 46));
  EXPECT_TRUE(analysis->Dominates(10, 50));
  EXPECT_TRUE(analysis->Dominates(10, 47));
  EXPECT_TRUE(analysis->Dominates(10, 57));
  EXPECT_TRUE(analysis->Dominates(10, 61));
  EXPECT_TRUE(analysis->Dominates(10, 59));
  EXPECT_TRUE(analysis->Dominates(10, 58));
  EXPECT_TRUE(analysis->Dominates(10, 60));
  EXPECT_TRUE(analysis->Dominates(10, 48));
  EXPECT_TRUE(analysis->Dominates(10, 73));
  EXPECT_TRUE(analysis->Dominates(10, 77));
  EXPECT_TRUE(analysis->Dominates(10, 75));
  EXPECT_TRUE(analysis->Dominates(10, 106));
  EXPECT_TRUE(analysis->Dominates(10, 110));
  EXPECT_TRUE(analysis->Dominates(10, 107));
  EXPECT_TRUE(analysis->Dominates(10, 108));
  EXPECT_TRUE(analysis->Dominates(10, 109));
  EXPECT_TRUE(analysis->Dominates(10, 74));
  EXPECT_TRUE(analysis->Dominates(10, 86));
  EXPECT_TRUE(analysis->Dominates(10, 90));
  EXPECT_TRUE(analysis->Dominates(10, 87));
  EXPECT_TRUE(analysis->Dominates(10, 94));
  EXPECT_TRUE(analysis->Dominates(10, 98));
  EXPECT_TRUE(analysis->Dominates(10, 95));
  EXPECT_TRUE(analysis->Dominates(10, 97));
  EXPECT_TRUE(analysis->Dominates(10, 96));
  EXPECT_TRUE(analysis->Dominates(10, 88));
  EXPECT_TRUE(analysis->Dominates(10, 76));

  EXPECT_TRUE(analysis->Dominates(14, 11));
  EXPECT_TRUE(analysis->Dominates(14, 29));
  EXPECT_TRUE(analysis->Dominates(14, 33));
  EXPECT_TRUE(analysis->Dominates(14, 30));
  EXPECT_TRUE(analysis->Dominates(14, 32));
  EXPECT_TRUE(analysis->Dominates(14, 31));

  EXPECT_TRUE(analysis->Dominates(11, 29));
  EXPECT_TRUE(analysis->Dominates(11, 33));
  EXPECT_TRUE(analysis->Dominates(11, 30));
  EXPECT_TRUE(analysis->Dominates(11, 32));
  EXPECT_TRUE(analysis->Dominates(11, 31));

  EXPECT_TRUE(analysis->Dominates(29, 33));
  EXPECT_TRUE(analysis->Dominates(29, 30));
  EXPECT_TRUE(analysis->Dominates(29, 32));
  EXPECT_TRUE(analysis->Dominates(29, 31));

  EXPECT_TRUE(analysis->Dominates(33, 30));

  EXPECT_TRUE(analysis->Dominates(12, 46));
  EXPECT_TRUE(analysis->Dominates(12, 50));
  EXPECT_TRUE(analysis->Dominates(12, 47));
  EXPECT_TRUE(analysis->Dominates(12, 57));
  EXPECT_TRUE(analysis->Dominates(12, 61));
  EXPECT_TRUE(analysis->Dominates(12, 59));
  EXPECT_TRUE(analysis->Dominates(12, 58));
  EXPECT_TRUE(analysis->Dominates(12, 60));
  EXPECT_TRUE(analysis->Dominates(12, 48));
  EXPECT_TRUE(analysis->Dominates(12, 73));
  EXPECT_TRUE(analysis->Dominates(12, 77));
  EXPECT_TRUE(analysis->Dominates(12, 75));
  EXPECT_TRUE(analysis->Dominates(12, 106));
  EXPECT_TRUE(analysis->Dominates(12, 110));
  EXPECT_TRUE(analysis->Dominates(12, 107));
  EXPECT_TRUE(analysis->Dominates(12, 108));
  EXPECT_TRUE(analysis->Dominates(12, 109));
  EXPECT_TRUE(analysis->Dominates(12, 74));
  EXPECT_TRUE(analysis->Dominates(12, 86));
  EXPECT_TRUE(analysis->Dominates(12, 90));
  EXPECT_TRUE(analysis->Dominates(12, 87));
  EXPECT_TRUE(analysis->Dominates(12, 94));
  EXPECT_TRUE(analysis->Dominates(12, 98));
  EXPECT_TRUE(analysis->Dominates(12, 95));
  EXPECT_TRUE(analysis->Dominates(12, 97));
  EXPECT_TRUE(analysis->Dominates(12, 96));
  EXPECT_TRUE(analysis->Dominates(12, 88));
  EXPECT_TRUE(analysis->Dominates(12, 76));

  EXPECT_TRUE(analysis->Dominates(46, 50));
  EXPECT_TRUE(analysis->Dominates(46, 47));
  EXPECT_TRUE(analysis->Dominates(46, 57));
  EXPECT_TRUE(analysis->Dominates(46, 61));
  EXPECT_TRUE(analysis->Dominates(46, 59));
  EXPECT_TRUE(analysis->Dominates(46, 58));
  EXPECT_TRUE(analysis->Dominates(46, 60));
  EXPECT_TRUE(analysis->Dominates(46, 48));
  EXPECT_TRUE(analysis->Dominates(46, 73));
  EXPECT_TRUE(analysis->Dominates(46, 77));
  EXPECT_TRUE(analysis->Dominates(46, 75));
  EXPECT_TRUE(analysis->Dominates(46, 106));
  EXPECT_TRUE(analysis->Dominates(46, 110));
  EXPECT_TRUE(analysis->Dominates(46, 107));
  EXPECT_TRUE(analysis->Dominates(46, 108));
  EXPECT_TRUE(analysis->Dominates(46, 109));
  EXPECT_TRUE(analysis->Dominates(46, 74));
  EXPECT_TRUE(analysis->Dominates(46, 86));
  EXPECT_TRUE(analysis->Dominates(46, 90));
  EXPECT_TRUE(analysis->Dominates(46, 87));
  EXPECT_TRUE(analysis->Dominates(46, 94));
  EXPECT_TRUE(analysis->Dominates(46, 98));
  EXPECT_TRUE(analysis->Dominates(46, 95));
  EXPECT_TRUE(analysis->Dominates(46, 97));
  EXPECT_TRUE(analysis->Dominates(46, 96));
  EXPECT_TRUE(analysis->Dominates(46, 88));
  EXPECT_TRUE(analysis->Dominates(46, 76));

  EXPECT_TRUE(analysis->Dominates(50, 47));
  EXPECT_TRUE(analysis->Dominates(50, 57));
  EXPECT_TRUE(analysis->Dominates(50, 61));
  EXPECT_TRUE(analysis->Dominates(50, 59));
  EXPECT_TRUE(analysis->Dominates(50, 58));
  EXPECT_TRUE(analysis->Dominates(50, 60));

  EXPECT_TRUE(analysis->Dominates(47, 57));
  EXPECT_TRUE(analysis->Dominates(47, 61));
  EXPECT_TRUE(analysis->Dominates(47, 59));
  EXPECT_TRUE(analysis->Dominates(47, 58));
  EXPECT_TRUE(analysis->Dominates(47, 60));

  EXPECT_TRUE(analysis->Dominates(57, 61));
  EXPECT_TRUE(analysis->Dominates(57, 59));
  EXPECT_TRUE(analysis->Dominates(57, 58));
  EXPECT_TRUE(analysis->Dominates(57, 60));

  EXPECT_TRUE(analysis->Dominates(61, 59));

  EXPECT_TRUE(analysis->Dominates(48, 73));
  EXPECT_TRUE(analysis->Dominates(48, 77));
  EXPECT_TRUE(analysis->Dominates(48, 75));
  EXPECT_TRUE(analysis->Dominates(48, 106));
  EXPECT_TRUE(analysis->Dominates(48, 110));
  EXPECT_TRUE(analysis->Dominates(48, 107));
  EXPECT_TRUE(analysis->Dominates(48, 108));
  EXPECT_TRUE(analysis->Dominates(48, 109));
  EXPECT_TRUE(analysis->Dominates(48, 74));
  EXPECT_TRUE(analysis->Dominates(48, 86));
  EXPECT_TRUE(analysis->Dominates(48, 90));
  EXPECT_TRUE(analysis->Dominates(48, 87));
  EXPECT_TRUE(analysis->Dominates(48, 94));
  EXPECT_TRUE(analysis->Dominates(48, 98));
  EXPECT_TRUE(analysis->Dominates(48, 95));
  EXPECT_TRUE(analysis->Dominates(48, 97));
  EXPECT_TRUE(analysis->Dominates(48, 96));
  EXPECT_TRUE(analysis->Dominates(48, 88));
  EXPECT_TRUE(analysis->Dominates(48, 76));

  EXPECT_TRUE(analysis->Dominates(73, 77));
  EXPECT_TRUE(analysis->Dominates(73, 75));
  EXPECT_TRUE(analysis->Dominates(73, 106));
  EXPECT_TRUE(analysis->Dominates(73, 110));
  EXPECT_TRUE(analysis->Dominates(73, 107));
  EXPECT_TRUE(analysis->Dominates(73, 108));
  EXPECT_TRUE(analysis->Dominates(73, 109));
  EXPECT_TRUE(analysis->Dominates(73, 74));
  EXPECT_TRUE(analysis->Dominates(73, 86));
  EXPECT_TRUE(analysis->Dominates(73, 90));
  EXPECT_TRUE(analysis->Dominates(73, 87));
  EXPECT_TRUE(analysis->Dominates(73, 94));
  EXPECT_TRUE(analysis->Dominates(73, 98));
  EXPECT_TRUE(analysis->Dominates(73, 95));
  EXPECT_TRUE(analysis->Dominates(73, 97));
  EXPECT_TRUE(analysis->Dominates(73, 96));
  EXPECT_TRUE(analysis->Dominates(73, 88));
  EXPECT_TRUE(analysis->Dominates(73, 76));

  EXPECT_TRUE(analysis->Dominates(75, 106));
  EXPECT_TRUE(analysis->Dominates(75, 110));
  EXPECT_TRUE(analysis->Dominates(75, 107));
  EXPECT_TRUE(analysis->Dominates(75, 108));
  EXPECT_TRUE(analysis->Dominates(75, 109));

  EXPECT_TRUE(analysis->Dominates(106, 110));
  EXPECT_TRUE(analysis->Dominates(106, 107));
  EXPECT_TRUE(analysis->Dominates(106, 108));
  EXPECT_TRUE(analysis->Dominates(106, 109));

  EXPECT_TRUE(analysis->Dominates(110, 107));

  EXPECT_TRUE(analysis->Dominates(77, 74));
  EXPECT_TRUE(analysis->Dominates(77, 86));
  EXPECT_TRUE(analysis->Dominates(77, 90));
  EXPECT_TRUE(analysis->Dominates(77, 87));
  EXPECT_TRUE(analysis->Dominates(77, 94));
  EXPECT_TRUE(analysis->Dominates(77, 98));
  EXPECT_TRUE(analysis->Dominates(77, 95));
  EXPECT_TRUE(analysis->Dominates(77, 97));
  EXPECT_TRUE(analysis->Dominates(77, 96));
  EXPECT_TRUE(analysis->Dominates(77, 88));

  EXPECT_TRUE(analysis->Dominates(74, 86));
  EXPECT_TRUE(analysis->Dominates(74, 90));
  EXPECT_TRUE(analysis->Dominates(74, 87));
  EXPECT_TRUE(analysis->Dominates(74, 94));
  EXPECT_TRUE(analysis->Dominates(74, 98));
  EXPECT_TRUE(analysis->Dominates(74, 95));
  EXPECT_TRUE(analysis->Dominates(74, 97));
  EXPECT_TRUE(analysis->Dominates(74, 96));
  EXPECT_TRUE(analysis->Dominates(74, 88));

  EXPECT_TRUE(analysis->Dominates(86, 90));
  EXPECT_TRUE(analysis->Dominates(86, 87));
  EXPECT_TRUE(analysis->Dominates(86, 94));
  EXPECT_TRUE(analysis->Dominates(86, 98));
  EXPECT_TRUE(analysis->Dominates(86, 95));
  EXPECT_TRUE(analysis->Dominates(86, 97));
  EXPECT_TRUE(analysis->Dominates(86, 96));
  EXPECT_TRUE(analysis->Dominates(86, 88));

  EXPECT_TRUE(analysis->Dominates(90, 87));
  EXPECT_TRUE(analysis->Dominates(90, 94));
  EXPECT_TRUE(analysis->Dominates(90, 98));
  EXPECT_TRUE(analysis->Dominates(90, 95));
  EXPECT_TRUE(analysis->Dominates(90, 97));
  EXPECT_TRUE(analysis->Dominates(90, 96));

  EXPECT_TRUE(analysis->Dominates(87, 94));
  EXPECT_TRUE(analysis->Dominates(87, 98));
  EXPECT_TRUE(analysis->Dominates(87, 95));
  EXPECT_TRUE(analysis->Dominates(87, 97));
  EXPECT_TRUE(analysis->Dominates(87, 96));

  EXPECT_TRUE(analysis->Dominates(94, 98));
  EXPECT_TRUE(analysis->Dominates(94, 95));
  EXPECT_TRUE(analysis->Dominates(94, 97));
  EXPECT_TRUE(analysis->Dominates(94, 96));

  EXPECT_TRUE(analysis->Dominates(98, 95));

  EXPECT_TRUE(analysis->StrictlyDominates(5, 10));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 14));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 11));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 29));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 33));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 30));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 32));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 31));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 13));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 12));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 46));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 50));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 47));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 57));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 61));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 59));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 58));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 60));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 48));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 73));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 77));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 75));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 106));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 110));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 107));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 108));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 109));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 74));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 86));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 90));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 87));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 94));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 98));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 95));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 97));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 96));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 88));
  EXPECT_TRUE(analysis->StrictlyDominates(5, 76));

  EXPECT_TRUE(analysis->StrictlyDominates(10, 14));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 11));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 29));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 33));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 30));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 32));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 31));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 13));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 12));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 46));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 50));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 47));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 57));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 61));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 59));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 58));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 60));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 48));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 73));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 77));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 75));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 106));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 110));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 107));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 108));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 109));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 74));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 86));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 90));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 87));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 94));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 98));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 95));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 97));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 96));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 88));
  EXPECT_TRUE(analysis->StrictlyDominates(10, 76));

  EXPECT_TRUE(analysis->StrictlyDominates(14, 11));
  EXPECT_TRUE(analysis->StrictlyDominates(14, 29));
  EXPECT_TRUE(analysis->StrictlyDominates(14, 33));
  EXPECT_TRUE(analysis->StrictlyDominates(14, 30));
  EXPECT_TRUE(analysis->StrictlyDominates(14, 32));
  EXPECT_TRUE(analysis->StrictlyDominates(14, 31));

  EXPECT_TRUE(analysis->StrictlyDominates(11, 29));
  EXPECT_TRUE(analysis->StrictlyDominates(11, 33));
  EXPECT_TRUE(analysis->StrictlyDominates(11, 30));
  EXPECT_TRUE(analysis->StrictlyDominates(11, 32));
  EXPECT_TRUE(analysis->StrictlyDominates(11, 31));

  EXPECT_TRUE(analysis->StrictlyDominates(29, 33));
  EXPECT_TRUE(analysis->StrictlyDominates(29, 30));
  EXPECT_TRUE(analysis->StrictlyDominates(29, 32));
  EXPECT_TRUE(analysis->StrictlyDominates(29, 31));

  EXPECT_TRUE(analysis->StrictlyDominates(33, 30));

  EXPECT_TRUE(analysis->StrictlyDominates(12, 46));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 50));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 47));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 57));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 61));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 59));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 58));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 60));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 48));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 73));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 77));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 75));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 106));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 110));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 107));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 108));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 109));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 74));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 86));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 90));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 87));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 94));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 98));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 95));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 97));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 96));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 88));
  EXPECT_TRUE(analysis->StrictlyDominates(12, 76));

  EXPECT_TRUE(analysis->StrictlyDominates(46, 50));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 47));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 57));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 61));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 59));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 58));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 60));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 48));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 73));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 77));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 75));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 106));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 110));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 107));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 108));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 109));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 74));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 86));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 90));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 87));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 94));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 98));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 95));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 97));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 96));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 88));
  EXPECT_TRUE(analysis->StrictlyDominates(46, 76));

  EXPECT_TRUE(analysis->StrictlyDominates(50, 47));
  EXPECT_TRUE(analysis->StrictlyDominates(50, 57));
  EXPECT_TRUE(analysis->StrictlyDominates(50, 61));
  EXPECT_TRUE(analysis->StrictlyDominates(50, 59));
  EXPECT_TRUE(analysis->StrictlyDominates(50, 58));
  EXPECT_TRUE(analysis->StrictlyDominates(50, 60));

  EXPECT_TRUE(analysis->StrictlyDominates(47, 57));
  EXPECT_TRUE(analysis->StrictlyDominates(47, 61));
  EXPECT_TRUE(analysis->StrictlyDominates(47, 59));
  EXPECT_TRUE(analysis->StrictlyDominates(47, 58));
  EXPECT_TRUE(analysis->StrictlyDominates(47, 60));

  EXPECT_TRUE(analysis->StrictlyDominates(57, 61));
  EXPECT_TRUE(analysis->StrictlyDominates(57, 59));
  EXPECT_TRUE(analysis->StrictlyDominates(57, 58));
  EXPECT_TRUE(analysis->StrictlyDominates(57, 60));

  EXPECT_TRUE(analysis->StrictlyDominates(61, 59));

  EXPECT_TRUE(analysis->StrictlyDominates(48, 73));
  EXPECT_TRUE(analysis->StrictlyDominates(48, 77));
  EXPECT_TRUE(analysis->StrictlyDominates(48, 75));
  EXPECT_TRUE(analysis->StrictlyDominates(48, 106));
  EXPECT_TRUE(analysis->StrictlyDominates(48, 110));
  EXPECT_TRUE(analysis->StrictlyDominates(48, 107));
  EXPECT_TRUE(analysis->StrictlyDominates(48, 108));
  EXPECT_TRUE(analysis->StrictlyDominates(48, 109));
  EXPECT_TRUE(analysis->StrictlyDominates(48, 74));
  EXPECT_TRUE(analysis->StrictlyDominates(48, 86));
  EXPECT_TRUE(analysis->StrictlyDominates(48, 90));
  EXPECT_TRUE(analysis->StrictlyDominates(48, 87));
  EXPECT_TRUE(analysis->StrictlyDominates(48, 94));
  EXPECT_TRUE(analysis->StrictlyDominates(48, 98));
  EXPECT_TRUE(analysis->StrictlyDominates(48, 95));
  EXPECT_TRUE(analysis->StrictlyDominates(48, 97));
  EXPECT_TRUE(analysis->StrictlyDominates(48, 96));
  EXPECT_TRUE(analysis->StrictlyDominates(48, 88));
  EXPECT_TRUE(analysis->StrictlyDominates(48, 76));

  EXPECT_TRUE(analysis->StrictlyDominates(73, 77));
  EXPECT_TRUE(analysis->StrictlyDominates(73, 75));
  EXPECT_TRUE(analysis->StrictlyDominates(73, 106));
  EXPECT_TRUE(analysis->StrictlyDominates(73, 110));
  EXPECT_TRUE(analysis->StrictlyDominates(73, 107));
  EXPECT_TRUE(analysis->StrictlyDominates(73, 108));
  EXPECT_TRUE(analysis->StrictlyDominates(73, 109));
  EXPECT_TRUE(analysis->StrictlyDominates(73, 74));
  EXPECT_TRUE(analysis->StrictlyDominates(73, 86));
  EXPECT_TRUE(analysis->StrictlyDominates(73, 90));
  EXPECT_TRUE(analysis->StrictlyDominates(73, 87));
  EXPECT_TRUE(analysis->StrictlyDominates(73, 94));
  EXPECT_TRUE(analysis->StrictlyDominates(73, 98));
  EXPECT_TRUE(analysis->StrictlyDominates(73, 95));
  EXPECT_TRUE(analysis->StrictlyDominates(73, 97));
  EXPECT_TRUE(analysis->StrictlyDominates(73, 96));
  EXPECT_TRUE(analysis->StrictlyDominates(73, 88));
  EXPECT_TRUE(analysis->StrictlyDominates(73, 76));

  EXPECT_TRUE(analysis->StrictlyDominates(75, 106));
  EXPECT_TRUE(analysis->StrictlyDominates(75, 110));
  EXPECT_TRUE(analysis->StrictlyDominates(75, 107));
  EXPECT_TRUE(analysis->StrictlyDominates(75, 108));
  EXPECT_TRUE(analysis->StrictlyDominates(75, 109));

  EXPECT_TRUE(analysis->StrictlyDominates(106, 110));
  EXPECT_TRUE(analysis->StrictlyDominates(106, 107));
  EXPECT_TRUE(analysis->StrictlyDominates(106, 108));
  EXPECT_TRUE(analysis->StrictlyDominates(106, 109));

  EXPECT_TRUE(analysis->StrictlyDominates(110, 107));

  EXPECT_TRUE(analysis->StrictlyDominates(77, 74));
  EXPECT_TRUE(analysis->StrictlyDominates(77, 86));
  EXPECT_TRUE(analysis->StrictlyDominates(77, 90));
  EXPECT_TRUE(analysis->StrictlyDominates(77, 87));
  EXPECT_TRUE(analysis->StrictlyDominates(77, 94));
  EXPECT_TRUE(analysis->StrictlyDominates(77, 98));
  EXPECT_TRUE(analysis->StrictlyDominates(77, 95));
  EXPECT_TRUE(analysis->StrictlyDominates(77, 97));
  EXPECT_TRUE(analysis->StrictlyDominates(77, 96));
  EXPECT_TRUE(analysis->StrictlyDominates(77, 88));

  EXPECT_TRUE(analysis->StrictlyDominates(74, 86));
  EXPECT_TRUE(analysis->StrictlyDominates(74, 90));
  EXPECT_TRUE(analysis->StrictlyDominates(74, 87));
  EXPECT_TRUE(analysis->StrictlyDominates(74, 94));
  EXPECT_TRUE(analysis->StrictlyDominates(74, 98));
  EXPECT_TRUE(analysis->StrictlyDominates(74, 95));
  EXPECT_TRUE(analysis->StrictlyDominates(74, 97));
  EXPECT_TRUE(analysis->StrictlyDominates(74, 96));
  EXPECT_TRUE(analysis->StrictlyDominates(74, 88));

  EXPECT_TRUE(analysis->StrictlyDominates(86, 90));
  EXPECT_TRUE(analysis->StrictlyDominates(86, 87));
  EXPECT_TRUE(analysis->StrictlyDominates(86, 94));
  EXPECT_TRUE(analysis->StrictlyDominates(86, 98));
  EXPECT_TRUE(analysis->StrictlyDominates(86, 95));
  EXPECT_TRUE(analysis->StrictlyDominates(86, 97));
  EXPECT_TRUE(analysis->StrictlyDominates(86, 96));
  EXPECT_TRUE(analysis->StrictlyDominates(86, 88));

  EXPECT_TRUE(analysis->StrictlyDominates(90, 87));
  EXPECT_TRUE(analysis->StrictlyDominates(90, 94));
  EXPECT_TRUE(analysis->StrictlyDominates(90, 98));
  EXPECT_TRUE(analysis->StrictlyDominates(90, 95));
  EXPECT_TRUE(analysis->StrictlyDominates(90, 97));
  EXPECT_TRUE(analysis->StrictlyDominates(90, 96));

  EXPECT_TRUE(analysis->StrictlyDominates(87, 94));
  EXPECT_TRUE(analysis->StrictlyDominates(87, 98));
  EXPECT_TRUE(analysis->StrictlyDominates(87, 95));
  EXPECT_TRUE(analysis->StrictlyDominates(87, 97));
  EXPECT_TRUE(analysis->StrictlyDominates(87, 96));

  EXPECT_TRUE(analysis->StrictlyDominates(94, 98));
  EXPECT_TRUE(analysis->StrictlyDominates(94, 95));
  EXPECT_TRUE(analysis->StrictlyDominates(94, 97));
  EXPECT_TRUE(analysis->StrictlyDominates(94, 96));

  EXPECT_TRUE(analysis->StrictlyDominates(98, 95));
}

}  // namespace
}  // namespace opt
}  // namespace spvtools