text:
package mesosphere.marathon

import java.util.concurrent.atomic.AtomicBoolean

import akka.event.EventStream
import com.codahale.metrics.MetricRegistry
import com.twitter.common.zookeeper.Candidate
import mesosphere.marathon.metrics.Metrics
import org.mockito.Mockito
import org.scalatest.{Matchers, GivenWhenThen}

class MarathonLeaderInfoTest extends MarathonSpec with GivenWhenThen with Matchers
{
  class Fixture {
    lazy val candidate = mock[Candidate]
    lazy val maybeCandidate = Some(candidate)
    lazy val leader = new AtomicBoolean(false)
    lazy val eventStream = new EventStream()
    lazy val metrics = new MarathonLeaderInfoMetrics(new Metrics(new MetricRegistry))
    lazy val leaderInfo = new MarathonLeaderInfo(maybeCandidate, leader, eventStream, metrics)

    def verifyNoMoreInteractions(): Unit = {
      Mockito.verifyNoMoreInteractions(candidate)
    }
  }

  test("currentLeaderHostPort handles exceptions and returns None") {
    Given("a leaderInfo with a candidate which throws exceptions")
    val f = new Fixture
    Mockito
      .when(f.candidate.getLeaderData)
      .thenThrow(new RuntimeException("test failure!"))

    When("querying for currentLeaderHostPort")
    val currentLeaderHostPort = f.leaderInfo.currentLeaderHostPort()

    Then("it should return none")
    currentLeaderHostPort should be(None)
  }
}

redpajama_set_name: RedPajamaGithub


text:
package org.xworker.lang;

import xworker.lang.executor.Executor;

public class TestExecutor {
	public static void main(String[] args) {
		Executor.info("Test", "Hello world!");

	}
}


text:
RSpec.configure do |config|
  config.before(:suite) do
    DatabaseCleaner[:mongoid].strategy = :truncation
  end

  config.before(:each) do
    DatabaseCleaner.strategy = :truncation
    DatabaseCleaner.start
  end

  config.after(:each) do
    DatabaseCleaner.clean
  end
end


text:
<?php
namespace Xaamin\Hashing;

class Random
{
    /**
     * Create a random string .
     *
     * @param  int $length
     * @return string
     */
    public static function string($length)
    {
        if ($salt = static::openssl($length)) {
            return $salt;
        }

        if ($salt = static::mcrypt($length)) {
            return $salt;
        }

        return static::random($length);
    }

    /**
     * Open SSL random string generator
     *
     * @param  int $length
     * @return string|null
     */
    protected static function openssl($length)
    {
        if(function_exists('openssl_random_pseudo_bytes'))
        {
            return substr(bin2hex(openssl_random_pseudo_bytes($length)), 0, $length);
        }

        return null;
    }

    /**
     * MCrypt random string generator
     *
     * @param  int $length
     * @return string|null
     */
    protected static function mcrypt($length)
    {
        if(function_exists('mcrypt_create_iv'))
        {
            $salt = mcrypt_create_iv($length, static::getRandomizer());

            $salt = base64_encode($salt);
            $salt = substr(str_replace('+', '.', $salt), 0, $length);

            return $salt;
        }

        return null;
    }

    /**
     * Random string generator
     *
     * @param  int $length
     * @return string
     */
    public function random($length)
    {
        $pool = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

        return substr(str_shuffle(str_repeat($pool, 5)), 0, $length);
    }

    /**
     * Get the most secure random number generator for the system.
     *
     * @return int
     */
    protected static function getRandomizer()
    {
        // There are various sources from which we can get random numbers
        // but some are more random than others. We'll choose the most
        // random source we can for this server environment.
        if (defined('MCRYPT_DEV_URANDOM'))
        {
            return MCRYPT_DEV_URANDOM;
        }
        elseif (defined('MCRYPT_DEV_RANDOM'))
        {
            return MCRYPT_DEV_RANDOM;
        }
        // When using the default random number generator, we'll seed
        // the generator on each call to ensure the results are as
        // random as we can possibly get them.
        else
        {
            mt_srand();

            return MCRYPT_RAND;
        }
    }
}


text:
package org.traccar.api.resource;

import org.traccar.Context;
import org.traccar.api.BaseObjectResource;
import org.traccar.database.UsersManager;
import org.traccar.helper.LogAction;
import org.traccar.model.ManagedUser;
import org.traccar.model.User;

import javax.annotation.security.PermitAll;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.sql.SQLException;
import java.util.Collection;
import java.util.Date;
import java.util.Set;

@Path("users")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class UserResource extends BaseObjectResource<User> {

    public UserResource() {
        super(User.class);
    }

    @GET
    public Collection<User> get(@QueryParam("userId") long userId) throws SQLException {
        UsersManager usersManager = Context.getUsersManager();
        Set<Long> result = null;
        if (Context.getPermissionsManager().getUserAdmin(getUserId())) {
            if (userId != 0) {
                result = usersManager.getUserItems(userId);
            } else {
                result = usersManager.getAllItems();
            }
        } else if (Context.getPermissionsManager().getUserManager(getUserId())) {
            result = usersManager.getManagedItems(getUserId());
        } else {
            throw new SecurityException("Admin or manager access required");
        }
        return usersManager.getItems(result);
    }

    @Override
    @PermitAll
    @POST
    public Response add(User entity) throws SQLException {
        if (!Context.getPermissionsManager().getUserAdmin(getUserId())) {
            Context.getPermissionsManager().checkUserUpdate(getUserId(), new User(), entity);
            if (Context.getPermissionsManager().getUserManager(getUserId())) {
                Context.getPermissionsManager().checkUserLimit(getUserId());
            } else {
                Context.getPermissionsManager().checkRegistration(getUserId());
                entity.setDeviceLimit(Context.getConfig().getInteger("users.defaultDeviceLimit", -1));
                int expirationDays = Context.getConfig().getInteger("users.defaultExpirationDays");
                if (expirationDays > 0) {
                    entity.setExpirationTime(
                        new Date(System.currentTimeMillis() + (long) expirationDays * 24 * 3600 * 1000));
                }
            }
        }
        Context.getUsersManager().addItem(entity);
        LogAction.create(getUserId(), entity);
        if (Context.getPermissionsManager().getUserManager(getUserId())) {
            Context.getDataManager().linkObject(User.class, getUserId(), ManagedUser.class, entity.getId(), true);
            LogAction.link(getUserId(), User.class, getUserId(), ManagedUser.class, entity.getId());
        }
        Context.getUsersManager().refreshUserItems();
        return Response.ok(entity).build();
    }

}


text:
using Frame_UriMapper.Resources;

namespace Frame_UriMapper
{
    /// <summary>
    /// Provides access to string resources.
    /// </summary>
    public class LocalizedStrings
    {
        private static AppResources _localizedResources = new AppResources();

        public AppResources LocalizedResources { get { return _localizedResources; } }
    }
}


text:
layout: page
title: Cowan Group Executive Retreat
date: 2016-05-24
author: Billy Keith
tags: weekly links, java
status: published
summary: Suspendisse tincidunt gravida arcu, sed interdum lectus.
banner: images/banner/people.jpg
booking:
  startDate: 02/19/2019
  endDate: 02/22/2019
  ctyhocn: SLDCOHX
  groupCode: CGER
published: true
---
Duis egestas rutrum rutrum. Nulla facilisi. Integer hendrerit non augue vel pellentesque. Sed rhoncus sollicitudin nunc id suscipit. Nulla rhoncus lectus nisl. Sed id lacus ut turpis aliquam ornare. Aenean condimentum molestie nisi, vitae accumsan lectus bibendum vitae. In imperdiet lectus ultrices ligula viverra, sed semper lacus malesuada. Duis auctor congue mi eget vestibulum. Duis posuere mauris eget aliquam efficitur. Aliquam eget nibh odio. Quisque sed interdum dolor, nec venenatis eros.
Curabitur rutrum finibus libero non lacinia. Cras cursus auctor velit, id cursus lacus accumsan in. Sed molestie libero eget risus aliquet, nec facilisis sapien mattis. Donec tempor ligula et sodales venenatis. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Nulla in fermentum magna. Quisque neque justo, varius id urna non, interdum pellentesque ligula. Maecenas ac aliquam lorem. Sed risus lorem, varius a euismod id, tempor at augue. Nam venenatis id lorem commodo pulvinar. Quisque iaculis mauris nisl, ac semper elit commodo vitae. Quisque semper elit enim, at mattis justo feugiat porttitor.

* Nullam iaculis lorem sit amet sapien fermentum, feugiat interdum lectus tincidunt.

Nullam mattis velit vitae diam mattis sagittis. Sed vel velit sit amet risus iaculis finibus ut eget nibh. Nam tincidunt ut dolor non dictum. Praesent dui orci, elementum et tempus at, cursus at erat. In lobortis, ligula sit amet pulvinar pharetra, magna dolor pulvinar arcu, et cursus nunc nunc non eros. Maecenas finibus tincidunt dolor, a bibendum justo pellentesque quis. Quisque ut pulvinar orci. Donec rutrum tortor sit amet ligula lobortis, ac elementum metus pulvinar.


text:
extern "C" {

// CL 1.0
cl_int CL_API_ENTRY CL_GetPlatformIDs(cl_uint num_entries,
                                      cl_platform_id *platforms,
                                      cl_uint *num_platforms)
{
    CL_EVENT(GetPlatformIDs,
             "num_entries = %u, platforms = 0x%016" PRIxPTR ", num_platforms = 0x%016" PRIxPTR "",
             num_entries, (uintptr_t)platforms, (uintptr_t)num_platforms);

    // TODO: GetPlatformIDs

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_GetPlatformInfo(cl_platform_id platform,
                                       cl_platform_info param_name,
                                       size_t param_value_size,
                                       void *param_value,
                                       size_t *param_value_size_ret)
{
    CL_EVENT(GetPlatformInfo,
             "platform = 0x%016" PRIxPTR
             ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
             ", param_value_size_ret = 0x%016" PRIxPTR "",
             (uintptr_t)platform, param_name, param_value_size, (uintptr_t)param_value,
             (uintptr_t)param_value_size_ret);

    // TODO: GetPlatformInfo

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_GetDeviceIDs(cl_platform_id platform,
                                    cl_device_type device_type,
                                    cl_uint num_entries,
                                    cl_device_id *devices,
                                    cl_uint *num_devices)
{
    CL_EVENT(GetDeviceIDs,
             "platform = 0x%016" PRIxPTR
             ", device_type = %lu, num_entries = %u, devices = 0x%016" PRIxPTR
             ", num_devices = 0x%016" PRIxPTR "",
             (uintptr_t)platform, device_type, num_entries, (uintptr_t)devices,
             (uintptr_t)num_devices);

    // TODO: GetDeviceIDs

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_GetDeviceInfo(cl_device_id device,
                                     cl_device_info param_name,
                                     size_t param_value_size,
                                     void *param_value,
                                     size_t *param_value_size_ret)
{
    CL_EVENT(GetDeviceInfo,
             "device = 0x%016" PRIxPTR
             ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
             ", param_value_size_ret = 0x%016" PRIxPTR "",
             (uintptr_t)device, param_name, param_value_size, (uintptr_t)param_value,
             (uintptr_t)param_value_size_ret);

    // TODO: GetDeviceInfo

    return (cl_int)0;
}

cl_context CL_API_ENTRY CL_CreateContext(const cl_context_properties *properties,
                                         cl_uint num_devices,
                                         const cl_device_id *devices,
                                         void(CL_CALLBACK *pfn_notify)(const char *errinfo,
                                                                       const void *private_info,
                                                                       size_t cb,
                                                                       void *user_data),
                                         void *user_data,
                                         cl_int *errcode_ret)
{
    CL_EVENT(CreateContext,
             "properties = 0x%016" PRIxPTR ", num_devices = %u, devices = 0x%016" PRIxPTR
             ", pfn_notify = 0x%016" PRIxPTR ", user_data = 0x%016" PRIxPTR
             ", errcode_ret = 0x%016" PRIxPTR "",
             (uintptr_t)properties, num_devices, (uintptr_t)devices, (uintptr_t)pfn_notify,
             (uintptr_t)user_data, (uintptr_t)errcode_ret);

    // TODO: CreateContext

    return (cl_context)0;
}

cl_context CL_API_ENTRY
CL_CreateContextFromType(const cl_context_properties *properties,
                         cl_device_type device_type,
                         void(CL_CALLBACK *pfn_notify)(const char *errinfo,
                                                       const void *private_info,
                                                       size_t cb,
                                                       void *user_data),
                         void *user_data,
                         cl_int *errcode_ret)
{
    CL_EVENT(CreateContextFromType,
             "properties = 0x%016" PRIxPTR ", device_type = %lu, pfn_notify = 0x%016" PRIxPTR
             ", user_data = 0x%016" PRIxPTR ", errcode_ret = 0x%016" PRIxPTR "",
             (uintptr_t)properties, device_type, (uintptr_t)pfn_notify, (uintptr_t)user_data,
             (uintptr_t)errcode_ret);

    // TODO: CreateContextFromType

    return (cl_context)0;
}

cl_int CL_API_ENTRY CL_RetainContext(cl_context context)
{
    CL_EVENT(RetainContext, "context = 0x%016" PRIxPTR "", (uintptr_t)context);

    // TODO: RetainContext

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_ReleaseContext(cl_context context)
{
    CL_EVENT(ReleaseContext, "context = 0x%016" PRIxPTR "", (uintptr_t)context);

    // TODO: ReleaseContext

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_GetContextInfo(cl_context context,
                                      cl_context_info param_name,
                                      size_t param_value_size,
                                      void *param_value,
                                      size_t *param_value_size_ret)
{
    CL_EVENT(GetContextInfo,
             "context = 0x%016" PRIxPTR
             ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
             ", param_value_size_ret = 0x%016" PRIxPTR "",
             (uintptr_t)context, param_name, param_value_size, (uintptr_t)param_value,
             (uintptr_t)param_value_size_ret);

    // TODO: GetContextInfo

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_RetainCommandQueue(cl_command_queue command_queue)
{
    CL_EVENT(RetainCommandQueue, "command_queue = 0x%016" PRIxPTR "", (uintptr_t)command_queue);

    // TODO: RetainCommandQueue

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_ReleaseCommandQueue(cl_command_queue command_queue)
{
    CL_EVENT(ReleaseCommandQueue, "command_queue = 0x%016" PRIxPTR "", (uintptr_t)command_queue);

    // TODO: ReleaseCommandQueue

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_GetCommandQueueInfo(cl_command_queue command_queue,
                                           cl_command_queue_info param_name,
                                           size_t param_value_size,
                                           void *param_value,
                                           size_t *param_value_size_ret)
{
    CL_EVENT(GetCommandQueueInfo,
             "command_queue = 0x%016" PRIxPTR
             ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
             ", param_value_size_ret = 0x%016" PRIxPTR "",
             (uintptr_t)command_queue, param_name, param_value_size, (uintptr_t)param_value,
             (uintptr_t)param_value_size_ret);

    // TODO: GetCommandQueueInfo

    return (cl_int)0;
}

cl_mem CL_API_ENTRY CL_CreateBuffer(cl_context context,
                                    cl_mem_flags flags,
                                    size_t size,
                                    void *host_ptr,
                                    cl_int *errcode_ret)
{
    CL_EVENT(CreateBuffer,
             "context = 0x%016" PRIxPTR ", flags = %lu, size = %zu, host_ptr = 0x%016" PRIxPTR
             ", errcode_ret = 0x%016" PRIxPTR "",
             (uintptr_t)context, flags, size, (uintptr_t)host_ptr, (uintptr_t)errcode_ret);

    // TODO: CreateBuffer

    return (cl_mem)0;
}

cl_int CL_API_ENTRY CL_RetainMemObject(cl_mem memobj)
{
    CL_EVENT(RetainMemObject, "memobj = 0x%016" PRIxPTR "", (uintptr_t)memobj);

    // TODO: RetainMemObject

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_ReleaseMemObject(cl_mem memobj)
{
    CL_EVENT(ReleaseMemObject, "memobj = 0x%016" PRIxPTR "", (uintptr_t)memobj);

    // TODO: ReleaseMemObject

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_GetSupportedImageFormats(cl_context context,
                                                cl_mem_flags flags,
                                                cl_mem_object_type image_type,
                                                cl_uint num_entries,
                                                cl_image_format *image_formats,
                                                cl_uint *num_image_formats)
{
    CL_EVENT(GetSupportedImageFormats,
             "context = 0x%016" PRIxPTR
             ", flags = %lu, image_type = %u, num_entries = %u, image_formats = 0x%016" PRIxPTR
             ", num_image_formats = 0x%016" PRIxPTR "",
             (uintptr_t)context, flags, image_type, num_entries, (uintptr_t)image_formats,
             (uintptr_t)num_image_formats);

    // TODO: GetSupportedImageFormats

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_GetMemObjectInfo(cl_mem memobj,
                                        cl_mem_info param_name,
                                        size_t param_value_size,
                                        void *param_value,
                                        size_t *param_value_size_ret)
{
    CL_EVENT(GetMemObjectInfo,
             "memobj = 0x%016" PRIxPTR
             ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
             ", param_value_size_ret = 0x%016" PRIxPTR "",
             (uintptr_t)memobj, param_name, param_value_size, (uintptr_t)param_value,
             (uintptr_t)param_value_size_ret);

    // TODO: GetMemObjectInfo

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_GetImageInfo(cl_mem image,
                                    cl_image_info param_name,
                                    size_t param_value_size,
                                    void *param_value,
                                    size_t *param_value_size_ret)
{
    CL_EVENT(GetImageInfo,
             "image = 0x%016" PRIxPTR
             ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
             ", param_value_size_ret = 0x%016" PRIxPTR "",
             (uintptr_t)image, param_name, param_value_size, (uintptr_t)param_value,
             (uintptr_t)param_value_size_ret);

    // TODO: GetImageInfo

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_RetainSampler(cl_sampler sampler)
{
    CL_EVENT(RetainSampler, "sampler = 0x%016" PRIxPTR "", (uintptr_t)sampler);

    // TODO: RetainSampler

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_ReleaseSampler(cl_sampler sampler)
{
    CL_EVENT(ReleaseSampler, "sampler = 0x%016" PRIxPTR "", (uintptr_t)sampler);

    // TODO: ReleaseSampler

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_GetSamplerInfo(cl_sampler sampler,
                                      cl_sampler_info param_name,
                                      size_t param_value_size,
                                      void *param_value,
                                      size_t *param_value_size_ret)
{
    CL_EVENT(GetSamplerInfo,
             "sampler = 0x%016" PRIxPTR
             ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
             ", param_value_size_ret = 0x%016" PRIxPTR "",
             (uintptr_t)sampler, param_name, param_value_size, (uintptr_t)param_value,
             (uintptr_t)param_value_size_ret);

    // TODO: GetSamplerInfo

    return (cl_int)0;
}

cl_program CL_API_ENTRY CL_CreateProgramWithSource(cl_context context,
                                                   cl_uint count,
                                                   const char **strings,
                                                   const size_t *lengths,
                                                   cl_int *errcode_ret)
{
    CL_EVENT(CreateProgramWithSource,
             "context = 0x%016" PRIxPTR ", count = %u, strings = 0x%016" PRIxPTR
             ", lengths = 0x%016" PRIxPTR ", errcode_ret = 0x%016" PRIxPTR "",
             (uintptr_t)context, count, (uintptr_t)strings, (uintptr_t)lengths,
             (uintptr_t)errcode_ret);

    // TODO: CreateProgramWithSource

    return (cl_program)0;
}

cl_program CL_API_ENTRY CL_CreateProgramWithBinary(cl_context context,
                                                   cl_uint num_devices,
                                                   const cl_device_id *device_list,
                                                   const size_t *lengths,
                                                   const unsigned char **binaries,
                                                   cl_int *binary_status,
                                                   cl_int *errcode_ret)
{
    CL_EVENT(CreateProgramWithBinary,
             "context = 0x%016" PRIxPTR ", num_devices = %u, device_list = 0x%016" PRIxPTR
             ", lengths = 0x%016" PRIxPTR ", binaries = 0x%016" PRIxPTR
             ", binary_status = 0x%016" PRIxPTR ", errcode_ret = 0x%016" PRIxPTR "",
             (uintptr_t)context, num_devices, (uintptr_t)device_list, (uintptr_t)lengths,
             (uintptr_t)binaries, (uintptr_t)binary_status, (uintptr_t)errcode_ret);

    // TODO: CreateProgramWithBinary

    return (cl_program)0;
}

cl_int CL_API_ENTRY CL_RetainProgram(cl_program program)
{
    CL_EVENT(RetainProgram, "program = 0x%016" PRIxPTR "", (uintptr_t)program);

    // TODO: RetainProgram

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_ReleaseProgram(cl_program program)
{
    CL_EVENT(ReleaseProgram, "program = 0x%016" PRIxPTR "", (uintptr_t)program);

    // TODO: ReleaseProgram

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_BuildProgram(cl_program program,
                                    cl_uint num_devices,
                                    const cl_device_id *device_list,
                                    const char *options,
                                    void(CL_CALLBACK *pfn_notify)(cl_program program,
                                                                  void *user_data),
                                    void *user_data)
{
    CL_EVENT(BuildProgram,
             "program = 0x%016" PRIxPTR ", num_devices = %u, device_list = 0x%016" PRIxPTR
             ", options = 0x%016" PRIxPTR ", pfn_notify = 0x%016" PRIxPTR
             ", user_data = 0x%016" PRIxPTR "",
             (uintptr_t)program, num_devices, (uintptr_t)device_list, (uintptr_t)options,
             (uintptr_t)pfn_notify, (uintptr_t)user_data);

    // TODO: BuildProgram

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_GetProgramInfo(cl_program program,
                                      cl_program_info param_name,
                                      size_t param_value_size,
                                      void *param_value,
                                      size_t *param_value_size_ret)
{
    CL_EVENT(GetProgramInfo,
             "program = 0x%016" PRIxPTR
             ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
             ", param_value_size_ret = 0x%016" PRIxPTR "",
             (uintptr_t)program, param_name, param_value_size, (uintptr_t)param_value,
             (uintptr_t)param_value_size_ret);

    // TODO: GetProgramInfo

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_GetProgramBuildInfo(cl_program program,
                                           cl_device_id device,
                                           cl_program_build_info param_name,
                                           size_t param_value_size,
                                           void *param_value,
                                           size_t *param_value_size_ret)
{
    CL_EVENT(GetProgramBuildInfo,
             "program = 0x%016" PRIxPTR ", device = 0x%016" PRIxPTR
             ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
             ", param_value_size_ret = 0x%016" PRIxPTR "",
             (uintptr_t)program, (uintptr_t)device, param_name, param_value_size,
             (uintptr_t)param_value, (uintptr_t)param_value_size_ret);

    // TODO: GetProgramBuildInfo

    return (cl_int)0;
}

cl_kernel CL_API_ENTRY CL_CreateKernel(cl_program program,
                                       const char *kernel_name,
                                       cl_int *errcode_ret)
{
    CL_EVENT(CreateKernel,
             "program = 0x%016" PRIxPTR ", kernel_name = 0x%016" PRIxPTR
             ", errcode_ret = 0x%016" PRIxPTR "",
             (uintptr_t)program, (uintptr_t)kernel_name, (uintptr_t)errcode_ret);

    // TODO: CreateKernel

    return (cl_kernel)0;
}

cl_int CL_API_ENTRY CL_CreateKernelsInProgram(cl_program program,
                                              cl_uint num_kernels,
                                              cl_kernel *kernels,
                                              cl_uint *num_kernels_ret)
{
    CL_EVENT(CreateKernelsInProgram,
             "program = 0x%016" PRIxPTR ", num_kernels = %u, kernels = 0x%016" PRIxPTR
             ", num_kernels_ret = 0x%016" PRIxPTR "",
             (uintptr_t)program, num_kernels, (uintptr_t)kernels, (uintptr_t)num_kernels_ret);

    // TODO: CreateKernelsInProgram

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_RetainKernel(cl_kernel kernel)
{
    CL_EVENT(RetainKernel, "kernel = 0x%016" PRIxPTR "", (uintptr_t)kernel);

    // TODO: RetainKernel

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_ReleaseKernel(cl_kernel kernel)
{
    CL_EVENT(ReleaseKernel, "kernel = 0x%016" PRIxPTR "", (uintptr_t)kernel);

    // TODO: ReleaseKernel

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_SetKernelArg(cl_kernel kernel,
                                    cl_uint arg_index,
                                    size_t arg_size,
                                    const void *arg_value)
{
    CL_EVENT(SetKernelArg,
             "kernel = 0x%016" PRIxPTR
             ", arg_index = %u, arg_size = %zu, arg_value = 0x%016" PRIxPTR "",
             (uintptr_t)kernel, arg_index, arg_size, (uintptr_t)arg_value);

    // TODO: SetKernelArg

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_GetKernelInfo(cl_kernel kernel,
                                     cl_kernel_info param_name,
                                     size_t param_value_size,
                                     void *param_value,
                                     size_t *param_value_size_ret)
{
    CL_EVENT(GetKernelInfo,
             "kernel = 0x%016" PRIxPTR
             ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
             ", param_value_size_ret = 0x%016" PRIxPTR "",
             (uintptr_t)kernel, param_name, param_value_size, (uintptr_t)param_value,
             (uintptr_t)param_value_size_ret);

    // TODO: GetKernelInfo

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_GetKernelWorkGroupInfo(cl_kernel kernel,
                                              cl_device_id device,
                                              cl_kernel_work_group_info param_name,
                                              size_t param_value_size,
                                              void *param_value,
                                              size_t *param_value_size_ret)
{
    CL_EVENT(GetKernelWorkGroupInfo,
             "kernel = 0x%016" PRIxPTR ", device = 0x%016" PRIxPTR
             ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
             ", param_value_size_ret = 0x%016" PRIxPTR "",
             (uintptr_t)kernel, (uintptr_t)device, param_name, param_value_size,
             (uintptr_t)param_value, (uintptr_t)param_value_size_ret);

    // TODO: GetKernelWorkGroupInfo

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_WaitForEvents(cl_uint num_events, const cl_event *event_list)
{
    CL_EVENT(WaitForEvents, "num_events = %u, event_list = 0x%016" PRIxPTR "", num_events,
             (uintptr_t)event_list);

    // TODO: WaitForEvents

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_GetEventInfo(cl_event event,
                                    cl_event_info param_name,
                                    size_t param_value_size,
                                    void *param_value,
                                    size_t *param_value_size_ret)
{
    CL_EVENT(GetEventInfo,
             "event = 0x%016" PRIxPTR
             ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
             ", param_value_size_ret = 0x%016" PRIxPTR "",
             (uintptr_t)event, param_name, param_value_size, (uintptr_t)param_value,
             (uintptr_t)param_value_size_ret);

    // TODO: GetEventInfo

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_RetainEvent(cl_event event)
{
    CL_EVENT(RetainEvent, "event = 0x%016" PRIxPTR "", (uintptr_t)event);

    // TODO: RetainEvent

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_ReleaseEvent(cl_event event)
{
    CL_EVENT(ReleaseEvent, "event = 0x%016" PRIxPTR "", (uintptr_t)event);

    // TODO: ReleaseEvent

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_GetEventProfilingInfo(cl_event event,
                                             cl_profiling_info param_name,
                                             size_t param_value_size,
                                             void *param_value,
                                             size_t *param_value_size_ret)
{
    CL_EVENT(GetEventProfilingInfo,
             "event = 0x%016" PRIxPTR
             ", param_name = %u, param_value_size = %zu, param_value = 0x%016" PRIxPTR
             ", param_value_size_ret = 0x%016" PRIxPTR "",
             (uintptr_t)event, param_name, param_value_size, (uintptr_t)param_value,
             (uintptr_t)param_value_size_ret);

    // TODO: GetEventProfilingInfo

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_Flush(cl_command_queue command_queue)
{
    CL_EVENT(Flush, "command_queue = 0x%016" PRIxPTR "", (uintptr_t)command_queue);

    // TODO: Flush

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_Finish(cl_command_queue command_queue)
{
    CL_EVENT(Finish, "command_queue = 0x%016" PRIxPTR "", (uintptr_t)command_queue);

    // TODO: Finish

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_EnqueueReadBuffer(cl_command_queue command_queue,
                                         cl_mem buffer,
                                         cl_bool blocking_read,
                                         size_t offset,
                                         size_t size,
                                         void *ptr,
                                         cl_uint num_events_in_wait_list,
                                         const cl_event *event_wait_list,
                                         cl_event *event)
{
    CL_EVENT(EnqueueReadBuffer,
             "command_queue = 0x%016" PRIxPTR ", buffer = 0x%016" PRIxPTR
             ", blocking_read = %u, offset = %zu, size = %zu, ptr = 0x%016" PRIxPTR
             ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
             ", event = 0x%016" PRIxPTR "",
             (uintptr_t)command_queue, (uintptr_t)buffer, blocking_read, offset, size,
             (uintptr_t)ptr, num_events_in_wait_list, (uintptr_t)event_wait_list, (uintptr_t)event);

    // TODO: EnqueueReadBuffer

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_EnqueueWriteBuffer(cl_command_queue command_queue,
                                          cl_mem buffer,
                                          cl_bool blocking_write,
                                          size_t offset,
                                          size_t size,
                                          const void *ptr,
                                          cl_uint num_events_in_wait_list,
                                          const cl_event *event_wait_list,
                                          cl_event *event)
{
    CL_EVENT(EnqueueWriteBuffer,
             "command_queue = 0x%016" PRIxPTR ", buffer = 0x%016" PRIxPTR
             ", blocking_write = %u, offset = %zu, size = %zu, ptr = 0x%016" PRIxPTR
             ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
             ", event = 0x%016" PRIxPTR "",
             (uintptr_t)command_queue, (uintptr_t)buffer, blocking_write, offset, size,
             (uintptr_t)ptr, num_events_in_wait_list, (uintptr_t)event_wait_list, (uintptr_t)event);

    // TODO: EnqueueWriteBuffer

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_EnqueueCopyBuffer(cl_command_queue command_queue,
                                         cl_mem src_buffer,
                                         cl_mem dst_buffer,
                                         size_t src_offset,
                                         size_t dst_offset,
                                         size_t size,
                                         cl_uint num_events_in_wait_list,
                                         const cl_event *event_wait_list,
                                         cl_event *event)
{
    CL_EVENT(EnqueueCopyBuffer,
             "command_queue = 0x%016" PRIxPTR ", src_buffer = 0x%016" PRIxPTR
             ", dst_buffer = 0x%016" PRIxPTR
             ", src_offset = %zu, dst_offset = %zu, size = %zu, num_events_in_wait_list = %u, "
             "event_wait_list = 0x%016" PRIxPTR ", event = 0x%016" PRIxPTR "",
             (uintptr_t)command_queue, (uintptr_t)src_buffer, (uintptr_t)dst_buffer, src_offset,
             dst_offset, size, num_events_in_wait_list, (uintptr_t)event_wait_list,
             (uintptr_t)event);

    // TODO: EnqueueCopyBuffer

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_EnqueueReadImage(cl_command_queue command_queue,
                                        cl_mem image,
                                        cl_bool blocking_read,
                                        const size_t *origin,
                                        const size_t *region,
                                        size_t row_pitch,
                                        size_t slice_pitch,
                                        void *ptr,
                                        cl_uint num_events_in_wait_list,
                                        const cl_event *event_wait_list,
                                        cl_event *event)
{
    CL_EVENT(EnqueueReadImage,
             "command_queue = 0x%016" PRIxPTR ", image = 0x%016" PRIxPTR
             ", blocking_read = %u, origin = 0x%016" PRIxPTR ", region = 0x%016" PRIxPTR
             ", row_pitch = %zu, slice_pitch = %zu, ptr = 0x%016" PRIxPTR
             ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
             ", event = 0x%016" PRIxPTR "",
             (uintptr_t)command_queue, (uintptr_t)image, blocking_read, (uintptr_t)origin,
             (uintptr_t)region, row_pitch, slice_pitch, (uintptr_t)ptr, num_events_in_wait_list,
             (uintptr_t)event_wait_list, (uintptr_t)event);

    // TODO: EnqueueReadImage

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_EnqueueWriteImage(cl_command_queue command_queue,
                                         cl_mem image,
                                         cl_bool blocking_write,
                                         const size_t *origin,
                                         const size_t *region,
                                         size_t input_row_pitch,
                                         size_t input_slice_pitch,
                                         const void *ptr,
                                         cl_uint num_events_in_wait_list,
                                         const cl_event *event_wait_list,
                                         cl_event *event)
{
    CL_EVENT(EnqueueWriteImage,
             "command_queue = 0x%016" PRIxPTR ", image = 0x%016" PRIxPTR
             ", blocking_write = %u, origin = 0x%016" PRIxPTR ", region = 0x%016" PRIxPTR
             ", input_row_pitch = %zu, input_slice_pitch = %zu, ptr = 0x%016" PRIxPTR
             ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
             ", event = 0x%016" PRIxPTR "",
             (uintptr_t)command_queue, (uintptr_t)image, blocking_write, (uintptr_t)origin,
             (uintptr_t)region, input_row_pitch, input_slice_pitch, (uintptr_t)ptr,
             num_events_in_wait_list, (uintptr_t)event_wait_list, (uintptr_t)event);

    // TODO: EnqueueWriteImage

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_EnqueueCopyImage(cl_command_queue command_queue,
                                        cl_mem src_image,
                                        cl_mem dst_image,
                                        const size_t *src_origin,
                                        const size_t *dst_origin,
                                        const size_t *region,
                                        cl_uint num_events_in_wait_list,
                                        const cl_event *event_wait_list,
                                        cl_event *event)
{
    CL_EVENT(EnqueueCopyImage,
             "command_queue = 0x%016" PRIxPTR ", src_image = 0x%016" PRIxPTR
             ", dst_image = 0x%016" PRIxPTR ", src_origin = 0x%016" PRIxPTR
             ", dst_origin = 0x%016" PRIxPTR ", region = 0x%016" PRIxPTR
             ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
             ", event = 0x%016" PRIxPTR "",
             (uintptr_t)command_queue, (uintptr_t)src_image, (uintptr_t)dst_image,
             (uintptr_t)src_origin, (uintptr_t)dst_origin, (uintptr_t)region,
             num_events_in_wait_list, (uintptr_t)event_wait_list, (uintptr_t)event);

    // TODO: EnqueueCopyImage

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_EnqueueCopyImageToBuffer(cl_command_queue command_queue,
                                                cl_mem src_image,
                                                cl_mem dst_buffer,
                                                const size_t *src_origin,
                                                const size_t *region,
                                                size_t dst_offset,
                                                cl_uint num_events_in_wait_list,
                                                const cl_event *event_wait_list,
                                                cl_event *event)
{
    CL_EVENT(EnqueueCopyImageToBuffer,
             "command_queue = 0x%016" PRIxPTR ", src_image = 0x%016" PRIxPTR
             ", dst_buffer = 0x%016" PRIxPTR ", src_origin = 0x%016" PRIxPTR
             ", region = 0x%016" PRIxPTR
             ", dst_offset = %zu, num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
             ", event = 0x%016" PRIxPTR "",
             (uintptr_t)command_queue, (uintptr_t)src_image, (uintptr_t)dst_buffer,
             (uintptr_t)src_origin, (uintptr_t)region, dst_offset, num_events_in_wait_list,
             (uintptr_t)event_wait_list, (uintptr_t)event);

    // TODO: EnqueueCopyImageToBuffer

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_EnqueueCopyBufferToImage(cl_command_queue command_queue,
                                                cl_mem src_buffer,
                                                cl_mem dst_image,
                                                size_t src_offset,
                                                const size_t *dst_origin,
                                                const size_t *region,
                                                cl_uint num_events_in_wait_list,
                                                const cl_event *event_wait_list,
                                                cl_event *event)
{
    CL_EVENT(EnqueueCopyBufferToImage,
             "command_queue = 0x%016" PRIxPTR ", src_buffer = 0x%016" PRIxPTR
             ", dst_image = 0x%016" PRIxPTR ", src_offset = %zu, dst_origin = 0x%016" PRIxPTR
             ", region = 0x%016" PRIxPTR
             ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
             ", event = 0x%016" PRIxPTR "",
             (uintptr_t)command_queue, (uintptr_t)src_buffer, (uintptr_t)dst_image, src_offset,
             (uintptr_t)dst_origin, (uintptr_t)region, num_events_in_wait_list,
             (uintptr_t)event_wait_list, (uintptr_t)event);

    // TODO: EnqueueCopyBufferToImage

    return (cl_int)0;
}

void *CL_API_ENTRY CL_EnqueueMapBuffer(cl_command_queue command_queue,
                                       cl_mem buffer,
                                       cl_bool blocking_map,
                                       cl_map_flags map_flags,
                                       size_t offset,
                                       size_t size,
                                       cl_uint num_events_in_wait_list,
                                       const cl_event *event_wait_list,
                                       cl_event *event,
                                       cl_int *errcode_ret)
{
    CL_EVENT(EnqueueMapBuffer,
             "command_queue = 0x%016" PRIxPTR ", buffer = 0x%016" PRIxPTR
             ", blocking_map = %u, map_flags = %lu, offset = %zu, size = %zu, "
             "num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
             ", event = 0x%016" PRIxPTR ", errcode_ret = 0x%016" PRIxPTR "",
             (uintptr_t)command_queue, (uintptr_t)buffer, blocking_map, map_flags, offset, size,
             num_events_in_wait_list, (uintptr_t)event_wait_list, (uintptr_t)event,
             (uintptr_t)errcode_ret);

    // TODO: EnqueueMapBuffer

    return (void *)0;
}

void *CL_API_ENTRY CL_EnqueueMapImage(cl_command_queue command_queue,
                                      cl_mem image,
                                      cl_bool blocking_map,
                                      cl_map_flags map_flags,
                                      const size_t *origin,
                                      const size_t *region,
                                      size_t *image_row_pitch,
                                      size_t *image_slice_pitch,
                                      cl_uint num_events_in_wait_list,
                                      const cl_event *event_wait_list,
                                      cl_event *event,
                                      cl_int *errcode_ret)
{
    CL_EVENT(EnqueueMapImage,
             "command_queue = 0x%016" PRIxPTR ", image = 0x%016" PRIxPTR
             ", blocking_map = %u, map_flags = %lu, origin = 0x%016" PRIxPTR
             ", region = 0x%016" PRIxPTR ", image_row_pitch = 0x%016" PRIxPTR
             ", image_slice_pitch = 0x%016" PRIxPTR
             ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
             ", event = 0x%016" PRIxPTR ", errcode_ret = 0x%016" PRIxPTR "",
             (uintptr_t)command_queue, (uintptr_t)image, blocking_map, map_flags, (uintptr_t)origin,
             (uintptr_t)region, (uintptr_t)image_row_pitch, (uintptr_t)image_slice_pitch,
             num_events_in_wait_list, (uintptr_t)event_wait_list, (uintptr_t)event,
             (uintptr_t)errcode_ret);

    // TODO: EnqueueMapImage

    return (void *)0;
}

cl_int CL_API_ENTRY CL_EnqueueUnmapMemObject(cl_command_queue command_queue,
                                             cl_mem memobj,
                                             void *mapped_ptr,
                                             cl_uint num_events_in_wait_list,
                                             const cl_event *event_wait_list,
                                             cl_event *event)
{
    CL_EVENT(EnqueueUnmapMemObject,
             "command_queue = 0x%016" PRIxPTR ", memobj = 0x%016" PRIxPTR
             ", mapped_ptr = 0x%016" PRIxPTR
             ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
             ", event = 0x%016" PRIxPTR "",
             (uintptr_t)command_queue, (uintptr_t)memobj, (uintptr_t)mapped_ptr,
             num_events_in_wait_list, (uintptr_t)event_wait_list, (uintptr_t)event);

    // TODO: EnqueueUnmapMemObject

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_EnqueueNDRangeKernel(cl_command_queue command_queue,
                                            cl_kernel kernel,
                                            cl_uint work_dim,
                                            const size_t *global_work_offset,
                                            const size_t *global_work_size,
                                            const size_t *local_work_size,
                                            cl_uint num_events_in_wait_list,
                                            const cl_event *event_wait_list,
                                            cl_event *event)
{
    CL_EVENT(EnqueueNDRangeKernel,
             "command_queue = 0x%016" PRIxPTR ", kernel = 0x%016" PRIxPTR
             ", work_dim = %u, global_work_offset = 0x%016" PRIxPTR
             ", global_work_size = 0x%016" PRIxPTR ", local_work_size = 0x%016" PRIxPTR
             ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
             ", event = 0x%016" PRIxPTR "",
             (uintptr_t)command_queue, (uintptr_t)kernel, work_dim, (uintptr_t)global_work_offset,
             (uintptr_t)global_work_size, (uintptr_t)local_work_size, num_events_in_wait_list,
             (uintptr_t)event_wait_list, (uintptr_t)event);

    // TODO: EnqueueNDRangeKernel

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_EnqueueNativeKernel(cl_command_queue command_queue,
                                           void(CL_CALLBACK *user_func)(void *),
                                           void *args,
                                           size_t cb_args,
                                           cl_uint num_mem_objects,
                                           const cl_mem *mem_list,
                                           const void **args_mem_loc,
                                           cl_uint num_events_in_wait_list,
                                           const cl_event *event_wait_list,
                                           cl_event *event)
{
    CL_EVENT(EnqueueNativeKernel,
             "command_queue = 0x%016" PRIxPTR ", user_func = 0x%016" PRIxPTR
             ", args = 0x%016" PRIxPTR
             ", cb_args = %zu, num_mem_objects = %u, mem_list = 0x%016" PRIxPTR
             ", args_mem_loc = 0x%016" PRIxPTR
             ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
             ", event = 0x%016" PRIxPTR "",
             (uintptr_t)command_queue, (uintptr_t)user_func, (uintptr_t)args, cb_args,
             num_mem_objects, (uintptr_t)mem_list, (uintptr_t)args_mem_loc, num_events_in_wait_list,
             (uintptr_t)event_wait_list, (uintptr_t)event);

    // TODO: EnqueueNativeKernel

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_SetCommandQueueProperty(cl_command_queue command_queue,
                                               cl_command_queue_properties properties,
                                               cl_bool enable,
                                               cl_command_queue_properties *old_properties)
{
    CL_EVENT(SetCommandQueueProperty,
             "command_queue = 0x%016" PRIxPTR
             ", properties = %lu, enable = %u, old_properties = 0x%016" PRIxPTR "",
             (uintptr_t)command_queue, properties, enable, (uintptr_t)old_properties);

    // TODO: SetCommandQueueProperty

    return (cl_int)0;
}

cl_mem CL_API_ENTRY CL_CreateImage2D(cl_context context,
                                     cl_mem_flags flags,
                                     const cl_image_format *image_format,
                                     size_t image_width,
                                     size_t image_height,
                                     size_t image_row_pitch,
                                     void *host_ptr,
                                     cl_int *errcode_ret)
{
    CL_EVENT(
        CreateImage2D,
        "context = 0x%016" PRIxPTR ", flags = %lu, image_format = 0x%016" PRIxPTR
        ", image_width = %zu, image_height = %zu, image_row_pitch = %zu, host_ptr = 0x%016" PRIxPTR
        ", errcode_ret = 0x%016" PRIxPTR "",
        (uintptr_t)context, flags, (uintptr_t)image_format, image_width, image_height,
        image_row_pitch, (uintptr_t)host_ptr, (uintptr_t)errcode_ret);

    // TODO: CreateImage2D

    return (cl_mem)0;
}

cl_mem CL_API_ENTRY CL_CreateImage3D(cl_context context,
                                     cl_mem_flags flags,
                                     const cl_image_format *image_format,
                                     size_t image_width,
                                     size_t image_height,
                                     size_t image_depth,
                                     size_t image_row_pitch,
                                     size_t image_slice_pitch,
                                     void *host_ptr,
                                     cl_int *errcode_ret)
{
    CL_EVENT(
        CreateImage3D,
        "context = 0x%016" PRIxPTR ", flags = %lu, image_format = 0x%016" PRIxPTR
        ", image_width = %zu, image_height = %zu, image_depth = %zu, image_row_pitch = %zu, "
        "image_slice_pitch = %zu, host_ptr = 0x%016" PRIxPTR ", errcode_ret = 0x%016" PRIxPTR "",
        (uintptr_t)context, flags, (uintptr_t)image_format, image_width, image_height, image_depth,
        image_row_pitch, image_slice_pitch, (uintptr_t)host_ptr, (uintptr_t)errcode_ret);

    // TODO: CreateImage3D

    return (cl_mem)0;
}

cl_int CL_API_ENTRY CL_EnqueueMarker(cl_command_queue command_queue, cl_event *event)
{
    CL_EVENT(EnqueueMarker, "command_queue = 0x%016" PRIxPTR ", event = 0x%016" PRIxPTR "",
             (uintptr_t)command_queue, (uintptr_t)event);

    // TODO: EnqueueMarker

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_EnqueueWaitForEvents(cl_command_queue command_queue,
                                            cl_uint num_events,
                                            const cl_event *event_list)
{
    CL_EVENT(EnqueueWaitForEvents,
             "command_queue = 0x%016" PRIxPTR ", num_events = %u, event_list = 0x%016" PRIxPTR "",
             (uintptr_t)command_queue, num_events, (uintptr_t)event_list);

    // TODO: EnqueueWaitForEvents

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_EnqueueBarrier(cl_command_queue command_queue)
{
    CL_EVENT(EnqueueBarrier, "command_queue = 0x%016" PRIxPTR "", (uintptr_t)command_queue);

    // TODO: EnqueueBarrier

    return (cl_int)0;
}

cl_int CL_API_ENTRY CL_UnloadCompiler()
{
    CL_EVENT(UnloadCompiler, "");

    // TODO: UnloadCompiler

    return (cl_int)0;
}

void *CL_API_ENTRY CL_GetExtensionFunctionAddress(const char *func_name)
{
    CL_EVENT(GetExtensionFunctionAddress, "func_name = 0x%016" PRIxPTR "", (uintptr_t)func_name);

    // TODO: GetExtensionFunctionAddress

    return (void *)0;
}

cl_command_queue CL_API_ENTRY CL_CreateCommandQueue(cl_context context,
                                                    cl_device_id device,
                                                    cl_command_queue_properties properties,
                                                    cl_int *errcode_ret)
{
    CL_EVENT(CreateCommandQueue,
             "context = 0x%016" PRIxPTR ", device = 0x%016" PRIxPTR
             ", properties = %lu, errcode_ret = 0x%016" PRIxPTR "",
             (uintptr_t)context, (uintptr_t)device, properties, (uintptr_t)errcode_ret);

    // TODO: CreateCommandQueue

    return (cl_command_queue)0;
}

cl_sampler CL_API_ENTRY CL_CreateSampler(cl_context context,
                                         cl_bool normalized_coords,
                                         cl_addressing_mode addressing_mode,
                                         cl_filter_mode filter_mode,
                                         cl_int *errcode_ret)
{
    CL_EVENT(CreateSampler,
             "context = 0x%016" PRIxPTR
             ", normalized_coords = %u, addressing_mode = %u, filter_mode = %u, errcode_ret = "
             "0x%016" PRIxPTR "",
             (uintptr_t)context, normalized_coords, addressing_mode, filter_mode,
             (uintptr_t)errcode_ret);

    // TODO: CreateSampler

    return (cl_sampler)0;
}

cl_int CL_API_ENTRY CL_EnqueueTask(cl_command_queue command_queue,
                                   cl_kernel kernel,
                                   cl_uint num_events_in_wait_list,
                                   const cl_event *event_wait_list,
                                   cl_event *event)
{
    CL_EVENT(EnqueueTask,
             "command_queue = 0x%016" PRIxPTR ", kernel = 0x%016" PRIxPTR
             ", num_events_in_wait_list = %u, event_wait_list = 0x%016" PRIxPTR
             ", event = 0x%016" PRIxPTR "",
             (uintptr_t)command_queue, (uintptr_t)kernel, num_events_in_wait_list,
             (uintptr_t)event_wait_list, (uintptr_t)event);

    // TODO: EnqueueTask

    return (cl_int)0;
}

}  // extern "C"


text:
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
// Copyright (C) 2007-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef EIGEN_DIAGONALMATRIX_H
#define EIGEN_DIAGONALMATRIX_H

namespace Eigen {

#ifndef EIGEN_PARSED_BY_DOXYGEN
template<typename Derived>
class DiagonalBase : public EigenBase<Derived>
{
  public:
    typedef typename internal::traits<Derived>::DiagonalVectorType DiagonalVectorType;
    typedef typename DiagonalVectorType::Scalar Scalar;
    typedef typename DiagonalVectorType::RealScalar RealScalar;
    typedef typename internal::traits<Derived>::StorageKind StorageKind;
    typedef typename internal::traits<Derived>::StorageIndex StorageIndex;

    enum {
      RowsAtCompileTime = DiagonalVectorType::SizeAtCompileTime,
      ColsAtCompileTime = DiagonalVectorType::SizeAtCompileTime,
      MaxRowsAtCompileTime = DiagonalVectorType::MaxSizeAtCompileTime,
      MaxColsAtCompileTime = DiagonalVectorType::MaxSizeAtCompileTime,
      IsVectorAtCompileTime = 0,
      Flags = NoPreferredStorageOrderBit
    };

    typedef Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, 0, MaxRowsAtCompileTime, MaxColsAtCompileTime> DenseMatrixType;
    typedef DenseMatrixType DenseType;
    typedef DiagonalMatrix<Scalar,DiagonalVectorType::SizeAtCompileTime,DiagonalVectorType::MaxSizeAtCompileTime> PlainObject;

    EIGEN_DEVICE_FUNC
    inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
    EIGEN_DEVICE_FUNC
    inline Derived& derived() { return *static_cast<Derived*>(this); }

    EIGEN_DEVICE_FUNC
    DenseMatrixType toDenseMatrix() const { return derived(); }

    EIGEN_DEVICE_FUNC
    inline const DiagonalVectorType& diagonal() const { return derived().diagonal(); }
    EIGEN_DEVICE_FUNC
    inline DiagonalVectorType& diagonal() { return derived().diagonal(); }

    EIGEN_DEVICE_FUNC
    inline Index rows() const { return diagonal().size(); }
    EIGEN_DEVICE_FUNC
    inline Index cols() const { return diagonal().size(); }

    template<typename MatrixDerived>
    EIGEN_DEVICE_FUNC
    const Product<Derived,MatrixDerived,LazyProduct>
    operator*(const MatrixBase<MatrixDerived> &matrix) const
    {
      return Product<Derived, MatrixDerived, LazyProduct>(derived(),matrix.derived());
    }

    typedef DiagonalWrapper<const CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const DiagonalVectorType> > InverseReturnType;
    EIGEN_DEVICE_FUNC
    inline const InverseReturnType
    inverse() const
    {
      return InverseReturnType(diagonal().cwiseInverse());
    }

    EIGEN_DEVICE_FUNC
    inline const DiagonalWrapper<const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(DiagonalVectorType,Scalar,product) >
    operator*(const Scalar& scalar) const
    {
      return DiagonalWrapper<const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(DiagonalVectorType,Scalar,product) >(diagonal() * scalar);
    }
    EIGEN_DEVICE_FUNC
    friend inline const DiagonalWrapper<const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar,DiagonalVectorType,product) >
    operator*(const Scalar& scalar, const DiagonalBase& other)
    {
      return DiagonalWrapper<const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar,DiagonalVectorType,product) >(scalar * other.diagonal());
    }

    template<typename OtherDerived>
    EIGEN_DEVICE_FUNC
    #ifdef EIGEN_PARSED_BY_DOXYGEN
    inline unspecified_expression_type
    #else
    inline const DiagonalWrapper<const EIGEN_CWISE_BINARY_RETURN_TYPE(DiagonalVectorType,typename OtherDerived::DiagonalVectorType,sum) >
    #endif
    operator+(const DiagonalBase<OtherDerived>& other) const
    {
      return (diagonal() + other.diagonal()).asDiagonal();
    }

    template<typename OtherDerived>
    EIGEN_DEVICE_FUNC
    #ifdef EIGEN_PARSED_BY_DOXYGEN
    inline unspecified_expression_type
    #else
    inline const DiagonalWrapper<const EIGEN_CWISE_BINARY_RETURN_TYPE(DiagonalVectorType,typename OtherDerived::DiagonalVectorType,difference) >
    #endif
    operator-(const DiagonalBase<OtherDerived>& other) const
    {
      return (diagonal() - other.diagonal()).asDiagonal();
    }
};

#endif

/** \class DiagonalMatrix
  * \ingroup Core_Module
  *
  * \brief Represents a diagonal matrix with its storage
  *
  * \param _Scalar the type of coefficients
  * \param SizeAtCompileTime the dimension of the matrix, or Dynamic
  * \param MaxSizeAtCompileTime the dimension of the matrix, or Dynamic. This parameter is optional and defaults
  *        to SizeAtCompileTime. Most of the time, you do not need to specify it.
  *
  * \sa class DiagonalWrapper
  */

namespace internal {
template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime>
struct traits<DiagonalMatrix<_Scalar,SizeAtCompileTime,MaxSizeAtCompileTime> >
 : traits<Matrix<_Scalar,SizeAtCompileTime,SizeAtCompileTime,0,MaxSizeAtCompileTime,MaxSizeAtCompileTime> >
{
  typedef Matrix<_Scalar,SizeAtCompileTime,1,0,MaxSizeAtCompileTime,1> DiagonalVectorType;
  typedef DiagonalShape StorageKind;
  enum {
    Flags = LvalueBit | NoPreferredStorageOrderBit
  };
};
}
template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime>
class DiagonalMatrix
  : public DiagonalBase<DiagonalMatrix<_Scalar,SizeAtCompileTime,MaxSizeAtCompileTime> >
{
  public:
    #ifndef EIGEN_PARSED_BY_DOXYGEN
    typedef typename internal::traits<DiagonalMatrix>::DiagonalVectorType DiagonalVectorType;
    typedef const DiagonalMatrix& Nested;
    typedef _Scalar Scalar;
    typedef typename internal::traits<DiagonalMatrix>::StorageKind StorageKind;
    typedef typename internal::traits<DiagonalMatrix>::StorageIndex StorageIndex;
    #endif

  protected:

    DiagonalVectorType m_diagonal;

  public:

    /** const version of diagonal(). */
    EIGEN_DEVICE_FUNC
    inline const DiagonalVectorType& diagonal() const { return m_diagonal; }
    /** \returns a reference to the stored vector of diagonal coefficients. */
    EIGEN_DEVICE_FUNC
    inline DiagonalVectorType& diagonal() { return m_diagonal; }

    /** Default constructor without initialization */
    EIGEN_DEVICE_FUNC
    inline DiagonalMatrix() {}

    /** Constructs a diagonal matrix with given dimension  */
    EIGEN_DEVICE_FUNC
    explicit inline DiagonalMatrix(Index dim) : m_diagonal(dim) {}

    /** 2D constructor. */
    EIGEN_DEVICE_FUNC
    inline DiagonalMatrix(const Scalar& x, const Scalar& y) : m_diagonal(x,y) {}

    /** 3D constructor. */
    EIGEN_DEVICE_FUNC
    inline DiagonalMatrix(const Scalar& x, const Scalar& y, const Scalar& z) : m_diagonal(x,y,z) {}

    #if EIGEN_HAS_CXX11
    /** \brief Construct a diagonal matrix with fixed size from an arbitrary number of coefficients. \cpp11
      *
      * There exists C++98 anologue constructors for fixed-size diagonal matrices having 2 or 3 coefficients.
      *
      * \warning To construct a diagonal matrix of fixed size, the number of values passed to this
      * constructor must match the fixed dimension of \c *this.
      *
      * \sa DiagonalMatrix(const Scalar&, const Scalar&)
      * \sa DiagonalMatrix(const Scalar&, const Scalar&, const Scalar&)
      */
    template <typename... ArgTypes>
    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
    DiagonalMatrix(const Scalar& a0, const Scalar& a1, const Scalar& a2, const ArgTypes&... args)
      : m_diagonal(a0, a1, a2, args...) {}

    /** \brief Constructs a DiagonalMatrix and initializes it by elements given by an initializer list of initializer
      * lists \cpp11
      */
    EIGEN_DEVICE_FUNC
    explicit EIGEN_STRONG_INLINE DiagonalMatrix(const std::initializer_list<std::initializer_list<Scalar>>& list)
      : m_diagonal(list) {}
    #endif  // EIGEN_HAS_CXX11

    /** Copy constructor. */
    template<typename OtherDerived>
    EIGEN_DEVICE_FUNC
    inline DiagonalMatrix(const DiagonalBase<OtherDerived>& other) : m_diagonal(other.diagonal()) {}

    #ifndef EIGEN_PARSED_BY_DOXYGEN
    /** copy constructor. prevent a default copy constructor from hiding the other templated constructor */
    inline DiagonalMatrix(const DiagonalMatrix& other) : m_diagonal(other.diagonal()) {}
    #endif

    /** generic constructor from expression of the diagonal coefficients */
    template<typename OtherDerived>
    EIGEN_DEVICE_FUNC
    explicit inline DiagonalMatrix(const MatrixBase<OtherDerived>& other) : m_diagonal(other)
    {}

    /** Copy operator. */
    template<typename OtherDerived>
    EIGEN_DEVICE_FUNC
    DiagonalMatrix& operator=(const DiagonalBase<OtherDerived>& other)
    {
      m_diagonal = other.diagonal();
      return *this;
    }

    #ifndef EIGEN_PARSED_BY_DOXYGEN
    /** This is a special case of the templated operator=. Its purpose is to
      * prevent a default operator= from hiding the templated operator=.
      */
    EIGEN_DEVICE_FUNC
    DiagonalMatrix& operator=(const DiagonalMatrix& other)
    {
      m_diagonal = other.diagonal();
      return *this;
    }
    #endif

    /** Resizes to given size. */
    EIGEN_DEVICE_FUNC
    inline void resize(Index size) { m_diagonal.resize(size); }
    /** Sets all coefficients to zero. */
    EIGEN_DEVICE_FUNC
    inline void setZero() { m_diagonal.setZero(); }
    /** Resizes and sets all coefficients to zero. */
    EIGEN_DEVICE_FUNC
    inline void setZero(Index size) { m_diagonal.setZero(size); }
    /** Sets this matrix to be the identity matrix of the current size. */
    EIGEN_DEVICE_FUNC
    inline void setIdentity() { m_diagonal.setOnes(); }
    /** Sets this matrix to be the identity matrix of the given size. */
    EIGEN_DEVICE_FUNC
    inline void setIdentity(Index size) { m_diagonal.setOnes(size); }
};

/** \class DiagonalWrapper
  * \ingroup Core_Module
  *
  * \brief Expression of a diagonal matrix
  *
  * \param _DiagonalVectorType the type of the vector of diagonal coefficients
  *
  * This class is an expression of a diagonal matrix, but not storing its own vector of diagonal coefficients,
  * instead wrapping an existing vector expression. It is the return type of MatrixBase::asDiagonal()
  * and most of the time this is the only way that it is used.
  *
  * \sa class DiagonalMatrix, class DiagonalBase, MatrixBase::asDiagonal()
  */

namespace internal {
template<typename _DiagonalVectorType>
struct traits<DiagonalWrapper<_DiagonalVectorType> >
{
  typedef _DiagonalVectorType DiagonalVectorType;
  typedef typename DiagonalVectorType::Scalar Scalar;
  typedef typename DiagonalVectorType::StorageIndex StorageIndex;
  typedef DiagonalShape StorageKind;
  typedef typename traits<DiagonalVectorType>::XprKind XprKind;
  enum {
    RowsAtCompileTime = DiagonalVectorType::SizeAtCompileTime,
    ColsAtCompileTime = DiagonalVectorType::SizeAtCompileTime,
    MaxRowsAtCompileTime = DiagonalVectorType::MaxSizeAtCompileTime,
    MaxColsAtCompileTime = DiagonalVectorType::MaxSizeAtCompileTime,
    Flags =  (traits<DiagonalVectorType>::Flags & LvalueBit) | NoPreferredStorageOrderBit
  };
};
}

template<typename _DiagonalVectorType>
class DiagonalWrapper
  : public DiagonalBase<DiagonalWrapper<_DiagonalVectorType> >, internal::no_assignment_operator
{
  public:
    #ifndef EIGEN_PARSED_BY_DOXYGEN
    typedef _DiagonalVectorType DiagonalVectorType;
    typedef DiagonalWrapper Nested;
    #endif

    /** Constructor from expression of diagonal coefficients to wrap. */
    EIGEN_DEVICE_FUNC
    explicit inline DiagonalWrapper(DiagonalVectorType& a_diagonal) : m_diagonal(a_diagonal) {}

    /** \returns a const reference to the wrapped expression of diagonal coefficients. */
    EIGEN_DEVICE_FUNC
    const DiagonalVectorType& diagonal() const { return m_diagonal; }

  protected:
    typename DiagonalVectorType::Nested m_diagonal;
};

/** \returns a pseudo-expression of a diagonal matrix with *this as vector of diagonal coefficients
  *
  * \only_for_vectors
  *
  * Example: \include MatrixBase_asDiagonal.cpp
  * Output: \verbinclude MatrixBase_asDiagonal.out
  *
  * \sa class DiagonalWrapper, class DiagonalMatrix, diagonal(), isDiagonal()
  **/
template<typename Derived>
EIGEN_DEVICE_FUNC inline const DiagonalWrapper<const Derived>
MatrixBase<Derived>::asDiagonal() const
{
  return DiagonalWrapper<const Derived>(derived());
}

/** \returns true if *this is approximately equal to a diagonal matrix,
  *          within the precision given by \a prec.
  *
  * Example: \include MatrixBase_isDiagonal.cpp
  * Output: \verbinclude MatrixBase_isDiagonal.out
  *
  * \sa asDiagonal()
  */
template<typename Derived>
bool MatrixBase<Derived>::isDiagonal(const RealScalar& prec) const
{
  if(cols() != rows()) return false;
  RealScalar maxAbsOnDiagonal = static_cast<RealScalar>(-1);
  for(Index j = 0; j < cols(); ++j)
  {
    RealScalar absOnDiagonal = numext::abs(coeff(j,j));
    if(absOnDiagonal > maxAbsOnDiagonal) maxAbsOnDiagonal = absOnDiagonal;
  }
  for(Index j = 0; j < cols(); ++j)
    for(Index i = 0; i < j; ++i)
    {
      if(!internal::isMuchSmallerThan(coeff(i, j), maxAbsOnDiagonal, prec)) return false;
      if(!internal::isMuchSmallerThan(coeff(j, i), maxAbsOnDiagonal, prec)) return false;
    }
  return true;
}

namespace internal {

template<> struct storage_kind_to_shape<DiagonalShape> { typedef DiagonalShape Shape; };

struct Diagonal2Dense {};

template<> struct AssignmentKind<DenseShape,DiagonalShape> { typedef Diagonal2Dense Kind; };

// Diagonal matrix to Dense assignment
template< typename DstXprType, typename SrcXprType, typename Functor>
struct Assignment<DstXprType, SrcXprType, Functor, Diagonal2Dense>
{
  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
  {
    Index dstRows = src.rows();
    Index dstCols = src.cols();
    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
      dst.resize(dstRows, dstCols);

    dst.setZero();
    dst.diagonal() = src.diagonal();
  }

  static void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
  { dst.diagonal() += src.diagonal(); }

  static void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
  { dst.diagonal() -= src.diagonal(); }
};

} // namespace internal

} // end namespace Eigen

#endif // EIGEN_DIAGONALMATRIX_H


text:
package space.kyu.crawlaway;

import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import space.kyu.crawlaway.entity.Page;
import space.kyu.crawlaway.entity.Request;
import space.kyu.crawlaway.processor.Processor;

class AVSOProcessor implements Processor {
	public static final String domain = "https://avso.pw";
	public static final String startUrl = "https://avso.pw/cn";
	private  Map<String, AVItem> detailPage;

	{
		detailPage = new ConcurrentHashMap<>();
	}

	public void processPage(Page page) {
		String oriUrl = page.getRequest().getUrl();
		if (oriUrl.endsWith("avso.pw/cn") || oriUrl.contains("avso.pw/cn/page")) {
			handleIndexPage(page);
		} else if(oriUrl.contains("avso.pw/cn/movie")){
			handleDetailPage(page);
		} else {
			System.out.println(oriUrl);
		}
//		} else if (oriUrl.contains("search")) {
//			handleDownloadePage(page);
//		} else if (oriUrl.contains("btso.pw/magnet/detail")) {
//			handleMagnetPage(page);
//		}
	}

	private void handleMagnetPage(Page page) {
		// TODO Auto-generated method stub

	}

	private void handleDownloadePage(Page page) {
		String content = page.getContent();
		AVItem item = (AVItem) page.getExtraInfo();
		Document document = Jsoup.parse(content);
		Elements rows = document.select("div.data-list").select("row");
		Iterator<Element> iterator = rows.iterator();
		while (iterator.hasNext()) {
			Element element = (Element) iterator.next();
			Elements a = element.select("a");
			if (a.size() != 0) {
				String url = a.first().attr("href");
				System.out.println(url);
				Request request = new Request(url);
				request.setExtraInfo(item);
			}
		}
	}

	private void handleDetailPage(Page page) {
		AVItem item = (AVItem) page.getExtraInfo();
		String content = page.getContent();
		String actorName=null,duration=null,desi=null,date=null,series=null,imgUrl = null;
		StringBuilder builder = new StringBuilder();
		Document document = Jsoup.parse(content);
		try {
			Elements bigImage = document.select("a.bigImage");
			imgUrl = bigImage.first().attr("href");

			Elements actor = document.select("a.avatar-box");
			actorName = actor.first().select("span").text();

			Elements info = document.select("div.col-md-3");
			Elements subinfo = info.select("p");
			desi = subinfo.get(0).select("span").get(1).text();
			date = subinfo.get(1).text();
			date = date.substring(date.indexOf(":")+1).trim();
			duration = subinfo.get(2).text();
			duration = duration.substring(duration.indexOf(":")+1).trim();
			series = subinfo.get(6).select("a").text();
			Elements cates = subinfo.get(8).select("span");
			Iterator<Element> iterator = cates.iterator();
			builder = new StringBuilder();
			while (iterator.hasNext()) {
				Element element = (Element) iterator.next();
				String cate = element.select("a").text();
				builder.append(cate).append("\t");
			}
		} catch (Exception e) {
			// TODO: handle exception
		}

		item.setActor(actorName);
		item.setCategory(builder.toString());
		item.setDesignation(desi);
		item.setDuration(duration);
		item.setDate(date);
		item.setSeries(series);
		item.setImgURL(imgUrl);

		String target = document.select("div.ptb-10").get(2).select("a").attr("href");
		Request request = new Request(target);
		request.setExtraInfo(item);
		page.addTargetRequest(request);
	}

	private void handleIndexPage(Page page) {
		AVItem item = new AVItem();
		String content = page.getContent();
		Document document = Jsoup.parse(content);
		Elements waterfall = document.select("#waterfall");
		Elements moveBox = waterfall.select("a.movie-box");
		Iterator<Element> moveIterator = moveBox.iterator();
		while (moveIterator.hasNext()) {
			Element i = (Element) moveIterator.next();
			String url = i.attr("href");
			Elements img = i.select("div.photo-frame").select("img");
			Element image = img.first();
			String title = image.attr("title");
			item.setTitle(title);
			Request request = new Request(url);
			request.setExtraInfo(item);
			page.addTargetRequest(request);
		}
		Elements pagination = document.select("ul.pagination");
		Elements number = pagination.select("li").select("a");
		Iterator<Element> pageIterator = number.iterator();
		while (pageIterator.hasNext()) {
			Element p = (Element) pageIterator.next();
			String href = p.attr("href");
			String targetUrl = domain + href;
			page.addTargetRequest(targetUrl);
		}
	}

}


text:
@interface HXAppInfo : NSObject

@property (nonatomic, strong) NSArray *languageCodesISO2A;
@property (nonatomic, strong) NSArray *supportedDevices;
@property (nonatomic, strong) NSArray *ipadScreenshotUrls;
@property (nonatomic, strong) NSArray *appletvScreenshotUrls;
@property (nonatomic, strong) NSArray *genreIds;
@property (nonatomic, strong) NSArray *screenshotUrls;
@property (nonatomic, strong) NSArray *advisories;
@property (nonatomic, strong) NSArray *genres;

@property (nonatomic, copy) NSString *primaryGenreName;
@property (nonatomic, copy) NSString *artworkUrl100;
@property (nonatomic, copy) NSString *currency;
@property (nonatomic, copy) NSString *artworkUrl512;
@property (nonatomic, copy) NSString *fileSizeBytes;
@property (nonatomic, copy) NSString *artworkUrl60;
@property (nonatomic, copy) NSString *trackViewUrl;
//@property (nonatomic, copy) NSString *description;
@property (nonatomic, copy) NSString *version;
@property (nonatomic, copy) NSString *bundleId;
@property (nonatomic, copy) NSString *artistViewUrl;
@property (nonatomic, copy) NSString *releaseDate;
@property (nonatomic, copy) NSString *isGameCenterEnabled;
@property (nonatomic, copy) NSString *wrapperType;
@property (nonatomic, copy) NSString *trackId;
@property (nonatomic, copy) NSString *minimumOsVersion;
@property (nonatomic, copy) NSString *formattedPrice;
@property (nonatomic, copy) NSString *primaryGenreId;
@property (nonatomic, copy) NSString *currentVersionReleaseDate;
@property (nonatomic, copy) NSString *artistId;
@property (nonatomic, copy) NSString *trackContentRating;
@property (nonatomic, copy) NSString *artistName;

@property (nonatomic, copy) NSString *price;
@property (nonatomic, copy) NSString *trackCensoredName;
@property (nonatomic, copy) NSString *trackName;

@property (nonatomic, copy) NSString *kind;
@property (nonatomic, copy) NSString *contentAdvisoryRating;
@property (nonatomic, copy) NSString *releaseNotes;
@property (nonatomic, copy) NSString *isVppDeviceBasedLicensingEnabled;
@property (nonatomic, copy) NSString *sellerName;

@end


text:
package main

type Question struct {
	Id        int                  `json:"id"`
	Question  string               `json:"question"`
	Responses map[string]*Response `json:"responses"`
	updated   chan bool
}

type Response struct {
	Response string `json:"response"`
	Count    int    `json:"count"`
}

func GenerateQuestion(id int, q string, r1 string, r2 string, r3 string, r4 string) *Question {
	ques := new(Question)
	ques.Id = id
	ques.Question = q
	ques.Responses = make(map[string]*Response)
	ques.Responses["1"] = &Response{r1, 0}
	ques.Responses["2"] = &Response{r2, 0}
	ques.Responses["3"] = &Response{r3, 0}
	ques.Responses["4"] = &Response{r4, 0}
	return ques
}


text:
package io.truthencode.ddo.model.feats

import io.truthencode.ddo.enhancement.BonusType
import io.truthencode.ddo.model.abilities.ActiveAbilities
import io.truthencode.ddo.model.effect
import io.truthencode.ddo.model.effect.TriggerEvent
import io.truthencode.ddo.model.effect.features.{FeaturesImpl, GrantAbilityFeature}
import io.truthencode.ddo.support.requisite.{FeatRequisiteImpl, RequiresAllOfFeat}

import java.time.Duration

/**
 * Icon Feat Improved Trip.png [[https://ddowiki.com/page/Improved_Trip Improved Trip]] Active -
 * Special Attack This feat has a chance to trip the target, if the target fails a Balance check (DC
 * 14 + Str mod), rendering it prone for a longer period of time than Trip. Some creatures may be
 * immune to this effect. * Combat Expertise
 */
protected[feats] trait ImprovedTrip
  extends FeatRequisiteImpl with ActiveFeat with Tactical with RequiresAllOfFeat
  with FighterBonusFeat with MartialArtsFeat with FeaturesImpl with GrantAbilityFeature {
  self: GeneralFeat =>
  override lazy val grantedAbility: ActiveAbilities = ActiveAbilities.ImprovedTrip
  override protected[this] val triggerOn: Seq[TriggerEvent] = Seq(TriggerEvent.AtWill)
  override protected[this] val triggerOff: Seq[TriggerEvent] = Seq(TriggerEvent.OnCoolDown)
  override protected[this] val grantAbilityCategories: Seq[effect.EffectCategories.Value] = Seq(
    effect.EffectCategories.Ability)
  override val abilityId: String = "Trip"
  override val description: String =
    "This feat has a chance to trip the target rendering it prone for a short time."

  override val allOfFeats = List(GeneralFeat.CombatExpertise)
  override val grantBonusType: BonusType = BonusType.Feat

  override def coolDown: Option[Duration] = Some(Duration.ofSeconds(10))
}


text:
import m from 'mithril';
import _ from 'underscore';
import h from '../h';
import userFriends from  '../c/user-friends';
import userFollows from  '../c/user-follows';
import userFollowers from  '../c/user-followers';
import userCreators from  '../c/user-creators';

const FollowFoundFriends = {
    controller(args) {
        const user = h.getUser(),
              hash = m.prop(window.location.hash),
              displayTabContent = () => {
                  const c_opts = {
                      user: user
                  },
                  tabs = {
                            '#creators': m.component(userCreators, c_opts),
                            '#friends': m.component(userFriends, c_opts),
                            '#follows': m.component(userFollows, c_opts),
                            '#followers': m.component(userFollowers, c_opts)
                        };

                  hash(window.location.hash);

                  if (_.isEmpty(hash()) || hash() === '#_=_') {
                      return tabs['#friends'];
                  }

                  return tabs[hash()];
              };

        h.redrawHashChange();

        return {
            user: user,
            displayTabContent: displayTabContent
        };
    },
    view(ctrl, args) {
        return [
            m('.w-section.dashboard-header', [
                m('.w-container', [
                    m('.w-row.u-margintop-20.u-marginbottom-20', [
                        m('.w-col.w-col-1'),
                        m('.w-col.w-col-10.u-text-center', [
                            m('.fontsize-larger.fontweight-semibold.u-marginbottom-10', 'Discover projects with your friends'),
                            m('.fontsize-small', 'Follow your friends and we will notify you whenever they launch or support any project')
                        ]),
                        m('.w-col.w-col-1')
                    ])
                ])
            ]),
            [m('.divider.u-margintop-30'),
              m('.project-nav',
                m('.u-text-center.w-container',
                  [
                    m('a[id="creators-link"][class="dashboard-nav-link ' + (h.hashMatch('#creators') ? 'selected' : '') + '"] [href="#creators"]',
                      'Find filmmakers'
                     ),
                    m('a[id="friends-link"][class="dashboard-nav-link ' + (h.hashMatch('#friends') || h.hashMatch('') ? 'selected' : '') + '"] [href="#friends"]',
                      'Find friends'
                    ),
                    m('a[id="follows-link"][class="dashboard-nav-link ' + (h.hashMatch('#follows') ? 'selected' : '') + '"] [href="#follows"]',
                      [
                        'Following',
                        m.trust(' '),
                        m('span.w-hidden-small.w-hidden-tiny.badge',
                          ctrl.user.follows_count
                        )
                      ]
                    ),
                    m('a[id="followers-link"][class="dashboard-nav-link ' + (h.hashMatch('#followers') ? 'selected' : '') + '"] [href="#followers"]',
                      [
                        'Followers',
                        m.trust(' '),
                        m('span.w-hidden-small.w-hidden-tiny.badge',
                          ctrl.user.followers_count
                        )
                      ]
                    )
                  ]
                )
              )
            ],
            ctrl.displayTabContent()
        ];
    }
};

export default FollowFoundFriends;


text:
<?php
/**
 * UserDefined.php
 *
 * Creation date: 2014-09-27
 * Creation time: 20:25
 *
 * @author Arkadiusz Moskwa <a.moskwa@gmail.com>
 */

namespace Nakard\MusicFormats\Media\Id3v2\Frame\UrlLink;

use Nakard\MusicFormats\Media\Id3v2\DescriptionTrait;
use Nakard\MusicFormats\Media\Id3v2\TextEncodingTrait;

/**
 * Class UserDefined
 *
 * @package Nakard\MusicFormats\Media\Id3v2\Frame\UrlLink
 */
class UserDefined extends AbstractFrame
{
    use TextEncodingTrait, DescriptionTrait;

    protected $identifier = 'WXXX';

    /**
     * Constructs new user defined url link frame
     */
    public function __construct()
    {
        parent::__construct();
        $this->textEncoding = 0x00;
        $this->description = '';
    }
}


text:
package logger

import (
	log "github.com/Sirupsen/logrus"
)

// Fields represents map between log parameter name and value.
type Fields map[string]interface{}

// Level represents logging level.
type Level uint8

const (
	// PanicLevel represents Panic logging level.
	PanicLevel Level = iota
	// FatalLevel represents Fatal logging level.
	FatalLevel
	// ErrorLevel represents Error logging level.
	ErrorLevel
	// WarningLevel represents Warning logging level.
	WarningLevel
	// InfoLevel represents Panic Info level.
	InfoLevel
	// DebugLevel represents Debug logging level.
	DebugLevel
)

// Logger represents logging mechanism.
type Logger interface {
	Panic(args ...interface{})
	PanicWithFields(fields Fields, args ...interface{})

	Fatal(args ...interface{})
	FatalWithFields(fields Fields, args ...interface{})

	Error(args ...interface{})
	ErrorWithFields(fields Fields, args ...interface{})

	Warning(args ...interface{})
	WarningWithFields(fields Fields, args ...interface{})

	Info(args ...interface{})
	InfoWithFields(fields Fields, args ...interface{})

	Debug(args ...interface{})
	DebugWithFields(fields Fields, args ...interface{})

	SetLevel(level Level)
	IsLevel(level Level) bool
}

var logger = NewLogger()

// SetInternalLogger sets logger for quark-go framework internal logging.
// Internal logger is required and default implementation is base on "github.com/Sirupsen/logrus" library.
func SetInternalLogger(l Logger) {
	if l == nil {
		panic("Internal logger must be set!")
	}

	logger = l
}

// Log returns internally configured logger. By default it is set to "github.com/Sirupsen/logrus" library logger.
func Log() Logger {
	return logger
}

// LogrusLogger represents loging mechanism based on "github.com/Sirupsen/logrus" library.
type LogrusLogger struct {
}

// NewLogger creates logger based on logrus library. It is default logger implementation for internal logging.
func NewLogger() Logger {
	return &LogrusLogger{}
}

// Panic logs message and panics.
func (logger LogrusLogger) Panic(args ...interface{}) {
	log.Panic(args...)
}

// PanicWithFields logs message with custom fields and panic.
func (logger LogrusLogger) PanicWithFields(fields Fields, args ...interface{}) {
	log.WithFields(log.Fields(fields)).Panic(args...)
}

// Fatal logs message and calls exit(1).
func (logger LogrusLogger) Fatal(args ...interface{}) {
	log.Fatal(args...)
}

// FatalWithFields logs message with custom fields and calls exit(1).
func (logger LogrusLogger) FatalWithFields(fields Fields, args ...interface{}) {
	log.WithFields(log.Fields(fields)).Fatal(args...)
}

// Error logs error level message.
func (logger LogrusLogger) Error(args ...interface{}) {
	log.Error(args...)
}

// ErrorWithFields logs error level message with custom fields.
func (logger LogrusLogger) ErrorWithFields(fields Fields, args ...interface{}) {
	log.WithFields(log.Fields(fields)).Error(args...)
}

// Warning logs warning level message.
func (logger LogrusLogger) Warning(args ...interface{}) {
	log.Warning(args...)
}

// WarningWithFields logs warning level message with custom fields.
func (logger LogrusLogger) WarningWithFields(fields Fields, args ...interface{}) {
	log.WithFields(log.Fields(fields)).Warning(args...)
}

// Info logs info level message.
func (logger LogrusLogger) Info(args ...interface{}) {
	log.Info(args...)
}

// InfoWithFields logs info level message with custom fields.
func (logger LogrusLogger) InfoWithFields(fields Fields, args ...interface{}) {
	log.WithFields(log.Fields(fields)).Info(args...)
}

// Debug logs debug level message.
func (logger LogrusLogger) Debug(args ...interface{}) {
	log.Debug(args...)
}

// DebugWithFields log debug level message with custom fields.
func (logger LogrusLogger) DebugWithFields(fields Fields, args ...interface{}) {
	log.WithFields(log.Fields(fields)).Debug(args...)
}

// SetLevel sets logging level.
func (logger LogrusLogger) SetLevel(level Level) {
	l := log.Level(uint8(level))

	log.SetLevel(l)
}

// IsLevel returs true if log level specified in parameter matches log level currently sets on logger.
func (logger LogrusLogger) IsLevel(level Level) bool {
	l := Level(log.GetLevel())
	if l == level {
		return true
	}
	return false
}


text:
from .. import main

def get_template_data(**kwargs):
    template_data = dict(main.config['BASE_TEMPLATE_DATA'], **kwargs)
    return template_data


text:
import { DirectionStraightRight32 } from "../../";

export = DirectionStraightRight32;


text:
#ifndef TUT_RESULT_H_GUARD
#define TUT_RESULT_H_GUARD
#include <tut/tut_config.hpp>

#include <string>

#if defined(TUT_USE_RTTI)
#if (defined(_MSC_VER) && !defined(_CPPRTTI)) || (defined(__GNUC__) && !defined(__GXX_RTTI))
#undef TUT_USE_RTTI
#endif
#endif

#if defined(TUT_USE_RTTI)
#include <typeinfo>
#endif

namespace tut
{

#if defined(TUT_USE_RTTI)
template<typename T>
inline std::string type_name(const T& t)
{
    return typeid(t).name();
}
#else
template<typename T>
inline std::string type_name(const T& t)
{
    return "Unknown type, RTTI disabled";
}

inline std::string type_name(const std::exception&)
{
    return "Unknown std::exception, RTTI disabled";
}
#endif

#if defined(TUT_USE_POSIX)
struct test_result_posix
{
    test_result_posix()
        : pid(getpid())
    {
    }

    virtual ~test_result_posix()
    {
    }

    pid_t pid;
};
#else
struct test_result_posix
{
    virtual ~test_result_posix()
    {
    }
};
#endif

/**
 * Return type of runned test/test group.
 *
 * For test: contains result of test and, possible, message
 * for failure or exception.
 */
struct test_result : public test_result_posix
{
    /**
     * Test group name.
     */
    std::string group;

    /**
     * Test number in group.
     */
    int test;

    /**
     * Test name (optional)
     */
    std::string name;

    /**
     * result of a test
     */
    enum result_type
    {
        ok,       ///< test finished successfully
        fail,     ///< test failed with ensure() or fail() methods
        ex,       ///< test throwed an exceptions
        warn,     ///< test finished successfully, but test destructor throwed
        term,     ///< test forced test application to terminate abnormally
        ex_ctor,  ///<
        rethrown, ///<
        skipped,  ///<
        dummy     ///<
    };

    result_type result;

    /**
     * Exception message for failed test.
     */
    std::string message;
    std::string exception_typeid;

    /**
     * Default constructor.
     */
    test_result()
        : group(),
          test(0),
          name(),
          result(ok),
          message(),
          exception_typeid()
    {
    }

    /**
     * Constructor.
     */
    test_result(const std::string& grp, int pos,
                const std::string& test_name, result_type res)
        : group(grp),
          test(pos),
          name(test_name),
          result(res),
          message(),
          exception_typeid()
    {
    }

    /**
     * Constructor with exception.
     */
    test_result(const std::string& grp,int pos,
                const std::string& test_name, result_type res,
                const std::exception& ex)
        : group(grp),
          test(pos),
          name(test_name),
          result(res),
          message(ex.what()),
          exception_typeid(type_name(ex))
    {
    }

    /** Constructor with typeid.
    */
    test_result(const std::string& grp,int pos,
                const std::string& test_name, result_type res,
                const std::string& ex_typeid,
                const std::string& msg)
        : group(grp),
          test(pos),
          name(test_name),
          result(res),
          message(msg),
          exception_typeid(ex_typeid)
    {
    }

    virtual ~test_result()
    {
    }
};

}

#endif


text:
/*
 *  Created by Martin on 19/07/2017
 *
 *  Distributed under the Boost Software License, Version 1.0. (See accompanying
 *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */

#include "catch_test_case_tracker.h"

#include "catch_enforce.h"
#include "catch_string_manip.h"

#include <algorithm>
#include <cassert>
#include <stdexcept>
#include <memory>
#include <sstream>

#if defined(__clang__)
#    pragma clang diagnostic push
#    pragma clang diagnostic ignored "-Wexit-time-destructors"
#endif

namespace Catch {
namespace TestCaseTracking {

    NameAndLocation::NameAndLocation( std::string const& _name, SourceLineInfo const& _location )
    :   name( _name ),
        location( _location )
    {}

    ITracker::~ITracker() = default;

    ITracker& TrackerContext::startRun() {
        m_rootTracker = std::make_shared<SectionTracker>( NameAndLocation( "{root}", CATCH_INTERNAL_LINEINFO ), *this, nullptr );
        m_currentTracker = nullptr;
        m_runState = Executing;
        return *m_rootTracker;
    }

    void TrackerContext::endRun() {
        m_rootTracker.reset();
        m_currentTracker = nullptr;
        m_runState = NotStarted;
    }

    void TrackerContext::startCycle() {
        m_currentTracker = m_rootTracker.get();
        m_runState = Executing;
    }
    void TrackerContext::completeCycle() {
        m_runState = CompletedCycle;
    }

    bool TrackerContext::completedCycle() const {
        return m_runState == CompletedCycle;
    }
    ITracker& TrackerContext::currentTracker() {
        return *m_currentTracker;
    }
    void TrackerContext::setCurrentTracker( ITracker* tracker ) {
        m_currentTracker = tracker;
    }

    TrackerBase::TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
    :   m_nameAndLocation( nameAndLocation ),
        m_ctx( ctx ),
        m_parent( parent )
    {}

    NameAndLocation const& TrackerBase::nameAndLocation() const {
        return m_nameAndLocation;
    }
    bool TrackerBase::isComplete() const {
        return m_runState == CompletedSuccessfully || m_runState == Failed;
    }
    bool TrackerBase::isSuccessfullyCompleted() const {
        return m_runState == CompletedSuccessfully;
    }
    bool TrackerBase::isOpen() const {
        return m_runState != NotStarted && !isComplete();
    }
    bool TrackerBase::hasChildren() const {
        return !m_children.empty();
    }

    void TrackerBase::addChild( ITrackerPtr const& child ) {
        m_children.push_back( child );
    }

    ITrackerPtr TrackerBase::findChild( NameAndLocation const& nameAndLocation ) {
        auto it = std::find_if( m_children.begin(), m_children.end(),
            [&nameAndLocation]( ITrackerPtr const& tracker ){
                return
                    tracker->nameAndLocation().location == nameAndLocation.location &&
                    tracker->nameAndLocation().name == nameAndLocation.name;
            } );
        return( it != m_children.end() )
            ? *it
            : nullptr;
    }
    ITracker& TrackerBase::parent() {
        assert( m_parent ); // Should always be non-null except for root
        return *m_parent;
    }

    void TrackerBase::openChild() {
        if( m_runState != ExecutingChildren ) {
            m_runState = ExecutingChildren;
            if( m_parent )
                m_parent->openChild();
        }
    }

    bool TrackerBase::isSectionTracker() const { return false; }
    bool TrackerBase::isGeneratorTracker() const { return false; }

    void TrackerBase::open() {
        m_runState = Executing;
        moveToThis();
        if( m_parent )
            m_parent->openChild();
    }

    void TrackerBase::close() {

        // Close any still open children (e.g. generators)
        while( &m_ctx.currentTracker() != this )
            m_ctx.currentTracker().close();

        switch( m_runState ) {
            case NeedsAnotherRun:
                break;

            case Executing:
                m_runState = CompletedSuccessfully;
                break;
            case ExecutingChildren:
                if( std::all_of(m_children.begin(), m_children.end(), [](ITrackerPtr const& t){ return t->isComplete(); }) )
                    m_runState = CompletedSuccessfully;
                break;

            case NotStarted:
            case CompletedSuccessfully:
            case Failed:
                CATCH_INTERNAL_ERROR( "Illogical state: " << m_runState );

            default:
                CATCH_INTERNAL_ERROR( "Unknown state: " << m_runState );
        }
        moveToParent();
        m_ctx.completeCycle();
    }
    void TrackerBase::fail() {
        m_runState = Failed;
        if( m_parent )
            m_parent->markAsNeedingAnotherRun();
        moveToParent();
        m_ctx.completeCycle();
    }
    void TrackerBase::markAsNeedingAnotherRun() {
        m_runState = NeedsAnotherRun;
    }

    void TrackerBase::moveToParent() {
        assert( m_parent );
        m_ctx.setCurrentTracker( m_parent );
    }
    void TrackerBase::moveToThis() {
        m_ctx.setCurrentTracker( this );
    }

    SectionTracker::SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
    :   TrackerBase( nameAndLocation, ctx, parent ),
        m_trimmed_name(trim(nameAndLocation.name))
    {
        if( parent ) {
            while( !parent->isSectionTracker() )
                parent = &parent->parent();

            SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
            addNextFilters( parentSection.m_filters );
        }
    }

    bool SectionTracker::isComplete() const {
        bool complete = true;

        if ((m_filters.empty() || m_filters[0] == "")
            || std::find(m_filters.begin(), m_filters.end(), m_trimmed_name) != m_filters.end()) {
            complete = TrackerBase::isComplete();
        }
        return complete;
    }

    bool SectionTracker::isSectionTracker() const { return true; }

    SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
        std::shared_ptr<SectionTracker> section;

        ITracker& currentTracker = ctx.currentTracker();
        if( ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
            assert( childTracker );
            assert( childTracker->isSectionTracker() );
            section = std::static_pointer_cast<SectionTracker>( childTracker );
        }
        else {
            section = std::make_shared<SectionTracker>( nameAndLocation, ctx, &currentTracker );
            currentTracker.addChild( section );
        }
        if( !ctx.completedCycle() )
            section->tryOpen();
        return *section;
    }

    void SectionTracker::tryOpen() {
        if( !isComplete() )
            open();
    }

    void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
        if( !filters.empty() ) {
            m_filters.reserve( m_filters.size() + filters.size() + 2 );
            m_filters.push_back(""); // Root - should never be consulted
            m_filters.push_back(""); // Test Case - not a section filter
            m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
        }
    }
    void SectionTracker::addNextFilters( std::vector<std::string> const& filters ) {
        if( filters.size() > 1 )
            m_filters.insert( m_filters.end(), filters.begin()+1, filters.end() );
    }

} // namespace TestCaseTracking

using TestCaseTracking::ITracker;
using TestCaseTracking::TrackerContext;
using TestCaseTracking::SectionTracker;

} // namespace Catch

#if defined(__clang__)
#    pragma clang diagnostic pop
#endif